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