void FayeMessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args) {
string message;
using (var reader = args.GetDataReader()) {
message = reader.ReadString(reader.UnconsumedBufferLength);
}
message = message.Trim().TrimStart('[').TrimEnd(']');
var obj = Helpers.Deserialize<FayeResponse>(message);
if (obj.Channel == "/meta/handshake" && !_asyncHandshake) {
FinishHandshake(message);
Send(new ConnectRequest());
return;
}
if (obj.Channel == "/meta/connect") {
Send(new ConnectRequest());
}
if (obj.Successful != null && obj.Id != null) {
Guid guid;
if (Guid.TryParse(obj.Id, out guid)) {
if (_requestWaiters.ContainsKey(guid)) {
_requestSuccesses[guid] = (bool)obj.Successful;
_requestResponses[guid] = message;
Debug.WriteLine("Doing set for response on " + obj.Channel);
_requestWaiters[guid].Set();
return;
}
}
}
Event(MessageReceived, new FayeMessageEventArgs { Data = message, Channel = obj.Channel });
}
void _socket_MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args)
{
if (this.Message != null)
{
try
{
using (MemoryStream ms = new MemoryStream())
{
//Get the DataReader
using (var dataReader = new JsonTextReader(new StreamReader(ms)))
{
args.GetDataStream().AsStreamForRead().CopyTo(ms);
ms.Position = 0;
dataReader.SupportMultipleContent = true;
while (dataReader.Read())
{
var parsedMessage = JArray.Load(dataReader);
Message(this, new WampMessageEventArgs(parsedMessage));
}
}
}
}
catch (Exception ex)
{
var status = Windows.Networking.Sockets.WebSocketError.GetStatus(ex.HResult);
if (status != Windows.Web.WebErrorStatus.Unknown)
this.OnError(this, status);
}
}
}
private void socket_MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args)
{
using (StreamReader streamReader = new StreamReader(args.GetDataStream().AsStreamForRead()))
{
using (JsonReader jsonReader = new JsonTextReader(streamReader))
{
JObject jmessage = JObject.Load(jsonReader);
}
}
}
//Sends the data
private void MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args)
{
try
{
using (DataReader reader = args.GetDataReader())
{
reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
string read = reader.ReadString(reader.UnconsumedBufferLength);
}
}
catch (Exception ex)
{
String.Format("There is an error sending the data");
}
}
private async void Sck_MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args)
{
//[email protected]("Message received " + args);
if (args.MessageType == SocketMessageType.Utf8)
{
Windows.Storage.Streams.DataReader messageReader = args.GetDataReader();
messageReader.UnicodeEncoding = UnicodeEncoding.Utf8;
string messageString = messageReader.ReadString(messageReader.UnconsumedBufferLength);
com.codename1.io.websocket.WebSocket.messageReceived(id, messageString);
} else
{
Windows.Storage.Streams.IInputStream readStream = args.GetDataStream();
byte[] readBuffer = new byte[4096];
try
{
while (true)
{
if (sender != sck)
{
return;
}
IBuffer res = await readStream.ReadAsync(readBuffer.AsBuffer(), (uint)readBuffer.Length, 0);
if (res.Length == 0)
{
return;
}
byte[] resArr = new byte[res.Length];
res.CopyTo(resArr);
com.codename1.io.websocket.WebSocket.messageReceived(1, resArr);
}
} catch (Exception ex)
{
com.codename1.io.websocket.WebSocket.errorReceived(id, ex.Message, ex.HResult);
}
}
}
private void Mws_MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args)
{
// TODO
// 1. get the message out of the args.
// 2. add it to the outputBox content.
// Note that you're not necessarily on the UI thread when called asynchronously,
// and marshall over to the UI thread rather than just stuffing the UI element.
using (DataReader reader = args.GetDataReader())
{
reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
string read = reader.ReadString(reader.UnconsumedBufferLength);
MarshalText(outputBox, read + "\r\n");
}
}
private void WebSocket_MessageReceived(Windows.Networking.Sockets.MessageWebSocket sender, Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args)
{
using (DataReader dataReader = args.GetDataReader())
{
byte[] bytes = new byte[dataReader.UnconsumedBufferLength];
dataReader.ReadBytes(bytes);
Gabriel.ToClient toClient = Gabriel.ToClient.Parser.ParseFrom(bytes);
if (toClient.ResultWrapper == null)
{
// Set num tokens on welcome message
lock (_tokenLock)
{
_numTokens = toClient.NumTokens;
}
return;
}
// We only return one to avoid race conditions when we have multiple messages in flight
lock (_tokenLock)
{
_numTokens++;
}
Gabriel.ResultWrapper resultWrapper = toClient.ResultWrapper;
if (resultWrapper.Status != Gabriel.ResultWrapper.Types.Status.Success)
{
UnityEngine.Debug.Log("Output status was: " + resultWrapper.Status);
return;
}
Instruction.EngineFields newEngineFields = resultWrapper.EngineFields.Unpack <Instruction.EngineFields>();
if (newEngineFields.UpdateCount <= _engineFields.UpdateCount)
{
// There was no update or there was an update based on a stale frame
return;
}
for (int i = 0; i < resultWrapper.Results.Count(); i++)
{
Gabriel.ResultWrapper.Types.Result result = resultWrapper.Results[i];
if (!result.EngineName.Equals(Const.ENGINE_NAME))
{
UnityEngine.Debug.LogError("Got result from engine " + result.EngineName);
}
if (result.PayloadType == Gabriel.PayloadType.Text)
{
_speechFeedback = result.Payload.ToStringUtf8();
textToSpeechManager.SpeakText(_speechFeedback);
}
}
_engineFields = newEngineFields;
UpdateHologram(newEngineFields, resultWrapper.FrameId);
}
}
/// <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 OnMessageReceived(int id, MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args)
{
try
{
using (var reader = args.GetDataReader())
{
var message = reader.ReadString(reader.UnconsumedBufferLength);
SendEvent("websocketMessage", new JObject
{
{ "id", id },
{ "data", message },
});
}
}
catch (Exception ex)
{
OnError(id, ex);
}
}
public MessageReceivedEventArgsWrapper(MessageWebSocketMessageReceivedEventArgs messageReceivedEventArgs)
{
_messageReceivedEventArgs = messageReceivedEventArgs;
}
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");
}
}
private void MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args)
{
try
{
using (DataReader reader = args.GetDataReader())
{
reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
string read = reader.ReadString(reader.UnconsumedBufferLength);
}
}
catch (Exception ex)
{
WebErrorStatus status = WebSocketError.GetStatus(ex.GetBaseException().HResult);
}
}
private void OnMessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args)
{
using (DataReader reader = args.GetDataReader())
{
uint dataAvailable;
while ((dataAvailable = reader.UnconsumedBufferLength) > 0)
{
ArraySegment<byte> buffer;
try
{
buffer = _receiveAsyncBufferTcs.Task.GetAwaiter().GetResult();
}
catch (OperationCanceledException) // Caused by Abort call on WebSocket
{
return;
}
_receiveAsyncBufferTcs = new TaskCompletionSource<ArraySegment<byte>>();
WebSocketMessageType messageType;
if (args.MessageType == SocketMessageType.Binary)
{
messageType = WebSocketMessageType.Binary;
}
else
{
messageType = WebSocketMessageType.Text;
}
bool endOfMessage = false;
uint readCount = Math.Min(dataAvailable, (uint) buffer.Count);
var dataBuffer = reader.ReadBuffer(readCount);
// Safe to cast readCount to int as the maximum value that readCount can be is buffer.Count.
dataBuffer.CopyTo(0, buffer.Array, buffer.Offset, (int) readCount);
if (dataAvailable == readCount)
{
endOfMessage = true;
}
WebSocketReceiveResult recvResult = new WebSocketReceiveResult((int) readCount, messageType,
endOfMessage);
_webSocketReceiveResultTcs.TrySetResult(recvResult);
}
}
}
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, () =>
{
AppendOutputLine("Message Received; Type: " + args.MessageType);
using (DataReader reader = args.GetDataReader())
{
reader.UnicodeEncoding = UnicodeEncoding.Utf8;
try
{
string read = reader.ReadString(reader.UnconsumedBufferLength);
AppendOutputLine(read);
}
catch (Exception ex)
{
AppendOutputLine(MainPage.BuildWebSocketError(ex));
AppendOutputLine(ex.Message);
}
}
});
}
/// <summary>
/// The message web socket on message received.
/// </summary>
/// <param name="sender">
/// The sender.
/// </param>
/// <param name="args">
/// The args.
/// </param>
private void MessageWebSocketOnMessageReceived(
MessageWebSocket sender,
MessageWebSocketMessageReceivedEventArgs args)
{
using (var reader = args.GetDataReader())
{
reader.UnicodeEncoding = UnicodeEncoding.Utf8;
var stringRead = reader.ReadString(reader.UnconsumedBufferLength);
this.receiveQueue.Add(stringRead);
}
}
private void OnMessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args)
{
var t = args;
HasRecieved = false;
_deferral.Complete();
}
private void MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args)
{
ChatMessage msg = null;
try
{
using (DataReader reader = args.GetDataReader())
{
// get message and deserialize to ChatMessage
reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
string read = reader.ReadString(reader.UnconsumedBufferLength);
msg = JsonConvert.DeserializeObject<ChatMessage>(read);
}
}
catch (Exception ex) // For debugging
{
WebErrorStatus status = WebSocketError.GetStatus(ex.GetBaseException().HResult);
// Add your specific error-handling code here.
}
// Add item to the local queue
_queue.Enqueue(msg);
// Dispatch the queue handler
this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, DisplayMessage);
}
private void Message_MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args)
{
}
private void MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args)
{
try
{
using (DataReader reader = args.GetDataReader())
{
reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
string read = reader.ReadString(reader.UnconsumedBufferLength);
// parse the message
JObject messageObject = null;
try
{
messageObject = JObject.Parse(read);
}
catch(Exception e)
{
messageObject = null;
App.AddNotification(new Notification() { Title = "Error Parsing WebSocket Data Package", Message = e.Message });
}
// if we have an object and it is of type play
if (messageObject != null && "Play" == (string)messageObject["MessageType"])
{
Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
Frame rootFrame = Window.Current.Content as Frame;
rootFrame.Navigate(typeof(PlayerPage), messageObject);
});
}
}
}
catch (Exception ex) // For debugging
{
WebErrorStatus status = WebSocketError.GetStatus(ex.GetBaseException().HResult);
// Add your specific error-handling code here.
}
}
void _websocket_MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args)
{
try
{
using (var reader = args.GetDataReader())
{
reader.UnicodeEncoding = UnicodeEncoding.Utf8;
var text = reader.ReadString(reader.UnconsumedBufferLength);
OnMessage(text);
}
}
catch
{
OnError("Failed to read message.");
}
}
private string GetOnMessage(MessageWebSocketMessageReceivedEventArgs args)
{
try
{
var dataStream = args.GetDataStream();
using (DataReader reader = args.GetDataReader())
{
reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
string read = reader.ReadString(reader.UnconsumedBufferLength);
return read;
}
}
catch (Exception ex)
{
WebErrorStatus status = WebSocketError.GetStatus(ex.GetBaseException().HResult);
}
return String.Empty;
}
private void webSocketClient_MessageReceivedV2(object sender, MessageWebSocketMessageReceivedEventArgs e)
{
try
{
var dataStream = e.GetDataStream();
using (DataReader reader = e.GetDataReader())
{
reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
string read = reader.ReadString(reader.UnconsumedBufferLength);
IDictionary<string, object> e1 = AVClient.DeserializeJsonString(read);
if (this.m_onRecevied == null)
return;
this.m_onRecevied((object)this, e1);
}
}
catch (ArgumentException ex)
{
throw ex;
}
}
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");
var callback = default(TaskCompletionSource<JToken>);
if (_callbacks.TryGetValue(replyId, out callback))
{
var result = default(JToken);
if (json != null && json.TryGetValue("result", out result))
{
if (result.Type == JTokenType.String)
{
callback.TrySetResult(JToken.Parse(result.Value<string>()));
}
else
{
callback.TrySetResult(result);
}
}
else
{
callback.TrySetResult(null);
}
}
}
}
}
private IDictionary<string, object> CaptureResponseByCMDId(string cmdId, MessageWebSocketMessageReceivedEventArgs e)
{
IDictionary<string, object> dictionary = null;
IDictionary<string, object> data = AVClient.DeserializeJsonString(GetOnMessage(e));
if (AVRMProtocolUtils.CaptureValueFromDictionary<long>(data, "i").ToString() == cmdId)
dictionary = data;
return dictionary;
}
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 webSocketClient_MessageReceived(object sender, MessageWebSocketMessageReceivedEventArgs e)
{
string[] array = new string[6]
{
"session",
"direct",
"presence",
"ackreq",
"ack",
"room"
};
EventHandler<AVIMEventArgs>[] eventHandlerArray = new EventHandler<AVIMEventArgs>[6]
{
this.m_OnSessionChanged,
this.m_OnMessage,
this.m_OnPresenceChanged,
this.m_OnAskReqGet,
this.m_OnMessageSent,
this.m_OnGroupAction
};
RealtimeMessageHooks.CreateAVSessionEventArgs[] sessionEventArgsArray = new RealtimeMessageHooks.
CreateAVSessionEventArgs[6]
{
new RealtimeMessageHooks.CreateAVSessionEventArgs(this.ProcessAVSession),
new RealtimeMessageHooks.CreateAVSessionEventArgs(this.ProcessAVMessage),
new RealtimeMessageHooks.CreateAVSessionEventArgs(this.ProcessAVPresence),
new RealtimeMessageHooks.CreateAVSessionEventArgs(this.ProcessAckReq),
new RealtimeMessageHooks.CreateAVSessionEventArgs(this.ProcessAck),
new RealtimeMessageHooks.CreateAVSessionEventArgs(this.ProcessAVGroupOp)
};
IDictionary<string, object> data = AVClient.DeserializeJsonString(GetOnMessage(e));
try
{
string str = AVRMProtocolUtils.CaptureValueFromDictionary<string>(data, "cmd");
int index = Array.IndexOf<string>(array, str);
if (index <= -1)
return;
EventHandler<AVIMEventArgs> eventHandler = eventHandlerArray[index];
AVIMEventArgs e1 = sessionEventArgsArray[index](data);
if (eventHandler == null)
return;
eventHandler((object) this, e1);
}
catch
{
}
}
private void MessageReceived(MessageWebSocket webSocket, MessageWebSocketMessageReceivedEventArgs eventArgs)
{
MessageReceived(new MessageReceivedEventArgsWrapper(eventArgs), _connection);
}
private void HandleMessage(MessageWebSocketMessageReceivedEventArgs args)
{
string message;
DataReader reader = null;
try
{
try
{
reader = args.GetDataReader();
}
catch
{
try
{
_webSocket.Close(1001, "Abnormal Closure");
}
catch
{
HandleConnectionClose();
}
return;
}
reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
message = reader.ReadString(reader.UnconsumedBufferLength);
}
finally
{
if (reader != null)
{
reader.Dispose();
}
}
var json = JObject.Parse(message);
var requestId = (string)json["requestId"];
if (requestId == null)
{
// handle server notifications
var action = (string)json["action"];
switch (action)
{
case "notification/insert":
{
var notification = Deserialize<DeviceNotification>(json);
InvokeSubscriptionCallback(notification.SubscriptionId, notification.Notification.Timestamp.Value, notification.Notification);
}
return;
case "command/insert":
{
var command = Deserialize<DeviceCommand>(json);
InvokeSubscriptionCallback(command.SubscriptionId, command.Command.Timestamp.Value, command.Command);
}
return;
case "command/update":
{
var command = Deserialize<Command>((JObject)json["command"]);
InvokeCommandCallback(command);
}
return;
}
}
// handle responses to client requests
RequestInfo requestInfo = null;
lock (_requests)
{
if (_requests.TryGetValue(requestId, out requestInfo))
_requests.Remove(requestId);
}
if (requestInfo != null)
requestInfo.SetResult(json);
}
private void WebSocket_MessageReceived(Windows.Networking.Sockets.MessageWebSocket sender, Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args)
{
try
{
using (var datastr = args.GetDataStream().AsStreamForRead())
using (var ms = new MemoryStream())
{
datastr.CopyTo(ms);
ms.Position = 0;
byte[] data = new byte[ms.Length];
ms.Read(data, 0, (int)ms.Length);
int index = 0;
int count = data.Length;
using (var decompressed = new MemoryStream())
{
if (data[0] == 0x78)
{
_compressed.Write(data, index + 2, count - 2);
_compressed.SetLength(count - 2);
}
else
{
_compressed.Write(data, index, count);
_compressed.SetLength(count);
}
_compressed.Position = 0;
if (decompressed == null)
{
return;
}
_decompressor.CopyTo(decompressed);
_compressed.Position = 0;
decompressed.Position = 0;
using (var reader = new StreamReader(decompressed))
OnMessageReceived(reader.ReadToEnd());
}
}
}
catch (Exception)
{
FinishedTask = true;
UpdateLastRunStatus("There was a problem while decrypting a websocket message on the last run");
}
}
void MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args)
{
var ev = _onMessageReceived;
if (ev == null)
return;
try
{
using (var reader = args.GetDataReader())
{
reader.UnicodeEncoding = UnicodeEncoding.Utf8;
var read = reader.ReadString(reader.UnconsumedBufferLength);
ev(read);
}
}
catch
{
}
}
private async void WebSocket_MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args)
{
StreamReader reader = new StreamReader(args.GetDataStream().AsStreamForRead(), System.Text.Encoding.UTF8);
// get the result in and check if its of type message
string result = null;
result = await reader.ReadToEndAsync();
WriteToOutputBox(result);
JObject responseObject = JObject.Parse(result);
string responseType = (string)responseObject["type"];
if (responseType == "message")
{
// then check if it was from the general channel
string channel = (string)responseObject["channel"];
if (channel == generalChannelId)
{
// then try to pull the user
string sendingUser = (string)responseObject["user"];
if (string.IsNullOrEmpty(sendingUser))
{
return;
}
SlackUser user = GetSlackUser(sendingUser);
if (user == null)
{
return;
}
// and pull what they said
string messageText = (string)responseObject["text"];
// construct our output message
string outputMessage = "";
if (user.FirstName != null)
{
outputMessage += user.FirstName + ": ";
}
else if (user.RealName != null)
{
outputMessage += user.RealName + ": ";
}
else
{
outputMessage += user.Username + ": ";
}
SmsUser smsToUser = null;
string rest = null;
if (messageText.StartsWith("<@"))
{
// if they are an actual slack member then pull up their info using their id
int nextBracket = messageText.IndexOf('>');
if (nextBracket == -1)
{
return;
}
string userId = messageText.Substring(2, nextBracket - 2);
SlackUser slackToUser = GetSlackUser(userId);
if (slackToUser == null)
{
return;
}
// and then try to find their SMS info
smsToUser = GetSmsUserByName(slackToUser.Username);
if (smsToUser == null)
{
smsToUser = GetSmsUserByName(slackToUser.FirstName);
}
if (smsToUser == null)
{
return;
}
rest = messageText.Substring(nextBracket + 1);
}
foreach (SmsUser smsUser in Secrets.SmsUsers)
{
if (smsUser.RealName == null)
{
// SMS user needs to at least have a real name
return;
}
// if they arent a slack member then just match using their name
if (messageText.StartsWith("@" + smsUser.RealName.ToLower()))
{
smsToUser = smsUser;
rest = messageText.Substring(smsToUser.RealName.Length + 1);
break;
}
}
if (smsToUser == null)
{
return;
}
if (rest.StartsWith(":"))
{
rest = rest.Substring(1);
}
rest = rest.Trim();
outputMessage += rest;
// then send the message to them
Message sentMessage = null;
try
{
twilioClient = new TwilioRestClient(Secrets.TwilioSid, Secrets.TwilioAuthToken);
sentMessage = twilioClient.SendMessage(Secrets.TwilioNumber, smsToUser.PhoneNumber, outputMessage);
}
catch (Exception ex)
{
WriteToOutputBox("Twilio SendMessage Exception: " + ex.Message);
}
}
}
if (responseType == "team_migration_started")
{
// hold my socket we're going in
// server is going down: https://api.slack.com/events/team_migration_started
serverIsDead = true;
// we shoudn't probably call ConnectToWebSocket here because we need this method to exit
// because ConnectToWebSocket turns everything into null
// so I stuck it in the listener since that's separate
return;
}
}
private void WebSocket_MessageReceived(Windows.Networking.Sockets.MessageWebSocket sender, Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args)
{
Debug.Log("message received");
try
{
using (DataReader dataReader = args.GetDataReader())
{
dataReader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
string messageString = dataReader.ReadString(dataReader.UnconsumedBufferLength);
JsonArray msgcontent = JsonObject.Parse(messageString).GetNamedArray("message");
Debug.Log("Message received from MessageWebSocket: " + msgcontent);
//this.messageWebSocket.Dispose(); //this closes the websocket
//do something with the message
try
{
foreach (IJsonValue message in msgcontent)
{
if (message.ValueType == JsonValueType.Object)
{
JsonObject messageObject = message.GetObject();
if (messageObject.GetNamedString("type") == "sensor") //{message: [{ type: 'sensor', id: 'temp1', data: '23.5'},
{ // { type: 'UIaction', id: 'ventilation', data: 'on'}]}
//update sensor with the received data
string sensor = messageObject.GetNamedString("id");
double data = messageObject.GetNamedValue("data").GetNumber();
UpdateStuff.Instance.UpdateSensor(sensor, data);
}
else if (messageObject.GetNamedString("type") == "UIaction")
{
//send action to buttons
string button = messageObject.GetNamedString("id");
string data = messageObject.GetNamedString("data");
UpdateStuff.Instance.UpdateButton(button, data);
}
}
}
}
catch (Exception e)
{
//this should catch bad format messages or Unity related errors
Debug.Log(e.Message);
}
}
}
catch (Exception ex)
{
Windows.Web.WebErrorStatus webErrorStatus = Windows.Networking.Sockets.WebSocketError.GetStatus(ex.GetBaseException().HResult);
Debug.Log(ex);
//close the websocket
this.messageWebSocket.Close(1006, ex.Message);
//create a new one and reconnect
this.Initialize();
}
}
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 WebSocket_MessageReceived(Windows.Networking.Sockets.MessageWebSocket sender, Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args)
{
try
{
using (Windows.Storage.Streams.DataReader dataReader = args.GetDataReader())
{
dataReader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
string message = dataReader.ReadString(dataReader.UnconsumedBufferLength);
Debug.Log("Message received from MessageWebSocket: " + message);
cmds.Enqueue(message);
//m_Socket.Dispose();
}
}
catch (Exception ex)
{
Windows.Web.WebErrorStatus webErrorStatus = Windows.Networking.Sockets.WebSocketError.GetStatus(ex.GetBaseException().HResult);
// Add additional code here to handle exceptions.
}
}
