private async Task <Result> Write(byte[] data, Result resultInput)
{
Result result = resultInput;
DataWriter writer;
using (writer = new DataWriter(_socket.OutputStream))
{
// Set the Unicode character encoding for the output stream
writer.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
// Specify the byte order of a stream.
writer.ByteOrder = ByteOrder.LittleEndian;
// Gets the size of UTF-8 string.
writer.MeasureString(Encoding.UTF8.GetString(data));
// Write a string value to the output stream.
writer.WriteBytes(data);
// Send the contents of the writer to the backing stream.
try
{
await writer.StoreAsync();
await writer.FlushAsync();
}
catch (Exception ex)
{
SocketErrorStatus webErrorStatus = Windows.Networking.Sockets.SocketError.GetStatus(ex.GetBaseException().HResult);
result.ErrorMessage = (webErrorStatus.ToString() != "Unknown" ? webErrorStatus.ToString() : ex.Message);
return(result);
}
// In order to prolong the lifetime of the stream, detach it from the DataWriter
writer.DetachStream();
}
return(result);
}
public async void SendMessage(string message)
{
try
{
using (DatagramSocket dataGramSocket = new DatagramSocket())
{
using (Stream outputStream =
(await dataGramSocket.GetOutputStreamAsync(RemoteHostName, _remotePortNumber))
.AsStreamForWrite())
{
using (StreamWriter streamWriter = new StreamWriter(outputStream))
{
await streamWriter.WriteLineAsync(message);
await streamWriter.FlushAsync();
}
}
}
Debug.WriteLine($"Message sent: \"{message}\"");
}
catch (Exception ex)
{
SocketErrorStatus webErrorStatus = SocketError.GetStatus(ex.GetBaseException().HResult);
Debug.WriteLine(webErrorStatus.ToString() != "Unknown" ? webErrorStatus.ToString() : ex.Message);
}
}
private async Task <string> StartServerTask(string serverSocketKey, string iface, int port)
{
PluginResult result = new PluginResult();
try
{
ISocketServerAdapter socketServerAdapter = new SocketServerAdapter(socketStorage, dataConsumeDelegate, closeEventDelegate, errorDelegate);
socketServerAdapter.StoppedEventHandler = async(hasError) => await StoppedEventHandler(serverSocketKey, hasError);
socketServerAdapter.OpenedEventHandler = async(socketKey) => await OpenedEventHandler(serverSocketKey, socketKey);
socketStorage.AddServerSocket(serverSocketKey, socketServerAdapter);
socketServerAdapter.Start(iface, port);
result.Result = PluginResult.Status.OK;
}
catch (Exception ex)
{
SocketErrorStatus webErrorStatus = Windows.Networking.Sockets.SocketError.GetStatus(ex.GetBaseException().HResult);
var message = webErrorStatus.ToString() != "Unknown" ? webErrorStatus.ToString() : ex.Message;
result.Result = PluginResult.Status.IO_EXCEPTION;
result.Message = message;
}
JsonObject jsonObject = new JsonObject();
jsonObject.SetNamedValue("Result", JsonValue.CreateNumberValue((int)result.Result));
if (result.Message != null)
{
jsonObject.SetNamedValue("Message", JsonValue.CreateStringValue(result.Message));
}
return(jsonObject.ToString());
}
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;
}
}
}
////////////////////////////////////////////////////////////////////////
// Establish Connection
public async void Connect()
{
// Reset.
Disconnect();
this.client = new StreamSocket();
this.connectionCancellationTokenSource = new CancellationTokenSource();
this.sendCancellationTokenSource = new CancellationTokenSource();
this.flagConnected = false;
try {
this.connectionCancellationTokenSource.CancelAfter(this.timeout);
await this.client.ConnectAsync(new HostName(this.remoteIP), this.remotePort.ToString())
.AsTask(this.connectionCancellationTokenSource.Token);
StartSending();
this.flagConnected = true;
// Acknowledge.
#if DEBUG
DebugUtilities.UniversalDebug(this.sourceName, "Connection Stablished!", ref this.debugMessages);
#endif
// return true;
} catch (TaskCanceledException) {
#if DEBUGWARNING
DebugUtilities.UniversalWarning(this.sourceName, "Failed to connect", ref this.debugMessages);
#endif
} catch (Exception exception) {
SocketErrorStatus webErrorStatus = SocketError.GetStatus(exception.GetBaseException().HResult);
string errorMessage = (webErrorStatus.ToString() != "Unknown") ? webErrorStatus.ToString() : exception.Message;
#if DEBUGWARNING
DebugUtilities.UniversalWarning(this.sourceName, "UnhandledException: " + errorMessage, ref this.debugMessages);
#endif
// return false;
}
}
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;
}
}
}
private async void StartServer()
{
try
{
_streamSocketListener = new StreamSocketListener();
// The ConnectionReceived event is raised when connections are received.
_streamSocketListener.ConnectionReceived += StreamSocketListener_ConnectionReceived;
// Start listening for incoming TCP connections on the specified port. You can specify any port that's not currently in use.
await _streamSocketListener.BindServiceNameAsync(PortNumber);
Debug.WriteLine("server is listening...", "TcpSocketServer");
}
catch (Exception ex)
{
SocketErrorStatus webErrorStatus = SocketError.GetStatus(ex.GetBaseException().HResult);
string errorMessage = webErrorStatus.ToString() != "Unknown" ? webErrorStatus.ToString() : ex.Message;
Debug.WriteLine(errorMessage);
Error.Message = errorMessage;
Error.DetailedMessage = ex.ToString();
Error.Unacknowledged = true;
ListenForConnections = false;
}
}
private async Task <Tuple <Result, byte[]> > Read(Result resultInput)
{
Result result = resultInput;
DataReader reader;
StringBuilder strBuilder;
using (reader = new DataReader(_socket.InputStream))
{
strBuilder = new StringBuilder();
// Set the DataReader to only wait for available data (so that we don't have to know the data size)
reader.InputStreamOptions = InputStreamOptions.Partial;
// The encoding and byte order need to match the settings of the writer we previously used.
reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
reader.ByteOrder = ByteOrder.LittleEndian;
// Send the contents of the writer to the backing stream.
// Get the size of the buffer that has not been read.
try
{
do
{
await reader.LoadAsync(_readBuffer);
strBuilder.Append(reader.ReadString(reader.UnconsumedBufferLength));
// Keep reading until we consume the complete stream.
}while (reader.UnconsumedBufferLength > 0);
}
catch (Exception ex)
{
SocketErrorStatus webErrorStatus = SocketError.GetStatus(ex.GetBaseException().HResult);
result.ErrorMessage = (webErrorStatus.ToString() != "Unknown" ? webErrorStatus.ToString() : ex.Message);
var RSP_packet2 = new byte[strBuilder.ToString().Length];
return(new Tuple <Result, byte[]>(result, RSP_packet2));
}
finally
{
reader.DetachStream();
}
}
var RSP_packet = new byte[strBuilder.ToString().Length];
RSP_packet = Encoding.UTF8.GetBytes(strBuilder.ToString());
return(new Tuple <Result, byte[]>(result, RSP_packet));
}
/// <summary>
/// 建立连接
/// </summary>
/// <returns>成功/失败</returns>
public async Task <bool> BuiildConnectionAsync()
{
bool result = false;
List <string> error = new List <string>();
for (int i = 0; i < ip_address.Count; i++)
{
try
{
await this.socket.ConnectAsync(new HostName(ip_address[i]), port[i]);
result = true;
break;
}
catch (Exception ex)
{
SocketErrorStatus errorStatus = Windows.Networking.Sockets.SocketError.GetStatus(ex.GetBaseException().HResult);
error.Add(errorStatus.ToString() != "Unknown" ? errorStatus.ToString() : ex.Message);
continue;
}
}
if (result == false)
{
ContentDialog connectFailedDialog = new ContentDialog
{
Title = "ConnectionFailed",
Content = "",
CloseButtonText = "Ok"
};
for (int i = 0; i < error.Count; i++)
{
connectFailedDialog.Content += ("Time " + i.ToString() + ": " + error[i] + ".\n");
}
connectFailedDialog.Content += "\n Please check your connection status and try again later.";
await connectFailedDialog.ShowAsync();
}
ifConnected = result;
return(result);
}
private async void StartServer()
{
try
{
DatagramSocket dataGramSocket = new DatagramSocket();
dataGramSocket.MessageReceived += DataGramSocket_MessageReceived;
Debug.WriteLine("Server is about to bind...");
await dataGramSocket.BindServiceNameAsync(_listeningPortNumber);
Debug.WriteLine($"Server is bound to {_listeningPortNumber}");
}
catch (Exception ex)
{
SocketErrorStatus webErrorStatus = SocketError.GetStatus(ex.GetBaseException().HResult);
Debug.WriteLine(webErrorStatus.ToString() != "Unknown" ? webErrorStatus.ToString() : ex.Message);
}
}
public async Task <Result> Connect(string Port, string IP)
{
Result result = new Result();
_socket = new StreamSocket();
GC.Collect(); // Clean garbage collection
try
{
await _socket.ConnectAsync(new HostName(IP), Port);
result.Succeeded = true;
return(result);
}
catch (Exception ex)
{
SocketErrorStatus webErrorStatus = SocketError.GetStatus(ex.GetBaseException().HResult);
result.ErrorMessage = (webErrorStatus.ToString() != "Unknown" ? webErrorStatus.ToString() : ex.Message);
return(result);
}
}
public async void StartClient()
{
if (!running)
{
try
{
//Create the DatagramSocket and establish a connection to the server.
socket = new DatagramSocket();
//Set Low Latency mode for the socket
socket.Control.QualityOfService = SocketQualityOfService.LowLatency;
//Set don't fragment
socket.Control.DontFragment = true;
//The ConnectionReceived event is raised when connections are received.
socket.MessageReceived += MessageReceived;
// The server hostname that we will be establishing a connection to.
hostName = new HostName(IP);
Debug.WriteLine("Client is about to bind...");
await socket.BindServiceNameAsync(Port);
Debug.WriteLine("Client is bound to port number " + Port);
try
{
Stream output = (await socket.GetOutputStreamAsync(hostName, Port)).AsStreamForWrite();
writer = new BinaryWriter(output);
new Connecting().WriteData(writer);
//await writer.FlushAsync();
writer.Flush();
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
}
running = true;
}
catch (Exception e)
{
SocketErrorStatus status = SocketError.GetStatus(e.GetBaseException().HResult);
Debug.WriteLine(status.ToString() + " : " + e.Message);
}
}
else
{
throw new ArgumentException("Client already running!");
}
}
//--------------------------------------------------------Set-, Get- Methods:---------------------------------------------------------\\
#region --Set-, Get- Methods--
#endregion
//--------------------------------------------------------Misc Methods:---------------------------------------------------------------\\
#region --Misc Methods (Public)--
public override string ToString()
{
StringBuilder sb = new StringBuilder("[ConnectionError] ");
sb.Append("SOCKET_ERROR: ");
sb.Append(SOCKET_ERROR.ToString());
sb.Append(", ERROR_CODE: ");
sb.Append(ERROR_CODE.ToString());
sb.Append(", ERROR_MESSAGE: ");
sb.Append(ERROR_MESSAGE ?? "NULL");
return(sb.ToString());
}
public async void StartServer()
{
try
{
streamSocketListener = new StreamSocketListener();
// The ConnectionReceived event is raised when connections are received.
streamSocketListener.ConnectionReceived += StreamSocketListener_ConnectionReceived;
// Start listening for incoming TCP connections on the specified port. You can specify any port that's not currently in use.
await streamSocketListener.BindServiceNameAsync(PortNumber);
serverIsRunning = true;
ServerItems.Add(string.Format("server is listening on port {0} ...", PortNumber));
}
catch (Exception ex)
{
SocketErrorStatus webErrorStatus = SocketError.GetStatus(ex.GetBaseException().HResult);
ServerItems.Add(webErrorStatus.ToString() != "Unknown" ? webErrorStatus.ToString() : ex.Message);
}
}
private async void StreamSocketListener_ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
{
bool clientconnected = true;
await CoreApplication.MainView.CoreWindow.
Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() => ServerItems.Add(string.Format("client connected from {0}:{1} ...",
args.Socket.Information.RemoteAddress, args.Socket.Information.RemotePort)));
while (clientconnected)
{
try
{
string request;
if (streamReader == null)
{
streamReader = new StreamReader(args.Socket.InputStream.AsStreamForRead());
}
request = await streamReader.ReadLineAsync();
await CoreApplication.MainView.CoreWindow.
Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() => ServerItems.Add(string.Format("server received the request: \"{0}\"", request)));
// Echo the request back as the response.
if (streamWriter == null)
{
Stream ServeroutputStream = args.Socket.OutputStream.AsStreamForWrite();
streamWriter = new StreamWriter(ServeroutputStream);
}
await streamWriter.WriteLineAsync(request);
await streamWriter.FlushAsync();
await CoreApplication.MainView.CoreWindow.Dispatcher.
RunAsync(CoreDispatcherPriority.Normal,
() => ServerItems.Add(string.Format("server sent back the response: \"{0}\"", request)));
}
catch (Exception ex)
{
clientconnected = false;
CloseServerConnection();
SocketErrorStatus webErrorStatus = SocketError.GetStatus(ex.GetBaseException().HResult);
await CoreApplication.MainView.CoreWindow.Dispatcher.
RunAsync(CoreDispatcherPriority.Normal,
() => ServerItems.Add(webErrorStatus.ToString() != "Unknown" ? webErrorStatus.ToString() : ex.Message));
}
}
}
public async void StartClient()
{
try
{
// Create the StreamSocket and establish a connection to the echo server.
streamSocket = new StreamSocket();
// The server hostname that we will be establishing a connection to. In this example, the server and client are in the same process.
var hostName = new Windows.Networking.HostName(ServerAddress);
ClientItems.Add(string.Format("client is trying to connect to {0}:{1} ...", ServerAddress, ServerPort));
await streamSocket.ConnectAsync(hostName, ServerPort);
clientIsConnected = true;
ClientItems.Add("client connected");
}
catch (Exception ex)
{
SocketErrorStatus webErrorStatus = SocketError.GetStatus(ex.GetBaseException().HResult);
ClientItems.Add(webErrorStatus.ToString() != "Unknown" ? webErrorStatus.ToString() : ex.Message);
}
}
public async void SendClientMessage()
{
try {
// Send a request to the echo server.
//string request = "Hello, World!";
if (outputStream == null)
{
outputStream = streamSocket.OutputStream.AsStreamForWrite();
}
var streamWriter = new StreamWriter(outputStream);
await streamWriter.WriteLineAsync(ClientMessage);
await streamWriter.FlushAsync();
ClientItems.Add(string.Format("client sent the request: \"{0}\"", ClientMessage));
// Read data from the echo server.
string response;
if (inputStream == null)
{
inputStream = streamSocket.InputStream.AsStreamForRead();
}
StreamReader streamReader = new StreamReader(inputStream);
response = await streamReader.ReadLineAsync();
ClientItems.Add(string.Format("client received the response: \"{0}\" ", response));
}
catch (Exception ex)
{
SocketErrorStatus webErrorStatus = SocketError.GetStatus(ex.GetBaseException().HResult);
ClientItems.Add(webErrorStatus.ToString() != "Unknown" ? webErrorStatus.ToString() : ex.Message);
CloseClient();
}
}
private async void StartServer()
{
try
{
var streamSocketListener = new StreamSocketListener();
//接收到连接时将引发ConnectionReceived事件。
streamSocketListener.ConnectionReceived += this.StreamSocketListener_ConnectionReceived;
////开始监听指定端口上传入的TCP连接。您可以指定当前未使用的任何端口。
await streamSocketListener.BindServiceNameAsync(StreamSocketAndListenerPage.PortNumber);
this.serverListBox.Items.Add("server is listening...");
}
catch (Exception ex)
{
SocketErrorStatus webErrorStatus = SocketError.GetStatus(ex.GetBaseException().HResult);
this.serverListBox.Items.Add(webErrorStatus.ToString() != "Unknown" ? webErrorStatus.ToString() : ex.Message);
}
}
// Constantly check for new messages on given port.
private async void ReceiveConnection()
{
try {
// Open.
this.listener = new StreamSocketListener();
this.listener.ConnectionReceived += OnClientFound;
await this.listener.BindServiceNameAsync(this.localPort.ToString());
#if DEBUG
DebugUtilities.UniversalDebug(this.sourceName, "Started Listening for Incoming Connections.", ref this.debugMessages);
#endif
} catch (Exception exception) {
// Exception.
SocketErrorStatus webErrorStatus = SocketError.GetStatus(exception.GetBaseException().HResult);
string webError = (webErrorStatus.ToString() != "Unknown") ? webErrorStatus.ToString() :
exception.Message;
#if DEBUGWARNING
DebugUtilities.UniversalWarning(this.sourceName, "Exception: " + webError, ref this.debugMessages);
#endif
}
}
private async void StartServer()
{
try
{
//instantitate a listener
var streamSocketListener = new StreamSocketListener();
//挂接事件处理器。
//每次连接后，就会调用事件处理器，接受请求，回复请求。不知道是不是每次发送都需要来回收发，最好的状态是建立一次连接，然后随便发送最好。
// The ConnectionReceived event is raised when connections are received.
streamSocketListener.ConnectionReceived += this.StreamSocketListener_ConnectionReceived;
//开始监听。
// Start listening for incoming TCP connections on the specified port. You can specify any port that's not currently in use.
await streamSocketListener.BindServiceNameAsync("8080");
}
catch (Exception ex)
{
SocketErrorStatus webErrorStatus = SocketError.GetStatus(ex.GetBaseException().HResult);
this.serverListBox.Items.Add(webErrorStatus.ToString() != "Unknown" ? webErrorStatus.ToString() : ex.Message);
}
}
public async void StartServer()
{
if (!running)
{
try
{
socket = new DatagramSocket();
//Set Low Latency mode for the socket
socket.Control.QualityOfService = SocketQualityOfService.LowLatency;
//Set don't fragment
socket.Control.DontFragment = true;
//The ConnectionReceived event is raised when connections are received.
socket.MessageReceived += MessageReceived;
Debug.WriteLine("Server is about to bind...");
//Start listening for incoming UDP connections on the specified port. You can specify any port that's not currently in use.
await socket.BindServiceNameAsync(Port);
Debug.WriteLine("Server is bound to port number " + Port);
running = true;
}
catch (Exception e)
{
SocketErrorStatus status = SocketError.GetStatus(e.GetBaseException().HResult);
Debug.WriteLine(status.ToString() + " : " + e.Message);
}
}
else
{
throw new ArgumentException("Server already running!");
}
}
// ugly but somewhat functional
private async Task allowRemoteControl()
{
TaskCompletionSource <bool> canStopListening = new TaskCompletionSource <bool>();
try {
var streamSocketListener = new StreamSocketListener();
streamSocketListener.ConnectionReceived += async
(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args) => {
Debug.WriteLine("TCP: connection received");
string request;
using (var streamReader = new StreamReader(args.Socket.InputStream.AsStreamForRead())) {
while (true)
{
request = await streamReader.ReadLineAsync();
Debug.WriteLine("TCP <- " + request);
if (request.StartsWith("close"))
{
canStopListening.SetResult(true);
args.Socket.Dispose();
}
if (request.StartsWith("serial"))
{
string sFromUART = await m_rOvenManager.readFromUART();
Debug.WriteLine("UART <- " + sFromUART);
}
else if (request.StartsWith("konami"))
{
await sendInputSequence(KONAMI_CODE);;
}
else if (request.StartsWith("JP"))
{
await sendInputSequence(INGR_1);
}
else if (request.StartsWith("PP"))
{
await sendInputSequence(INGR_2);
}
else if (request.StartsWith("MR"))
{
await sendInputSequence(INGR_3);
}
else if (request.StartsWith("SA"))
{
await sendInputSequence(INGR_4);
}
else // key press/release - request is one of [U|D|L|R][0|1]
{
OvenManager.eBtn btn = s_rLetterToBtnMapping[request[0]];
OvenManager.eBtnState btnState = request[1] == '0' ?
OvenManager.eBtnState.PRESSED : OvenManager.eBtnState.UNPRESSED;
m_rOvenManager.setBtn(btn, btnState);
}
}
}
};
await streamSocketListener.BindServiceNameAsync("12345");
Debug.WriteLine("TCP: waiting for connections");
await canStopListening.Task;
Debug.WriteLine("TCP: closing");
streamSocketListener.Dispose();
} catch (Exception ex) {
SocketErrorStatus webErrorStatus = SocketError.GetStatus(ex.GetBaseException().HResult);
Debug.WriteLine(webErrorStatus.ToString() != "Unknown" ? webErrorStatus.ToString() : ex.Message);
}
}
public async Task <Result> ReadVariable(string pVarName)
{
Result result = new Result();
// Read Variable request packet structure example:
// 0 1 2 3 4 5 6
// xx xx | 00 0A | 00 | 00 07 | 24 4F 56 5F 50 52 4F
// | 10 | 0 | 7 | $ O V _ P R O
// REQ ID | REQ LEN | READ=00 | VAR NAME LEN | VAR NAME CHARS
// (RANDOM)|
if (pVarName.Length == 0)
{
result.ErrorMessage = "No variable was written";
return(result);
}
var PKT_var_name = new byte[pVarName.Length];
PKT_var_name = Encoding.UTF8.GetBytes(pVarName);
var PKT_name_length = new byte[2];
PKT_name_length[0] = (byte)((pVarName.Length >> 8) & 255);
PKT_name_length[1] = (byte)(pVarName.Length & 255);
byte PKT_mode_is_read = 0;
var PKT_req_len = new byte[2];
PKT_req_len[0] = (byte)(((pVarName.Length + 3) >> 8) & 255);
PKT_req_len[1] = (byte)((pVarName.Length + 3) & 255);
var PKT_req_id = new byte[2];
PKT_req_id[0] = (byte)((_msgID >> 8) & 255);
PKT_req_id[1] = (byte)(_msgID & 255);
_msgID++;
if (_msgID > _lastID)
{
_msgID = _firstID;
}
var REQ_packet = new byte[pVarName.Length + 7 + 1];
REQ_packet[0] = PKT_req_id[0];
REQ_packet[1] = PKT_req_id[1];
REQ_packet[2] = PKT_req_len[0];
REQ_packet[3] = PKT_req_len[1];
REQ_packet[4] = PKT_mode_is_read;
REQ_packet[5] = PKT_name_length[0];
REQ_packet[6] = PKT_name_length[1];
PKT_var_name.CopyTo(REQ_packet, 7);
DataWriter writer;
using (writer = new DataWriter(_socket.OutputStream))
{
// Set the Unicode character encoding for the output stream
writer.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
// Specify the byte order of a stream.
writer.ByteOrder = ByteOrder.LittleEndian;
// Gets the size of UTF-8 string.
writer.MeasureString(Encoding.UTF8.GetString(REQ_packet));
// Write a string value to the output stream.
writer.WriteBytes(REQ_packet);
// Send the contents of the writer to the backing stream.
try
{
await writer.StoreAsync();
await writer.FlushAsync();
}
catch (Exception ex)
{
SocketErrorStatus webErrorStatus = Windows.Networking.Sockets.SocketError.GetStatus(ex.GetBaseException().HResult);
result.ErrorMessage = (webErrorStatus.ToString() != "Unknown" ? webErrorStatus.ToString() : ex.Message);
return(result);
}
// In order to prolong the lifetime of the stream, detach it from the DataWriter
writer.DetachStream();
}
// Read Variable response packet structure example:
// 0 1 2 3 4 5 6
// xx xx | 00 0A | 00 | 00 06 | 35 35 33 39 39 33 | 00 01 01
// | 10 | 0 | 6 | 5 5 3 9 9 3 | 0 1 1
// SAME AS| RSP LEN | READ=00 | VALUE LEN | VALUE CHARS | TRAILER
// REQUEST|
DataReader reader;
ByteBuilder byteBuilder = new ByteBuilder();
using (reader = new DataReader(_socket.InputStream))
{
// Read the length of the payload that will be received.
reader.InputStreamOptions = InputStreamOptions.Partial;
// The encoding and byte order need to match the settings of the writer we previously used.
reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
reader.ByteOrder = ByteOrder.LittleEndian;
// Send the contents of the writer to the backing stream.
// Get the size of the buffer that has not been read.
try
{
do
{
await reader.LoadAsync(_readBuffer);
var bytes = new Byte[reader.UnconsumedBufferLength];
reader.ReadBytes(bytes);
byteBuilder.AppendBytes(bytes);
// Keep reading until we consume the complete stream.
}while (reader.UnconsumedBufferLength > 0);
}
catch (Exception ex)
{
SocketErrorStatus webErrorStatus = SocketError.GetStatus(ex.GetBaseException().HResult);
result.ErrorMessage = (webErrorStatus.ToString() != "Unknown" ? webErrorStatus.ToString() : ex.Message);
return(result);
}
finally
{
reader.DetachStream();
}
}
var flattenedList = byteBuilder._bytes.SelectMany(bytes => bytes);
var RSP_packet = flattenedList.ToArray();
try
{
int RSP_len = (RSP_packet[2] << 8) | RSP_packet[3];
int RSP_val_len = (RSP_packet[5] << 8) | RSP_packet[6];
result.Data = Encoding.ASCII.GetString(RSP_packet, 7, RSP_val_len);
int RSP_read_status = RSP_packet[7 + (RSP_val_len + 2)];
if ((RSP_read_status > 0) & (RSP_val_len > 0) &
(RSP_packet[0] == PKT_req_id[0]) & (RSP_packet[1] == PKT_req_id[1]))
{
result.Succeeded = true;
return(result);
}
else
{
result.ErrorMessage = "Cannot be read";
return(result);
}
}
catch (Exception ex)
{
result.ErrorMessage = ex.Message;
return(result);
}
}
