/// <summary>
/// Sends a string of text to the target device.
/// </summary>
/// <param name="message">message to be sent. Only use the ASCII character range of UNICODE.</param>
/// <returns>true if the transmission was successful.</returns>
public async Task <bool> SendStringAsync(string message)
{
if (internalStatus != ManagerStatus.GotConnection)
{
return(false);
}
byte[] buffer = new byte[message.Length];
for (int i = 0; i < buffer.Length; i++)
{
buffer[i] = (byte)message[i];
}
try
{
bluetoothWriter.WriteBytes(buffer);
await bluetoothWriter.StoreAsync();
await bluetoothWriter.FlushAsync();
}
catch
{
DiagnosticStringNotify = "Lost connection on write";
internalStatus = ManagerStatus.LostConnection;
return(false);
}
return(true);
}
private async Task WriteBytes(byte[] bytes)
{
#if !UNITY_EDITOR && WINDOWS_UWP
_dataWriter.WriteBytes(bytes);
await _dataWriter.StoreAsync();
await _dataWriter.FlushAsync();
#endif
}
async Task SendAsyncTask(string message)
{
// "flush before changing type"
await MessageWriter.FlushAsync();
socket.Control.MessageType = SocketMessageType.Utf8;
MessageWriter.WriteString(message);
await MessageWriter.StoreAsync();
}
//This method should send all waiting commands and clear the list of known commands
private async void timerCallback(object state)
{
try
{
if (dataWriter != null && amountOfCommandsInBuffer != 0)
{
await dataWriter.FlushAsync();
amountOfCommandsInBuffer = 0;
}
}
catch (Exception) { }
}
private async void SendData_Click(object sender, RoutedEventArgs e)
{
if (deviceService != null)
{
//send data
string sendData = "test";// messagesent.Text;
if (string.IsNullOrEmpty(sendData))
{
// errorStatus.Visibility = Visibility.Visible;
// errorStatus.Text = "Please specify the string you are going to send";
}
else
{
DataWriter dwriter = new DataWriter(streamSocket.OutputStream);
UInt32 len = dwriter.MeasureString(sendData);
dwriter.WriteUInt32(len);
dwriter.WriteString(sendData);
await dwriter.StoreAsync();
await dwriter.FlushAsync();
}
}
else
{
// errorStatus.Visibility = Visibility.Visible;
// errorStatus.Text = "Bluetooth is not connected correctly!";
}
}
/// <summary>
///
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public async Task send(string message)
{
DataWriter writer;
// Create the data writer object backed by the in-memory stream.
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(message);
// Write a string value to the output stream.
writer.WriteString(message);
// Send the contents of the writer to the backing stream.
try
{
await writer.StoreAsync();
}
catch (Exception ex)
{
throw ex;
}
await writer.FlushAsync();
// In order to prolong the lifetime of the stream, detach it from the DataWriter
writer.DetachStream();
}
}
public async void Send(string message)
{
if (_writer != null)
{
// Envia o tamanho da string...
_writer.WriteUInt32(_writer.MeasureString(message));
// Envia a string em si...
_writer.WriteString(message);
try
{
//Faz o envio da mensagem...
await _writer.StoreAsync();
await _writer.FlushAsync();
}
catch (Exception e)
{
if (OnError != null)
{
OnError(e.Message);
}
}
}
}
public async Task <EchoResult> CloseAsync()
{
if (tcpSocket != null)
{
await tcpDw.FlushAsync();
tcpDw.Dispose();
tcpSocket.Dispose();
tcpSocket = null;
tcpDw = null;
// Wait for the TcpReadTask to finish
if (TcpReadTask != null)
{
await TcpReadTask;
}
}
if (udpSocket != null) //TODO: what other clients need to close their UDP sockets?
{
udpDw.Dispose();
udpDw = null;
udpSocket = null;
}
return(TcpReadEchoResult); // Not really fully correct.
}
private async Task SendFileToPeerAsync(PeerInformation selectedPeer, StreamSocket socket, StorageFile selectedFile)
{
byte[] buff = new byte[BLOCK_SIZE];
var prop = await selectedFile.GetBasicPropertiesAsync();
using (var dw = new DataWriter(socket.OutputStream))
{
// 1. Send the filename length
dw.WriteInt32(selectedFile.Name.Length); // filename length is fixed
// 2. Send the filename
dw.WriteString(selectedFile.Name);
// 3. Send the file length
dw.WriteUInt64(prop.Size);
// 4. Send the file
var fileStream = await selectedFile.OpenStreamForReadAsync();
while (fileStream.Position < (long)prop.Size)
{
var rlen = await fileStream.ReadAsync(buff, 0, buff.Length);
dw.WriteBytes(buff);
}
await dw.FlushAsync();
await dw.StoreAsync();
await socket.OutputStream.FlushAsync();
}
}
/// <summary>
/// 通过指定socket通道发送字符串信息
/// </summary>
/// <param name="message"> {"FullName":"我的电脑","FileTyp":null,"Name":"我的电脑","Lable":"我的电脑"}"}</param>
/// <param name="socket"> App.SocketCmd</param>
public async static void SendData(string message, StreamSocket socket)
{
string sendMessage = string.Format("XiYou#{0}", message);
Debug.WriteLine("SocketCmd发送的命令:" + sendMessage);
byte[] buffer = Encoding.UTF8.GetBytes(sendMessage);
//Encoding.UTF8.GetBytes(sendMessage, 0, sendMessage.Length,buffer, 0);
using (DataWriter writer = new DataWriter(socket.OutputStream))
{
writer.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
try
{
writer.WriteBytes(buffer);
var a = await writer.StoreAsync();
await writer.FlushAsync();
writer.DetachStream();
writer.Dispose();
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
//await new MessageDialog(e.Message).ShowAsync();
//writer.Dispose();
return;
}
}
}
private const int SPP_PACKET_DATA_SIZE = 62; // This is because the mtu in wp is 63.
private async Task SendJob(JobDesc job)
{
byte[] p = job.Data;
int byte_sent = 0;
int byte_to_send = p.Length;
while (byte_to_send - byte_sent > 0)
{
int byteLeft = byte_to_send - byte_sent;
int subPacketSize = byteLeft;
if (subPacketSize > SPP_PACKET_DATA_SIZE)
{
subPacketSize = SPP_PACKET_DATA_SIZE;
}
byte[] temp = new byte[subPacketSize + 1];
temp[0] = 0;
if (byte_sent == 0)
{
temp[0] |= 0x01;
}
if (subPacketSize == byteLeft)
{
temp[0] |= 0x02;
}
Array.Copy(p, byte_sent, temp, 1, subPacketSize);
dataWriter.WriteBytes(temp);
await dataWriter.StoreAsync();
await dataWriter.FlushAsync();
byte_sent += subPacketSize;
}
}
private async void SocketListener_ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
{
if (_sensorConnection != null)
{
// send sensor busy?
args.Socket.Dispose();
}
_sensorConnection = args.Socket;
_dataReader = new DataReader(_sensorConnection.InputStream);
_dataWriter = new DataWriter(_sensorConnection.OutputStream);
_dataWriter.ByteOrder = ByteOrder.LittleEndian;
_dataReader.ByteOrder = ByteOrder.LittleEndian;
var operation = await _dataReader.LoadAsync(8);
var hello = HelloPacket.Read(_dataReader);
// reply with version - resend hello packet
hello.Write(_dataWriter);
await _dataWriter.StoreAsync();
await _dataWriter.FlushAsync();
// todo: start receive loop
}
private async void UWPSyncTileLayer_BitmapRequested(CustomMapTileDataSource sender, MapTileBitmapRequestedEventArgs args)
{
var deferral = args.Request.GetDeferral();
try
{
var data = await _makeTileUri(args.X, args.Y, args.ZoomLevel);
if (data != null)
{
MemoryStream stream = new MemoryStream();
stream.Write(data, 0, data.Length);
stream.Position = 0;
var decoder = await Windows.Graphics.Imaging.BitmapDecoder.CreateAsync(stream.AsRandomAccessStream());
var pixelProvider = await decoder.GetPixelDataAsync(Windows.Graphics.Imaging.BitmapPixelFormat.Rgba8, Windows.Graphics.Imaging.BitmapAlphaMode.Straight, new Windows.Graphics.Imaging.BitmapTransform(), Windows.Graphics.Imaging.ExifOrientationMode.RespectExifOrientation, Windows.Graphics.Imaging.ColorManagementMode.ColorManageToSRgb);
var pixelData = pixelProvider.DetachPixelData();
InMemoryRandomAccessStream randomAccessStream = new InMemoryRandomAccessStream();
IOutputStream outputStream = randomAccessStream.GetOutputStreamAt(0);
DataWriter writer = new DataWriter(outputStream);
writer.WriteBytes(pixelData);
await writer.StoreAsync();
await writer.FlushAsync();
args.Request.PixelData = RandomAccessStreamReference.CreateFromStream(randomAccessStream);
}
deferral.Complete();
}
catch (Exception ex)
{
deferral.Complete();
}
}
public async Task SendAsync(ILogView log)
{
Copy(log);
var message = new EmailMessage
{
Body = s_resources.GetString("MessageBody"),
Subject = string.Format(s_resources.GetString("MessageSubject"), log.Id, File.ReadAllText("version.txt").Trim())
};
message.To.Add(new EmailRecipient(s_resources.GetString("MessageTo"), s_resources.GetString("MessageToName")));
using (var ms = new InMemoryRandomAccessStream())
{
using (var writer = new DataWriter(ms.GetOutputStreamAt(0)))
{
writer.WriteString(log.Log);
await writer.StoreAsync();
await writer.FlushAsync();
var data = RandomAccessStreamReference.CreateFromStream(ms);
var attachment = new EmailAttachment($"{log.Id}.log", data);
message.Attachments.Add(attachment);
await EmailManager.ShowComposeNewEmailAsync(message);
}
}
}
public async Task <byte[]> Decrypt(byte[] encryptedBytes)
{
var provider = new DataProtectionProvider();
var encryptedContentBuffer = CryptographicBuffer.CreateFromByteArray(encryptedBytes);
var contentInputStream = new InMemoryRandomAccessStream();
var unprotectedContentStream = new InMemoryRandomAccessStream();
IOutputStream outputStream = contentInputStream.GetOutputStreamAt(0);
var dataWriter = new DataWriter(outputStream);
dataWriter.WriteBuffer(encryptedContentBuffer);
await dataWriter.StoreAsync();
await dataWriter.FlushAsync();
IInputStream decodingInputStream = contentInputStream.GetInputStreamAt(0);
IOutputStream protectedOutputStream = unprotectedContentStream.GetOutputStreamAt(0);
await provider.UnprotectStreamAsync(decodingInputStream, protectedOutputStream);
await protectedOutputStream.FlushAsync();
DataReader reader2 = new DataReader(unprotectedContentStream.GetInputStreamAt(0));
await reader2.LoadAsync((uint)unprotectedContentStream.Size);
IBuffer unprotectedBuffer = reader2.ReadBuffer((uint)unprotectedContentStream.Size);
return(unprotectedBuffer.ToArray());
}
public async Task SendAsync(string msg)
{
// Sometimes dataWriter is blocking for an infinite time, so give it a timeout:
sendCTS = new CancellationTokenSource(SEND_TIMEOUT_MS);
sendCTS.CancelAfter(SEND_TIMEOUT_MS);
Exception ex = await Task.Run(async() =>
{
try
{
// Append a NULL-Byte to inform the server, this is everything:
msg += '\0';
uint l = dataWriter.WriteString(msg);
// Check if all bytes got actually written to the TCP buffer:
if (l < msg.Length)
{
return(new Exception("Send only " + l + " of " + msg.Length + " bytes."));
}
await dataWriter.StoreAsync();
await dataWriter.FlushAsync();
}
catch (Exception e) { return(e); }
return(null);
}, sendCTS.Token).ConfigureAwait(false);
if (!(ex is null))
{
throw ex;
}
}
internal async Task sendTCPData(StreamSocket socket, byte[] data)
{
if (socket == null)
{
return;
}
byte[] dataToSend = data;
DataWriter writer = new DataWriter(socket.OutputStream);
writer.WriteUInt32((uint)dataToSend.Length);
writer.WriteBytes(dataToSend);
try
{
await writer.StoreAsync();
await writer.FlushAsync();
writer.DetachStream();
}
catch (Exception e)
{
if (SocketError.GetStatus(e.HResult) == SocketErrorStatus.Unknown)
{
socket.Dispose();
}
}
}
public async Task WriteLine(DataWriter writer, string str)
{
if (ReadOrWriteFailed)
{
return;
}
try
{
if (ConnCheck.HasInternetAccess && !IsReconnecting)
{
writer.WriteString(str + "\r\n");
await writer.StoreAsync();
await writer.FlushAsync();
}
}
catch (Exception e)
{
ReadOrWriteFailed = true;
var autoReconnect = Config.GetBoolean(Config.AutoReconnect);
var msg = autoReconnect
? "Attempting to reconnect..."
: "Please try again later.";
AddError("Error whilst connecting: " + e.Message + "\n" + msg);
AddError(e.StackTrace);
DisconnectAsync(attemptReconnect: autoReconnect);
Debug.WriteLine(e.Message);
Debug.WriteLine(e.StackTrace);
}
}
public async Task <object> GetBitmapAsync(byte[] data)
{
var bitmapImage = new BitmapImage();
if (data == null || data.Length == 0)
{
return(bitmapImage);
}
using (var stream = new InMemoryRandomAccessStream())
{
using (var writer = new DataWriter(stream))
{
writer.WriteBytes(data);
await writer.StoreAsync();
await writer.FlushAsync();
writer.DetachStream();
}
stream.Seek(0);
await bitmapImage.SetSourceAsync(stream);
}
return(bitmapImage);
}
/// <summary>
/// Send a message to all active clients
/// </summary>
/// <param name="socket"></param>
/// <param name="buffer"></param>
/// <returns></returns>
private bool SendMessage(StreamSocket socket, byte[] buffer)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
if (socket == null || socket.OutputStream == null)
{
return(false);
}
Debug.WriteLine("Send Buffer:");
Debug.Write(ArrayExtensions.HexDump(buffer));
try
{
using (DataWriter outputWriter = new DataWriter(socket.OutputStream))
{
outputWriter.WriteBytes(buffer);
outputWriter.StoreAsync().AsTask().GetAwaiter().GetResult();
outputWriter.FlushAsync().AsTask().GetAwaiter().GetResult();
outputWriter.DetachStream();
}
}
catch (Exception)
{
return(false);
}
return(true);
}
private static async Task <StorageFile> SavePhotoAsync(FilteredPhotoModel photo, StorageFile file)
{
CachedFileManager.DeferUpdates(file);
using (var fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite))
using (var photoStream = await photo.GetFilteredPhotoAsync())
using (var reader = new DataReader(photoStream))
using (var writer = new DataWriter(fileStream))
{
await reader.LoadAsync((uint)photoStream.Size);
var buffer = reader.ReadBuffer((uint)photoStream.Size);
writer.WriteBuffer(buffer);
await writer.StoreAsync();
await writer.FlushAsync();
}
var status = await CachedFileManager.CompleteUpdatesAsync(file);
if (status == Windows.Storage.Provider.FileUpdateStatus.Complete)
{
return(file);
}
else
{
return(null);
}
}
private async Task HandleReceivedRequest(Request request)
{
RequestReceived?.Invoke(this, request);
Response response = null;
foreach (var handler in RequestPipeline.GetHandlers())
{
var resp = await handler.Invoke(request);
if (resp != null)
{
response = resp;
break;
}
}
if (response != null)
{
// Only if response was handled
// Remember, notifications do not get a reply
await _transportLock.WaitAsync();
await DataWriter.WriteLineAsync(response.ToString());
await DataWriter.FlushAsync();
_transportLock.Release();
}
}
private async Task RetrieveJitterResult()
{
streamSocket = new StreamSocket();
await streamSocket.ConnectAsync(hostName, server.JitterRetrieveResultPort.ToString());
await Task.Delay(1500);
DataWriter writer = new DataWriter(streamSocket.OutputStream);
DataReader reader = new DataReader(streamSocket.InputStream);
writer.WriteString("get");
await writer.StoreAsync();
await writer.FlushAsync();
reader.InputStreamOptions = InputStreamOptions.Partial;
var read = await reader.LoadAsync(16);
string message = reader.ReadString(read);
network.Jitter = Convert.ToInt32(message);
Close(ref writer);
Close(ref reader);
Close(ref streamSocket);
}
private async Task JitterCalculation()
{
datagramSocket = new DatagramSocket();
datagramSocket.MessageReceived += delegate(DatagramSocket socket, DatagramSocketMessageReceivedEventArgs args)
{
System.Diagnostics.Debug.WriteLine("[ProfileNetworkFull]: Jitter Finish");
};
string port = server.JitterTestPort.ToString();
await datagramSocket.BindServiceNameAsync(port);
using (DataWriter writer = new DataWriter(await datagramSocket.GetOutputStreamAsync(hostName, port)))
{
for (int i = 0; i < 21; i++)
{
writer.WriteString("jitter");
await writer.StoreAsync();
await writer.FlushAsync();
await Task.Delay(250);
}
}
Close(ref datagramSocket);
}
public override async Task WriteBuffer(byte[] buffer)
{
_writer.WriteBuffer(buffer.AsBuffer());
await _writer.StoreAsync();
var result = await _writer.FlushAsync();
}
public static async Task DisconnectAsync()
{
if (imageComparisonServer != null)
{
try
{
// Properly sends a message notifying we want to close the connection
using (var dataWriter = new DataWriter(imageComparisonServer.OutputStream))
{
dataWriter.WriteInt32((int)ImageServerMessageType.ConnectionFinished);
await dataWriter.StoreAsync();
await dataWriter.FlushAsync();
dataWriter.DetachStream();
}
imageComparisonServer.Dispose();
}
catch (Exception)
{
}
imageComparisonServer = null;
}
}
/// <summary>
/// Convert the given MemoryStream to a stream that allows random access
/// </summary>
/// <param name="memoryStream">The MemoryStream to convert</param>
/// <returns>Stream that allows random access</returns>
public static async Task <IRandomAccessStream> ConvertToRandomAccessStream(MemoryStream memoryStream)
{
InMemoryRandomAccessStream randomAccessStream = new InMemoryRandomAccessStream();
MemoryStream contentStream = new MemoryStream();
memoryStream.CopyTo(contentStream);
using (IOutputStream outputStream = randomAccessStream.GetOutputStreamAt(0))
{
using (DataWriter dw = new DataWriter(outputStream))
{
Task task = new Task(() => dw.WriteBytes(contentStream.ToArray()));
task.Start();
await task;
await dw.StoreAsync();
await outputStream.FlushAsync();
await dw.FlushAsync();
outputStream.Dispose();
dw.DetachStream();
dw.Dispose();
}
}
return(randomAccessStream);
}
public static async Task <bool> WriteStringToFileWithAppendOption(StorageFile f, string data, bool append)
{
bool result = true;
try
{
using (var stream = await f.OpenAsync(FileAccessMode.ReadWrite))
{
if (append)
{
ulong fileSize = stream.Size;
stream.Seek(fileSize);
}
using (DataWriter dataWriter = new DataWriter(stream))
{
dataWriter.WriteString(data);
await dataWriter.StoreAsync();
await dataWriter.FlushAsync();
}
}
}
catch (Exception ex)
{
result = false;
}
return(result);
}
private async Task EchoUdpAsync(string type, DataReader dr, DataWriter dw)
{
uint count = dr.UnconsumedBufferLength;
if (count > 0)
{
byte[] buffer = new byte[count];
dr.ReadBytes(buffer);
Stats.NBytesRead += count;
LogEchoBuffer(buffer);
try
{
dw.WriteBytes(buffer);
await dw.StoreAsync();
Stats.IncrementNResponses();
}
catch (Exception ex)
{
Stats.NExceptions++;
Log($"SERVER: ECHO: {type} exception while writing {ex.Message}");
}
}
else // socket is done
{
Log($"SERVER: {type} closing down the current reading socket");
await dw.FlushAsync();
dw.Dispose();
}
}
private async Task <bool> SendRequest(Command command, string passkey)
{
string requestData = CommandParserHelper.SerializeAndEncryptCommand(command, passkey);
try
{
//First byte is the size of the message
_writer.WriteUInt32(_writer.MeasureString(requestData));
//Next is the actual message
_writer.WriteString(requestData);
//Send the message
await _writer.StoreAsync();
await _writer.FlushAsync();
//Log
Debug.WriteLine($"Sent: {command.BaseCommand}, {command.Data}");
return(true);
}
catch (Exception e)
{
Debug.WriteLine($"SendRequest: {e.Message}");
return(false);
}
}
