private void onMessage(object sender, WebSocketSharp.MessageEventArgs evt)
{
if (MessageRecieved != null)
{
MessageRecieved.Invoke(evt.Data);
}
}
private async void Ws_OnMessage(object sender, WebSocketSharp.MessageEventArgs e)
{
waitBack = false;
LastReceiveTime = DateTime.Now;
foreach (var m in PackageParser.GetPackages(e.RawData))
{
try
{
var msg = new BilibiliMessage(m);
if (msg.MsgType == MessageType.Unknown)
{
// Trace.TraceInformation("BilibiliListener: MessageType: Unknown, skipped.");
Database.CollectSample(m);
}
else
{
await KeepMessage(new BilibiliMessage(m));
}
}catch (Exception ex)
{
Trace.TraceError(ex.Message);
Trace.TraceError(ex.StackTrace);
Trace.TraceError("================================");
}
}
}
protected override void OnMessage(WebSocketSharp.MessageEventArgs e)
{
var text = e.Data;
text += "\n";
return(text);
}
void socket_OnMessage(object sender, WebSocketSharp.MessageEventArgs e)
{
if (OnReceive != null)
{
OnReceiveBytes(e.RawData);
}
}
public void ReceiveMessage(DRP_WebsocketConn wsConn, EventArgs e)
{
var thisEndpoint = this;
// We received data
WebSocketSharp.MessageEventArgs messageArgs = (WebSocketSharp.MessageEventArgs)e;
//Console.WriteLine("> " + messageArgs.Data);
// See what we received
DRP_MsgIn message = Newtonsoft.Json.JsonConvert.DeserializeObject <DRP_MsgIn>(messageArgs.Data);
//Console.WriteLine(messageArgs.Data);
switch (message.type)
{
case "cmd":
thisEndpoint.ProcessCmd(wsConn, message);
break;
case "reply":
thisEndpoint.ProcessReply(wsConn, message);
break;
case "stream":
thisEndpoint.ProcessStream(wsConn, message);
break;
default:
Console.WriteLine("Invalid message.type; here's the JSON data..." + messageArgs.Data);
break;
}
}
void webSocket_OnMessage(object sender, WebSocketSharp.MessageEventArgs e)
{
if (traceWriter != null)
{
traceWriter.WriteLine("message received");
}
}
//TODO: modify .....
//直接对象序列化,找第一个对象名字.....
public Packet Decode(WebSocketSharp.MessageEventArgs e)
{
try
{
#if SOCKET_IO_DEBUG
Debug.Log("[SocketIO] Decoding: " + e.Data);
#endif
string data = e.Data;
Packet packet = new Packet();
int offset = 0;
// look up json data
if (++offset < data.Length - 1)
{
try {
#if SOCKET_IO_DEBUG
Debug.Log("[SocketIO] Parsing JSON: " + data.Substring(offset));
#endif
packet.json = new JSONObject(data.Substring(offset));
} catch (Exception ex) {
Debug.LogException(ex);
}
}
#if SOCKET_IO_DEBUG
Debug.Log("[SocketIO] Decoded: " + packet);
#endif
return(packet);
} catch (Exception ex) {
throw new SocketIOException("Packet decoding failed: " + e.Data, ex);
}
}
//uniform asyncronzilly interface...
protected void OnMessage(object sender, WebSocketSharp.MessageEventArgs e)
{
#if SOCKET_IO_DEBUG
debugMethod.Invoke("[SocketIO] Raw message: " + e.Data);
#endif
Debug.Log("[SocketIO] OnMessage e.Data: " + e.Data);
//for to unserizlized
JSONObject jsonObject = new JSONObject(e.Data);
jsonObject.bClassNameExist = false;
/*
* Packet packet = decoder.Decode(e);*/
/*
*
* switch (jsonObject.className) {
* case GameAccountRegisterRsp.CLASS_NAME: HandJsonObject(jsonObject); break;
* case GameAccountLoginRsp.CLASS_NAME: HandLoginJsonObject(jsonObject); break;
* case GameBetRsp.CLASS_NAME: HandBetJsonObject(jsonObject); break;
* //case EnginePacketType.CLOSE: EmitEvent("close"); break;
* //case EnginePacketType.PING: HandlePing(); break;
* //case EnginePacketType.PONG: HandlePong(); break;
* //case EnginePacketType.MESSAGE: HandleMessage(packet); break;
* }*/
HandSynChronizeJsonObject(jsonObject);
}
protected override void OnMessage(WebSocketSharp.MessageEventArgs e)
{
base.OnMessage(e);
try
{
if (e.IsText)
{
IncomingMessage message = JsonConvert.DeserializeObject <IncomingMessage>(e.Data);
#if DEBUG
Logger.Instance.Log($"Got message from RCON client: ID={message.Identifier}, Message={message.Message}");
#endif
List <string> args = Program.ParseLine(message.Message);
var response = Program.ProcessCommand(args[0], args.Skip(1).ToArray());
OutgoingMessage outMsg = new OutgoingMessage()
{
Identifier = message.Identifier, Message = response, Type = "Generic", Stacktrace = ""
};
Send(JsonConvert.SerializeObject(outMsg));
}
}catch (Exception ex)
{
Logger.Instance.Warning("Unable to proccess a command from RCON client! Exception: " + ex);
}
}
public static void ChangeListener(object sender, WebSocketSharp.MessageEventArgs e)
{
String[] dataParams = e.Data.Split(' ');
switch (dataParams[0])
{
case "RefreshFile":
string file = dataParams[1];
string fileToModify = Misc.Config.fullProjectPath + @"\" + file;
string bytes = e.Data.Substring(e.Data.IndexOf(dataParams[3]));
if (Misc.Userdata.Username != dataParams[2])
{
string str = Other.MiscFunctions.StringDecompressBytes(bytes);
FileMgmt.Manager.UpdateFile(fileToModify, str);
Console.WriteLine("File Refresh");
}
break;
case "CreateFile":
string fileToCreate = Misc.Config.fullProjectPath + @"\" + dataParams[2];
string bys = e.Data.Substring(e.Data.IndexOf(dataParams[3]));
if (!FileMgmt.Manager.FileExists(fileToCreate) || Misc.Userdata.Username != dataParams[1])
{
Watcher.Watcher.ignore.Add(fileToCreate);
string str = Other.MiscFunctions.StringDecompressBytes(bys);
FileMgmt.Manager.CreateAndPopulateFile(fileToCreate, str);
Console.WriteLine("New File Addition");
}
break;
case "CreateFolder":
string folderToCreate = Misc.Config.fullProjectPath + @"\" + dataParams[2];
if (!FileMgmt.Manager.DirExists(folderToCreate) || Misc.Userdata.Username != dataParams[1])
{
Watcher.Watcher.ignore.Add(folderToCreate);
FileMgmt.Manager.CreateDirectory(folderToCreate);
Console.WriteLine("New Folder Addition");
}
break;
case "DeleteFile":
string fileToRemove = Misc.Config.fullProjectPath + @"\" + dataParams[2];
if (FileMgmt.Manager.FileExists(fileToRemove) || Misc.Userdata.Username != dataParams[1])
{
Watcher.Watcher.ignore.Add(fileToRemove);
FileMgmt.Manager.DeleteFile(fileToRemove);
Console.WriteLine("File Deletion");
}
break;
case "DeleteFolder":
string folderToRemove = Misc.Config.fullProjectPath + @"\" + dataParams[2];
if (FileMgmt.Manager.DirExists(folderToRemove) || Misc.Userdata.Username != dataParams[1])
{
Watcher.Watcher.ignore.Add(folderToRemove);
FileMgmt.Manager.DeleteDirectory(folderToRemove);
Console.WriteLine("Folder Deletion");
}
break;
}
}
private void ReceiveMessage(WebSocketSharp.MessageEventArgs e)
{
SaferizeEvent evt = JsonConvert.DeserializeObject <SaferizeEvent>(e.Data);
switch (evt.EventType)
{
case "ApprovalStatusChangedEvent":
HandleApprovalStatusChangedEvent(JsonConvert.DeserializeObject <ApprovalStatusChangedEvent>(e.Data));
break;
case "ApprovalStateChangedEvent":
HandleApprovalStateChangedEvent(JsonConvert.DeserializeObject <ApprovalStateChangedEvent>(e.Data));
break;
case "UsageTimerTimeIsUpEvent":
OnTimeIsUp?.Invoke();
break;
case "PinChangedEvent":
PinChangedEvent pinChanged = JsonConvert.DeserializeObject <PinChangedEvent>(e.Data);
OnPINChange?.Invoke(pinChanged.pinHash);
break;
case "AppUserChangedAppFeaturesEvent":
AppUserChangedAppFeaturesEvent appFeaturesChangedEvent = JsonConvert.DeserializeObject <AppUserChangedAppFeaturesEvent>(e.Data);
OnAppFeaturesChange?.Invoke(appFeaturesChangedEvent.Features);
break;
default:
break;
}
}
void HandleMessage(object sender, WebSocketSharp.MessageEventArgs e)
{
HFTRelayFromPlayerMessage message = null;
try
{
message = deserializer_.Deserialize <HFTRelayFromPlayerMessage>(e.Data);
}
catch (System.Exception ex)
{
log_.Error(ex.ToString());
return;
}
string cmd = message.cmd;
CmdEventHandler handler = null;
if (!messageHandlers_.TryGetValue(cmd, out handler))
{
log_.Error("unknown player message: " + cmd);
return;
}
handler(deserializer_, message.data);
}
/// <summary>
/// 新消息
/// </summary>
/// <param name="e"></param>
protected override void OnMessage(WebSocketSharp.MessageEventArgs e)
{
try
{
LastRecvTime = DateTime.Now;
if (e.IsText)
{
switch (e.Data)
{
case "HeartBeat":
this.Send(Newtonsoft.Json.JsonConvert.SerializeObject(new WSResModel(ResCode.HeartBeatRes)));
return;
case "TaskIsExist":
if (HandlerTaskManager.ContainsTask(this.TaskId))
{
this.Send(Newtonsoft.Json.JsonConvert.SerializeObject(new WSResModel(ResCode.Wait)));
}
else
{
SendAndClose(new WSResModel(ResCode.Err, "任务不存在！"));
}
return;
}
}
BaseHandler handler = HandlerManager.CreateHandler(PathName);
if (handler == null)
{
SendAndClose(new WSResModel(ResCode.Err, string.Format("请求路径{0}未找到对应Handler", PathName)));
return;
}
handler.Path = this.PathName;
handler.TaskId = this.TaskId;
handler.ReqIsWebSocket = true;
handler.InPara = e.Data;
//添加任务并执行
if (HandlerTaskManager.AddTask(handler))
{
ThreadPool.QueueUserWorkItem((state) =>
{
BaseHandler bh = state as BaseHandler;
try
{
bh.HandlerTask(bh.InPara);
}
catch (Exception ex)
{
bh.ReturnToClient(new WSResModel(ResCode.Err, ex.Message));
}
}, handler);
}
}
catch (Exception ex)
{
CommonInfo.Output("WS处理消息异常：{0}", ex.Message);
SendAndClose(new WSResModel(ResCode.Err, string.Format("服务器WS处理消息异常", ex.Message)));
}
}
protected override void onMessage(object sender, WebSocketSharp.MessageEventArgs e)
{
try
{
if (e.Type != WebSocketSharp.Frame.Opcode.TEXT)
{
throw new FormatException("only accept text msg");
}
log4net.LogManager.GetLogger(GetType()).Debug(e.Data);
PairingClientMsgs msg = null;
try
{
msg = JsonConvert.DeserializeObject <PairingClientMsgs>(e.Data);
}
catch (Exception err)
{
throw new FormatException(err.Message, err);
}
if (msg.subscribe != null && msg.subscribe.pairing)
{
addToSubscribers();
}
if (msg.pairing_mode != null)
{
raisePairingModeChangingEvent(msg.pairing_mode.enabled);
}
if (msg.accept != null)
{
raiseNewDeviceAcceptingEvent(msg.accept.device_id);
}
if (msg.reject != null)
{
raiseNewDeviceRejectingEvent(msg.reject.device_id);
}
}
catch (FormatException err)
{
log4net.LogManager.GetLogger(GetType()).Warn(err.Message, err);
Stop(WebSocketSharp.Frame.CloseStatusCode.INCORRECT_DATA, "Msg format error");
removeFromSubscribers();
}
catch (Exception err)
{
log4net.LogManager.GetLogger(GetType()).Warn("Error handling income msg: " + ((e.Type == WebSocketSharp.Frame.Opcode.TEXT) ? e.Data : e.RawData.ToString()), err);
Stop(WebSocketSharp.Frame.CloseStatusCode.SERVER_ERROR, "server failed to handle data");
removeFromSubscribers();
}
}
protected override void OnMessage(WebSocketSharp.MessageEventArgs e)
{
Dictionary <string, string> headers = new Dictionary <string, string> ();
headers.Add(StompHeaders.DESTINATION, "/test");
headers.Add(StompHeaders.MESSAGE_ID, "1");
MessageFrame frame = new MessageFrame("Hello world", headers);
Send(frame.AsStompMessage());
}
private void OnWebSocketMessage(object sender, WebSocketSharp.MessageEventArgs e)
{
if (logMessages)
{
Debug.Log("OnMessage: " + e.Data);
}
JSONObject message = new JSONObject(e.Data);
messageQueue.Enqueue(message);
}
protected override void OnMessage(WebSocketSharp.MessageEventArgs e)
{
var args = new DataReceivedArgs
{
Data = new ArraySegment <byte>(e.RawData, 0, e.RawData.Length),
SessionID = this
};
_source.FireRecieved(args);
}
private void Socket_OnMessage(object sender, WebSocketSharp.MessageEventArgs e)
{
try
{
Queue.Enqueue(e.Data);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return;
}
}
public JsonData GetResponseJsonData()
{
WebSocketSharp.MessageEventArgs e = hs.MessageRepsonseEvent;
if (e == null)
{
return(null);
}
JsonData jsonData = JsonMapper.ToObject(e.Data);
//jsonObject.bClassNameExist = false;
return(jsonData);
}
//must done.
public JSONObject GetResponseJsonObject()
{
WebSocketSharp.MessageEventArgs e = hs.MessageRepsonseEvent;
if (e == null)
{
return(null);
}
JSONObject jsonObject = new JSONObject(e.Data);
jsonObject.bClassNameExist = false;
return(jsonObject);
}
protected override void OnMessage(WebSocketSharp.MessageEventArgs e)
{
if (e.IsBinary)
{
Log(ID + ": Received: bytes(" + e.RawData.Length + ")");
Send(e.RawData);
}
else
{
Log(ID + ": Received: " + e.Data + "");
Send(e.Data);
}
}
public void OnMessage(object sender, WebSocketSharp.MessageEventArgs message)
{
HFTRelayFromPlayerMessage msg = deserializer_.Deserialize <HFTRelayFromPlayerMessage>(message.Data);
CmdEventHandler handler = null;
if (!messageHandlers_.TryGetValue(msg.cmd, out handler))
{
log_.Error("unknown game message: " + msg.cmd + " for :" + gameId_);
return;
}
handler(deserializer_, msg.id, msg.data);
}
internal virtual void _OnStompFrameIn(Action <StompFrame> Successful, WebSocketSharp.MessageEventArgs e)
{
StompFrame message = new StompFrame(e.Data.Substring(1));
if (message.Command.GetType() == typeof(ConnectedCommand))
{
Successful(message);
_OnStompConnectionEstablished();
}
else
{
_OnStompMessageIn(message);
}
}
static StackObject *get_Data_0(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 1);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
WebSocketSharp.MessageEventArgs instance_of_this_method = (WebSocketSharp.MessageEventArgs) typeof(WebSocketSharp.MessageEventArgs).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags) 0);
__intp.Free(ptr_of_this_method);
var result_of_this_method = instance_of_this_method.Data;
return(ILIntepreter.PushObject(__ret, __mStack, result_of_this_method));
}
private static void onSocketMessageRecieved(ISession session, object sender, WebSocketSharp.MessageEventArgs e)
{
try
{
OnSnipePokemon(session, e.Data);
OnPokemonData(session, e.Data);
ONFPMBridgeData(session, e.Data);
}
catch (Exception ex)
{
#if DEBUG
Logger.Write("ERROR TO ADD SNIPE< DEBUG ONLY " + ex.Message, LogLevel.Info, ConsoleColor.Yellow);
#endif
}
}
private static void Ws_OnMessage(object sender, WebSocketSharp.MessageEventArgs ev)
{
if (!ev.IsText)
{
return;
}
string rawMessage = ev.Data.TrimEnd();
if (rawMessage.StartsWith("PING"))
{
Plugin.Log("Ping... Pong.");
_ws.Send("PONG :tmi.twitch.tv");
}
var messageType = _twitchMessageRegex.Match(rawMessage);
if (messageType.Length == 0)
{
Plugin.Log($"Unhandled message: {rawMessage}");
return;
}
string channelName = messageType.Groups["ChannelName"].Value;
if (channelName != Config.Instance.TwitchChannelName)
{
return;
}
// Instantiate our twitch message
TwitchMessage twitchMsg = new TwitchMessage();
twitchMsg.rawMessage = rawMessage;
twitchMsg.message = _messageRegex.Match(twitchMsg.rawMessage).Groups["Message"].Value;
twitchMsg.hostString = messageType.Groups["HostName"].Value;
twitchMsg.messageType = messageType.Groups["MessageType"].Value;
twitchMsg.channelName = channelName;
// Find all the message tags
var tags = _tagRegex.Matches(rawMessage);
// Call the appropriate handler for this messageType
if (_messageHandlers.ContainsKey(twitchMsg.messageType))
{
_messageHandlers[twitchMsg.messageType]?.Invoke(twitchMsg, tags);
}
}
private void OnMessageReveived(object sender, EventArgs e)
{
WebSocketSharp.MessageEventArgs args = e as WebSocketSharp.MessageEventArgs;
if (args == null || args.RawData == null)
{
return;
}
lock (m_sync_lock)
{
if (OnMessage != null)
{
OnMessage(0, args.RawData, args.RawData.Length);
}
}
}
private static void onSocketMessageRecieved(ISession session, object sender, WebSocketSharp.MessageEventArgs e)
{
try
{
var match = Regex.Match(e.Data, "42\\[\"pokemon\",(.*)]");
if (match != null && !string.IsNullOrEmpty(match.Groups[1].Value))
{
var data = JsonConvert.DeserializeObject <EncounteredEvent>(match.Groups[1].Value);
data.IsRecievedFromSocket = true;
session.EventDispatcher.Send(data);
}
}
catch (Exception)
{
}
}
static StackObject *get_IsText_1(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 1);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
WebSocketSharp.MessageEventArgs instance_of_this_method = (WebSocketSharp.MessageEventArgs) typeof(WebSocketSharp.MessageEventArgs).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
var result_of_this_method = instance_of_this_method.IsText;
__ret->ObjectType = ObjectTypes.Integer;
__ret->Value = result_of_this_method ? 1 : 0;
return(__ret + 1);
}
private void OnMessage(object _sender, WebSocketSharp.MessageEventArgs _args)
{
if (_args.IsBinary)
{
if (DataReceived != null)
{
DataReceived(this, _args.RawData, _args.RawData.Length);
}
}
else if (_args.IsText)
{
if (TextReceived != null)
{
TextReceived(this, _args.Data);
}
}
}
