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);
}
