private void Socket_MessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
try
{
var bl3pBook = JsonConvert.DeserializeObject <Bl3pOrderBook>(e.Message);
var currencyPair = _bl3pCurrencyMapper.GetCurrency(bl3pBook.MarketPlace);
var book = new OrderBook();
book.Asks = new List <OrderBookItem>();
book.Bids = new List <OrderBookItem>();
book.CurrencyPair = currencyPair;
foreach (var item in bl3pBook.Bids)
{
book.Bids.Add(new OrderBookItem()
{
Price = item.Price / 100000m, Volume = item.Amount / 100000000m
});
}
foreach (var item in bl3pBook.Asks)
{
book.Asks.Add(new OrderBookItem()
{
Price = item.Price / 100000m, Volume = item.Amount / 100000000m
}); //Amount / 1e8
}
_orderBookDict[currencyPair] = book;
}
catch (Exception ex)
{
_logger.LogCritical(ex, "Bl3p data client get a wrong message");
}
}
private void WhenMessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
try
{
if (Info.Status == "closed")
{
return;
}
if (e.Message.Length <= 0)
{
return;
}
else
{
IsReceiving = true;
Info.LastActiveTime = DateTime.Now;
Info.LastDataTime = Info.LastActiveTime.ToString("yyyy-MM-dd HH:mm:ss");
}
}
catch
{
return;
}
Info.MediaInfo = e.Message.Trim();
var parts = Info.MediaInfo.Split('|');
if (parts.Length >= 2)
{
m_RawVideoType = "h264";
m_RawAudioType = parts[1].Trim();
if (parts[1].IndexOf('x') > 0 && parts[1].Length > 4)
{
m_RawAudioType = parts[0].Trim();
}
}
else if (parts.Length >= 1)
{
if (Info.MediaInfo.IndexOf('x') > 0 && Info.MediaInfo.Length > 4)
{
m_RawVideoType = "h264";
m_RawAudioType = "";
}
else
{
m_RawVideoType = "";
m_RawAudioType = parts[0].Trim();
}
}
if (m_RawAudioType.Length > 0 && m_RawAudioType.Contains('@'))
{
m_RawAudioType = m_RawAudioType.Split('@')[0].Trim();
}
if (m_RawAudioType.Length > 0 && m_RawAudioType.Contains('('))
{
m_RawAudioType = m_RawAudioType.Split('(')[0].Trim();
}
}
private async void OnMessageReceived(object sender, MessageReceivedEventArgs args)
{
if (OnData == null) return;
var exceptionOccured = false;
try
{
var text = args.Message;
OnData(sender, new DataReceivedEventArgs { TextData = text });
}
catch (Exception)
{
exceptionOccured = true;
}
// cannot await in catch
if (exceptionOccured)
{
_connectionState = ConnectionState.Failed;
try
{
await Reconnect();
}
catch (Exception e)
{
Error(e);
}
}
}
/// <summary>
/// Handles the MessageReceived event of the websocket control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="MessageReceivedEventArgs"/> instance containing the event data.</param>
void websocket_MessageReceived(object sender, MessageReceivedEventArgs e)
{
if (OnReceiveDelegate != null)
{
OnReceiveDelegate(e.Message);
}
}
private void websocketmessage(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
string s = e.Message;
Console.WriteLine("мы получили сообщение");
Console.WriteLine(s);
}
void _socket_MessageReceived(object sender, MessageReceivedEventArgs e)
{
if (! _handle_Ping(e.Message))
{
this._client.AddItem(e.Message);
}
}
void HandleMessage(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
List <object> parsedMessage = Json.Deserialize(e.Message) as List <object>;
string messageType = (string)parsedMessage[0];
try
{
if (messageType == "call-error")
{
Console.WriteLine("Received error message: {0}", e.Message);
}
else if (messageType == "call")
{
HandleCallMessage(e.Message, parsedMessage);
}
else if (messageType == "call-reply")
{
HandleCallReplyMessage(e.Message, parsedMessage);
}
}
catch (Exception ex)
{
Console.WriteLine("Failed to parse incoming message: " + e.Message, ex);
}
}
/// <summary>
/// Handles the MessageReceived event of the websocket control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="MessageReceivedEventArgs"/> instance containing the event data.</param>
void websocket_MessageReceived(object sender, MessageReceivedEventArgs e)
{
if (OnReceiveDelegate != null)
{
OnReceiveDelegate(Encoding.UTF8.GetBytes(e.Message));
}
}
private void websocket_MessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
WebsocketResponse response = JsonConvert.DeserializeObject <WebsocketResponse>(e.Message);
switch (response.Command)
{
case "get_request":
if (response.Values == null)
{
return;
}
if (LocalValues != ServerValues && !initialStart)
{
ServerValues = response.Values;
valuesPending = true;
this.Invoke((MethodInvoker)(() => this.Refresh()));
}
else
{
ServerValues = response.Values;
initialStart = false;
this.Invoke((MethodInvoker)(() => this.UpdateLocalWithServer()));
this.Invoke((MethodInvoker)(() => this.Refresh()));
}
break;
}
}
protected override void websocket_MessageReceived(object sender, MessageReceivedEventArgs e)
{
base.websocket_MessageReceived(sender, e);
try
{
BinResponce res = JsonHelper.JsonToObject(typeof(BinResponce), null, e.Message) as BinResponce;
switch (res.code)
{
case 100:
{
mainPage.Dispatcher.BeginInvoke(new Action(() => {
mainPage.GotoOnlinePage();
}));
break;
}
default:
break;
}
}
catch (Exception ex)
{
;
}
}
private void App_state_websocket_MessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
lock (waitlock)
{
var status = JObject.Parse(e.Message);
CheckWaitStatus(status);
}
}
static void ws_MessageReceived(object sender, MessageReceivedEventArgs e)
{
System.Threading.Interlocked.Increment(ref backCount);
if (backCount == count)
{
Console.WriteLine((DateTime.Now - dt));
}
}
/// <summary>
/// Websocket Message Received event handler. Either tries to match incoming messages as
/// replies to messages we've sent, or fires an event related to an incoming event, like
/// device additions/removals, log messages, etc.
/// </summary>
/// <param name="aSender">Object sending the open event, unused.</param>
/// <param name="aArgs">Event parameters, including the data received.</param>
private void MessageReceivedHandler(object aSender, WebSocket4Net.MessageReceivedEventArgs aArgs)
{
var msgs = Deserialize(aArgs.Message);
foreach (var msg in msgs)
{
if (msg.Id > 0 && _waitingMsgs.TryRemove(msg.Id, out TaskCompletionSource <ButtplugMessage> queued))
{
queued.TrySetResult(msg);
continue;
}
switch (msg)
{
case Log l:
_owningDispatcher.Send(_ =>
{
Log?.Invoke(this, new LogEventArgs(l));
}, null);
break;
case DeviceAdded d:
var dev = new ButtplugClientDevice(d);
_devices.AddOrUpdate(d.DeviceIndex, dev, (idx, old) => dev);
_owningDispatcher.Send(_ =>
{
DeviceAdded?.Invoke(this, new DeviceEventArgs(dev, DeviceEventArgs.DeviceAction.ADDED));
}, null);
break;
case DeviceRemoved d:
if (_devices.TryRemove(d.DeviceIndex, out ButtplugClientDevice oldDev))
{
_owningDispatcher.Send(_ =>
{
DeviceRemoved?.Invoke(this, new DeviceEventArgs(oldDev, DeviceEventArgs.DeviceAction.REMOVED));
}, null);
}
break;
case ScanningFinished sf:
_owningDispatcher.Send(_ =>
{
ScanningFinished?.Invoke(this, new ScanningFinishedEventArgs(sf));
}, null);
break;
case Error e:
_owningDispatcher.Send(_ =>
{
ErrorReceived?.Invoke(this, new ErrorEventArgs(e));
}, null);
break;
}
}
}
private void conn_message(object sender, WebSocket4Net.MessageReceivedEventArgs msg)
{
if (msg.Message != "empty")
{
typedata income = new typedata();
income = (typedata)primeJSON.DeserializeObject(msg.Message, income.GetType());
doMessage(income);
}
}
private void websocket_MessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
System.Diagnostics.Debug.WriteLine("Message received");
string s = e.Message;
//new Note().apply_patch(s);
System.Diagnostics.Debug.WriteLine(e.Message);
apply_patch(s);
}
/// <summary>
/// An auto-login handler which is only raised once.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
static void doLogin(object sender, MessageReceivedEventArgs e)
{
socket.MessageReceived -= doLogin;
send("login", new {
username = email,
password = pass,
userAgent = ua
});
}
internal static void OnWebsocketMessage(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
SystemCommand C = new SystemCommand(e.Message.ToString());
if (C.OpCode == "PIN")
{
Core.websocket.Send("PIN"); return;
}
IncomingMessageQueue.Enqueue(C);
}
private void jsokmessage(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
string s = e.Message;
Console.WriteLine("мы получили сообщение");
typedata q = new typedata();
q = (typedata)DeserializeObject(s, q.GetType());
q.display();
}
void m_WebSocket_MessageReceived(object sender, MessageReceivedEventArgs e)
{
AppendText("Received:" + e.Message);
if (e.Message.Equals(m_CurrentSendMessage))
AppendText("Receive correct");
else
AppendText("Receive error");
m_WebSocket.Close();
}
void webSocket_MessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
if (ChromeEvent != null)
{
ChromeNetworkEvent networkEvent = JsonConvert.DeserializeObject <ChromeNetworkEvent>(e.Message);
if (networkEvent.method == "Network.requestWillBeSent")
{
ChromeEvent(networkEvent);
}
}
}
public void receiveChat(object sender, MessageReceivedEventArgs args)
{
ludo_client.dto.Message newIncomingMessage = JsonConvert.DeserializeObject<ludo_client.dto.Message>(args.Message);
if (newIncomingMessage.TargetRoomID != Main.ludo.Users[ClientBase.myUserListIndex].CurrentRoomID)
{
updateMessageList(this.messageList, newIncomingMessage); // for global server chat
}
else
{
updateMessageList(this.roomMessageList, newIncomingMessage); // for room chat
}
}
static void btc_MessageReceived(object sender, MessageReceivedEventArgs e)
{
int eioMessageType = -1;
if (int.TryParse(e.Message.Substring(0, 1), out eioMessageType))
{
switch ((engineioMessageType)eioMessageType)
{
case engineioMessageType.PING:
//replace incoming PING with PONG in incoming message and resend it.
btc.Send(string.Format("{0}{1}", (int)engineioMessageType.PONG, e.Message.Substring(1, e.Message.Length - 1)));
break;
case engineioMessageType.PONG:
pong = true;
break;
case engineioMessageType.MESSAGE:
int sioMessageType = -1;
if (int.TryParse(e.Message.Substring(1, 1), out sioMessageType))
{
switch ((socketioMessageType)sioMessageType)
{
case socketioMessageType.CONNECT:
//Send "42["subscribe",["marketdata_cnybtc","marketdata_cnyltc","marketdata_btcltc"]]"
btc.Send(string.Format("{0}{1}{2}", (int)engineioMessageType.MESSAGE,
(int)socketioMessageType.EVENT,
"[\"subscribe\",[\"marketdata_cnybtc\",\"marketdata_cnyltc\",\"marketdata_btcltc\"]]"));
break;
case socketioMessageType.EVENT:
if (e.Message.Substring(4, 5) == "trade")//listen on "trade"
Console.WriteLine(e.Message.Substring(e.Message.IndexOf('{'), e.Message.LastIndexOf('}') - e.Message.IndexOf('{') + 1));
break;
default:
Console.WriteLine("error switch socket.io messagetype:" + e.Message);
break;
}
}
else
{
Console.WriteLine("error parse socket.io messagetype!");
}
break;
default:
Console.WriteLine("error switch engine.io messagetype");
break;
}
}
else
{
Console.WriteLine("error parsing engine.io messagetype!");
}
}
private void receiveThisUserObject(object sender, MessageReceivedEventArgs args)
{
var jsonString = JsonConvert.DeserializeObject<User>(args.Message);
int userListIndex = jsonString.UserListIndex;
this.user = JsonConvert.DeserializeObject<User>(args.Message); // receiving my user object
Main.ludo.Users[0] = this.user;
if (isUserNameAvailable())
{
ClientBase.myUserListIndex = userListIndex;
}
else
{
MessageBox.Show("Username is already used");
}
}
void socket_MessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
StompFrame frame = this.TransformResultFrame(e.Message);
switch (frame.Code)
{
case StatusCodeEnum.CONNECTED:
connected = true;
this.callbacks[CID](frame);
break;
case StatusCodeEnum.MESSAGE:
this.callbacks[frame.GetHeader(SubscriptionHeader)](frame);
break;
}
}
public void receive(object sender, MessageReceivedEventArgs e)
{
Console.WriteLine(e.Message);
JObject json = JObject.Parse(e.Message);
if (json.GetValue("result").ToString() != "success") return;
string src = json.GetValue("source").ToString();
switch (src)
{
case "getPlayerLimit":
MessageBox.Show("The actual Player limit is: " + json.GetValue("success").ToString());
break;
case "getPlayerNames":
clear x = new clear(clearbox);
this.Invoke(x);
JToken token = json.GetValue("success");
foreach (JToken f in token)
{
add c = new add(addbox);
this.Invoke(c, f.ToString());
}
break;
case "getPlayer":
JToken pos = json.GetValue("success").SelectToken("location");
string posi = "x: " + pos.SelectToken("x").ToString() + " y: " + pos.SelectToken("y").ToString() + " z: " + pos.SelectToken("z").ToString();
string op = Convert.ToString(json.GetValue("success").SelectToken("op"));
string world = json.GetValue("success").SelectToken("worldInfo").SelectToken("name").ToString();
string gamemode = json.GetValue("success").SelectToken("gameMode").ToString();
infoHandler handler = new infoHandler(addinfo);
this.Invoke(handler, posi, world, op, gamemode);
break;
case "kickPlayer":
if (!mk)
MessageBox.Show("Player gekickt");
break;
case "opPlayer":
MessageBox.Show("Player is OP.");
break;
case "deopPlayer":
MessageBox.Show("Player is no longer OP");
break;
default:
Console.WriteLine(e.Message);
break;
}
}
private void websocket_MessageReceived(object sender, MessageReceivedEventArgs e)
{
//Trace.WriteLine(e.Message);
if (e.Message.Equals("1::")) return;
if (e.Message.Equals("2::"))
{
_websocket.Send("2::");
return;
}
if (e.Message.StartsWith("5:::"))
{
var jsonObj = JObject.Parse(e.Message.Substring(4));
var args = JObject.Parse(jsonObj.GetValue("args").First.ToString());
var method = args.GetValue("method");
var paramsObject = args.GetValue("params");
switch (method.ToString())
{
case "loginMsg":
GuiMessage(hb.Username, "SYSTEM: Successfully connected to server.", "000000");
SendUserListMessage();
break;
case "chatMsg":
GuiMessage(paramsObject["name"].ToString(), paramsObject["text"].ToString(),
paramsObject["nameColor"].ToString());
break;
case "userList":
UserListThread = new Thread(() => { hb.LoadUserData(paramsObject.ToString()); });
UserListThread.Start();
break;
case "banList":
BanListThread = new Thread(() => { hb.LoadBanList(paramsObject.ToString()); });
BanListThread.Start();
break;
default:
return;
}
//Debug.WriteLine(jsonObj);
//Debug.WriteLine("jsonObj: {0}", jsonObj);
//Debug.WriteLine("test: {0}", args);
//Debug.WriteLine("method: {0}", method);
//Debug.WriteLine("Params: {0}", paramsObject);
}
}
private void WhenMessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
IsReceiving = true;
if (e.Message.Trim().Length <= 0)
{
return;
}
Info.MediaInfo = e.Message.Trim();
var parts = Info.MediaInfo.Split('|');
if (parts.Length >= 2)
{
m_RawVideoType = "h264";
m_RawAudioType = parts[1].Trim();
if (parts[1].IndexOf('x') > 0 && parts[1].Length > 4)
{
m_RawAudioType = parts[0].Trim();
}
}
else if (parts.Length >= 1)
{
if (Info.MediaInfo.IndexOf('x') > 0 && Info.MediaInfo.Length > 4)
{
m_RawVideoType = "h264";
m_RawAudioType = "";
}
else
{
m_RawVideoType = "";
m_RawAudioType = parts[0].Trim();
}
}
if (m_RawAudioType.Length > 0 && m_RawAudioType.Contains('@'))
{
m_RawAudioType = m_RawAudioType.Split('@')[0].Trim();
}
if (m_RawAudioType.Length > 0 && m_RawAudioType.Contains('('))
{
m_RawAudioType = m_RawAudioType.Split('(')[0].Trim();
}
}
private void MessageReceived(object s, MessageReceivedEventArgs e)
{
QuoteMessage message = null;
try
{
message = JsonConvert.DeserializeObject<QuoteMessage>(e.Message);
}
catch (Exception ex)
{
ErrorOccured(this, ex.Message);
}
if (message != null && message.Ok && message.Quote != null && QuoteReceived != null)
{
QuoteReceived(this, message.Quote);
}
}
private void Socket_MessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
Console.ForegroundColor = ConsoleColor.Green;
//Console.WriteLine (e.Message);//TODO:
Console.ForegroundColor = ConsoleColor.White;
XmlDocument doc = new XmlDocument();
doc.LoadXml(e.Message);
XmlElement node = (XmlElement)doc.FirstChild;
if (messageTypes.ContainsKey(node.Name))
{
XMPPMessage msg = messageTypes[node.Name];
if (msg != null)
{
msg(node);
}
}
}
void webSocket_MessageReceived(object sender, MessageReceivedEventArgs e)
{
var obj = (JsonObject)SimpleJson.SimpleJson.DeserializeObject(e.Message);
//var obj = new JsonObject();
//obj.
if (obj == null) {
return;
}
var tele = new Telemetry();
tele.Name = (string)obj ["Name"];
tele.SourceId = Int32.Parse(obj["SourceId"].ToString());
tele.Value = float.Parse(obj["Value"].ToString());
tele.Timestamp = DateTime.Parse((string)obj["TimeStamp"]);
Database.Main.InsertTelemetryAsync(tele);
Console.WriteLine(e.Message.ToString());
}
private void websocketClient_MessageReceieved(object sender, MessageReceivedEventArgs e)
{
/* We can let this go away fairly soon, since there's not much we can do in the API Worker anyways
* at this point. Maybe attach a logger here?
*/
dynamic data = JsonConvert.DeserializeObject(e.Message);
switch ((string)data.type)
{
case "welcome":
Console.WriteLine("API MOTD: " + data.data);
break;
case "assignment":
Console.WriteLine("Got a new assignment datafield: " + data.data);
break;
default:
Console.WriteLine("Unknown API type field: " + data.type + ": " + data.data);
break;
}
//appendStatus("Direct parse. Type:" + data.type + " Data:" + data.data);
}
private static void WebSocket_MessageReceived(object sender, MessageReceivedEventArgs e)
{
var baseEvent = JsonConvert.DeserializeObject<BaseEvent>(e.Message);
WriteLine($"Message received of type {baseEvent.Type}");
if (baseEvent.Type == "message")
{
var messageEvent = JsonConvert.DeserializeObject<MessageEvent>(e.Message);
WriteLine(messageEvent.Text);
var messageCommand = new MessageCommand
{
channel = messageEvent.Channel,
text = $"I'm in parrot mode: {messageEvent.Text}"
};
webSocket.Send(JsonConvert.SerializeObject(messageCommand));
}
}
private void handleGame(object sender, MessageReceivedEventArgs args)
{
oldRoom = Main.ludo.Rooms[ClientBase.roomListSelectionID];
//Room room = JsonConvert.DeserializeObject<Room>(args.Message);
Main.ludo = JsonConvert.DeserializeObject<Ludo>(args.Message);
Room room = Main.ludo.Rooms[ClientBase.roomListSelectionID];
if (room.RoomID == ClientBase.roomListSelectionID) // affects this my room?
{
updatePlayerListBox();
updateRollTheDiceButton(room);
if (room.RoomAction.Equals("diceRolled"))
{
printDiceValue(room.Game.DiceValue);
}
if (room.Game.MoveCount > 0)
{
updateTheMap(room);
}
}
}
void socket_MessageReceived(object sender, MessageReceivedEventArgs e)
{
//Console.WriteLine(e.Message);
JObject jObj = JObject.Parse(e.Message);
if (jObj["msg"] != null)
{
switch (jObj["msg"].ToString())
{
case "ping":
this.Send("{\"msg\": \"pong\"}");
Console.WriteLine("Ping? Pong!");
break;
default:
this._client.DataReceived(jObj);
break;
}
}
}
private void Connection_MessageReceived(object sender, MessageReceivedEventArgs e)
{
try
{
if (onReceive != null)
onReceive(e.Message);
if (onCallbackReceive != null)
if (e.Message[0] == '{')
{
JObject obj = JObject.Parse(e.Message);
if (obj["type"].Value<string>() == "callback")
{
onCallbackReceive(obj["node"].Value<string>(), obj["id"].Value<string>(), obj["data"].Value<JObject>());
}
}
}
catch (Exception ex)
{
Debug.Print("EXCP:" + ex.ToString());
}
}
static void MessageReceived(object sender, MessageReceivedEventArgs e)
{
var packet = JArray.Parse(e.Message);
foreach (var message in packet.Cast<JObject>())
{
switch ((string)message["channel"])
{
case "/meta/handshake":
HandshakeResponse(message);
break;
case "/meta/connect":
ConnectRequest();
break;
default:
if (((string)message["channel"]).StartsWith("/cloud") || ((string)message["channel"]).StartsWith("/cloud"))
{
Connection.OnMessageReceived(message);
}
break;
}
}
}
/// <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>
private void mws_MessageReceived(object sender, MessageReceivedEventArgs e)
{
try
{
Debug.WriteLine("[SOCKET_IO]: < " + e.Message);
IMessage iMsg = SocketIOClient.Messages.Message.Factory(e.Message);
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.OnErrorEvent(this, new ErrorEventArgs(((WebSocketError)ex.GetBaseException().HResult).ToString(), ex));
//this.Close();
}
}
private void SocketOnMessage(object sender, MessageReceivedEventArgs messageEventArgs)
{
var raw = JsonObject.Parse(messageEventArgs.Message);
if (raw["type"] == "message")
{
if (raw.ContainsKey("subtype"))
{
// Subtypes are things like channel join messages, etc.
return;
}
var channel = raw["channel"];
var text = raw["text"];
var user = raw["user"];
ReceiveMessage(channel, user, text);
}
if (raw["type"] == "team_join")
{
HandleTeamJoinMessage(raw);
}
if (raw["type"] == "channel_created")
{
HandleChannelCreatedMessage(raw);
}
if (raw["type"] == "channel_deleted")
{
HandleChannelDeletedMessage(raw);
}
if (raw["type"] == "channel_rename")
{
HandleChannelRenameMessage(raw);
}
}
void socket_MessageReceived(object sender, MessageReceivedEventArgs e)
{
_client.AddItem(e.Message);
_autoResetEvent.Set();
}
private void OnWebsocketMessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
if (e.Message == "\r\n" || e.Message == "\n")
{
Log.Trace("EOL received");
this.StompHeartbeatReceiveTimer?.Stop();
this.StompHeartbeatReceiveTimer?.Start();
return;
}
Log.Info($"Websocket message received: {e.Message}");
var stompFrame = IStompFrame.Deserialize(e.Message);
switch (stompFrame)
{
case ConnectedFrame frame:
if (frame.ServerExpectedHeartbeatInterval.TotalMilliseconds != 0)
{
this.StompHeartbeatSendTimer = new System.Timers.Timer(frame.ServerExpectedHeartbeatInterval.TotalMilliseconds);
this.StompHeartbeatSendTimer.Elapsed += this.HeartbeatSendTimerElapsed;
this.StompHeartbeatSendTimer.Start();
}
if (frame.ServerSendingHeartbeatInterval.TotalMilliseconds != 0)
{
this.StompHeartbeatReceiveTimer = new System.Timers.Timer((this.StompHeartbeatIntervalFromServerToClient + this.StompHeartbeatTimeout).TotalMilliseconds);
this.StompHeartbeatReceiveTimer.Elapsed += this.HeartbeatReceivedTimerElapsed;
this.StompHeartbeatReceiveTimer.Start();
}
this.InvokeConnectedEvent(new ConnectedEventArgs(frame));
break;
case ErrorFrame frame:
this.InvokeErrorReceivedEvent(new ErrorReceivedEventArgs(frame));
break;
case ReceiptFrame frame:
this.InvokeReceiptReceivedEvent(new ReceiptReceivedEventArgs(frame));
break;
case MessageFrame frame:
var eventArguments = new EventArguments.MessageReceivedEventArgs(frame);
if (this.subscriptionCallbacks.ContainsKey(frame.Headers.Destination))
{
var parameters = new object[]
{
this,
eventArguments,
};
this.subscriptionCallbacks[frame.Headers.Destination].DynamicInvoke(parameters);
}
else
{
this.InvokeMessageReceivedEvent(eventArguments);
}
break;
default:
Log.Info($"Unkown stomp frame: {stompFrame.Body}");
break;
}
this.StompHeartbeatReceiveTimer?.Stop();
this.StompHeartbeatReceiveTimer?.Start();
}
void SocketMessageReceivedFunction (object o, MessageReceivedEventArgs e)
{
Debug.WriteLine ("Received Message: {0}", e.Message);
TimeoutTimer.Change (TimeoutTime, Timeout.Infinite);
var match = Regex.Match (e.Message, socketIOEncodingPattern);
var messageType = (MessageType)int.Parse (match.Groups [1].Value);
var messageId = match.Groups [2].Value;
var endpoint = match.Groups [3].Value;
var socketMessageInfo = new MessageID (messageId, endpoint);
var data = match.Groups [4].Value;
if (!string.IsNullOrEmpty (data))
data = data.Substring (1); //ignore leading ':'
JObject jObjData = null;
switch (messageType) {
case MessageType.Disconnect:
Debug.WriteLine ("Disconnected");
SocketDisconnected (socketMessageInfo, endpoint);
break;
case MessageType.Connect:
Debug.WriteLine ("Connected");
SocketConnected (socketMessageInfo, endpoint);
break;
case MessageType.Heartbeat:
Debug.WriteLine ("Heartbeat");
SendHeartbeat ();
break;
case MessageType.Message:
Debug.WriteLine ("Message = {0}", data);
SocketReceivedMessage (socketMessageInfo, data);
break;
case MessageType.Json:
Debug.WriteLine ("Json = {0}", data);
if (!string.IsNullOrEmpty (data))
jObjData = JObject.Parse (data);
SocketReceivedJson (socketMessageInfo, jObjData);
break;
case MessageType.Event:
Debug.WriteLine ("Event");
string eventName = "";
if (!string.IsNullOrEmpty (data)) {
jObjData = JObject.Parse (data);
eventName = jObjData ["name"].ToString ();
}
if (!string.IsNullOrEmpty (eventName) && EventHandlers.ContainsKey (eventName)) {
var handlers = EventHandlers [eventName];
foreach (var handler in handlers) {
if (handler != null) {
JArray args = null;
if (jObjData != null && jObjData["args"] != null)
args = JArray.Parse (jObjData ["args"].ToString ());
handler (args.First);
Debug.WriteLine ("event: {0} with args: {1}", eventName, args);
}
}
}
break;
case MessageType.Ack:
Debug.WriteLine ("Ack");
if (!string.IsNullOrEmpty (data)) {
var ackMatch = Regex.Match (data, socketAckEncodingPattern);
var ackMessageId = int.Parse (ackMatch.Groups [1].Value);
var ackData = ackMatch.Groups [2].Value;
JArray jData = null;
if (!string.IsNullOrEmpty (ackData)) {
ackData = ackData.Substring (1); //ignore leading '+'
jData = JArray.Parse (ackData);
}
SocketReceivedAcknowledgement (ackMessageId, jData);
}
break;
case MessageType.Error:
Debug.WriteLine ("Error");
SocketReceivedError (socketMessageInfo, data);
break;
case MessageType.Noop:
Debug.WriteLine ("Noop");
break;
default:
Debug.WriteLine ("Something went wrong here...");
if (!string.IsNullOrEmpty (data)) {
jObjData = JObject.Parse (data);
Debug.WriteLine ("jObjData = {0}", jObjData.ToString ());
}
break;
}
}
void tmp_MessageReceived(object sender, MessageReceivedEventArgs e)
{
if (e.Message == "3probe")
{
tmp.Send("5");
}
else
{
if (e.Message != "3")
{
if (e.Message.StartsWith("42[\"chat\","))
{
string msg = e.Message.Substring("42[\"chat\",".Length);
msg = msg.Substring(0, msg.LastIndexOf("]"));
msg = msg.Replace("\"to\":0,", "\"to\":null,");
AddMessage(msg);
mdchat tmpChat = SeuntjieBot.SeuntjieBot.JsonDeserialize<mdchat>(msg);
if (tmpChat.type == "text" || tmpChat.type == "private")
{
chat tmpChat2 = tmpChat.ToChat();
if (seuntjie!=null)
seuntjie.ReceiveMessage(tmpChat2);
}
else if (tmpChat.type == "tip" )
{
if (tmpChat.tip!=null)
{
if (int.Parse(tmpChat.tip.user_id) == seuntjie.OwnID)
seuntjie.ReceiveTip(double.Parse(tmpChat.tip.amount), int.Parse(tmpChat.from.user_id));
}
}
}
}
}
//throw new NotImplementedException();
}
private void _ws_MessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
Received?.Invoke(this, e.Message);
}
void m_WebSocket_MessageReceived(object sender, MessageReceivedEventArgs e)
{
if (string.IsNullOrEmpty(e.Message))
{
return;
}
int pos = e.Message.IndexOf(' ');
string name;
string parameter;
string token = string.Empty;
if (pos > 0)
{
name = e.Message.Substring(0, pos);
parameter = e.Message.Substring(pos + 1);
pos = name.IndexOf('-');
if (pos > 0)
{
token = name.Substring(pos + 1);
name = name.Substring(0, pos);
}
}
else
{
name = e.Message;
parameter = string.Empty;
}
IJsonExecutor executor = GetExecutor(name, token);
if (executor == null)
{
return;
}
object value;
try
{
if (!executor.Type.IsSimpleType())
{
value = DeserializeObject(parameter, executor.Type);
}
else if (parameter.GetType() == executor.Type)
{
value = parameter;
}
else
{
value = Convert.ChangeType(parameter, executor.Type, null);
}
}
catch (Exception exc)
{
m_WebSocket_Error(this, new ErrorEventArgs(new Exception("DeserializeObject exception", exc)));
return;
}
try
{
executor.Execute(this, token, value);
}
catch (Exception exce)
{
m_WebSocket_Error(this, new ErrorEventArgs(new Exception("Message handling exception", exce)));
}
}
private void OnMessageReceived(object sender, MessageReceivedEventArgs messageReceivedEventArgs)
{
var serverMessages = JArray.Parse(messageReceivedEventArgs.Message);
foreach (var message in serverMessages) {
ProcessMessage((JObject)message);
}
}
/// <summary>
/// Called when a WebSocket message is received.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="MessageReceivedEventArgs"/> instance containing the event data.</param>
private void OnWebSocketMessageReceived(object sender, W4N.MessageReceivedEventArgs e)
{
DecodeJson(e.Message);
}
private void OnMessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
MessageReceived(this, new MessageReceivedEventArgs(e.Message));
}
private void OnWsMessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
_handler.OnMessageReceived(e.Message);
}
private void OnWebSocketText(object sender, MessageReceivedEventArgs e)
=> OnTextMessage(e.Message);
private void WsClient_MessageReceived(object sender, MessageReceivedEventArgs e)
{
OnMessage(e.Message);
}
void websocketclient_MessageReceived(object sender, MessageReceivedEventArgs e)
{
logger.Debug("WebSocket Native Client MessageReceived:" + e.Message);
try
{
JObject json = JObject.Parse(e.Message);
string type = (string)json["type"];
switch (type)
{
case "STARTPORTAL":
string portaltype = (string)json["portaltype"];
switch (portaltype)
{
case "STBHTML":
Thread portalThread = new Thread(new ParameterizedThreadStart(startPortal));
portalThread.Start(json);
break;
}
break;
default:
this.BeginInvoke((Action)delegate
{
if (null != portal)
{
portal.onMessage(json);
}
});
break;
}
}
catch (Exception ex)
{
logger.Error(ex.Message, ex);
}
}
private void OnWebsocketMessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
var receivedMessage = e.Message;
string data;
if (receivedMessage.Length < 8)
{
return;
}
else if (this.UseSockJs)
{
receivedMessage = receivedMessage.Substring(3, receivedMessage.Length - 5);
data = receivedMessage.Substring(2);
data = data.Replace("\\\"", "\"");
}
else
{
data = receivedMessage.Substring(2);
}
string messageType = MessageType.GetTypeOfMessage(receivedMessage);
Log.Debug($"WebsocketMessage [{messageType}]: {receivedMessage}");
switch (messageType)
{
case MessageType.PING:
this.webSocket.Send(MessageGenerator.GeneratePingAnswerMessage(this.UseSockJs));
break;
case MessageType.IO_CONNECTED:
this.receivedIOConnected = true;
this.reconnectInProgress = false;
Task.Run(() =>
{
foreach (var registeredService in this.RegisteredServices.Values)
{
Log.Debug($"Re-registering service '{registeredService.Uuid}' after IO_CONNECTED");
this.RegisterAsync(registeredService).Wait();
}
foreach (var cacheEntry in this.EventCache)
{
foreach (var cachedEventData in cacheEntry.Value.ToArray())
{
if (this.PublishAsync(cacheEntry.Key, cachedEventData).Result)
{
cacheEntry.Value.Remove(cachedEventData);
}
}
}
});
this.Connected?.Invoke(this, EventArgs.Empty);
break;
case MessageType.NIO_ALREADY_CONNECTED:
this.ConnectionFailed?.Invoke(this, EventArgs.Empty);
break;
case MessageType.NIO_UNAUTHORIZED_CONNECTION:
this.ConnectionFailed?.Invoke(this, EventArgs.Empty);
break;
case MessageType.IO_REGISTERED:
this.receivedIORegistered = true;
this.Registered?.Invoke(this, EventArgs.Empty);
break;
case MessageType.NIO_REGISTRATION_ERROR:
this.RegistrationFailed?.Invoke(this, EventArgs.Empty);
break;
case MessageType.NIO_UNEXPECTED_REGISTRATION_ERROR:
this.RegistrationFailed?.Invoke(this, EventArgs.Empty);
break;
case MessageType.IO_PUBLISHED:
this.receivedIOPublished = true;
this.EventPublished?.Invoke(this, EventArgs.Empty);
break;
case MessageType.NIO_EVENT_FORWARDING_ERROR:
this.EventPublishingFailed?.Invoke(this, EventArgs.Empty);
break;
case MessageType.NIO_UNEXPECTED_EVENT_FORWARDING_ERROR:
this.EventPublishingFailed?.Invoke(this, EventArgs.Empty);
break;
case MessageType.FUNCTION_CALLBACK:
// Simple fix for https://cb.ipa.fraunhofer.de/cb/issue/164519 (Invalid escape of nested JSON trough websocket)
data = data.Replace("\\\\", "\\");
var functionCall = JsonConvert.DeserializeObject <FunctionCall>(data);
this.HandleFunctionCall(functionCall);
break;
case MessageType.CONFIG:
var configMessage = JsonConvert.DeserializeObject <Dictionary <string, object> >(data);
string serviceUuid = configMessage["uuid"].ToString();
if (this.RegisteredServices.ContainsKey(serviceUuid))
{
var service = this.RegisteredServices[serviceUuid];
var configParameters = ((JObject)configMessage["params"]).ToObject <Dictionary <string, object> >();
foreach (var configParameter in configParameters)
{
service.Configuration.Parameters[configParameter.Key] = new ConfigurationParameterValue(configParameter.Value);
}
ConfigurationParameterReceivedEventArgs eventArgs = new ConfigurationParameterReceivedEventArgs(service, configParameters);
this.ConfigurationParameterReceived?.Invoke(this, eventArgs);
if (service.AutoPersistConfiguration)
{
service.Configuration.SaveToFile(service.ConfigurationPersistencePath);
}
}
else
{
Log.Error($"Service '{serviceUuid}' not registered via this MsbClient");
}
break;
default:
Log.Error($"Unknown type of message: {receivedMessage}");
break;
}
}
/// <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="e"></param>
private void wsClient_MessageReceived(object sender, MessageReceivedEventArgs e)
{
IMessage iMsg = SocketIOClient.Messages.Message.Factory(e.Message);
if (iMsg.Event == "responseMsg")
Trace.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:
Trace.WriteLine("unknown wsClient message Received...");
break;
}
}
private void SockJsClient_MessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
//接受到消息后还需要根据SockJs的格式处理一下
this.OnMessageReceived?.Invoke(sender, new MessageReceivedEventArgs(e.Message));
}
