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);
}
