//###########################################################################################
/// <summary>
/// Overrided method that read message as a single byte.
/// </summary>
/// <param name="args"> message informations </param>
protected override void ReadMessage(DatagramSocketMessageReceivedEventArgs args)
{
using (DataReader dataReader = args.GetDataReader())
{
_message = dataReader.ReadByte();
}
}
//async
private async void outSock_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args)
{
DataReader reader = args.GetDataReader();
string message = reader.ReadString(5); // reads first 5 characters
Debug.Log(string.Format("Recieved message: {0}, from: {1} - {2}", message, args.RemoteAddress, args.RemotePort));
}
private async void _socket_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args)
{
_upnpLastMessageReceived = DateTime.Now;
DataReader reader = args.GetDataReader();
uint count = reader.UnconsumedBufferLength;
string data = reader.ReadString(count);
var response = new Dictionary <string, string>();
foreach (string x in data.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None))
{
if (x.Contains(":"))
{
string[] strings = x.Split(':');
response.Add(strings[0].ToLower(), x.Remove(0, strings[0].Length + 1));
}
}
if (response.ContainsKey("location"))
{
Uri myUri = new Uri(response["location"]);
await AddDeviceAsync(myUri, false);
}
}
// Constantly check for new messages on given port.
private async void ReceiveData(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args)
{
//Read the message that was received from the UDP client.
DataReader reader = args.GetDataReader();
string receiveString = reader.ReadString(reader.UnconsumedBufferLength).Trim();
// If string not empty and not read yet - react to it.
if (!string.IsNullOrEmpty(receiveString))
{
#if DEBUG2
DebugUtilities.UniversalDebug(this.sourceName, "Total Data found: " + receiveString, ref this.debugMessages);
#endif
if ((this.dataMessages.Count == 0) ||
(this.flagForce || (this.dataMessages[this.dataMessages.Count - 1] != receiveString)))
{
this.dataMessages.Add(receiveString);
this.connectionHistory.Add(args.RemoteAddress.RawName);
this.flagDataRead = false;
if (OnReceive != null)
{
OnReceive();
}
}
else
{
#if DEBUG2
DebugUtilities.UniversalDebug(this.sourceName, "Message already added.", ref this.debugMessages);
#endif
}
}
}
private void MessageReceived(DatagramSocket socket, DatagramSocketMessageReceivedEventArgs eventArguments)
{
DataReader reader;
try
{
reader = eventArguments.GetDataReader();
}
catch (Exception ex)
{
Debug.WriteLine("MessageReceived:" + ex);
return;
}
uint dataLength = reader.UnconsumedBufferLength;
byte[] data = new byte[dataLength];
reader.ReadBytes(data);
var packet = new NavigationPacket
{
Timestamp = DateTime.UtcNow.Ticks,
Data = data
};
UpdateNavigationData(packet);
_TimeoutStopWatch.Restart();
}
/// <summary>
/// Delegate for when a datagram is received
/// </summary>
private async void LeapDataReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args)
{
try
{
Stream inStream = args.GetDataStream().AsStreamForRead();
StreamReader reader = new StreamReader(inStream);
string data = await reader.ReadLineAsync();
LeapFrameData frameData = JsonUtility.FromJson <LeapFrameData>(data);
// Temp workaround because JsonUtility creates objects even if you have an empty JSON string
if (!data.Contains("left_arm"))
{
frameData.left_arm = null;
}
if (!data.Contains("right_arm"))
{
frameData.right_arm = null;
}
_frameStream.OnNext(frameData);
}
catch (Exception e)
{
Debug.LogErrorFormat("Exception when receiving Leap data: {0}", e.Message);
}
}
async void UDPMulticastMessageReceived(DatagramSocket socket, DatagramSocketMessageReceivedEventArgs eventArguments)
{
try
{
/*
* using (var writer = new DataWriter(await socket.GetOutputStreamAsync(address, port)))
* {
* writer.WriteBytes(info.ToByteArray());
* await writer.StoreAsync();
* await writer.FlushAsync();
* }*/
uint stringLength = eventArguments.GetDataReader().UnconsumedBufferLength;
string message = eventArguments.GetDataReader().ReadString(stringLength);
await ParseMessage(message);
}
catch (Exception exception)
{
SocketErrorStatus socketError = SocketError.GetStatus(exception.HResult);
if (socketError == SocketErrorStatus.ConnectionResetByPeer)
{
}
else if (socketError != SocketErrorStatus.Unknown)
{
}
else
{
throw;
}
}
}
private async void UdpListener_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args)
{
Log(ServerOptions.Verbosity.Verbose, $"SERVER: UDP: Got incoming message");
Stats.IncrementNConnections();
HostName remoteHost;
string remotePort = "not set";
try
{
remoteHost = args.RemoteAddress;
remotePort = args.RemotePort;
var dr = args.GetDataReader();
var os = await sender.GetOutputStreamAsync(remoteHost, remotePort);
var dw = new DataWriter(os);
Task t = DaytimeUdpAsync(dr, dw, remotePort);
await t;
}
catch (Exception)
{
Stats.NExceptions++;
Log(ServerOptions.Verbosity.Verbose, $"SERVER: UDP EXCEPTION when processing message remote {remotePort} ");
}
}
private async void UdpListener_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args)
{
Log(ServerOptions.Verbosity.Verbose, $"SERVER: UDP: Got incoming message");
Interlocked.Increment(ref Stats.NConnections);
HostName remoteHost;
string remotePort = "not set";
try
{
remoteHost = args.RemoteAddress;
remotePort = args.RemotePort;
var dr = args.GetDataReader();
var len = dr.UnconsumedBufferLength;
Stats.NBytesRead += len;
var os = await sender.GetOutputStreamAsync(remoteHost, remotePort);
var dw = new DataWriter(os);
Task t = CharGenUdpAsync(dw, remotePort);
await t;
}
catch (Exception)
{
Log(ServerOptions.Verbosity.Verbose, $"SERVER: UDP EXCEPTION when processing message remote {remotePort} ");
Stats.NExceptions++;
}
}
public async void ClientSocketMessageReceived2(DatagramSocket socket, DatagramSocketMessageReceivedEventArgs eventArguments)
{
IBuffer MyBuffer = eventArguments.GetDataReader().DetachBuffer();
// Convert the received IBuffer into a string.
byte[] MessageArray = MyBuffer.ToArray();
using (MemoryStream ms = new MemoryStream(MessageArray, 0, MessageArray.Length))
{
ms.Write(MessageArray, 0, MessageArray.Length);
//showVideo(ms);
Debug.WriteLine(ms.ToString());
CoreDispatcher c = CoreApplication.MainView.CoreWindow.Dispatcher;
await c.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
scr_bmp = new BitmapImage();
scr_bmp.SetSource(ms);
ScreenStream.Source = scr_bmp;
});
//Deployment.Current.Dispatcher.BeginInvoke(new Action(() => showVideo(ms)));
//Deployment.Current.Dispatcher.BeginInvoke(() => MessageBox.Show(ms.ToString()));
}
}
private async void SocketOnMessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args)
{
var result = args.GetDataStream();
var resultStream = result.AsStreamForRead(1024);
try
{
byte[] buffer = new byte[5];
byte[] message = IPMessage();
await resultStream.ReadAsync(buffer, 0, 5);
for (int i = 0; i <= 5; i++) //compare arrays
{
if (buffer[i] != message[i])
{
if (buffer[0] == 1 && OnClientFound != null)
{
await SendMessage(message,
args.RemoteAddress.ToString(), args.RemotePort);
OnClientFound(buffer.Skip(1).ToArray());
break;
}
}
}
}
catch
{ //TODO: Error handler
}
}
protected void OnMessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args)
{
string remoteAddress = args.RemoteAddress.CanonicalName;
// Reject messages from this computer
if (remoteAddress == information.LocalAddress)
{
return;
}
DataReader reader = args.GetDataReader();
byte[] data = new byte[reader.UnconsumedBufferLength];
reader.ReadBytes(data);
EndpointInformation message = EndpointInformation.Deserialize(data);
if (message != null)
{
// Did message originate from a server?
if (message.Type == EndpointType.Server)
{
ServerDiscovered?.Invoke(this, message);
}
}
}
private void OnMessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args)
{
lock (syncer)
{
DataReader reader = null;
try
{
reader = args.GetDataReader();
uint receivedByteCount = reader.UnconsumedBufferLength;
if (receivedByteCount > 0)
{
var resultBytes = new byte[receivedByteCount];
reader.ReadBytes(resultBytes);
//TODO: check result bytes!
this.Successful = receivedByteCount == PingLength && resultBytes[resultBytes.Length - 1] == PingId;
this.GotResult = true;
}
}
catch
{
// TODO: handle error
}
}
}
//###########################################################################################
/// <summary>
/// Overrided method that read message as a string.
/// </summary>
/// <param name="args"> message informations </param>
protected override void ReadMessage(DatagramSocketMessageReceivedEventArgs args)
{
using (DataReader dataReader = args.GetDataReader())
{
_message = dataReader.ReadString(dataReader.UnconsumedBufferLength).Trim();
}
}
void MessageReceived(DatagramSocket socket, DatagramSocketMessageReceivedEventArgs eventArguments)
{
try
{
eventArguments.GetDataReader().ReadBytes(receiveBytes);
listener.onEvent(ByteArrayToEventData(receiveBytes));
}
catch (Exception exception)
{
SocketErrorStatus socketError = SocketError.GetStatus(exception.HResult);
if (socketError == SocketErrorStatus.ConnectionResetByPeer)
{
// This error would indicate that a previous send operation resulted in an
// ICMP "Port Unreachable" message.
Debug.Log(
"Peer does not listen on the specific port. Please make sure that you run step 1 first " +
"or you have a server properly working on a remote server.");
}
else if (socketError != SocketErrorStatus.Unknown)
{
Debug.Log(
"Error happened when receiving a datagram: " + socketError.ToString()
);
}
else
{
throw;
}
}
}
void OnUDPMessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args)
{
try
{
var reader = args.GetDataReader();
var guid = reader.ReadGuid();
var count = reader.UnconsumedBufferLength;
var data = reader.ReadString(count);
if (guid == AppGUID || !EnforceGUIDMatch)
{
Debug.WriteLine("UDPMessage Recieved: " + data);
if (UDPMessageRecieved != null)
{
var outputArgs = new ReceivedMessageEventArgs(data, new NetworkConnectionEndpoint(args.RemoteAddress, args.RemotePort));
UDPMessageRecieved(this, outputArgs);
}
if (data == ConnectionCloseMessage)
{
ResetUDP();
}
}
}
catch (Exception ex) { Debug.WriteLine(DebugTools.PrintOutException("OnUDPMessageRecieved", ex)); }
}
private void SocketOnMessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args)
{
var dr = args.GetDataReader();
string message = dr.ReadString(dr.UnconsumedBufferLength);
_wsresponses.Add(new WSDiscoveryResponse(message, args.RemoteAddress, args.RemotePort));
}
private async void RecvData(DatagramSocket socket, DatagramSocketMessageReceivedEventArgs args)
{
StreamReader reader = new StreamReader(args.GetDataStream().AsStreamForRead());
string data = reader.ReadToEnd();
NodeBroadcastInfo nodeInfo = ParseData(ref data);
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.High, new DispatchedHandler(() =>
{
nodeBroadcastInfoViewModel.updateNode(nodeInfo);
}));
if (NodeTable.ContainsKey(nodeInfo.Name))
{
MaoNode node = NodeTable[nodeInfo.Name];
if (node.IP != nodeInfo.IP)
{
node.updateIP(nodeInfo.IP);
}
node.seeAgain();
}
else
{
NodeTable.Add(nodeInfo.Name, new MaoNode(nodeInfo.Name, nodeInfo.IP));
}
}
async void OnMessage(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args)
{
using (var stream = args.GetDataStream().AsStreamForRead())
{
await stream.ReadAsync(buffer, 0, MAX_BUFFER_SIZE);
Vector3 cameraPosition = new Vector3(
BitConverter.ToSingle(buffer, 0),
BitConverter.ToSingle(buffer, 4),
BitConverter.ToSingle(buffer, 8));
Quaternion cameraRotation = new Quaternion(
BitConverter.ToSingle(buffer, 12),
BitConverter.ToSingle(buffer, 16),
BitConverter.ToSingle(buffer, 20),
BitConverter.ToSingle(buffer, 24));
string address = args.RemoteAddress.ToString();
object[] values = new object[] { cameraPosition, cameraRotation };
lock (devices.SyncRoot)
{
devices[address] = values;
}
}
}
void MessageReceived(DatagramSocket socket, DatagramSocketMessageReceivedEventArgs eventArguments)
{
try
{
uint stringLength = eventArguments.GetDataReader().UnconsumedBufferLength;
NotifyUserFromAsyncThread(
"Receive data from remote peer: \"" +
eventArguments.GetDataReader().ReadString(stringLength) + "\"",
NotifyType.StatusMessage);
}
catch (Exception exception)
{
SocketErrorStatus socketError = SocketError.GetStatus(exception.HResult);
if (socketError == SocketErrorStatus.ConnectionResetByPeer)
{
// This error would indicate that a previous send operation resulted in an
// ICMP "Port Unreachable" message.
NotifyUserFromAsyncThread(
"Peer does not listen on the specific port. Please make sure that you run step 1 first " +
"or you have a server properly working on a remote server.",
NotifyType.ErrorMessage);
}
else if (socketError != SocketErrorStatus.Unknown)
{
NotifyUserFromAsyncThread(
"Error happened when receiving a datagram: " + socketError.ToString(),
NotifyType.ErrorMessage);
}
else
{
throw;
}
}
}
/// <summary>
/// Echo the message back to the peer
/// </summary>
/// <param name="peer">The remote peer object</param>
/// <param name="eventArguments">The received message event arguments</param>
async void EchoMessage(RemotePeer peer, DatagramSocketMessageReceivedEventArgs eventArguments)
{
if (!peer.IsMatching(eventArguments.RemoteAddress, eventArguments.RemotePort))
{
// In the sample we are communicating with just one peer. To communicate with multiple peers
// application should cache output streams (i.e. by using a hash map), because creating an output
// stream for each received datagram is costly. Keep in mind though, that every cache requires logic
// to remove old or unused elements; otherwise cache turns into a memory leaking structure.
NotifyUserFromAsyncThread(
String.Format(
"Got datagram from {0}:{1}, but already 'connected' to {2}",
eventArguments.RemoteAddress,
eventArguments.RemotePort,
peer),
NotifyType.ErrorMessage);
}
try
{
await peer.OutputStream.WriteAsync(eventArguments.GetDataReader().DetachBuffer());
}
catch (Exception exception)
{
// If this is an unknown status it means that the error is fatal and retry will likely fail.
if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown)
{
throw;
}
NotifyUserFromAsyncThread("Send failed with error: " + exception.Message, NotifyType.ErrorMessage);
}
}
private void UdpSocket_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args)
{
var datareader = args.GetDataReader();
var dataLength = datareader.UnconsumedBufferLength;
var buff = new byte[dataLength];
datareader.ReadBytes(buff);
try
{
waveProvider.AddSamples(buff, 0, (int)dataLength);
player.Init(CreateReader);
player.Play();
var ep = (EndPoint)localEndPoint;
if (!udpConnectionActive)
{
datareader.Dispose();
udpSocket.OutputStream.Dispose();
}
}
catch (Exception)
{
udpConnectionActive = false;
}
}
private void UDPReceived(DatagramSocket socket, DatagramSocketMessageReceivedEventArgs args)
{
DataReader reader = args.GetDataReader();
try
{
uint len = reader.UnconsumedBufferLength;
uint packetLength = 0;
if (len > sizeof(uint))
{
packetLength = (uint)reader.ReadInt32();
if (packetLength == len - sizeof(uint))
{
byte[] data = new byte[packetLength];
reader.ReadBytes(data);
_udpCallback(socket, data);
}
else
{
// packet is corrupted.
}
}
} catch (Exception e)
{
SocketErrorStatus socketError = SocketError.GetStatus(e.HResult);
throw;
}
reader.Dispose();
}
private void OnMessageReceived(
DatagramSocket sender,
DatagramSocketMessageReceivedEventArgs args)
{
try
{
DataReader reader = args.GetDataReader();
reader.InputStreamOptions = InputStreamOptions.Partial;
// LoadAsync not needed. The reader comes already loaded.
// If called by a 'Udp send socket', next line throws an exception because message was not received.
// If remote peer didn't received message, "An existing connection was forcibly
// closed by the remote host. (Exception from HRESULT: 0x80072746)" exception is
// thrown. Maybe only when using ConenctAsync(), not GetOutputStreamAsync().
uint bytesRead = reader.UnconsumedBufferLength;
string message = reader.ReadString(bytesRead);
DisplayOutput(UdpReceiveOutput, "Message received from [" +
args.RemoteAddress.DisplayName + "]:" + args.RemotePort + ": " + message);
}
catch (Exception ex)
{
DisplayOutput(UdpSendOutput, "Peer didn't receive message.");
}
}
private async void Socket_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args)
{
Stream inputStream = args.GetDataStream().AsStreamForRead();
StreamReader streamReader = new StreamReader(inputStream);
string recievedMessage = await streamReader.ReadLineAsync();
print("received: " + recievedMessage);
}
private async void SendResponseAsync(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args)
{
var controllerSettings = _settingsService.GetSettings <ControllerSettings>();
var response = new DiscoveryResponse(controllerSettings.Caption, controllerSettings.Description);
await SendResponseAsync(args.RemoteAddress, response);
}
private void SendResponse(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args)
{
_controller.Logger.Verbose($"Received discovery request from {args.RemoteAddress}.");
var response = new DiscoveryResponse(_controller.Settings.Name.Value, _controller.Settings.Description.Value);
SendResponseAsync(args.RemoteAddress, response).Wait();
}
//这个就能接受消息了，好简单。。。
void MessageReceived(DatagramSocket socket, DatagramSocketMessageReceivedEventArgs eventArguments)
{
var reader = eventArguments.GetDataReader();
reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
String msg = reader.ReadString(reader.UnconsumedBufferLength);
//如果写在gamepage 之后可以调用函数处理操作了。。
}
private async void SocketMessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args)
{
Stream streamIn = args.GetDataStream().AsStreamForRead();
StreamReader reader = new StreamReader(streamIn);
string message = await reader.ReadLineAsync();
ParseMessage(message);
}
private void S_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args)
{
var remotePort = args.RemotePort;
var reader = args.GetDataReader();
byte[] b = new byte[reader.UnconsumedBufferLength];
reader.ReadBytes(b);
tun.PushPacket(b);
}
private void Socket_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args)
{
try
{
var connectionKey = GetConnectionKey(args.RemoteAddress, args.RemotePort);
Connection connection;
bool newConnection = false;
lock (this.connectionCache)
{
if (!this.connectionCache.TryGetValue(connectionKey, out connection))
{
connection = new Connection();
this.connectionCache.Add(connectionKey, connection);
newConnection = true;
}
connection.Touch();
}
var reader = args.GetDataReader();
string received = reader.ReadString(reader.UnconsumedBufferLength);
var msg = DeserializeInternalMessage(received);
var connectMessage = msg as Model.ConnectMessage;
if (connectMessage != null)
{
if (newConnection)
Debug.WriteLine("New connection {0}:{1} from host {2}", args.RemoteAddress, args.RemotePort, connectMessage.HostId);
Debug.WriteLine("Connect from " + connectMessage.HostId);
lock (this.hostIdLookup)
{
this.hostIdLookup[connectMessage.HostId] = connectionKey;
}
connection.HostId = connectMessage.HostId;
// Send alive message
Task.Run(async () => await SendAliveAsync(connectMessage.HostId));
}
var payloadMessage = msg as Model.PayloadMessage;
if (payloadMessage != null)
{
object payloadObject = DeserializePayload(payloadMessage.Payload);
try
{
this.payloadReceivedAction?.Invoke(connection.HostId, payloadObject);
}
catch (Exception ex)
{
Debug.WriteLine("Exception while invoking callback with payload object " + ex.ToString());
}
}
}
catch (Exception exception)
{
SocketErrorStatus socketError = SocketError.GetStatus(exception.HResult);
if (socketError == SocketErrorStatus.ConnectionResetByPeer)
{
// This error would indicate that a previous send operation resulted in an
// ICMP "Port Unreachable" message.
//NotifyUserFromAsyncThread(
// "Peer does not listen on the specific port. Please make sure that you run step 1 first " +
// "or you have a server properly working on a remote server.",
// NotifyType.ErrorMessage);
}
else if (socketError != SocketErrorStatus.Unknown)
{
//NotifyUserFromAsyncThread(
// "Error happened when receiving a datagram: " + socketError.ToString(),
// NotifyType.ErrorMessage);
}
else
{
throw;
}
}
}
private void OnMessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args)
{
var result = args.GetDataStream().ReadAsync(_buffer, _buffer.Capacity, InputStreamOptions.None).AsTask().Result;
int length = (int)result.Length;
if (length <= 0)
return;
if (_bufferEndPoint == null ||
!_bufferEndPoint.HostName.IsEqual(args.RemoteAddress) ||
!_bufferEndPoint.PortStr.Equals(args.RemotePort))
{
_bufferEndPoint = new NetEndPoint(args.RemoteAddress, args.RemotePort);
}
_onMessageReceived(_byteBuffer, length, 0, _bufferEndPoint);
}
