private void HandleEtcSocketPacket(SocketIOPacket Packet, bool IsBinary) { if (Packet != null && IsBinary) { if (Reconstructor.ConstructeeTokenCount > 0) { SocketIOPacket ReconstructedPacket = Reconstructor.Reconstruct(Packet.BinaryData); if (Reconstructor.ConstructeeTokenCount == 0) { using (Reconstructor) { if (ReconstructedPacket.ID >= 0) { HandleAck(ReconstructedPacket); } else { HandleEvent(ReconstructedPacket); } } } } } }
private void HandleMessage(SocketIOPacket Packet, bool IsBinary = false) { if (Packet != null) { HandleSocketPacket(Packet, IsBinary); } }
private void HandleEnginePacket(SocketIOPacket Packet, bool IsBinary) { if (Packet != null && !(JsonOnly && IsBinary)) { switch (Packet.EnginePacketType) { case EngineIOPacketType.OPEN: HandleOpen((JObject)Packet.JsonData); break; case EngineIOPacketType.CLOSE: HandleClose(); break; case EngineIOPacketType.PING: HandlePing(); break; case EngineIOPacketType.PONG: HandlePong(); break; case EngineIOPacketType.MESSAGE: HandleMessage(Packet, IsBinary); break; default: HandleEtcEnginePacket(); break; } } }
private void OnAck(SocketIOPacket Packet) { if (Packet?.JsonData != null) { AckManager.Invoke(Packet.ID, ((JArray)Packet.JsonData).ToArray()); } }
private void OnEtc(SocketIOPacket Packet) { if (Packet != null) { if (Reconstructor.ConstructeeTokenCount > 0) { SocketIOPacket ReconstructedPacket = Reconstructor.Reconstruct(Packet.RawData); if (Reconstructor.ConstructeeTokenCount == 0) { using (Reconstructor) { if (ReconstructedPacket.ID >= 0) { OnAck(ReconstructedPacket); } else { OnEvent(ReconstructedPacket); } } } } } }
private void HandleAck(SocketIOPacket Packet) { if (Packet != null && Packet.JsonData != null) { AckManager.Invoke(Packet.ID, ((JArray)Packet.JsonData).ToArray <JToken>()); } }
public TChildClass Emit(JToken Event, params object[] Arguments) { if (Event != null) { JArray JsonArray = new JArray(); Action <JToken[]> Callback = null; int ArgumentsCount = Arguments.Length; if (ArgumentsCount > 0 && Arguments[Arguments.Length - 1] is Action <JToken[]> ) { ArgumentsCount--; Callback = (Action <JToken[]>)Arguments[Arguments.Length - 1]; } JsonArray.Add(Event); for (int i = 0; i < ArgumentsCount; i++) { JToken Data; try { Data = JToken.FromObject(Arguments[i]); } catch { Data = JValue.CreateNull(); } JsonArray.Add(Data); } Emit(SocketIOPacket.CreateEventPacket(JsonArray, AckManager.CreateAck(Callback))); } return(this as TChildClass); }
public virtual void SetPacket(SocketIOPacket ConstructeePacket) { if (ConstructeePacket != null) { this.ConstructeePacket = ConstructeePacket; OriginalPacket = ConstructeePacket.DeepClone(); } }
private void HandleBinaryPacket(SocketIOPacket Packet) { if (Packet != null && Reconstructor.ConstructeeTokenCount == 0) { Reconstructor.SetPacket(Packet); } else { throw new SocketIOClientException(string.Format("Unexpected binary data: {0}. Reconstructor: {1}.", Packet, Reconstructor.OriginalPacket)); } }
private void CallHandler(SocketIOPacket Packet) { if (Packet != null && Packet.JsonData != null) { Queue <JToken> Temp = new Queue <JToken>(((JArray)Packet.JsonData).ToArray()); if (Temp.Count > 0) { JToken Event = Temp.Dequeue(); JToken[] Data = Temp.ToArray(); CallEventHandler(Event, Data); CallAckEventHandler(Event, Packet.ID, Data); } } }
private void CallAckEventHandler(JToken Event, int PacketID, params JToken[] Data) { if (Event != null) { Action <JToken[]> Callback = null; if (PacketID >= 0) { Callback = (AckData) => { Emit(SocketIOPacket.CreateAckPacket(new JArray(AckData), PacketID)); }; } AckEventHandlerManager.Emit(Event, new SocketIOAckEvent(Data, Callback)); } }
public SocketIOPacket Deconstruct() { int PlaceholderIndex = 0; while (ConstructeeTokenCount > 0) { JToken Parent = DequeueConstructeeTokenParent(out object Key); ConstructeePacket.Attachments.Enqueue(SocketIOPacket.Decode((byte[])Parent[Key])); Parent[Key] = new JObject { [PLACEHOLDER] = true, [NUM] = PlaceholderIndex++ }; } return(ConstructeePacket); }
public override void SetPacket(SocketIOPacket ConstructeePacket) { if (ConstructeePacket != null) { base.SetPacket(ConstructeePacket); ConstructorAction EnqueueAction = new ConstructorAction((Data) => ConstructeeTokens.Enqueue(Data)); Tuple <Condition, ConstructorAction>[] ConditionalActions = new Tuple <Condition, ConstructorAction>[] { new Tuple <Condition, ConstructorAction>(IsPlaceholder, EnqueueAction), }; DFS(ConstructeePacket.JsonData, ConditionalActions); if (ConstructeePacket.Attachments.Count != ConstructeeTokenCount) { throw new SocketIOException("Attachment count is not match to placeholder count. " + this); } } }
private void OnConnection(EngineIOSocket EngineIOSocket) { SocketIOSocket Socket = new SocketIOSocket(EngineIOSocket, this); SimpleMutex.Lock(ClientMutex, () => { _Clients.Add(Socket); Socket.On(SocketIOEvent.DISCONNECT, () => { SimpleMutex.Lock(ClientMutex, () => { _Clients.Remove(Socket); }); }); Socket.Emit(SocketIOPacket.CreateConnectionPacket()); ConnectionHandlerManager.Emit(SocketIOEvent.CONNECTION, Socket); }); }
private void Emit(SocketIOPacket Packet) { if (this.Client != null && Packet != null) { object Encoded = SocketIOPacket.Encode(Packet); if (Packet.IsBinary) { Client.Send((byte[])Encoded); } else { Client.Send((string)Encoded); } foreach (SocketIOPacket Attachment in Packet.Attachments) { this.Emit(Attachment); } } }
internal TChildClass Emit(SocketIOPacket Packet) { if (Packet != null) { object Encoded = Packet.Encode(); if (Packet.IsJson) { Emit((string)Encoded); } else { Emit((byte[])Encoded); } foreach (SocketIOPacket Attachment in Packet.Attachments) { Emit(Attachment); } } return(this as TChildClass); }
public override void SetPacket(SocketIOPacket ConstructeePacket) { if (ConstructeePacket != null) { base.SetPacket(ConstructeePacket); ConstructorAction EnqueueAction = new ConstructorAction((Data) => ConstructeeTokens.Enqueue(Data)); ConstructorAction CountAction = new ConstructorAction((Data) => PlaceholderCount++); Tuple <Condition, ConstructorAction>[] ConditionalActions = new Tuple <Condition, ConstructorAction>[] { new Tuple <Condition, ConstructorAction>(IsBytes, EnqueueAction), new Tuple <Condition, ConstructorAction>(IsPlaceholder, CountAction) }; DFS(ConstructeePacket.JsonData, ConditionalActions); if (PlaceholderCount > 0) { throw new SocketIOException("Bytes token count is not match to placeholder count. " + this); } } }
private void OnPacket(SocketIOPacket Packet) { switch (Packet.Type) { case SocketIOPacketType.CONNECT: OnConnect(); break; case SocketIOPacketType.DISCONNECT: Close(); break; case SocketIOPacketType.EVENT: OnEvent(Packet); break; case SocketIOPacketType.ACK: OnAck(Packet); break; case SocketIOPacketType.ERROR: OnError(Packet); break; case SocketIOPacketType.BINARY_EVENT: OnBinaryEvent(Packet); break; case SocketIOPacketType.BINARY_ACK: OnBinaryAck(Packet); break; default: OnEtc(Packet); break; } }
private void HandleSocketPacket(SocketIOPacket Packet, bool IsBinary) { switch (Packet.SocketPacketType) { case SocketIOPacketType.CONNECT: HandleConnect(); break; case SocketIOPacketType.DISCONNECT: HandleDisconnect(); break; case SocketIOPacketType.EVENT: HandleEvent(Packet); break; case SocketIOPacketType.ACK: HandleAck(Packet); break; case SocketIOPacketType.ERROR: HandleError(Packet); break; case SocketIOPacketType.BINARY_EVENT: HandleBinaryEvent(Packet); break; case SocketIOPacketType.BINARY_ACK: HandleBinaryAck(Packet); break; default: HandleEtcSocketPacket(Packet, IsBinary); break; } }
private void HandleBinaryEvent(SocketIOPacket Packet) { HandleBinaryPacket(Packet); }
private void OnBinaryAck(SocketIOPacket Packet) { OnBinaryPacket(Packet); }
private void OnWebsocketMessage(object sender, WebSocketSharp.MessageEventArgs e) { SocketIOPacket Packet = (e.IsText ? SocketIOPacket.Decode(e.Data) : (e.IsBinary ? SocketIOPacket.Decode(e.RawData) : null)); this.HandleEnginePacket(Packet, e.IsBinary); }
protected void OnPacket(EngineIOPacket Packet) { OnPacket(SocketIOPacket.Decode(Packet)); }
private void OnError(SocketIOPacket Packet) { CallEventHandler(SocketIOEvent.ERROR, Packet?.JsonData?.ToString() ?? string.Empty); }
private void OnBinaryEvent(SocketIOPacket Packet) { OnBinaryPacket(Packet); }
private void HandleEvent(SocketIOPacket Packet) { CallHandler(Packet); }
private void HandleBinaryAck(SocketIOPacket Packet) { HandleBinaryPacket(Packet); }
private void HandleError(SocketIOPacket Packet) { CallEventHandler(Event.ERROR, Packet != null && Packet.JsonData != null ? Packet.JsonData.ToString() : string.Empty); }