/// <summary>
/// 处理Packet
/// </summary>
/// <param name="packet"></param>
/// <returns></returns>
private async Task TryProcessReceivedPacketAsync(Packet packet)
{
_logger.LogDebug("Try process received packet: {0}", packet.PacketType);
try
{
if (packet is PingReqPacket)
{
await _clientChannel.WriteAndFlushAsync(new PingRespPacket());
return;
}
if (packet is DisconnectPacket)
{
await DisconnectAsync();
return;
}
if (packet is PubAckPacket)
{
return;
}
if (packet is PublishPacket publishPacket)
{
await ProcessReceivedPublishPacketAsync(publishPacket);
return;
}
if (packet is PubRecPacket pubRecPacket)
{
await _clientChannel.WriteAndFlushAsync(new PubRelPacket(pubRecPacket.PacketId));
return;
}
if (packet is PubRelPacket pubRelPacket)
{
await _clientChannel.WriteAndFlushAsync(new PubCompPacket(pubRelPacket.PacketId));
return;
}
_packetDispatcher.Dispatch(packet);
}
catch (Exception ex)
{
_logger.LogError(ex, "Unhandled exception while process packets.");
_packetDispatcher.Dispatch(ex);
}
}
public void NonStaticHandlerRegister()
{
bool wasCalled = false;
EventHandlerNonStatic eventHandler = new EventHandlerNonStatic();
eventHandler.OnHandlerCalled = packet =>
{
wasCalled = true;
Assert.Equal(m_Packet, packet);
};
m_Dispatcher.RegisterPacketHandlers(eventHandler);
m_Dispatcher.Dispatch(EConnectionState.Disconnected, m_Packet);
Assert.True(wasCalled);
}
public void HandlePacket(NetworkPacket packet)
{
if (!dispatcher.Dispatch(packet))
{
Debug.LogWarning("Unhandled packet: " + (LoginHeader)packet.Header);
}
}
public void PushReceivedData(byte[] data)
{
lock (lockobj)
{
dispatcher.Dispatch(data, 0);
}
}
public void Receive(ArraySegment <byte> buffer)
{
if (State == EConnectionState.Disconnected)
{
return;
}
EPacket eType = PacketReader.DecodePacketType(buffer.Array[buffer.Offset]);
if (eType == EPacket.Persistence)
{
GameStatePersistence.Receive(buffer);
}
else
{
if (m_PackageReader == null)
{
m_PackageReader = new PacketReader();
}
Packet packet = m_PackageReader.Read(new ByteReader(buffer));
if (packet != null)
{
m_PackageReader = null;
Dispatcher.Dispatch(State, packet);
}
}
}
private async void PacketPump()
{
try
{
_session.Connect(_host, _port);
_connected = true;
while (true)
{
var packet = await _session.Receive();
Invoke(
new MethodInvoker(
() => _dispatcher.Dispatch(packet, _session)));
}
}
catch
{
}
_connected = false;
}
private Task ProcessReceivedPacketAsync(Packet packet)
{
_logger.LogInformation("【ProcessReceivedPacketAsync】: " + packet.PacketType);
if (packet is PingReqPacket)
{
return(SendAsync(PingRespPacket.Instance));
}
if (packet is DisconnectPacket)
{
return(DisconnectAsync());
}
if (packet is PubAckPacket)
{
return(Task.CompletedTask);
}
if (packet is PublishPacket publishPacket)
{
return(ProcessReceivedPublishPacketAsync(publishPacket));
}
if (packet is PubRecPacket pubRecPacket)
{
return(SendAsync(new PubRelPacket(pubRecPacket.PacketId)));
}
if (packet is PubRelPacket pubRelPacket)
{
return(SendAsync(new PubCompPacket(pubRelPacket.PacketId)));
}
if (packet is PubCompPacket)
{
return(Task.CompletedTask);
}
return(_packetDispatcher.Dispatch(packet));
}
IEnumerator BeginLoop()
{
var url = ServerURL;
Debug.Log($"connect to {url}");
ws = new WebSocket(new Uri(url));
yield return(StartCoroutine(ws.Connect()));
if (ws.error != null)
{
_error.OnNext(ws.error);
yield break;
}
// connection success
readySubject.OnNext(true);
SendImmediate(new ConnectPacket());
while (ws != null)
{
byte[] bytes = null;
while (ws != null && bytes == null)
{
if (ws.error != null)
{
_error.OnNext(ws.error);
}
bytes = ws.Recv();
yield return(null);
}
var now = TimeUtils.NowTimestamp;
bandwidth.AddReceived(bytes.Length, now);
dispatcher.Dispatch(bytes, 0);
}
}
public void OnNext(Session session, byte[] data)
{
dispatcher.Dispatch(data, session);
}
