private void OnMessageReceived(object sender, UdpSocketMessageReceivedEventArgs e) { try { switch (Networking.GetServiceType(e.ByteData)) { case ServiceType.ConnectionResponse: this.ProcessConnectResponse(e.ByteData); break; case ServiceType.ConnectionStateResponse: this.ProcessConnectionStateResponse(e.ByteData); break; case ServiceType.TunnelingAck: this.ProcessTunnelingAck(e.ByteData); break; case ServiceType.DisconnectRequest: this.ProcessDisconnectRequest(e.ByteData); break; case ServiceType.TunnelingRequest: this.ProcessDatagramHeaders(e.ByteData); break; } } catch (Exception ex) { if (this.IsDebug) { System.Diagnostics.Debug.WriteLine(ex.Message); } } }
public void OnMessageReceived(object sneder, UdpSocketMessageReceivedEventArgs args) { // get the remote endpoint details and convert the received data into a string var from = String.Format("{0}:{1}", args.RemoteAddress, args.RemotePort); var data = Encoding.UTF8.GetString(args.ByteData, 0, args.ByteData.Length); Console.WriteLine("Received UDP {0} - {1}", from, data); }
//This method runs in a seperate thread. //This is undesirable because windows form elements will complain about shared resources not being avaliable //solution is to use a semaphore that is picked up in the other thread private async void ListenerUDP_MessageReceived(object sender, UdpSocketMessageReceivedEventArgs e) { //wait until previous message has been handled await messageProccessed.WaitAsync(); //update the shared memory curUDPMessage = e; //tell main thread of new message (using signal) messageReceive.Release(); }
private void OnMessageReceived(object sender, UdpSocketMessageReceivedEventArgs e) { var from = String.Format("{0}:{1}", e.RemoteAddress, e.RemotePort); var data = Encoding.UTF8.GetString(e.ByteData, 0, e.ByteData.Length); Messages.Add(new UDPMessage() { Value = data }); Debug.WriteLine("{0} - {1}", @from, data); RaisePropertyChanged(() => Messages); }
private void ReceiverOnMessageReceived(object sender, UdpSocketMessageReceivedEventArgs args) { // get the remote endpoint details and convert the received data into a string string from = $"{args.RemoteAddress}:{args.RemotePort}"; string data = Encoding.UTF8.GetString(args.ByteData, 0, args.ByteData.Length); var content = "roger"; new UdpSocketClient().SendToAsync(Encoding.UTF8.GetBytes(content), args.RemoteAddress, this.responsePort); this.log($"received from {from}; message: '{data}'"); }
private async void ListenUdpLoop() { bool udpListenerActive = true; while (udpListenerActive) { //wait until signal is recieved UdpSocketMessageReceivedEventArgs udpMsg = await MessageReceivedUdp(); IncomingMsg?.Invoke(this, new MsgReceivedEventArgs(udpMsg.RemoteAddress, udpMsg.ByteData, TransportType.UDP)); } }
private void BroadcastReplied(object sender, UdpSocketMessageReceivedEventArgs args) { if (args.RemoteAddress.Equals(address.ToString())) { return; } var ServerResponse = Encoding.UTF8.GetString(args.ByteData, 0, args.ByteData.Length); SharingResult Result; try { Result = JsonConvert.DeserializeObject <SharingResult>(ServerResponse); } catch (Exception ex) { Device.BeginInvokeOnMainThread(() => { SendLog.Text += "Error when deserializing the response.\n"; }); return; } if (Result.Type != ValueType.IPResponse) { return; } IPAddress ip; if (IPAddress.TryParse(Result.Value, out ip)) { if (!discoveredDevices.Any(item => item.Address.ToString().Equals(Result.Value))) { Device.BeginInvokeOnMainThread(() => { SendLog.Text += $"Discovered device \"{Result.Name}\" ({ip.ToString()})\n"; }); discoveredDevices.Add(new DeviceDetails() { Name = Result.Name, Address = ip }); } } else { Device.BeginInvokeOnMainThread(() => { SendLog.Text += $"Could not parse the ip address sent back: {Result.Value}\n"; }); } }
private void OnMessageReceived(object sender, UdpSocketMessageReceivedEventArgs e) { var source = e.RemoteAddress; var messageData = e.ByteData; var response = _serviceDefinition.ResponseFor(messageData); if (response == null) { return; } _backingReceiver.SendToAsync(response, source, _serviceDefinition.ResponsePort); }
protected override void OnMessageReceived(object sender, UdpSocketMessageReceivedEventArgs e) { var payload = _serviceDefinition.BytesToPayload(e.ByteData); // add the remote host data var port = -1; Int32.TryParse(e.RemotePort, out port); payload.RemoteAddress = e.RemoteAddress; payload.RemotePort = port; // pump the discovery response _discoveredServices.OnNext(payload); }
private async void HandleMessageReceived(object sender, UdpSocketMessageReceivedEventArgs args) { var data = args.ByteData; Matrix matrix = new Matrix(); matrix.PostRotate(270); Bitmap image = BitmapFactory.DecodeByteArray(data, 0, data.Length); image = Bitmap.CreateBitmap(image, 0, 0, image.Width, image.Height, matrix, true); ((MainActivity)Context)?.RunOnUiThread(() => { _streamImage?.SetImageBitmap(image); }); }
internal async void RunMessageReceiver(CancellationToken cancellationToken) { while (!cancellationToken.IsCancellationRequested) { var didReceive = false; var msg = new UdpReceiveResult(); try { // attempt to read next datagram msg = await _backingUdpClient .ReceiveAsync() .WrapNativeSocketExceptions(); didReceive = true; } catch { // exception may occur because we stopped listening // (i.e. cancelled the token) - if so exit loop // otherwise throw. if (!cancellationToken.IsCancellationRequested) { throw; } } if (!didReceive) { return; // cancelled, exit loop; } // generate the message received event var remoteAddress = msg.RemoteEndPoint.Address.ToString(); var remotePort = msg.RemoteEndPoint.Port.ToString(); var data = msg.Buffer; var wrapperArgs = new UdpSocketMessageReceivedEventArgs(remoteAddress, remotePort, data); // fire if (MessageReceived != null) { MessageReceived(this, wrapperArgs); } } }
private void UdpSocketMulticastClientOnMessageReceived(object sender, UdpSocketMessageReceivedEventArgs args) { try { var from = String.Format("{0}:{1}", args.RemoteAddress, args.RemotePort); var data = Encoding.UTF8.GetString(args.ByteData, 0, args.ByteData.Length); var guirlande = data.Split(';'); if (guirlande != null) { var entry = guirlande[_position]; EntryGuirlande.BackgroundColor = Color.FromHex(entry); } Debug.WriteLine("{0} - {1}", from, data); } catch (Exception e) { //throw; } }
private void StartSendCredentials(object source, UdpSocketMessageReceivedEventArgs e) { lock (m_lock) { if (pairStarted) { return; } if (e.RemoteAddress == "192.168.0.1" && e.RemotePort == "4000" && Encoding.UTF8.GetString(e.ByteData) == "PAIRING") { Task.Run(async() => { pairStarted = true; int retry = 0; ProgressText = $"Sending information to the device"; OnPropertyChanged("ProgressText"); udpReceiver.MessageReceived -= StartSendCredentials; var msg = $"SSID={HttpUtility.UrlEncode(Encoding.UTF8.GetBytes(SSID))};PASS={HttpUtility.UrlEncode(Encoding.UTF8.GetBytes(Password))};SASKEY={HttpUtility.UrlEncode(Encoding.UTF8.GetBytes(sasKey))};SCOPEID={HttpUtility.UrlEncode(Encoding.UTF8.GetBytes(credentials.IdScope))};DEVICEID={HttpUtility.UrlEncode(Encoding.UTF8.GetBytes(credentials.DeviceId))};AUTH=S"; var msgBytes = Encoding.UTF8.GetBytes(msg); await Task.Delay(2000); try { while (retry < 5) { await udpClient.SendToAsync(msgBytes, address, port); await Task.Delay(2000); retry++; } wifiManager.Connect(currentSSID); ProgressText = "Waiting for the device to connect to network..."; OnPropertyChanged("ProgressText"); await Task.Delay(2000); wifiManager.ReceiveBroadcast(); } catch (SocketException ex) { } }); } } }
internal async void DatagramMessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { var remoteAddress = args.RemoteAddress.CanonicalName; var remotePort = args.RemotePort; byte[] allBytes; var stream = args.GetDataStream().AsStreamForRead(); using (var mem = new MemoryStream()) { await stream.CopyToAsync(mem); allBytes = mem.ToArray(); } var wrapperArgs = new UdpSocketMessageReceivedEventArgs(remoteAddress, remotePort, allBytes); if (MessageReceived != null) { MessageReceived(this, wrapperArgs); } }
private async void ListenUdpLoop() { bool udpListenerActive = true; while (udpListenerActive) { //wait until signal is recieved UdpSocketMessageReceivedEventArgs udpMsg = await MessageReceivedUdp(); if (ca != null) { IncomingMsg?.Invoke(this, new MsgReceivedEventArgs(udpMsg.RemoteAddress, udpMsg.ByteData, TransportType.UDP)); } else //catch (System.MissingMethodException e0) { IncomingMsg2?.Invoke(this, new MsgReceivedEventArgs(udpMsg.RemoteAddress, udpMsg.ByteData, TransportType.UDP)); } //catch (Exception e) //{ // throw e; //} } }
private void OnMessageReceived(object sender, UdpSocketMessageReceivedEventArgs e) { try { KnxDatagram knxDatagram; switch (DatagramProcessing.ProcessDatagram(e.ByteData, ThreeLevelGroupAddressing, IsDebug, out knxDatagram)) { case ResponseType.Event: base.EventReceived(knxDatagram.DestinationAddress, knxDatagram.Data); break; case ResponseType.Status: base.StatusReceived(knxDatagram.DestinationAddress, knxDatagram.Data); break; } } catch (Exception ex) { if (IsDebug) { System.Diagnostics.Debug.WriteLine(ex.Message); } } }
private void BroadcastReceived(object sender, UdpSocketMessageReceivedEventArgs args) { if (isReceiving) { Task.WaitAny(listener.StopListeningAsync()); return; } if (args.RemoteAddress.Equals(address.ToString())) { return; } var ClientRequest = Encoding.UTF8.GetString(args.ByteData, 0, args.ByteData.Length); SharingResult Result; try { Result = JsonConvert.DeserializeObject <SharingResult>(ClientRequest); } catch (Exception ex) { Device.BeginInvokeOnMainThread(() => { ReceiveLog.Text += "Error when deserializing the response.\n"; }); return; } if (Result.Type == ValueType.RequestIP && Result.Value.Equals("GIMMEHYOURADDRESS")) { Device.BeginInvokeOnMainThread(() => { ReceiveLog.Text += $"Received broadcast from {args.RemoteAddress}\n"; }); var Response = JsonConvert.SerializeObject(new SharingResult() { Name = DeviceInfo.Name, Type = ValueType.IPResponse, Value = address.ToString(), IsDiscoverable = isDiscoverable }); var ResponseData = Encoding.UTF8.GetBytes(Response); if (Result.IsDiscoverable) { IPAddress ip; if (IPAddress.TryParse(args.RemoteAddress, out ip)) { if (!discoveredDevices.Any(item => item.Address.ToString().Equals(ip.ToString()))) { Device.BeginInvokeOnMainThread(() => { ReceiveLog.Text += $"Discovered device \"{Result.Name}\" ({ip.ToString()})\n"; }); discoveredDevices.Add(new DeviceDetails() { Name = Result.Name, Address = ip }); } } } Task.WaitAny(listener.SendToAsync(ResponseData, args.RemoteAddress, BROADCAST_PORT)); } }
protected abstract void OnMessageReceived(object sender, UdpSocketMessageReceivedEventArgs e);
private void messageReceived(object sender, UdpSocketMessageReceivedEventArgs e) { MessageReceived?.Invoke(this, new MessageReceivedEventArgs( new IpEndpoint(IpAddress.Parse(e.RemoteAddress), int.Parse(e.RemotePort)), e.ByteData)); }
private void _UdpSocketReceiver_MessageReceived(object sender, UdpSocketMessageReceivedEventArgs e) { _data = Encoding.UTF8.GetString(e.ByteData, 0, e.ByteData.Length); Debug.WriteLine(_data); }
private void BackingReceiverOnMessageReceived(object sender, UdpSocketMessageReceivedEventArgs args) { Log.Info("UDP", $"from {args.RemoteAddress}:{args.RemotePort}; msg: {Encoding.UTF8.GetString(args.ByteData)}"); }
protected override void OnMessageReceived(object sender, UdpSocketMessageReceivedEventArgs e) { _discoveredServices.OnNext(e.ByteData); }