void OnMessageRecieved(MessageWebSocket FromSocket, MessageWebSocketMessageReceivedEventArgs InputMessage) { UnityEngine.WSA.Application.InvokeOnAppThread(() => { try { MessageEventArgs OutputMessage = null; var dr = InputMessage.GetDataReader(); if (InputMessage.MessageType == SocketMessageType.Utf8) { var stringLength = dr.UnconsumedBufferLength; string receivedMessage = dr.ReadString(stringLength); OutputMessage = new MessageEventArgs(receivedMessage); } else { var buf = new byte[dr.UnconsumedBufferLength]; dr.ReadBytes(buf); OutputMessage = new MessageEventArgs(buf); } unprocessedMessageEvents.Enqueue(OutputMessage); } catch (Exception e) { OnError?.Invoke(this, new ErrorEventArgs("Socket recieve error: " + e.Message)); } }, false); }
private void MessageRecieved(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args) { if (SocketMessageType.Utf8 == args.MessageType) { try { using (var reader = args.GetDataReader()) { reader.UnicodeEncoding = UnicodeEncoding.Utf8; var read = reader.ReadString(reader.UnconsumedBufferLength); var sensorReadings = JsonConvert.DeserializeObject <List <Messenger.SensorReading> >(read); if (sensorReadings != null) { #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues Messenger.Instance.NewSensorDataPoint.Invoke(sensorReadings, true); #pragma warning restore CS4014 } //Debug.WriteLine(read); } } catch (Exception ex) { Debug.WriteLine(ex.Message); //If it's not inc connected state, then probably someone is already cleaning it up if ( (ConnectionState) Interlocked.CompareExchange(ref _connectionState, (long)ConnectionState.WillTryConnect, (long)ConnectionState.Connected) == ConnectionState.Connected) { CleanUp(); ScheduleReconnection(false); } } } }
private void HandleOnMessage(object sender, MessageWebSocketMessageReceivedEventArgs args) { if (OnMessage == null) { return; } try { using (var reader = args.GetDataReader()) { if (args.MessageType == SocketMessageType.Utf8) { string text = reader.ReadString(reader.UnconsumedBufferLength); OnMessage.Invoke(sender, new WebSocketMessageEventArgs(text)); } else if (args.MessageType == SocketMessageType.Binary) { byte[] data = new byte[reader.UnconsumedBufferLength]; reader.ReadBytes(data); OnMessage.Invoke(sender, new WebSocketMessageEventArgs(data)); } } } catch (Exception ex) { WebErrorStatus status = WebSocketError.GetStatus(ex.GetBaseException().HResult); RaiseError(status.ToString() + " " + ex.Message); } }
private void Websocket_MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args) { using (var reader = args.GetDataReader()) { string message = reader.ReadString(reader.UnconsumedBufferLength); OnMessage(message); } }
private void OnMessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args) { try { using (DataReader reader = args.GetDataReader()) { reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; byte[] read = new byte[reader.UnconsumedBufferLength]; reader.ReadBytes(read); try { WebSocketMessage message = WebSocketMessage.ParseFrom(read); Debug.WriteLine("Message Type: " + message.Type); if (message.Type == WebSocketMessage.Types.Type.REQUEST) { incomingRequests.AddFirst(message.Request); MessageReceived(this, message.Request); } } catch (InvalidProtocolBufferException e) { Debug.WriteLine(e.Message); } } } catch (Exception e) { throw new Exception(e.Message); } }
private void MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args) { // Dispatch the event to the UI thread so we can update UI. var ignore = Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { string partialOrCompleted = "Partial"; if (args.IsMessageComplete) { partialOrCompleted = "Complete"; } AppendOutputLine(partialOrCompleted + " message received; Type: " + args.MessageType); using (DataReader reader = args.GetDataReader()) { reader.UnicodeEncoding = UnicodeEncoding.Utf8; try { // Note that it may be possible for partial UTF8 messages to be split between a character if it // extends multiple bytes. We avoid this by using only ASCII characters in this example. // Should your application use multi-byte characters, you will need to do checks for broken characters. string read = reader.ReadString(reader.UnconsumedBufferLength); AppendOutputLine(read); } catch (Exception ex) { AppendOutputLine(MainPage.BuildWebSocketError(ex)); AppendOutputLine(ex.Message); } } }); }
private void MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args) { try { System.Diagnostics.Debug.WriteLine("Message Received; Type: " + args.MessageType); using (DataReader reader = args.GetDataReader()) { reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; string read = reader.ReadString(reader.UnconsumedBufferLength); //Convert to JSON if (read != "") { } System.Diagnostics.Debug.WriteLine(read); } } catch (Exception ex) // For debugging { WebErrorStatus status = WebSocketError.GetStatus(ex.GetBaseException().HResult); if (status == WebErrorStatus.Unknown) { throw; } // Normally we'd use the status to test for specific conditions we want to handle specially, // and only use ex.Message for display purposes. In this sample, we'll just output the // status for debugging here, but still use ex.Message below. System.Diagnostics.Debug.WriteLine("Error: " + status); System.Diagnostics.Debug.WriteLine(ex.Message); } }
private async void OnMessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args) { if (OnData == null) { return; } Exception exception = null; try { var reader = args.GetDataReader(); var text = reader.ReadString(reader.UnconsumedBufferLength); OnData(sender, new DataReceivedEventArgs { TextData = text }); } catch (Exception e) { exception = e; } // cannot await in catch if (exception != null) { _connectionState = ConnectionState.Failed; try { await Reconnect(); } catch (Exception e) { Error(e); } } }
/// <summary> /// Handler for received message. /// Associated with Websocket. /// </summary> private void ReceivedMessage(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args) { try { // Use a datareader to read the message // out of the websocket args. using (DataReader dataReader = args.GetDataReader()) { dataReader.UnicodeEncoding = UnicodeEncoding.Utf8; string wrapped = dataReader.ReadString(dataReader.UnconsumedBufferLength); SignallerMessage unwrapped = this.MessageProtocol.UnwrapMessage(wrapped); this.MessageHandlers[(string)unwrapped.Type]?.Invoke(this, unwrapped); } } catch (Exception ex) { Windows.Web.WebErrorStatus webErrorStatus = WebSocketError.GetStatus ( ex.GetBaseException().HResult ); System.Diagnostics.Debug.WriteLine(ex.ToString()); this.IsConnected = false; this.ConnectionFailedUIHandler?.Invoke(this, EventArgs.Empty); } }
// Regarding the async modifier - see https://github.com/Code-Sharp/WampSharp/issues/122 protected override async void OnMessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args) { try { Stream stream = args.GetDataStream().AsStreamForRead(); MemoryStream memoryStream = new MemoryStream(); await stream.CopyToAsync(memoryStream); stream.Position = 0; WampMessage <TMessage> message = mBinaryBinding.Parse(stream); RaiseMessageArrived(message); } catch (Exception ex) { RaiseConnectionError(ex); if (mWebSocket != null) { mWebSocket.Dispose(); } } }
private void MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args) { try { MarshalText(OutputField, "Message Received; Type: " + args.MessageType + "\r\n"); using (DataReader reader = args.GetDataReader()) { reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; string read = reader.ReadString(reader.UnconsumedBufferLength); MarshalText(OutputField, read + "\r\n"); } } catch (Exception ex) // For debugging { WebErrorStatus status = WebSocketError.GetStatus(ex.GetBaseException().HResult); if (status == WebErrorStatus.Unknown) { throw; } // Normally we'd use the status to test for specific conditions we want to handle specially, // and only use ex.Message for display purposes. In this sample, we'll just output the // status for debugging here, but still use ex.Message below. MarshalText(OutputField, "Error: " + status + "\r\n"); MarshalText(OutputField, ex.Message + "\r\n"); } }
// When it is echoed back private void SocketMessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args) { try { Dispatcher.RunAsync( CoreDispatcherPriority.Normal, () => { this.Status.Text = "Message Received."; using (var reader = args.GetDataReader()) { reader.UnicodeEncoding = UnicodeEncoding.Utf8; var text = reader.ReadString(reader.UnconsumedBufferLength); this.Response.Text = text; } }); } catch (Exception ex) { Dispatcher.RunAsync( CoreDispatcherPriority.Normal, () => this.Status.Text = ToErrorMessage(ex)); } finally { if (this.socket != null) { this.socket.Dispose(); this.socket = null; } } }
private async void OnMessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args) { using (DataReader dataReader = args.GetDataReader()) { dataReader.UnicodeEncoding = UnicodeEncoding.Utf8; string messageReceived = dataReader.ReadString(dataReader.UnconsumedBufferLength); Debug.WriteLine($"[{DateTime.Now}]Message received from MessageWebSocket: {messageReceived}"); dynamic message = JsonConvert.DeserializeObject(messageReceived); if (message.msg != null && message.msg == "ping") { await PongRequest(); return; } if (message.msg != null) { if (message.msg == "changed" && message.collection == "stream-notify-logged") { HandleUserConnectionStatusChange(messageReceived); } if (message.msg == "changed" && message.collection == "stream-room-messages") { if (message.fields.eventName == "__my_messages__") { HandleUserNotifyStream(messageReceived); } } } } }
private void WebSocket_MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args) { try { DataReader reader = args.GetDataReader(); reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; // Read Message string message = reader.ReadString(reader.UnconsumedBufferLength); // Parse Message JsonObject json = JsonValue.Parse(message).GetObject(); if (json.GetNamedString("type") == "answer") { AnswerReceived(json.GetNamedString("sdp")); } else if (json.GetNamedString("type") == "ice") { RemoteICECandidateReceived(json.GetNamedString("candidate"), (ushort)json.GetNamedNumber("sdpMLineIndex"), json.GetNamedString("sdpMid")); } } catch (Exception) { } }
private void OnMessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args) { using (var reader = args.GetDataReader()) { reader.UnicodeEncoding = UnicodeEncoding.Utf8; var response = reader.ReadString(reader.UnconsumedBufferLength); var json = JObject.Parse(response); if (json.ContainsKey("replyID")) { var replyId = json.Value <int>("replyID"); if (_callbacks.TryGetValue(replyId, out var callback)) { if (json != null && json.TryGetValue("result", out var result)) { if (result.Type == JTokenType.String) { callback.TrySetResult(JToken.Parse(result.Value <string>())); } else { callback.TrySetResult(result); } } else { callback.TrySetResult(null); } } } } }
public static void Socket_MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args) { try { using (DataReader dataReader = args.GetDataReader()) { dataReader.UnicodeEncoding = UnicodeEncoding.Utf8; string rawMsg = dataReader.ReadString(dataReader.UnconsumedBufferLength); var(msg, cvt) = SocketMessageConverter.Read(rawMsg); if (cvt != null) { var cvtType = cvt.GetType(); switch (cvtType.Name) { case nameof(OpenConverter): SocketId = msg; break; case nameof(MessageConverter): MessageReceived(msg); break; case nameof(FeedConverter): FeedReceived(msg); break; } } } } catch { } }
private void OnMessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args) { try { if (args.MessageType == SocketMessageType.Utf8) { string jsonOutput; using (var dataReader = args.GetDataReader()) { dataReader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; jsonOutput = dataReader.ReadString(dataReader.UnconsumedBufferLength); } var result = JsonConvert.DeserializeObject <SpeechTranslationResult>(jsonOutput); this.onSpeechTranslateResult(result); } else if (args.MessageType == SocketMessageType.Binary) { using (var dataReader = args.GetDataReader()) { dataReader.ByteOrder = ByteOrder.LittleEndian; this.onTextToSpeechData(AudioFrameHelper.GetAudioFrame(dataReader)); } } } catch (Exception e) { this.onSpeechTranslateResult(new SpeechTranslationResult() { Status = e.Message }); } }
//Message Arrived Handler private void WebSocket_MessageArrived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args) { #if !UNITY_EDITOR try { if (OnReceiveMessenger == null) { return; } using (DataReader dataReader = args.GetDataReader()) { if (dataReader != null) { dataReader.UnicodeEncoding = UnicodeEncoding.Utf8; string message = dataReader.ReadString(dataReader.UnconsumedBufferLength); OnReceiveMessenger?.Invoke(message); } } } catch (Exception ex) { Debug.WriteLine(ex.Message); } #endif }
/// <summary> /// Raw websocket messages from server - convert to message types and call subscribers of events and/or callbacks /// </summary> /// <param name="sender"></param> /// <param name="args"></param> void mws_MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args) { string read = null; try { using (DataReader reader = args.GetDataReader()) { reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; read = reader.ReadString(reader.UnconsumedBufferLength); Debug.WriteLine("[SOCKET_IO]: < " + read); } IMessage iMsg = SocketIOClient.Messages.Message.Factory(read); if (iMsg.Event == "responseMsg") { Debug.WriteLine(string.Format("InvokeOnEvent: {0}", iMsg.RawMessage)); } switch (iMsg.MessageType) { case SocketIOMessageTypes.Disconnect: this.OnMessageEvent(iMsg); if (string.IsNullOrWhiteSpace(iMsg.Endpoint)) // Disconnect the whole socket { this.Close(); } break; case SocketIOMessageTypes.Heartbeat: this.OnHeartBeatTimerCallback(null); break; case SocketIOMessageTypes.Connect: case SocketIOMessageTypes.Message: case SocketIOMessageTypes.JSONMessage: case SocketIOMessageTypes.Event: case SocketIOMessageTypes.Error: this.OnMessageEvent(iMsg); break; case SocketIOMessageTypes.ACK: this.registrationManager.InvokeCallBack(iMsg.AckId, iMsg.Json); break; default: Debug.WriteLine("unknown mws message Received..."); break; } } catch (Exception ex) // For debugging { this.mwsState = WebSocketState.Closed; WebErrorStatus status = WebSocketError.GetStatus(ex.GetBaseException().HResult); Debug.WriteLine("mws_MessageReceived::exception : " + status); this.OnErrorEvent(this, new ErrorEventArgs(status.ToString(), ex)); //this.Close(); } }
private void MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args) { var reader = args.GetDataReader(); reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; receiveJson = JsonConvert.DeserializeObject <JObject>(reader.ReadString(reader.UnconsumedBufferLength)); ClassificationMsg(); }
private void HandleMessage(object sender, MessageWebSocketMessageReceivedEventArgs e) { using (var dataReader = e.GetDataReader()) { string messageString = dataReader.ReadString(dataReader.UnconsumedBufferLength); OnMessageReceived(messageString); } }
/// <summary> /// Read a single string and return it. /// </summary> /// <param name="args"> /// The args. /// </param> /// <returns> /// The string which was read. /// </returns> private static string ReadString(MessageWebSocketMessageReceivedEventArgs args) { using (var stream = args.GetDataReader()) { stream.UnicodeEncoding = UnicodeEncoding.Utf8; return(stream.ReadString(stream.UnconsumedBufferLength)); } }
private void MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args) { using (DataReader reader = args.GetDataReader()) { reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; socketSubject.OnNext(reader.ReadString(reader.UnconsumedBufferLength)); } }
void ws_MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args) { var log = LogManager.GetLogger(Global.CallerName()); try { // Instead of using args.GetDataReader, using args.GetDataStream. and create DataReader ourself. // Because if there's no length to read then using GetDataReader would cause exception var dataReader = new DataReader(args.GetDataStream()); if (args.MessageType == SocketMessageType.Utf8) { using (dataReader) { // if there's no length to read then do nothing. preventing exception if (dataReader.UnconsumedBufferLength == 0) { return; } // The encoding and byte order need to match the settings of the writer // we previously used. dataReader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; dataReader.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian; var data = dataReader.ReadString(dataReader.UnconsumedBufferLength); log.Info("ws_MessageReceived e.Message= " + data); this.OnData(data); } } else if (args.MessageType == SocketMessageType.Binary) { using (dataReader) { // if there's no length to read then do nothing. preventing exception if (dataReader.UnconsumedBufferLength == 0) { return; } dataReader.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian; byte[] bytes = new byte[dataReader.UnconsumedBufferLength]; dataReader.ReadBytes(bytes); log.Info("ws_MessageReceived e.Message= " + bytes); this.OnData(bytes); } } else { throw new InvalidDataException("MessageWebSocketMessageReceivedEventArgs wrong MessageType "); } } catch (Exception e) { this.OnError("ws_MessageReceived", e); } }
private void MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args) { var messageReader = args.GetDataReader(); messageReader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; var messageString = messageReader.ReadString(messageReader.UnconsumedBufferLength); this.OnMessageReceived?.Invoke(this, messageString); }
//The MessageReceived event handler. DON'T ACCESS CANVAS!!!! private void WebSock_MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args) { DataReader messageReader = args.GetDataReader(); messageReader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; messageReader.ByteOrder = ByteOrder.LittleEndian; incomingMessageString = messageReader.ReadString(messageReader.UnconsumedBufferLength); ReceiveAndEnqueue(incomingMessageString); }
void Websocket_MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args) { if (OnMessaged != null) { var reader = args.GetDataReader(); reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; OnMessaged(sender, new WebSocketEventArgs(reader.ReadString(reader.UnconsumedBufferLength))); } }
private void WebSocketMessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args) { if (args.MessageType == SocketMessageType.Utf8) { string jsonOutput; using (var dataReader = args.GetDataReader()) { dataReader.UnicodeEncoding = UnicodeEncoding.Utf8; jsonOutput = dataReader.ReadString(dataReader.UnconsumedBufferLength); } var result = JsonConvert.DeserializeObject <Result>(jsonOutput); foreach (var receiver in TextReceivers) { receiver.OnTextReceived(result); } } else if (args.MessageType == SocketMessageType.Binary) { // the binary output is the text to speech audio using (var dataReader = args.GetDataReader()) { dataReader.ByteOrder = ByteOrder.LittleEndian; // Read the data from the audio returned - convert to [-1.0f, 1.0f] // then we can use an AudioClip in Unity and set the data into it and // play it back... var numBytes = dataReader.UnconsumedBufferLength; // Skip over the RIFF header for PCM 16bit 16kHz mono output var headerSize = 44; var bytes = new byte[headerSize]; dataReader.ReadBytes(bytes); // skip the header var numSamples = (int)(numBytes - headerSize); float[] data = new float[numSamples]; //var count = await dataReader.LoadAsync(numSamples); int numInt16s = numSamples / sizeof(Int16); for (int i = 0; i < numInt16s; i++) { data[i] = dataReader.ReadInt16() / (float)Int16.MaxValue; } // Notify observers with this audio data.. (probably should notify the header // to future-proof but skip that for now - API data is signed 16bit PCM mono audio) _args.Data = data; foreach (var receiver in AudioReceivers) { receiver.OnAudioReceived(_args); } } } }
private static void WebSocket_ReceivedMessage(MessageWebSocket ws, MessageWebSocketMessageReceivedEventArgs args) { DataReader reader = args.GetDataReader(); reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; string result = reader.ReadString(reader.UnconsumedBufferLength); //Here, you need to put receive message to the chat room view model. Debug.WriteLine(result); }
private void WebSock_MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args) { DataReader messageReader = args.GetDataReader(); messageReader.UnicodeEncoding = UnicodeEncoding.Utf8; string messageString = messageReader.ReadString(messageReader.UnconsumedBufferLength); OnMessageReceived?.Invoke(messageString); messageReader.Dispose(); }