async void ProcessRequestAsync(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
{
using (var socket = args.Socket)
{
string httpResponse;
try
{
using (var input = socket.InputStream)
{
var buffer = new Windows.Storage.Streams.Buffer(10);
var result = await input.ReadAsync(buffer, 10, InputStreamOptions.None);
var tamanho = uint.Parse(Encoding.UTF8.GetString(result.ToArray()));
buffer = new Windows.Storage.Streams.Buffer(tamanho);
result = await input.ReadAsync(buffer, tamanho, InputStreamOptions.None);
var xml = XElement.Load(result.AsStream());
var request = new RestRequest
{
Content = xml.Element("Content"),
Uri = xml.Element("Uri").Value
};
httpResponse = await _requestHandler.HandleRequestAsync(request);
}
}
catch (Exception e)
{
httpResponse = e.Message;
}
await Task.Delay(500);
var bytes = Encoding.UTF8.GetBytes(httpResponse);
httpResponse = $"{bytes.Length.ToString("0000000000")}{httpResponse}";
using (var output = socket.OutputStream)
{
await output.WriteAsync(Encoding.UTF8.GetBytes(httpResponse).AsBuffer());
await output.FlushAsync();
}
}
}
/// <summary>
/// Invoked once a connection is accepted by StreamSocketListener.
/// </summary>
/// <param name="sender">The listener that accepted the connection.</param>
/// <param name="args">Parameters associated with the accepted connection.</param>
private async void Listener_ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
{
StreamSocket socket = args.Socket;
var reader = new DataReader(args.Socket.InputStream);
try
{
while (_cts != null && !_cts.IsCancellationRequested)
{
// Receive data
byte[] data = await ReceiveData(reader);
if (data != null)
{
IBuffer buffer = data.AsBuffer();
//Decrypt message
string text = helper.Decrypt(buffer, _password);
//Invoke event when message is received
Message msg = helper.Deserialize <Message>(text);
if (msg.Token == Convert.ToString(_token))
{
_ServerHeartbeat = DateTime.UtcNow;
}
}
}
}
catch (Exception ex)
{
int errCode = ex.HResult;
switch (errCode)
{
case -2147024873:
// Could not decrypt message, so just ignore it.
break;
default:
throw;
}
}
}
private async void OnConnection(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
{
Writer = null;
ClientSockets.Add(args.Socket);
var reader = new DataReader(args.Socket.InputStream);
try
{
while (Working)
{
var sizeFaildCount = await reader.LoadAsync(sizeof(uint));
var stringLength = reader.ReadUInt32();
var actualStringLength = await reader.LoadAsync(stringLength);
if (sizeFaildCount != sizeof(uint) || actualStringLength != stringLength)
{
reader.DetachStream();
reader.Dispose();
ClientSockets?.Remove(args.Socket);
return;
}
var dataArrary = new byte[actualStringLength];
reader.ReadBytes(dataArrary);
var dataJson = Encoding.UTF8.GetString(dataArrary);
var data = JsonConvert.DeserializeObject <MessageModel>(dataJson);
await SendMsg(data, args.Socket);
MsgReceivedAction?.Invoke(data);
}
}
catch (Exception e)
{
if (SocketError.GetStatus(e.HResult) == SocketErrorStatus.Unknown)
{
}
Debug.WriteLine(string.Format("Received data: \"{0}\"", "Read stream failed with error: " + e.Message));
reader.DetachStream();
reader.Dispose();
ClientSockets?.Remove(args.Socket);
}
}
private async void ListenerOnConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
{
var socket = args.Socket;
var request = await GetRequest(socket);
string requestAsString = request.ToString();
string[] splitRequestAsString = requestAsString.Split('\n');
if (splitRequestAsString.Length != 0)
{
string requestMethod = splitRequestAsString[0];
string[] requestParts = requestMethod.Split(' ');
if (requestParts.Length > 1)
{
var httpVerb = requestParts[0];
await WriteResponse(httpVerb, requestParts[1], socket);
}
}
}
/// <summary>
/// When a connection is made to us, this call back gets called and
/// we send our data.
/// </summary>
/// <param name="sender">The listener that was connected to.</param>
/// <param name="args">some args that we don't use.</param>
private void NetworkListener_ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
{
// If we have data, send it.
if (mostRecentDataBuffer != null)
{
IOutputStream stream = args.Socket.OutputStream;
using (DataWriter writer = new DataWriter(stream))
{
writer.WriteInt32(mostRecentDataBuffer.Length);
writer.WriteBytes(mostRecentDataBuffer);
writer.StoreAsync().AsTask().Wait();
writer.FlushAsync().AsTask().Wait();
}
}
else
{
Debug.LogError("No data to send but we've been connected to. This is unexpected.");
}
}
private async void ProcessRequestAsync(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
{
var socket = args.Socket;
try
{
var request = new StringBuilder();
using (var input = socket.InputStream)
{
var data = new byte[BUFFER_SIZE];
var buffer = data.AsBuffer();
var dataRead = BUFFER_SIZE;
while (dataRead == BUFFER_SIZE)
{
await input.ReadAsync(buffer, BUFFER_SIZE, InputStreamOptions.Partial);
request.Append(Encoding.UTF8.GetString(data, 0, data.Length));
dataRead = buffer.Length;
}
}
using (var output = socket.OutputStream)
{
Debug.WriteLine(request);
if (request.ToString().ToLower().Contains("favicon"))
{
await WriteResponseAsync(socket, "text", 404, "NOT FOUND");
}
else
{
var requestMethod = request.ToString().Split('\n')[0];
var requestParts = requestMethod.Split(' ');
await Process(socket, requestParts[0], requestParts[1]);
}
}
}
catch (Exception ex)
{
LogException("ProcessRequestAsync", ex);
}
}
/// <summary> Clientとの接続が確立したとき呼び出されるイベント </summary>
public void OnConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
{
//接続が確立した後はソケットリスナーは必要ないため閉じる
socketListener.Dispose();
socketListener = null;
try
{
socket = args.Socket;
//接続が確立したことをMainプログラムに通知
mMain.Player_Connect(deviceInfo);
}
catch
{
Disconnect();
Console.WriteLine("【connect】Player" + (deviceId + 1) + "との通信が切断されました");
return;
}
}
private void _OnConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
{
_Provider.StopAdvertising();
Socket = args.Socket;
System.Diagnostics.Debug.WriteLine("OnConnect");
if (Socket != null)
{
SendDataWriter = new DataWriter(Socket.OutputStream);
ConnectionEstablishState = ConnectionEstablishState.Succeeded;
_SendDetectorTimer = new Timer(new TimerCallback(_SendDetectorTimerCallback), null, 0, 500);
OnConnectionEstalblishResult?.Invoke(this, ConnectionEstablishState);
}
else
{
ConnectionEstablishState = ConnectionEstablishState.Failed;
OnConnectionEstalblishResult?.Invoke(this, ConnectionEstablishState);
}
_ReceiveTask = ReceiveAsync();
}
async void OnConnectionReceived(StreamSocketListener listener, StreamSocketListenerConnectionReceivedEventArgs args)
{
_logger.Info("OnConnectionReceived in");
await Task.Run(() =>
{
try
{
BluetoothClientConnected?.Invoke(this, new BluetoothClientConnectedEventArgs(
args.Socket.InputStream.AsStreamForRead(),
args.Socket.OutputStream.AsStreamForWrite()));
}
catch (Exception e)
{
_logger.Error(e);
}
});
_logger.Info("OnConnectionReceived out");
}
private async void OnConnection(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
{
#region "Stream Reader / Writer"
//Read line from the remote client.
Stream inStream = args.Socket.InputStream.AsStreamForRead();
StreamReader reader = new StreamReader(inStream);
string request = await reader.ReadLineAsync();
Core.Communication.TCP_Helper helper = new Core.Communication.TCP_Helper(args.Socket.OutputStream.AsStreamForWrite());
helper.Interpret(request);
////reader.ReadAsync(request);
////Send the line back to the remote client.
//Stream outStream = args.Socket.OutputStream.AsStreamForWrite();
//StreamWriter writer = new StreamWriter(outStream);
//await writer.WriteLineAsync(request);
//await writer.FlushAsync();
#endregion
#region "Data Reader / Writer"
//DataReader reader = new DataReader(args.Socket.InputStream);
//uint sizeFieldCount = await reader.LoadAsync(sizeof(uint));
//if (sizeFieldCount != sizeof(uint))
//{
// return;
//}
//uint stringLength = reader.ReadUInt32();
//uint actualStringLength = await reader.LoadAsync(stringLength);
#endregion
#region "UI Update Code"
await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
// Your UI update code goes here!
//Logs.Add(new Shared.Classes.Log(request)); //StreamReader
//Logs.Add(new Shared.Classes.Log(reader.ReadBytes())); //DataReader
//Logs.Add(new Shared.Classes.Log(reader.ReadString(actualStringLength)));
});
#endregion
}
// コネクションが確立したときのハンドラ
private async void OnConnection(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
{
var reader = new DataReader(args.Socket.InputStream);
try
{
while (true)
{
// 最初の4バイトを読み込む
var sizeFieldCount = await reader.LoadAsync(sizeof(uint));
if (sizeFieldCount != sizeof(uint))
{
return;
}
var stringLength = reader.ReadUInt32();
var actualStringLength = await reader.LoadAsync(stringLength);
if (stringLength != actualStringLength)
{
return;
}
NotifyUserFromAsyncThread(
string.Format("Received data: \"{0}\"", reader.ReadString(actualStringLength)),
NotifyType.StatusMessage);
}
}
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(
"Read stream failed with error: " + exception.Message,
NotifyType.ErrorMessage);
}
}
/// <summary>
/// Invoked once a connection is accepted by StreamSocketListener.
/// </summary>
/// <param name="sender">The listener that accepted the connection.</param>
/// <param name="args">Parameters associated with the accepted connection.</param>
private async void OnConnection(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
{
DataReader reader = new DataReader(args.Socket.InputStream);
try
{
while (true)
{
// Read first 4 bytes (length of the subsequent string).
uint sizeFieldCount = await reader.LoadAsync(sizeof(uint));
if (sizeFieldCount != sizeof(uint))
{
// The underlying socket was closed before we were able to read the whole data.
return;
}
// Read the string.
uint stringLength = reader.ReadUInt32();
uint actualStringLength = await reader.LoadAsync(stringLength);
if (stringLength != actualStringLength)
{
// The underlying socket was closed before we were able to read the whole data.
return;
}
// Display the string on the screen. The event is invoked on a non-UI thread, so we need to marshal the text back to the UI thread.
NotifyUserFromAsyncThread(String.Format("Receive data: \"{0}\"", reader.ReadString(actualStringLength)), NotifyType.StatusMessage);
}
}
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("Read stream failed with error: " + exception.Message, NotifyType.ErrorMessage);
}
}
private async void OnConnection(
StreamSocketListener sender,
StreamSocketListenerConnectionReceivedEventArgs args)
{
DataReader reader = new DataReader(args.Socket.InputStream);
try
{
while (true)
{
// Read length of the subsequent buffer.
uint sizeFieldCount = await reader.LoadAsync(sizeof(uint));
if (sizeFieldCount != sizeof(uint))
{
return;
}
// Read the data
uint bufferLength = reader.ReadUInt32();
uint actualBufferLength = await reader.LoadAsync(bufferLength);
if (bufferLength != actualBufferLength)
{
return;
}
byte[] message = new byte[actualBufferLength];
reader.ReadBytes(message);
NetworkPacket packet = ConstructPacketFromMessage(message);
OnPacketReceived(args.Socket, packet);
}
}
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 new Exception(exception.Message);
}
}
}
/// <summary>
/// Invoked once a connection is accepted by StreamSocketListener.
/// </summary>
/// <param name="sender">The listener that accepted the connection.</param>
/// <param name="args">Parameters associated with the accepted connection.</param>
private static async void OnConnection(
StreamSocketListener sender,
StreamSocketListenerConnectionReceivedEventArgs args)
{
var reader = new DataReader(args.Socket.InputStream);
try
{
while (true)
{
// First int is the DataType enum
_ = await reader.LoadAsync(sizeof(int));
switch ((DataType)reader.ReadInt32())
{
case DataType.Player:
case DataType.PlayerReady:
case DataType.PlayerInstrument:
_ = await ReadPlayerInfoAsync(reader).ConfigureAwait(true);
break;
case DataType.StartTime:
_ = await ReadStartTimeInfoAsync(reader).ConfigureAwait(true);
break;
case DataType.MidiFile:
_ = await ReadMidiFileAsync(reader).ConfigureAwait(true);
break;
}
}
}
catch (Exception exception) when(SocketError.GetStatus(exception.HResult) != SocketErrorStatus.Unknown)
{
}
finally
{
reader.Dispose();
}
}
private async void Listener_ConnectionReceived(StreamSocketListener sender,
StreamSocketListenerConnectionReceivedEventArgs args)
{
StringBuilder strBuidler;
var reader = new DataReader(args.Socket.InputStream);
_writer = new DataWriter(args.Socket.OutputStream);
try
{
while (true)
{
string DataReceived;
strBuidler = new StringBuilder();
reader.InputStreamOptions = InputStreamOptions.Partial;
reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
reader.ByteOrder = ByteOrder.LittleEndian;
await reader.LoadAsync(4096);
while (reader.UnconsumedBufferLength > 0)
{
strBuidler.Append(reader.ReadString(reader.UnconsumedBufferLength));
}
reader.DetachStream();
DataReceived = strBuidler.ToString();
if (OnDataReceived != null)
{
// Dispara o evento de dado recebido...
OnDataReceived(DataReceived);
}
}
}
catch (Exception e)
{
if (OnError != null)
{
OnError(e.Message);
}
}
}
private async void RecieveConnection(StreamSocketListener listener, StreamSocketListenerConnectionReceivedEventArgs args)
{
Console.WriteLine("Connection Received from: " + listener.Information);
try
{
socket = args.Socket;
var device = await BluetoothDevice.FromHostNameAsync(socket.Information.RemoteHostName);
writer = new DataWriter(socket.OutputStream);
var reader = new DataReader(socket.InputStream);
var connectedDevice = new ConnectedDevice(device.Name, device, writer, reader, netctl);
netctl.AddDevice(connectedDevice);
Logging.Log.Trace("Connected to Client: " + device.Name);
}
catch (Exception e)
{
Console.WriteLine("Error while creating socket: " + e.Message);
}
}
private async Task <StringBuilder> ReadRequest(StreamSocketListenerConnectionReceivedEventArgs args)
{
StringBuilder request = new StringBuilder();
using (var input = args.Socket.InputStream)
{
var data = new byte[BUFFER_SIZE];
IBuffer buffer = data.AsBuffer();
var dataRead = BUFFER_SIZE;
while (dataRead == BUFFER_SIZE)
{
await input.ReadAsync(buffer, BUFFER_SIZE, InputStreamOptions.Partial);
request.Append(Encoding.UTF8.GetString(data, 0, data.Length));
dataRead = buffer.Length;
}
}
return(request);
}
public string dealServer(StreamSocketListenerConnectionReceivedEventArgs args)
{
string serverUri = "";
string value = "";
if (ipClientList.TryGetValue(args.Socket.Information.RemoteAddress.ToString(), out value) == true)
{
serverUri = value;
Debug.WriteLine("IP found in hash table.");
}
else
{
serverUri = balanceRequests();
ipClientList.Add(args.Socket.Information.RemoteAddress.ToString(), serverUri);
// Debug.WriteLine("IP not found in hash table.");
}
return(serverUri);
}
private void onConnectionReceived(StreamSocketListener listener, StreamSocketListenerConnectionReceivedEventArgs args)
{
_provider.StopAdvertising();
_socket = args.Socket;
System.Diagnostics.Debug.WriteLine("OnConnect");
//TextBlock_Log.Text = "成功";
if (_socket != null)
{
sendtDataWriter = new DataWriter(_socket.OutputStream);
System.Diagnostics.Debug.WriteLine("SUCCEES on Thread: " + Thread.CurrentThread.ManagedThreadId);
onConnectionEstablished?.Invoke(this);
}
else
{
System.Diagnostics.Debug.WriteLine("F**K NO");
}
_HandlePackMessageBuffer();
receive();
}
/// <summary>
/// When a new message is received, the participant is added to the list of Participants.
/// </summary>
private async void MessageToConnectReceivedFromParticipantAsync(
StreamSocketListener sender,
StreamSocketListenerConnectionReceivedEventArgs args)
{
var participant = new DnssdParticipantInformation {
Host = args.Socket.Information.RemoteAddress
};
// Read the subscriber's message.
using (var reader = new StreamReader(args.Socket.InputStream.AsStreamForRead()))
{
string message = await reader.ReadLineAsync();
if (message != TEST_MESSAGE)
{
// Add the participant.
base.AddParticipant(participant, message);
}
}
}
private async void ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
{
StreamReader reader = new StreamReader(args.Socket.InputStream.AsStreamForRead());
reader.BaseStream.ReadTimeout = 100;
writer.Add(new StreamWriter(args.Socket.OutputStream.AsStreamForWrite()));
while (ListenFlag)
{
try
{
string data = await reader.ReadToEndAsync();
for (int i = 0; i < writer.Count; i++)
{
await writer[i].WriteAsync(data);
await writer[i].FlushAsync();
}
}
catch (Exception) { }
}
}
private async void ListenerConnectionReceived(StreamSocketListener sender,
StreamSocketListenerConnectionReceivedEventArgs args)
{
Debug.Log("Connection received");
try
{
using (var reader = new DataReader(args.Socket.InputStream))
{
reader.InputStreamOptions = InputStreamOptions.Partial;
await reader.LoadAsync(sizeof(uint));
uint dsize = reader.ReadUInt32();
await reader.LoadAsync(dsize);
uint len = dsize / sizeof(uint) / 3;
Vector3[] path = new Vector3[len];
for (int i = 0; i < len; i++)
{
path[i].x = reader.ReadSingle();
path[i].y = reader.ReadSingle();
path[i].z = reader.ReadSingle();
}
queue_.Enqueue(path);
Debug.Log("received: " + dsize + ", " + len);
Debug.Log(path[0].ToString());
}
}
catch (Exception e)
{
Debug.Log("[ERROR] Disconnected" + e);
}
// Debug.Log("Sender disposed");
}
private async void Listener_ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
{
Debug.WriteLine("Got connection");
uint bufferSize = 1024 * 8;
byte[] buffer = new byte[bufferSize];
uint realCount = 0;
using (MemoryStream ms = new MemoryStream())
using (var dr = new DataReader(args.Socket.InputStream))
{
dr.InputStreamOptions = InputStreamOptions.Partial;
while ((realCount = await dr.LoadAsync(bufferSize)) > 0)
{
dr.ReadBytes(buffer);
await ms.WriteAsync(buffer, 0, (int)realCount);
}
var str = System.Text.Encoding.UTF8.GetString(ms.ToArray());
Debug.WriteLine($"data:{str}");
OnReceived.Invoke(System.Text.Encoding.UTF8.GetString(ms.ToArray()));
}
using (var dw = new DataWriter(args.Socket.OutputStream))
{
dw.WriteString(@"HTTP/1.1 200 OK
Cache-Control: private
Connection: Keep-Alive
Content-Length: 0
Content-Type: text/html; charset=UTF-8
Server: kumblr
");
await dw.StoreAsync();
dw.DetachStream();
}
}
private async void listener_ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
{
await Task.Factory.StartNew
(() =>
{
try
{
// create network channel to accept connection request
IMqttNetworkChannel channel = new MqttNetworkChannel(args.Socket);
channel.Accept();
// handling channel for connected client
MqttClient client = new MqttClient(channel);
// raise client raw connection event
this.OnClientConnected(client);
}
catch (Exception)
{
// TODO : check errors/exceptions on accepting connection
}
});
}
private void ListenerOnConnectionReceived(StreamSocketListener sender,
StreamSocketListenerConnectionReceivedEventArgs args)
{
try
{
if (args.Socket == null)
{
return;
}
var peerSocket = args.Socket;
var uri = new Uri("tcp://" + peerSocket.Information.RemoteHostName.RawName + ':' +
peerSocket.Information.RemoteServiceName);
var peer = new Peer("", uri, EncryptionTypes.All);
IConnection connection = new TCPConnection(peerSocket, true);
RaiseConnectionReceived(peer, connection, null);
}
catch
{
}
}
private async void OnConnection(
StreamSocketListener sender,
StreamSocketListenerConnectionReceivedEventArgs args)
{
DataReader reader = new DataReader(args.Socket.InputStream);
try
{
while (true)
{
// Read first 4 bytes (length of the subsequent string).
uint sizeFieldCount = await reader.LoadAsync(sizeof(uint));
if (sizeFieldCount != sizeof(uint))
{
return;
}
// Read the string.
uint stringLength = reader.ReadUInt32();
uint actualStringLength = await reader.LoadAsync(stringLength);
if (stringLength != actualStringLength)
{
return;
}
rootPage.NotifyUserFromAsyncThread("Received message: " + reader.ReadString(actualStringLength));
}
}
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;
}
}
}
private static async void OnConnection(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
{
_streamSocket = args.Socket;
_host = _streamSocket.Information.RemoteAddress.ToString();
ConnectionStatus = ConnectionStatus.Connected;
DataReader reader = new DataReader(_streamSocket.InputStream);
reader.InputStreamOptions = InputStreamOptions.Partial;
_writer = new DataWriter(_streamSocket.OutputStream);
try
{
while (true)
{
//uint sizeFieldCount = await reader.LoadAsync(sizeof(uint));
//if (sizeFieldCount != sizeof(uint))
//{
// return;
//}
//uint stringLength = 3; // reader.ReadUInt32();
//uint actualStringLength = await reader.LoadAsync(3);
//if (stringLength != actualStringLength)
//{
// return;
//}
await reader.LoadAsync(20);
Message = reader.ReadString(reader.UnconsumedBufferLength);
}
}
catch (Exception e)
{
ConnectionStatus = ConnectionStatus.Failed;
//TODO:send a connection status message with error, then try to reconnect
}
}
private async Task <Request> ParseRequest(StreamSocketListenerConnectionReceivedEventArgs args)
{
var request = new StringBuilder();
using (var input = args.Socket.InputStream)
{
var data = new byte[BufferSize];
IBuffer buffer = data.AsBuffer();
var dataRead = BufferSize;
while (dataRead == BufferSize)
{
await input.ReadAsync(
buffer, BufferSize, InputStreamOptions.Partial);
request.Append(Encoding.UTF8.GetString(
data, 0, data.Length));
dataRead = buffer.Length;
}
}
return(new Request(request.ToString()));
}
private async void ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
{
// sự kiện được kích hoạt trên một threat khác, không có quyền truy cập trực tiếp đến biến cục bộ của thread hiện tại.
// nên thay vì gán như thông thường ta cần dùng dispatcher để gán bằng thread
//this.textDebug.Text += "Server Received\n"; // => crash
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal,
async() =>
{
textDebug.Text += "Server received message from: " + args.Socket.Information.RemoteAddress + "\n";
if (_streamsocket == null)
{
_streamsocket = new StreamSocket();
await _streamsocket.ConnectAsync(args.Socket.Information.RemoteAddress, _port.ToString());
}
var msg = await this.readMessage(args.Socket.InputStream);
this.textDebug.Text += "Receive from " + args.Socket.Information.RemoteAddress + ": " + msg + "\n";
}
);
}
private void OnSocketConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
{
Windows.Foundation.IAsyncAction task = Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
//rootPage.NotifyUser("Connecting to remote side on L4 layer...", NotifyType.StatusMessage);
StreamSocket serverSocket = args.Socket;
SocketReaderWriter socketRW = new SocketReaderWriter(serverSocket, this);
// The first message sent is the name of the connection.
string message = await socketRW.ReadMessageAsync();
// Find the pending connection and add it to the list of active connections.
if (_pendingConnections.TryRemove(sender, out WiFiDirectDevice wfdDevice))
{
ConnectedDevices.Add(new ConnectedDevice(message, wfdDevice, socketRW));
}
while (message != null)
{
message = await socketRW.ReadMessageAsync();
}
});
