private async void StreamSkeleton() { try { var reader = new DataReader( Client.InputStream ); reader.InputStreamOptions = InputStreamOptions.Partial; while ( IsConnected ) { await reader.LoadAsync( 4 ); var size = reader.ReadUInt32(); await reader.LoadAsync( size ); byte[] bytes = new byte[size]; reader.ReadBytes( bytes ); MemoryStream ms = new MemoryStream( bytes ); BinaryReader br = new BinaryReader(ms); SkeletonFrameData frame = br.ReadSkeletonFrame(); SkeletonFrameReadyEventArgs args = new SkeletonFrameReadyEventArgs { SkeletonFrame = frame }; SkeletonFrame = frame; Context.Send(delegate { if(SkeletonFrameReady != null) SkeletonFrameReady(this, args); }, null); } } catch(IOException) { Disconnect(); } }
private async void OnRead(Object sender, RoutedEventArgs e) { StorageFolder local = ApplicationData.Current.LocalFolder; StorageFile file = await local.GetFileAsync("demo.dat"); if(file != null) { string strres = "读到的内容:\n"; using(IRandomAccessStream stream = await file.OpenReadAsync()) { DataReader dr = new DataReader(stream); dr.UnicodeEncoding = UnicodeEncoding.Utf8; await dr.LoadAsync((uint)stream.Size); bool b = dr.ReadBoolean(); strres += b.ToString() + "\n"; DateTimeOffset dt = dr.ReadDateTime(); strres += dt.ToString("yyyy-M-d") + "\n"; uint len = dr.ReadUInt32(); if(len > 0) { strres += dr.ReadString(len); } dr.Dispose(); } tbResult.Text = strres; } }
private async void Read() { _reader = new DataReader(_socket.InputStream); try { while (true) { uint sizeFieldCount = await _reader.LoadAsync(sizeof(uint)); //if desconneted if (sizeFieldCount != sizeof(uint)) return; uint stringLenght = _reader.ReadUInt32(); uint actualStringLength = await _reader.LoadAsync(stringLenght); //if desconneted if (stringLenght != actualStringLength) return; if (OnDataRecived != null) OnDataRecived(_reader.ReadString(actualStringLength)); } } catch (Exception ex) { if (OnError != null) OnError(ex.Message); } }
private static async void OnConnection(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args) { ConnectionStatus = ConnectionStatus.Connected; DataReader reader = new DataReader(args.Socket.InputStream); try { while (true) { uint sizeFieldCount = await reader.LoadAsync(sizeof (uint)); if (sizeFieldCount != sizeof (uint)) { return; } uint stringLength = reader.ReadUInt32(); uint actualStringLength = await reader.LoadAsync(stringLength); if (stringLength != actualStringLength) { return; } Message = reader.ReadString(actualStringLength); } } catch (Exception e) { ConnectionStatus = ConnectionStatus.Failed; //TODO:send a connection status message with error } }
public static async Task<bool> LoadFrom ( ObservableCollection<RecentData> datas ) { try { StorageFile sf = await ApplicationData.Current.LocalFolder.GetFileAsync ( "data.dat" ); FileRandomAccessStream stream = await sf.OpenAsync ( FileAccessMode.Read ) as FileRandomAccessStream; DataReader dr = new DataReader ( stream ); dr.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; dr.ByteOrder = ByteOrder.LittleEndian; await dr.LoadAsync ( ( uint ) stream.Size ); int len = dr.ReadInt32 (); for ( int i = 0; i < len; i++ ) { RecentData data = new RecentData (); uint srclen = dr.ReadUInt32 (); data.Source = dr.ReadString ( srclen ); data.SourceIndex = dr.ReadInt32 (); data.TargetIndex = dr.ReadInt32 (); datas.Add ( data ); } stream.Dispose (); } catch { return false; } return true; }
private async void ColorThread() { try { var reader = new DataReader( Client.InputStream ); reader.InputStreamOptions = InputStreamOptions.Partial; reader.ByteOrder = ByteOrder.LittleEndian; while ( IsConnected ) { await reader.LoadAsync( 4 ); var size = reader.ReadUInt32(); await reader.LoadAsync( size ); byte[] bytes = new byte[size]; reader.ReadBytes( bytes ); MemoryStream ms = new MemoryStream( bytes ); BinaryReader br = new BinaryReader(ms); ColorFrameReadyEventArgs args = new ColorFrameReadyEventArgs(); ColorFrameData cfd = new ColorFrameData(); cfd.Format = (ImageFormat)br.ReadInt32(); cfd.ImageFrame = br.ReadColorImageFrame(); MemoryStream msData = new MemoryStream( bytes, (int)ms.Position, (int)(ms.Length - ms.Position) ); if (cfd.Format == ImageFormat.Raw) { cfd.RawImage = ms.ToArray(); } else { InMemoryRandomAccessStream ras = new InMemoryRandomAccessStream(); DataWriter dw = new DataWriter(ras.GetOutputStreamAt(0)); dw.WriteBytes(msData.ToArray()); await dw.StoreAsync(); // Set to the image BitmapImage bImg = new BitmapImage(); bImg.SetSource(ras); cfd.BitmapImage = bImg; } ColorFrame = cfd; args.ColorFrame = cfd; if (ColorFrameReady != null) { ColorFrameReady(this, args); } } } catch(IOException) { Disconnect(); } }
private async void Listener_ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args) { Debug.WriteLine("Connection Received on Port {0}", sender.Information.LocalPort); StreamSocket streamSocket = args.Socket; if (streamSocket != null) { DataReader reader = new DataReader(streamSocket.InputStream); try { // 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 length of the 'packet'. uint length = reader.ReadUInt32(); uint actualLength = await reader.LoadAsync(length); if (length != actualLength) { // The underlying socket was closed before we were able to read the whole data. return; } string name = reader.ReadString(actualLength); Speaker speaker = new Speaker() { Name = name, Address = streamSocket.Information.RemoteAddress.DisplayName, Status = "Connected", Socket = streamSocket }; await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { Speakers.Add(speaker); }); reader.DetachStream(); Debug.WriteLine("New speaker added " + name); } catch (Exception e) { Debug.WriteLine("Error in connection received: " + e); } } }
private async void DepthThread() { try { short[] depthShort = null; var reader = new DataReader( Client.InputStream ); reader.InputStreamOptions = InputStreamOptions.Partial; while ( IsConnected ) { await reader.LoadAsync( 4 ); var size = reader.ReadUInt32(); await reader.LoadAsync( size ); byte[] bytes = new byte[size]; reader.ReadBytes( bytes ); MemoryStream ms = new MemoryStream( bytes ); BinaryReader br = new BinaryReader( ms ); DepthFrameData dfd = new DepthFrameData(); dfd.PlayerIndexBitmask = br.ReadInt32(); dfd.PlayerIndexBitmaskWidth = br.ReadInt32(); DepthImageFrame frame = br.ReadDepthImageFrame(); dfd.ImageFrame = frame; int dataLength = (int)(ms.Length - ms.Position); if ( depthShort == null || depthShort.Length != dataLength / 2 ) depthShort = new short[dataLength / 2]; Buffer.BlockCopy( bytes, (int)br.BaseStream.Position, depthShort, 0, dataLength ); dfd.DepthData = depthShort; DepthFrame = dfd; DepthFrameReadyEventArgs args = new DepthFrameReadyEventArgs(); args.DepthFrame = dfd; Context.Send( delegate { if ( DepthFrameReady != null ) DepthFrameReady( this, args ); }, null ); } } catch ( IOException ) { Disconnect(); } }
private async void OnConnection(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args) { string id = string.Empty; 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. string readedString = reader.ReadString(actualStringLength); string action = readedString.Split(';')[0].Split(':')[1].ToString(); id = readedString.Split(';')[1].Split(':')[1].ToString(); OnReceivedMessage(new ActionEventArgs(action, id)); } } catch (Exception exception) { OnReceivedMessage(new ActionEventArgs("closed", id)); } }
public async void StartReader(ConnectedPeer connectedPeer) { try { using (var socketReader = new Windows.Storage.Streams.DataReader(connectedPeer._socket.InputStream)) { // Read the message sent by the remote peer uint bytesRead = await socketReader.LoadAsync(sizeof(uint)); if (bytesRead > 0) { uint strLength = (uint)socketReader.ReadUInt32(); bytesRead = await socketReader.LoadAsync(strLength); if (bytesRead > 0) { String message = socketReader.ReadString(strLength); OnRaiseMessageEvent(new MessageEventArgs("Got message: " + message)); StartReader(connectedPeer); // Start another reader } else { OnRaiseSocketErrorEvent(new SocketEventArgs("The remote side closed the socket")); } } else { OnRaiseSocketErrorEvent(new SocketEventArgs("The remote side closed the socket")); } socketReader.DetachStream(); } } catch (Exception e) { if (!connectedPeer._socketClosed) { OnRaiseSocketErrorEvent(new SocketEventArgs("Reading from socket failed: " + e.Message)); } } }
async void streamSocketListener_ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args) { int i = 0; DataReader dataReader = new DataReader(args.Socket.InputStream); DataWriter serverWriter = new DataWriter(args.Socket.OutputStream); try { while (true) { uint sizeCount = await dataReader.LoadAsync(4); uint length = dataReader.ReadUInt32(); uint contentLength = await dataReader.LoadAsync(length); string msg = dataReader.ReadString(contentLength); i++; Deployment.Current.Dispatcher.BeginInvoke(() => msgList.Children.Add( new TextBlock { Text = "服务器接收到的消息:" + msg })); string serverStr = msg + "|" + i; serverWriter.WriteUInt32(serverWriter.MeasureString(serverStr)); serverWriter.WriteString(serverStr); try { await serverWriter.StoreAsync(); } catch (Exception err) { if (SocketError.GetStatus(err.HResult) == SocketErrorStatus.AddressAlreadyInUse) { } } } } catch (Exception err) { if (SocketError.GetStatus(err.HResult) == SocketErrorStatus.AddressAlreadyInUse) { } } }
private async void TcpService_ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args) { using (var client = args.Socket) using (var dr = new DataReader(client.InputStream)) using (var dw = new DataWriter(client.OutputStream)) { await dr.LoadAsync(sizeof(Int32)); var messageLenght = dr.ReadUInt32(); await dr.LoadAsync(messageLenght); var bytes = new Byte[messageLenght]; dr.ReadBytes(bytes); var request = Encoding.UTF8.GetString(bytes); var response = "Успешно получено"; var body = Encoding.UTF8.GetBytes(response); dw.WriteUInt32((UInt32)body.Length); dw.WriteBytes(body); await dw.StoreAsync(); } }
private async void Listener_ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args) { var reader = new DataReader(args.Socket.InputStream); _writer = new DataWriter(args.Socket.OutputStream); try { while (true) { uint sizeFieldCount = await reader.LoadAsync(sizeof(uint)); //Caso ocora um desconexão if (sizeFieldCount != sizeof(uint)) return; //Tamanho da string uint stringLenght = reader.ReadUInt32(); //Ler os dados do InputStream uint actualStringLength = await reader.LoadAsync(stringLenght); //Caso ocora um desconexão if (stringLenght != actualStringLength) return; //Dispara evento de dado recebido if (OnDataRecived != null) { //Le a string com o tamanho passado string data = reader.ReadString(actualStringLength); //Dispara evento de dado recebido OnDataRecived(data); } } } catch (Exception ex) { // Dispara evento em caso de erro, com a mensagem de erro if (OnError != null) OnError(ex.Message); } }
private static async Task<string> Receive(StreamSocket socket) { string result = null; if (socket != null) using (var reader = new DataReader(socket.InputStream)) { reader.InputStreamOptions = InputStreamOptions.Partial; uint sizeFieldLength = await reader.LoadAsync(sizeof(uint)); if (sizeFieldLength == sizeof(uint)) { uint dataLength = reader.ReadUInt32(); uint actualDataLength = await reader.LoadAsync(dataLength); if (dataLength == actualDataLength) result = reader.ReadString(actualDataLength); } reader.DetachStream(); } return result; }
/// <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("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); } }
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; } uint sizeFieldCount1 = await reader.LoadAsync(sizeof(uint)); if (sizeFieldCount1 != 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 msgtype = 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. if (msgtype == 1) { readByte = new byte[actualStringLength]; reader.ReadBytes(readByte); receive_byte_flag = 1; } else if (msgtype == 2) { stringtemp = reader.ReadString(actualStringLength); receive_client_ip = 1; } else if (msgtype == 3) { receiverbuf = reader.ReadBuffer(actualStringLength); receive_buf_flag = 1; } } } 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; } } }
/// <summary> /// Invoked when the socket listener accepts an incoming Bluetooth connection. /// </summary> /// <param name="sender">The socket listener that accepted the connection.</param> /// <param name="args">The connection accept parameters, which contain the connected socket.</param> private async void OnConnectionReceived( StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args) { // Don't need the listener anymore socketListener.Dispose(); socketListener = null; try { socket = args.Socket; } catch (Exception e) { await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { rootPage.NotifyUser(e.Message, NotifyType.ErrorMessage); }); Disconnect(); return; } // Note - this is the supported way to get a Bluetooth device from a given socket var remoteDevice = await BluetoothDevice.FromHostNameAsync(socket.Information.RemoteHostName); writer = new DataWriter(socket.OutputStream); var reader = new DataReader(socket.InputStream); bool remoteDisconnection = false; await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { rootPage.NotifyUser("Connected to Client: " + remoteDevice.Name, NotifyType.StatusMessage); }); // Infinite read buffer loop while (true) { try { // Based on the protocol we've defined, the first uint is the size of the message uint readLength = await reader.LoadAsync(sizeof(uint)); // Check if the size of the data is expected (otherwise the remote has already terminated the connection) if (readLength < sizeof(uint)) { remoteDisconnection = true; break; } uint currentLength = reader.ReadUInt32(); // Load the rest of the message since you already know the length of the data expected. readLength = await reader.LoadAsync(currentLength); // Check if the size of the data is expected (otherwise the remote has already terminated the connection) if (readLength < currentLength) { remoteDisconnection = true; break; } string message = reader.ReadString(currentLength); await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { ConversationListBox.Items.Add("Received: " + message); }); } // Catch exception HRESULT_FROM_WIN32(ERROR_OPERATION_ABORTED). catch (Exception ex) when ((uint)ex.HResult == 0x800703E3) { await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { rootPage.NotifyUser("Client Disconnected Successfully", NotifyType.StatusMessage); }); break; } } reader.DetachStream(); if (remoteDisconnection) { Disconnect(); await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { rootPage.NotifyUser("Client disconnected",NotifyType.StatusMessage); }); } }
/// <summary> /// Method used for the "Collection Thread" /// </summary> /// <param name="operation"></param> private async void CollectTelemetryData(IAsyncAction operation) { DataReader reader; uint unconsumedBufferLength = 0; lock (m_pConnectedSocket) { reader = new DataReader(m_pConnectedSocket.InputStream); } while (IsClientConnected | (unconsumedBufferLength > 0)) { await m_pTelemetryReaderSemaphoreSlim.WaitAsync(); try { await reader.LoadAsync(sizeof (byte)); unconsumedBufferLength = reader.UnconsumedBufferLength; } finally { m_pTelemetryReaderSemaphoreSlim.Release(); } if (reader.UnconsumedBufferLength <= 0) continue; await m_pTelemetryReaderSemaphoreSlim.WaitAsync(); try { byte b; var e = new OnTelemetryDataReceivedEventArgs(); b = reader.ReadByte(); var commandInformation = (CommandInformation) b; switch (commandInformation) { case CommandInformation.Information: await reader.LoadAsync(sizeof (uint)); var n = reader.ReadUInt32(); await reader.LoadAsync(n*sizeof (char)); e.CommandData = reader.ReadString(n); e.CommandType = CommandInformation.Information; break; case CommandInformation.Gyroscope: float angleX, angleY, angleZ; long gyroTime; await reader.LoadAsync(3*sizeof (double)); await reader.LoadAsync(sizeof (long)); angleX = Convert.ToSingle(reader.ReadDouble()); angleY = Convert.ToSingle(reader.ReadDouble()); angleZ = Convert.ToSingle(reader.ReadDouble()); gyroTime = reader.ReadInt64(); e.CommandData = new GyroscopeData() { Angle = new Vector3(angleX, angleY, angleZ), TimeStamp = new DateTime(gyroTime) }; e.CommandType = CommandInformation.Gyroscope; break; case CommandInformation.Accelerometer: float accX, accY, accZ; long accTime; await reader.LoadAsync(3*sizeof (double)); await reader.LoadAsync(sizeof (long)); accX = Convert.ToSingle(reader.ReadDouble()); accY = Convert.ToSingle(reader.ReadDouble()); accZ = Convert.ToSingle(reader.ReadDouble()); accTime = reader.ReadInt64(); e.CommandData = new AccelerometerData() { Acceleration = new Vector3(accX, accY, accZ), TimeStamp = new DateTime(accTime) }; e.CommandType = CommandInformation.Accelerometer; break; case CommandInformation.Servo: byte id, velocity; long servoTime; await reader.LoadAsync(2*sizeof (byte)); await reader.LoadAsync(sizeof (long)); id = reader.ReadByte(); velocity = reader.ReadByte(); servoTime = reader.ReadInt64(); e.CommandData = new ServoControllerData() {ServoId = id, VelocityValue = velocity, TimeStamp = new DateTime(servoTime)}; e.CommandType = CommandInformation.Servo; break; } var handler = OnTelemetryDataReceived; handler?.Invoke(this, e); } finally { m_pTelemetryReaderSemaphoreSlim.Release(); } } }
private async void PeerFinder_ConnectionRequested(object sender, ConnectionRequestedEventArgs args) { try { await this.textboxDebug.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async () => { this.textboxDebug.Text += "Connection Requested\n"; await this.connect(args.PeerInformation); if (_streamsocket != null) { while (true) { // nếu đã tồn tại một thể hiện của lớp DataReader thì đối tượng đó tự động được giải phóng. DataReader datareader = new DataReader(_streamsocket.InputStream); try { uint size = await datareader.LoadAsync(sizeof(uint)); if (size != sizeof(uint)) { return; } uint lenght = datareader.ReadUInt32(); uint exactlylenght = await datareader.LoadAsync(lenght); if (lenght != exactlylenght) { return; } string msg = datareader.ReadString(exactlylenght); this.textboxDebug.Text += "Receive from " + _streamsocket.Information.RemoteAddress + ": " + msg + "\n"; } catch (Exception ex) { this.textboxDebug.Text += ex.Message + "\n"; } } } }); } catch (Exception ex) { this.textboxDebug.Text += ex.Message + "\n"; } //await PeerFinder.ConnectAsync(args.PeerInformation); // throw new NotImplementedException(); }
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. string text = reader.ReadString(actualStringLength); // Get the language and the content received char delimiter = ':'; string[] res; res = text.Split(delimiter); string InLang = "en"; if (res[0].Contains("zh")) { InLang = "zh-CHS"; } string outLang = "en"; if (selectedLang.LanguageTag.Contains("zh")) { outLang = "zh-CHS"; } string content = res[1]; Translator Trans = new Translator(content, InLang, outLang); string translatedS = Trans.GetTranslatedString(); SpeechSynthesisStream stream = await synthesizer.SynthesizeTextToStreamAsync(translatedS); var ignored = Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { media.SetSource(stream, stream.ContentType); media.Play(); ReceivedText.Text = text; }); } } 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; } var ignored = Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { StatusText.Text = "Read stream failed with error: " + exception.Message; StatusText.Text += "Reconnecting Later!"; connected = false; CoreApplication.Properties.Remove("clientSocket"); CoreApplication.Properties.Remove("clientDataWriter"); }); } }
private async Task<Command> WaitForCommand(DataReader reader) { // Wait for a new message, here we wait for enough data to represent the string size // if we don't get all of the data, the socket was closed. UInt32 sizeFieldCount = await reader.LoadAsync(sizeof(UInt32)); if (sizeFieldCount != sizeof(uint)) { // We didn't get it all, the socket is closed. throw new Exception("Socket closed"); } // 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. throw new Exception("Socket closed"); } // Get the actual string string commandString = reader.ReadString(actualStringLength); // Parse the command return Newtonsoft.Json.JsonConvert.DeserializeObject<Command>(commandString); }
private async Task<String> readMessage(IInputStream input) { DataReader datareader = new DataReader(input); while (true) { try { uint size = await datareader.LoadAsync(sizeof(uint)); if (size != sizeof(uint)) { return String.Empty; } uint lenght = datareader.ReadUInt32(); uint exactlylenght = await datareader.LoadAsync(lenght); if (lenght != exactlylenght) { return String.Empty; } string msg = datareader.ReadString(exactlylenght); return msg; } catch (Exception ex) { this.OutputTextblock.Text += ex.Message + "\n"; } } }
private async void ReceiveStringLoop(DataReader chatReader) { try { uint size = await chatReader.LoadAsync(sizeof(uint)); if (size < sizeof(uint)) { Disconnect("Remote device terminated connection - make sure only one instance of server is running on remote device"); return; } uint stringLength = chatReader.ReadUInt32(); uint actualStringLength = await chatReader.LoadAsync(stringLength); if (actualStringLength != stringLength) { // The underlying socket was closed before we were able to read the whole data return; } ConversationList.Items.Add("Received: " + chatReader.ReadString(stringLength)); ReceiveStringLoop(chatReader); } catch (Exception ex) { lock (this) { if (chatSocket == null) { // Do not print anything here - the user closed the socket. // HResult = 0x80072745 - catch this (remote device disconnect) ex = {"An established connection was aborted by the software in your host machine. (Exception from HRESULT: 0x80072745)"} } else { Disconnect("Read stream failed with error: " + ex.Message); } } } }
async void StartReceiveData(DataReader socketReader) { try { uint bytesRead = await socketReader.LoadAsync(sizeof(uint)); if (bytesRead > 0) { uint strLength = (uint)socketReader.ReadUInt32(); bytesRead = await socketReader.LoadAsync(strLength); if (bytesRead > 0) { byte[] bytesIn = new byte[bytesRead]; Debug.WriteLine("ReadBytes"); socketReader.ReadBytes(bytesIn); Debug.WriteLine("ReadBytes End"); if (DataReceived != null) { DataReceivedEventArgs args = new DataReceivedEventArgs(); args.Bytes = bytesIn; DataReceived(this, args); } StartReceiveData(socketReader); // Start another reader } else { SocketError("The remote side closed the socket"); socketReader.Dispose(); UpdateConnectionStatus(ConnectionStatus.Disconnected); } } else { SocketError("The remote side closed the socket"); socketReader.Dispose(); UpdateConnectionStatus(ConnectionStatus.Disconnected); } } catch (Exception e) { if (!_socketClosed) { SocketError("Reading from socket failed: " + e.Message); } socketReader.Dispose(); } }
public async void StartReader(ConnectedPeer connectedPeer) { try { using (var socketReader = new Windows.Storage.Streams.DataReader(connectedPeer._socket.InputStream)) { // Read the message sent by the remote peer uint bytesRead = await socketReader.LoadAsync(sizeof(uint)); if (bytesRead > 0) { uint strLength = (uint)socketReader.ReadUInt32(); bytesRead = await socketReader.LoadAsync(strLength); if (bytesRead > 0) { String message = socketReader.ReadString(strLength); OnRaiseMessageEvent(new MessageEventArgs("Got message: " + message)); StartReader(connectedPeer); // Start another reader } else { OnRaiseSocketErrorEvent(new SocketEventArgs("The remote side closed the socket")); } } else { OnRaiseSocketErrorEvent(new SocketEventArgs("The remote side closed the socket")); } socketReader.DetachStream(); } } catch (Exception e) { if (!connectedPeer._socketClosed) { OnRaiseSocketErrorEvent(new SocketEventArgs("Reading from socket failed: " + e.Message)); } } }
/// <summary> /// When new client is added /// </summary> /// <param name="sender"></param> /// <param name="e"></param> public async void ClientAdded(object sender, EventArgs e) { var socket = ((CustomEventArgs)e).ClientSocket; var clientReader = new DataReader(socket.InputStream); clientReader.InputStreamOptions = InputStreamOptions.Partial; string clientName; while (true) { uint sizeFieldCount = await clientReader.LoadAsync(sizeof(uint)); if (sizeFieldCount != sizeof(uint)) { // The underlying socket was closed before we were able to read the whole data. return; } uint bytesLength = clientReader.ReadUInt32(); uint actualBytesLength = await clientReader.LoadAsync(bytesLength); if (bytesLength != actualBytesLength) { // The underlying socket was closed before we were able to read the whole data. return; } var buffer = new byte[bytesLength]; clientReader.ReadBytes(buffer); clientName = Encoding.Unicode.GetString(buffer); var newClient = new ConnectedClient(clientName, socket); clients.Add(newClient); break; } OnClientConnected(socket, clientName); foreach (var client in clients) SendUsersList(client.Connection, client.UserName, clientName, ChatHelper.CONNECTED); var state = new ChatHelper.StateObject { InputStream = socket.InputStream }; var dataReader = new DataReader(socket.InputStream); var buff = new byte[dataReader.UnconsumedBufferLength]; dataReader.ReadBytes(buff); //ChatHelper.WriteToEventLog(Log.ClientConnected, EventLogEntryType.Information); }
/// <summary> /// 监听后连接的事件 /// </summary> /// <param name="sender"></param> /// <param name="args"></param> private async void OnConnection(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args) { DataReader reader = new DataReader(args.Socket.InputStream); try { //循环接受数据 while (true) { uint sizeFieldCount = await reader.LoadAsync(sizeof(uint)); if (sizeFieldCount != sizeof(uint)) { //在socket关闭之前才可以读取全部的数据 return; } //读取监听到的信息 uint stringLength= reader.ReadUInt32(); uint actualStringLength = await reader.LoadAsync(stringLength); if (stringLength != actualStringLength) { //在socket关闭之前才可以读取全部的数据 return; } //读取监听到的信息的内容 string msg = reader.ReadString(actualStringLength); //将信息显示到界面 await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { TextBlock tb = new TextBlock { Text = msg, FontSize = 20 }; receive_Msg.Children.Add(tb); }); } } catch (Exception ex) { //未知异常 if (SocketError.GetStatus(ex.HResult) == SocketErrorStatus.Unknown) { throw; } } }
private async Task<string> Receive() { if (socket == null) return null; using (DataReader reader = new DataReader(socket.InputStream)) { // reader.InputStreamOptions = InputStreamOptions.Partial; reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; reader.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian; try { while (true) { StringBuilder ImageStrBuilder = new StringBuilder(); // Set the DataReader to only wait for available data (so that we don't have to know the data size) // reader.InputStreamOptions = Windows.Storage.Streams.InputStreamOptions.Partial; // The encoding and byte order need to match the settings of the writer we previously used. // Send the contents of the writer to the backing stream. // Get the size of the buffer that has not been read. // await Task.Delay(50); // if (socket == null) return null; 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 null; } 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 null; } // Keep reading until we consume the complete stream. // while (reader.UnconsumedBufferLength > 0) // { // ImageStrBuilder.Append(reader.ReadString(reader.UnconsumedBufferLength)); // await reader.LoadAsync(2048); // } // ImageString = ImageStrBuilder.ToString(); // else if (ImageStrBuilder.Length < 100 && ImageStrBuilder.Length > 0) // { // Calculate(ImageString); // } // ClientAddLine("Received(" + DateTime.Now.ToString("h:mm:ss") + "): " + ImageStrBuilder.ToString()); //await Task.Factory.StartNew(ReloadPicture); // Send(2); ImageStrBuilder.Append(reader.ReadString(actualStringLength)); // reader.DetachBuffer(); reader.DetachStream(); // reader.Dispose(); return ImageStrBuilder.ToString(); // return "error"; } } catch (Exception e) { // ClientWaitForMessage(); //received = false; return "error"; } } }
private async void btnConnect_Tapped(object sender, TappedRoutedEventArgs e) { // By default 'HostNameForConnect' is disabled and host name validation is not required. When enabling the // text box validating the host name is required since it was received from an untrusted source // (user input). The host name is validated by catching ArgumentExceptions thrown by the HostName // constructor for invalid input. HostName hostName; try { hostName = new HostName(this.txtBoxAddress.Text); } catch (ArgumentException) { rootPage.ShowMessage("Error: Invalid host name."); return; } this.socketSend = new StreamSocket(); // If necessary, tweak the socket's control options before carrying out the connect operation. // Refer to the StreamSocketControl class' MSDN documentation for the full list of control options. this.socketSend.Control.KeepAlive = false; try { rootPage.ShowMessage("Connecting to: " + hostName); // Connect to the server (by default, the listener we created in the previous step). await this.socketSend.ConnectAsync(hostName, ServiceName); isConnect = true; rootPage.ShowMessage("Connected"); await Task.Run(async () => { DataReader reader = new DataReader(this.socketSend.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; } byte[] dataArray = new byte[actualStringLength]; reader.ReadBytes(dataArray); await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async () => { inkCanvas.InkPresenter.StrokeContainer.Clear(); InMemoryRandomAccessStream randomAccessStream = new InMemoryRandomAccessStream(); await randomAccessStream.WriteAsync(dataArray.AsBuffer()); randomAccessStream.Seek(0); await inkCanvas.InkPresenter.StrokeContainer.LoadAsync(randomAccessStream); }).AsTask(); // 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. //Debug.WriteLine(String.Format("Received data: \"{0}\"", reader.ReadString(actualStringLength))); //string str = 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) { rootPage.ShowMessage("Connect failed with error: " + exception.Message); } } }); } 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) { rootPage.ShowMessage("Connect failed with error: " + exception.Message); } } }
/// <summary> /// Invoked when the socket listener accepted an incoming Bluetooth connection. /// </summary> /// <param name="sender">The socket listener that accecpted the connection.</param> /// <param name="args">The connection accept parameters, which contain the connected socket.</param> private async void OnConnectionReceived( StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args) { try { NotifyStatus("Client Connected"); // Don't need the listener anymore socketListener.Dispose(); socketListener = null; socket = args.Socket; writer = new DataWriter(socket.OutputStream); var reader = new DataReader(socket.InputStream); bool remoteDisconnection = false; while (true) { uint readLength = await reader.LoadAsync(sizeof(uint)); if (readLength < sizeof(uint)) { remoteDisconnection = true; break; } uint currentLength = reader.ReadUInt32(); readLength = await reader.LoadAsync(currentLength); if (readLength < currentLength) { remoteDisconnection = true; break; } string message = reader.ReadString(currentLength); await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { ConversationListBox.Items.Add("Received: " + message); }); } reader.DetachStream(); if (remoteDisconnection) { await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { Disconnect(); NotifyStatus("Client disconnected."); }); } } catch (Exception e) { NotifyError(e); } }
private async void OnConnection(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args) { DataReader reader = new DataReader(args.Socket.InputStream); socketReceive = args.Socket; this.isConnect = true; await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { this.txtBoxAddress.Text = "Connected"; }); 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; } byte[] dataArray = new byte[actualStringLength]; reader.ReadBytes(dataArray); await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async () => { //set new ink inkCanvas.InkPresenter.StrokeContainer.Clear(); InMemoryRandomAccessStream randomAccessStream = new InMemoryRandomAccessStream(); await randomAccessStream.WriteAsync(dataArray.AsBuffer()); randomAccessStream.Seek(0); await inkCanvas.InkPresenter.StrokeContainer.LoadAsync(randomAccessStream); }).AsTask(); } } 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) { rootPage.ShowMessage( "Start Receive failed with error: " + exception.Message); } } }