public bool SendFileList(string[] files) { try { TcpClient client = new TcpClient(IPAddress.Loopback.ToString(), Configuration.TcpPort); ConnectionMessage message = new ConnectionMessage(MessageType.IpcBaseFolder, true, files[0]); //SendMessage(client.Client,message); SendMessage(client, message); message.MessageType = MessageType.IpcElement; for (int i = 1; i < files.Length - 1; i++) { message.Message = files[i]; SendMessage(client, message); } message.Message = files[files.Length - 1]; message.Next = false; SendMessage(client, message); client.Close(); return(true); } catch (SocketException) { //Most likely failed to connect return(false); } }
public override void Init() { if (_init) { return; } //Enable Menu: Process Process = Process.ThisProcess(); ASCIIEncoding enc = new ASCIIEncoding(); Process.Write(enc.GetBytes("AAAAAA"), 0x890898); Version v = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version; zERROR.GetZErr(Process).Report(2, 'G', "GUC-Version: " + v.ToString(), 0, "Program.cs", 0); setupPlayer(); ConnectionMessage.Write(); PlayerKeyMessage.getPlayerKeyMessage().Init(); _init = true; TurnLeftID = oCNpc.Player(Process.ThisProcess()).GetModel().GetAniIDFromAniName("T_RUNTURNL"); TurnRightID = oCNpc.Player(Process.ThisProcess()).GetModel().GetAniIDFromAniName("T_RUNTURNR"); StartJumpID = oCNpc.Player(Process.ThisProcess()).GetModel().GetAniIDFromAniName("T_STAND_2_JUMP"); }
public Task Send(ConnectionMessage message) { if (!String.IsNullOrEmpty(message.Signal) && message.Signals != null) { throw new InvalidOperationException( String.Format(CultureInfo.CurrentCulture, Resources.Error_AmbiguousMessage, message.Signal, String.Join(", ", message.Signals))); } if (message.Signals != null) { return(MultiSend(message.Signals, message.Value, message.ExcludedSignals)); } else { Message busMessage = CreateMessage(message.Signal, message.Value); busMessage.Filter = GetFilter(message.ExcludedSignals); if (busMessage.WaitForAck) { Task ackTask = _ackHandler.CreateAck(busMessage.CommandId); return(_bus.Publish(busMessage).Then(task => task, ackTask)); } return(_bus.Publish(busMessage)); } }
private void DisconnectClient() { var msg = new ConnectionMessage(Connection.Disconnect, User); //Send message to server about disconnecting Connector.Stream.Write(msg.Serialize()); //Disconnect this client from server StopClient(); }
//evento propio S - se conectó un usuario ID 900 void OnUserConnected(NetworkMessage netMsg) { print("user connected"); var msg = new ConnectionMessage(); msg.connections = NetworkServer.connections.Count; NetworkServer.SendToClient(netMsg.conn.connectionId, MaxPlayers, msg); }
internal static Task Outgoing(IHubOutgoingInvokerContext context) { var message = new ConnectionMessage(context.Signal, context.Invocation) { ExcludedSignals = context.ExcludedSignals }; return(context.Connection.Send(message)); }
internal static void SendMessage(TcpClient to, ConnectionMessage message) { using (var writer = new BinaryWriter(to.GetStream(), Encoding.BigEndianUnicode, true)) { var formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter(); using (var memory = new MemoryStream()) { formatter.Serialize(memory, message); byte[] data = memory.ToArray(); writer.Write(data.Length); writer.Write(data); } } /* * IFormatter formatter = * new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter(); * * using (MemoryStream ms = new MemoryStream()) * { * formatter.Serialize(ms, message); * byte[] data = ms.ToArray(); * NetworkStream ns = to.GetStream(); * byte[] dataSize = BitConverter.GetBytes(IPAddress.HostToNetworkOrder(data.Length)); * ns.Write(dataSize, 0, dataSize.Length); * ns.Flush(); * ns.Write(data, 0, data.Length); * ns.Flush(); * } */ /* * string json = JsonConvert.SerializeObject(message); * * using (TextWriter textW = new StreamWriter(to.GetStream(), Encoding.UTF8,4096,true)) * using (JsonWriter jsonW = new JsonTextWriter(textW) * { * CloseOutput=false * } * ) * { * JObject jObject = JObject.Parse(json); * * jObject.WriteTo(jsonW); * jsonW.Flush(); * }*/ /* * NetworkStream ns = to.GetStream(); * byte[] data = ConnectionMessage.Serialize(message); * byte[] dataSize = BitConverter.GetBytes(IPAddress.HostToNetworkOrder(Encoding.UTF8.GetByteCount(JsonConvert.SerializeObject(message)))); * ns.Write(dataSize, 0, dataSize.Length); * ns.Flush(); * ns.Write(data, 0, data.Length); * ns.Flush(); */ }
public void ConnectionStatus(ConnectionMessage msg) { switch(msg){ case ConnectionMessage.disconnected: lostConnection = true; break; case ConnectionMessage.playerDisconnected: break; } }
public void ConnectionStatus(ConnectionMessage msg) { Debug.Log("network message to CreateGameGUI: "+msg); switch(msg){ case ConnectionMessage.serverInit: FinishCreateGame(); break; case ConnectionMessage.serverInitFailed: state = State.FailedToLaunchServer; break; } }
private static Task SendCommand(ITransportConnection connection, string connectionId, CommandType commandType) { var command = new Command { CommandType = commandType }; var message = new ConnectionMessage(PrefixHelper.GetConnectionId(connectionId), command); return(connection.Send(message)); }
private static Task SendCommand(ITransportConnection connection, string connectionId, CommandType commandType) { var command = new Command { CommandType = commandType }; var message = new ConnectionMessage(PrefixHelper.GetConnectionId(connectionId), command); return connection.Send(message); }
public void TestConnectionMessageUnwind() { //wait and get timeout Assert.IsFalse(Processor.ConnectionMessage().Wait(10)); //process ConnectionMessage msg = (ConnectionMessage)Processor.ReceiveLine("{\"op\":\"connection\", \"connectionId\":\"aconnid\"}"); //now unwound Assert.IsTrue(Processor.ConnectionMessage().Wait(10)); Assert.AreEqual("aconnid", Processor.ConnectionMessage().Result.ConnectionId); Assert.AreEqual(ConnectionStatus.CONNECTED, Processor.Status); }
public void ConnectionStatus(ConnectionMessage msg) { switch(msg){ case ConnectionMessage.connected: EnterGame(); joiningGame = false; break; case ConnectionMessage.connectFailed: joiningGame = false; failedToJoin = true; break; } }
public void RequestImage(User from) { FileStream f = null; Stopwatch stopwatch = null; try { TcpClient client = new TcpClient(from.UserAddress.ToString(), from.TcpPortTo); ConnectionMessage message = new ConnectionMessage(MessageType.ProfileImageRequest, false, null); SendMessage(client, message); message = ReadMessage(client); if (message.MessageType == MessageType.ProfileImageResponse && message.Next == true) { string p = Path.GetTempPath() + "\\LANShare"; string basePath = p; Directory.CreateDirectory(p); string fileName = (from.SessionId as string).Substring(0, 64); p = p + fileName + ".jpg"; if (File.Exists(p)) { string ext = ".jpg"; int fileCount = -1; do { fileCount++; } while (File.Exists(basePath + fileName + "(" + fileCount.ToString() + ")" + ext)); p = basePath + fileName + "(" + fileCount.ToString() + ")" + ext; } f = new FileStream(p, FileMode.Create, FileAccess.Write); stopwatch = new Stopwatch(); stopwatch.Reset(); stopwatch.Restart(); new FileDownloadHelper().ReceiveFile(f, client, stopwatch); f.Close(); stopwatch.Stop(); from.ProfilePicture = new BitmapImage(new Uri(p, UriKind.Relative)); } }catch (SocketException ex) { f?.Close(); stopwatch?.Stop(); } catch (IOException ex) { Debug.WriteLine(ex.Message); f?.Close(); stopwatch?.Stop(); } }
private void InitializeUserData() { var messageData = GetMessage(); var msg = new ConnectionMessage(messageData); if (!VersionVerifier.Verify(msg.Hash)) { Stream.Write(new PostCodeMessage(11).Serialize()); server.RemoveConnection(Id); return; } SendId(); server.BroadcastMessage(msg, Id); }
/// <summary> /// Process a line of json /// </summary> /// <exception cref="JsonException">Thrown if line was invalid json</exception> /// <param name="line"></param> public ResponseMessage ReceiveLine(string line) { //clear last response ResponseMessage message = null; LastResponseTime = DateTime.UtcNow; var time = Stopwatch.StartNew(); string operation = GetOperation(new JsonTextReader(new StringReader(line))); switch (operation) { case RESPONSE_CONNECTION: Trace.TraceInformation("ESA->Client: {0}", line); ConnectionMessage connectionMessage = ReadResponseMessage <ConnectionMessage>(line); message = connectionMessage; ProcessConnectionMessage(connectionMessage); break; case RESPONSE_STATUS: Trace.TraceInformation("ESA->Client: {0}", line); StatusMessage statusMessage = ReadResponseMessage <StatusMessage>(line); message = statusMessage; ProcessStatusMessage(statusMessage); break; case RESPONSE_MARKET_CHANGE_MESSAGE: TraceChange(line); MarketChangeMessage marketChangeMessage = ReadResponseMessage <MarketChangeMessage>(line); message = marketChangeMessage; ProcessMarketChangeMessage(marketChangeMessage); break; case RESPONSE_ORDER_CHANGE_MESSAGE: TraceChange(line); OrderChangeMessage orderChangeMessage = ReadResponseMessage <OrderChangeMessage>(line); message = orderChangeMessage; ProcessOrderChangeMessage(orderChangeMessage); break; default: Trace.TraceError("ESA->Client: Unknown message type: {0}, message:{1}", operation, line); break; } time.Stop(); return(message); }
public Task Send(ConnectionMessage message) { Message busMessage = CreateMessage(message.Signal, message.Value); if (message.ExcludedSignals != null) { busMessage.Filter = String.Join("|", message.ExcludedSignals); } if (busMessage.WaitForAck) { Task ackTask = _ackHandler.CreateAck(busMessage.CommandId); return(_bus.Publish(busMessage).Then(task => task, ackTask)); } return(_bus.Publish(busMessage)); }
public bool StartClient() { Connector.StartClient(receiveThread, listenThread); var joiningMessage = new ConnectionMessage(Connection.Connect, User); SendMessage(joiningMessage); Cmd.WriteLine("Successfully connected to the server"); receiveMessage = true; receiveThread = new Thread(ReceiveMessage); //Starting receive message thread receiveThread.Start(); return(true); }
private void setClient(ConnectionMessage connectionMessage) { print("set client called"); connectButton.enabled = false; connectButton.gameObject.SetActive(false); // usernameText.text = connectionMessage.playerName; //this.CurrentUsername = connectionMessage.username; this.CurrentPlayerName = connectionMessage.playerName; playerNameText.text = connectionMessage.playerName; print(connectionMessage.username + " player " + connectionMessage.playerName); }
public void SendConnection(SwitchConnection conn) { var scr = new ConnectionEnd() { Id = conn.Source.Address, Volumn = (byte)conn.Source.Volumn, Status = conn.Source.IsConnected ? eStatus.On : eStatus.Off }; var dest = new ConnectionEnd() { Id = conn.Dest.Address, Volumn = (byte)conn.Dest.Volumn, Status = conn.Dest.IsConnected ? eStatus.On : eStatus.Off }; var msg = new ConnectionMessage() { Source = scr, Dest = dest }; this.Presentation.SendData(msg); }
static void Incoming() { NetIncomingMessage msg; while ((msg = Server.ReadMessage()) != null) { switch (msg.MessageType) { case NetIncomingMessageType.DiscoveryRequest: Console.WriteLine("Request from "+msg.SenderEndpoint.Address + " - Port " + msg.SenderEndpoint.Port); NetOutgoingMessage reply = Server.CreateMessage(); reply.Write(Version); Server.SendDiscoveryResponse(reply, msg.SenderEndpoint); Console.WriteLine("Sending response to:" + msg.SenderEndpoint.Address + " - Port " + msg.SenderEndpoint.Port); break; case NetIncomingMessageType.StatusChanged: NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte(); Console.WriteLine(msg.SenderEndpoint.Address + " " + status); break; case NetIncomingMessageType.Data: Manager.HandleData(msg); break; case NetIncomingMessageType.UnconnectedData: var datatype = (NetMsgType)msg.ReadByte(); if (datatype == NetMsgType.Login) { var udata = new ConnectionMessage(msg); if (!UserData.UserExists(udata.Username)) { UserData.Add(udata.Username, udata.Password); var outmsg = Server.CreateMessage(); outmsg.Write((byte)ConnectMsgType.NewUserCreated); Server.SendUnconnectedMessage(outmsg, msg.SenderEndpoint); } else { if (UserData.Check(udata.Username, udata.Password)) { var outmsg = Server.CreateMessage(); outmsg.Write((byte)ConnectMsgType.LoginSuccess); Server.SendUnconnectedMessage(outmsg, msg.SenderEndpoint); } else { var outmsg = Server.CreateMessage(); outmsg.Write((byte)ConnectMsgType.WrongPassword); Server.SendUnconnectedMessage(outmsg, msg.SenderEndpoint); } } } break; case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.Error: case NetIncomingMessageType.ErrorMessage: case NetIncomingMessageType.WarningMessage: Console.WriteLine(msg.ReadString()); break; default: Console.WriteLine("Unhandled Message Type: " + msg.MessageType); break; } Server.Recycle(msg); } }
internal static Task Outgoing(IHubOutgoingInvokerContext context) { ConnectionMessage message = context.GetConnectionMessage(); return(context.Connection.Send(message)); }
// this will construct a connection using the given source, // and destination entities, relationship type and value // and send that to the message handler public void SendConnectionMessage() { InputField weightInput = GameObject.FindGameObjectWithTag("Weight").GetComponent<InputField>(); SetActiveCastMember(); // first we build the connection to send by fetching the values we set in the // UI // get the weight and store it as an int string weightString = weightInput.text; int weight = int.Parse(weightString); RelationshipType type = activeRelationshipType; Relationship rel = new Relationship(type, weight); GameObject to = activeCastMember; // our "from" attribute is always the castLead for this demo Connection connection = new Connection(castLead, to, rel); // then we send it ConnectionMessage connMessage = new ConnectionMessage(connection); castLead.GetComponent<Demo3Character>().HandleMessage(connMessage); }
public void TestExtraJsonField() { ConnectionMessage msg = (ConnectionMessage)Processor.ReceiveLine("{\"op\":\"connection\", \"connectionId\":\"aconnid\", \"extraField\":\"extraValue\"}"); Assert.AreEqual("aconnid", msg.ConnectionId); }
public void TestOpNotFirst() { ConnectionMessage msg = (ConnectionMessage)Processor.ReceiveLine("{\"connectionId\":\"aconnid\", \"op\":\"connection\"}"); Assert.AreEqual("aconnid", msg.ConnectionId); }
private void OnConnectionSucess(string message) { ConnectionMessage?.Invoke(this, message); }
public Task Send(ConnectionMessage message) { Message busMessage = CreateMessage(message.Signal, message.Value); if (message.ExcludedSignals != null) { busMessage.Filter = String.Join("|", message.ExcludedSignals); } if (busMessage.WaitForAck) { Task ackTask = _ackHandler.CreateAck(busMessage.CommandId); return _bus.Publish(busMessage).Then(task => task, ackTask); } return _bus.Publish(busMessage); }
public void ConnectionStatus(ConnectionMessage msg) { AddLogEntry("Network update: "+msg); }
public void Process() { try { Stream = client.GetStream(); //Gets stream InitializeUserData(); //Gets userData while (true) { try { var message = GetMessage(); //While stream is available lets read stream if (message.Length > 0) //If message is not empty { var msg = IMessageDeserializable.Parse(message); switch (msg.PostCode) { case { } i when(i >= 1 && i <= 4): { server.Notification(); server.BroadcastMessage(msg, Id); //If this is regular message then broadcast it break; } case 6: //if client updates his UserData { var userDataMessage = msg as UserDataMessage; if (userDataMessage?.Method == Method.Send) { user = new User(userDataMessage?.Sender.UserName, userDataMessage.Sender.Color); //Update UserData on server } break; } case 7: { var idMessage = msg as IDMessage; if (idMessage?.Method == Method.Get) { var sendMessage = new IDMessage(Method.Send, Id); Stream.Write(sendMessage.Serialize()); } break; } case 9: //If user Disconnecting { server.BroadcastMessage(msg, Id); //Broadcast it server.RemoveConnection(Id); //And remove connection break; } default: { continue; } } } } catch { var disconnectionMsg = new ConnectionMessage(Connection.Disconnect, user); //If there is error, disconnect this user server.BroadcastMessage(disconnectionMsg, Id); break; } } } catch (Exception e) { Console.WriteLine(e.Message); } finally { server.RemoveConnection(Id); Close(); } }
private void HandleClient(TcpClient client, CancellationToken ct) { ConnectionMessage message = ReadMessage(client); if (message == null) { return; } switch (message.MessageType) { case MessageType.IpcBaseFolder: List <string> files = new List <string>(); do { files.Add(message.Message as string); message = ReadMessage(client); } while (message.Next); files.Add(message.Message as string); OnSendRequested(files); break; case MessageType.ProfileImageRequest: Stopwatch stopwatch = null; try { FileStream f = File.OpenRead(AppDomain.CurrentDomain.SetupInformation.ApplicationBase + Configuration.UserPicPath); ConnectionMessage response = new ConnectionMessage(MessageType.ProfileImageResponse, true, null); SendMessage(client, response); stopwatch = new Stopwatch(); stopwatch.Reset(); stopwatch.Restart(); new FileUploadHelper().SendFile(f, client, stopwatch); f.Close(); stopwatch.Stop(); } catch (Exception ex) { stopwatch?.Stop(); if (ex is FileNotFoundException || ex is DirectoryNotFoundException) { ConnectionMessage response = new ConnectionMessage(MessageType.ProfileImageResponse, false, null); SendMessage(client, response); } } break; case MessageType.FileUploadRequest: User from = message.Message as User; from.UserAddress = ((IPEndPoint)client.Client.RemoteEndPoint).Address; from.NickName = string.IsNullOrEmpty(from.NickName) || string.IsNullOrWhiteSpace(from.NickName) ? from.Name : from.NickName; string username = from.NickName != null ? from.NickName : from.Name; //TODO Ask user for permission if (Configuration.FileAcceptanceMode.Equals(EFileAcceptanceMode.AskAlways)) { bool rejected = false; OnTransferRequested(from); System.Windows.Application.Current.Dispatcher.Invoke(() => { lock (l) { ConfirmationWindow C = new ConfirmationWindow("Incoming transfer from " + username + ".\nDo you want to accept it ?"); C.ShowDialog(); if (C.DialogResult == false) { message = new ConnectionMessage(MessageType.FileUploadResponse, false, null); SendMessage(client, message); rejected = true; } } }); requestSeen?.Invoke(this, null); if (rejected) { break; } } //TODO Ask user for permission message = new ConnectionMessage(MessageType.FileUploadResponse, true, null); SendMessage(client, message); message = ReadMessage(client); if (message.MessageType != MessageType.TotalUploadSize) { break; } //Ask for path to save files string savePath = null; if (Configuration.FileSavePathMode.Equals(EFileSavePathMode.AskForPath)) { FolderBrowserDialog folderBrowserDialog = new FolderBrowserDialog(); folderBrowserDialog.Description = "Save transmission from " + username; folderBrowserDialog.RootFolder = Environment.SpecialFolder.Personal; DialogResult dialogResult = folderBrowserDialog.ShowDialog(); if (dialogResult != DialogResult.OK) { break; } savePath = folderBrowserDialog.SelectedPath; } else if (Configuration.FileSavePathMode.Equals(EFileSavePathMode.UseCustom)) { savePath = Configuration.CustomSavePath; } else { savePath = Configuration.DefaultSavePath; } FileDownloadHelper helper = new FileDownloadHelper(); helper.Counterpart = from; from.UserAddress = ((IPEndPoint)client.Client.RemoteEndPoint).Address; if (File.Exists(Path.Combine("tmp", from.SessionId + ".jpg"))) { from.ProfilePicture = new BitmapImage(new Uri(Path.Combine("tmp", from.SessionId + ".jpg"), UriKind.Relative)); } else { from.SetupImage(); } helper.Status = TransferCompletitionStatus.Receiving; OnUploadAccepted(helper); helper.HandleFileDownload(client, savePath, (long)message.Message); break; } client.Close(); }
private void RelayConnectionStatus( ConnectionMessage msg) { // foreach( INetworkMessage i in messageRecipients){ // i.ConnectionStatus(msg); // } // for(int i=0; i<messageRecipients.Count;i++){ messageRecipients[i].ConnectionStatus(msg); } }
static void Incoming() { NetIncomingMessage msg; while ((msg = Server.ReadMessage()) != null) { switch (msg.MessageType) { case NetIncomingMessageType.DiscoveryRequest: Console.WriteLine("Request from " + msg.SenderEndpoint.Address + " - Port " + msg.SenderEndpoint.Port); NetOutgoingMessage reply = Server.CreateMessage(); reply.Write(Version); Server.SendDiscoveryResponse(reply, msg.SenderEndpoint); Console.WriteLine("Sending response to:" + msg.SenderEndpoint.Address + " - Port " + msg.SenderEndpoint.Port); break; case NetIncomingMessageType.StatusChanged: NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte(); Console.WriteLine(msg.SenderEndpoint.Address + " " + status); break; case NetIncomingMessageType.Data: Manager.HandleData(msg); break; case NetIncomingMessageType.UnconnectedData: var datatype = (NetMsgType)msg.ReadByte(); if (datatype == NetMsgType.Login) { var udata = new ConnectionMessage(msg); if (!UserData.UserExists(udata.Username)) { UserData.Add(udata.Username, udata.Password); var outmsg = Server.CreateMessage(); outmsg.Write((byte)ConnectMsgType.NewUserCreated); Server.SendUnconnectedMessage(outmsg, msg.SenderEndpoint); } else { if (UserData.Check(udata.Username, udata.Password)) { var outmsg = Server.CreateMessage(); outmsg.Write((byte)ConnectMsgType.LoginSuccess); Server.SendUnconnectedMessage(outmsg, msg.SenderEndpoint); } else { var outmsg = Server.CreateMessage(); outmsg.Write((byte)ConnectMsgType.WrongPassword); Server.SendUnconnectedMessage(outmsg, msg.SenderEndpoint); } } } break; case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.Error: case NetIncomingMessageType.ErrorMessage: case NetIncomingMessageType.WarningMessage: Console.WriteLine(msg.ReadString()); break; default: Console.WriteLine("Unhandled Message Type: " + msg.MessageType); break; } Server.Recycle(msg); } }
public void TestJsonMissingField() { ConnectionMessage msg = (ConnectionMessage)Processor.ReceiveLine("{\"op\":\"connection\"}"); Assert.IsNotNull(msg); }
protected void ProcessConnectionMessage(ConnectionMessage connectionMessage) { _connectionMessage.TrySetResult(connectionMessage); Status = ConnectionStatus.CONNECTED; }
/// <summary> /// Constructs a new object. /// </summary> /// <param name="type"></param> /// <param name="response"></param> public HandshakeResponse(HandshakeType type, ConnectionMessage response) { this.type = type; this.response = response; }
private void setOtherPlayers(ConnectionMessage connectionMessage) { gameObjectShow(avatar); displayMessage(""); }
public Task Send(ConnectionMessage message) { if (!String.IsNullOrEmpty(message.Signal) && message.Signals != null) { throw new InvalidOperationException( String.Format(CultureInfo.CurrentCulture, Resources.Error_AmbiguousMessage, message.Signal, String.Join(", ", message.Signals))); } if (message.Signals != null) { return MultiSend(message.Signals, message.Value, message.ExcludedSignals); } else { Message busMessage = CreateMessage(message.Signal, message.Value); busMessage.Filter = GetFilter(message.ExcludedSignals); if (busMessage.WaitForAck) { Task ackTask = _ackHandler.CreateAck(busMessage.CommandId); return _bus.Publish(busMessage).Then(task => task, ackTask); } return _bus.Publish(busMessage); } }
/// <summary> /// Constructs a new object. /// </summary> /// <param name="response"></param> public LoginResponse(ConnectionMessage response) { this.response = response; }
private void setOtherPlayers(ConnectionMessage connectionMessage) { displayMessage(""); }
protected override async Task ProcessParsedCommand(Message message) { await base.ProcessParsedCommand(message); switch (message.Type) { case PeerCommandType.CONNECTIONS: { var conectionsMessage = (ConnectionMessage)message; OnReceiveNumberOfConnections(conectionsMessage.ConnectionsAmount); break; } case PeerCommandType.DOWNLOAD_FILE_SLICE: { var downloadFileSliceMessage = (DownloadFileSliceMessage)message; OnDownloadFileSlice(downloadFileSliceMessage.File); break; } case PeerCommandType.GET_CONNECTIONS: { var numberOfConnections = await serverInstance.GetNumberOfConnectionsWithoutProcesor(ConnectedPeerInfo.Id); var connectionPeerMessage = new ConnectionMessage(numberOfConnections); Send(connectionPeerMessage); break; } case PeerCommandType.GET_FILE: { var fileMessage = (GetFileMessage)message; var file = await serverInstance.GetAllSlicesOfFile(fileMessage.FileName); var downloadFileMessage = new DownloadFileMessage(file); Send(downloadFileMessage); break; } case PeerCommandType.GET_FILE_SLICE: { var fileMessage = (GetFileSliceMessage)message; var file = await serverInstance.GetSlicesOfFile(fileMessage.FileName, ConnectedPeerInfo.Id); var downloadFileMessage = new DownloadFileSliceMessage(file); Send(downloadFileMessage); break; } case PeerCommandType.GET_KIND: { var kindOfConnectionMessage = new KindOfConnectionMessage(ConnectionType.PEER); Send(kindOfConnectionMessage); break; } case PeerCommandType.GET_LIST: { var files = serverInstance.GetFiles(); var listFilesMessage = new ListFilesMessage(files); Send(listFilesMessage); break; } case PeerCommandType.GET_INFO: { Send(new PeerInfoMessage(serverInstance.Info)); break; } case PeerCommandType.PEER_INFO: { var infoMessage = (PeerInfoMessage)message; OnReceivePeerInfo(infoMessage.Info); break; } case PeerCommandType.UPLOAD_FILE: { var uploadFileMessage = (UploadFileMessage)message; Console.WriteLine($"Receive file to upload => {uploadFileMessage.FileName}, {uploadFileMessage.FileBytes.Length}"); await serverInstance.UploadFile(uploadFileMessage.FileName, uploadFileMessage.FileBytes); break; } case PeerCommandType.UPLOAD_FILE_SLICE: { var fileMessage = (UploadFileSliceMessage)message; var file = fileMessage.File; await serverInstance.SaveAndShare(file, ConnectedPeerInfo.Id); break; } } }