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
});
}
}
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);
}
}
}
}
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 static async void WebSocketClient_MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args)
{
if (args.MessageType == SocketMessageType.Utf8)
{
string jsonOutput = null;
using (var dataReader = args.GetDataReader())
{
dataReader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
jsonOutput = dataReader.ReadString(dataReader.UnconsumedBufferLength);
}
// Occasionally, the Direct Line service sends an empty message as a liveness ping. Ignore these messages.
if (string.IsNullOrWhiteSpace(jsonOutput))
{
return;
}
var activitySet = JsonConvert.DeserializeObject <ActivitySet>(jsonOutput);
var activities = activitySet.Activities.Where(a => a.From.Id == Settings.Instance.BotId);
foreach (var activity in activities)
{
Debug.WriteLine(activity.Text);
OnResponseReceived?.Invoke(null, new BotEventArgs(activity.Text));
// If there is an audio attached to the response, automatically speaks it.
var audioResponseUrl = activity.Attachments?.FirstOrDefault(a => a.ContentType == "audio/mp3")?.ContentUrl;
if (audioResponseUrl != null)
{
await TextToSpeech.SpeakAsync(activity.Speak ?? activity.Text, Settings.Instance.Culture, audioResponseUrl);
}
}
}
}
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);
}
}
}
}
}
private void Websocket_MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args)
{
using (var reader = args.GetDataReader()) {
string message = reader.ReadString(reader.UnconsumedBufferLength);
OnMessage(message);
}
}
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");
}
}
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 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 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 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)
{
}
}
//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
}
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 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);
}
}
}
}
}
// 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;
}
}
}
/// <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);
}
}
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>
/// 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 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)
{
var reader = args.GetDataReader();
reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
receiveJson = JsonConvert.DeserializeObject <JObject>(reader.ReadString(reader.UnconsumedBufferLength));
ClassificationMsg();
}
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 OnMessageRecieved(MessageWebSocket FromSocket, MessageWebSocketMessageReceivedEventArgs InputMessage)
{
MessageEventArgs OutputMessage = null;
if (InputMessage.MessageType == SocketMessageType.Utf8)
{
var stringLength = InputMessage.GetDataReader().UnconsumedBufferLength;
string receivedMessage = InputMessage.GetDataReader().ReadString(stringLength);
OutputMessage = new MessageEventArgs(receivedMessage);
}
else
{
// todo!
//OutputMessage = new MessageEventArgs( InputMessage.GetDataStream().ReadAsync );
}
OnMessage.Invoke(this, OutputMessage);
}
void Receive(MessageWebSocket FromSocket, MessageWebSocketMessageReceivedEventArgs InputMessage)
{
try
{
using (var reader = InputMessage.GetDataReader())
{
var messageLength = InputMessage.GetDataReader().UnconsumedBufferLength;
byte[] receivedMessage = new byte[messageLength];
reader.UnicodeEncoding = UnicodeEncoding.Utf8;
reader.ReadBytes(receivedMessage);
OnReceive.Invoke(this, new MessageEventArgs(receivedMessage));
}
}
catch
{
return;
}
}
//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);
}
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);
}
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 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();
}
