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