protected override void Cleanup()
        {
            if (ether != null)
            {
                if (ether.Connected)
                {
                    OnDisconnecting?.Invoke(this);
                    //Update all writable registers one last time.
                    for (int id = 0; id < MaxNumDevices; id++)
                    {
                        if (registers[id] != null)
                        {
                            byte[] update = registers[id].SendUpdate;
                            if ((update != null) && (update.Length > 0))
                            {
                                ether?.Send(new UdpPacket((byte)id, update));
                            }
                        }
                    }
                }

                ether.Disconnect();
                ether.OnPacketReceived -= Ether_OnPacketReceived;
            }
            ThreadPool.QueueUserWorkItem(new WaitCallback((object callback) => { OnDisconnected?.Invoke(); }));
        }
        public void HandleMessages()
        {
            NetIncomingMessage message;

            while ((message = m_Server.ReadMessage()) != null)
            {
                switch (message.MessageType)
                {
                case NetIncomingMessageType.ConnectionApproval:
                    try
                    {
                        var packet = Packet.Read(message.Data);
                        ApproveConnection(message.SenderConnection);
                        OnConnectionApproved?.Invoke(new LidgrenMessage(message));
                    }
                    catch (Exception e)
                    {
                        DenyConnection(message.SenderConnection);
                        OnConnectionDenied?.Invoke(new LidgrenMessage(message));
                    }
                    break;

                case NetIncomingMessageType.StatusChanged:
                    switch (message.SenderConnection.Status)
                    {
                    case NetConnectionStatus.Connected:
                        OnConnected?.Invoke(new LidgrenMessage(message));
                        break;

                    case NetConnectionStatus.Disconnected:
                        OnDisconnecting?.Invoke(new LidgrenMessage(message));         //not firing from lidgren
                        OnDisconnected?.Invoke(new LidgrenMessage(message));
                        break;
                    }
                    break;

                case NetIncomingMessageType.Data:
                    TriggerCallback(new LidgrenConnection(message.SenderConnection), message.Data);
                    OnReceivedData?.Invoke(new LidgrenMessage(message));
                    break;

                case NetIncomingMessageType.DebugMessage:
                    // handle debug messages
                    // (only received when compiled in DEBUG mode)
                    Console.WriteLine("DEBUG: " + message.ReadString());
                    break;

                case NetIncomingMessageType.WarningMessage:
                    Console.WriteLine("WARNING: " + message.ReadString());
                    break;

                /* .. */
                default:
                    Console.WriteLine("unhandled message with type: "
                                      + message.MessageType);
                    break;
                }
            }
        }
Exemple #3
0
 public async Task DisconnectAsync(
     WebSocketCloseStatus closeStatus = WebSocketCloseStatus.NormalClosure,
     string statusDescription         = "")
 {
     OnDisconnecting?.Invoke(closeStatus, statusDescription);
     _reading = false;
     _cancellation.Cancel();
     try
     {
         await RawSocket.CloseAsync(closeStatus, statusDescription, CancellationToken.None);
     }
     catch (Exception)
     {
         // Exit normally
     }
     OnDisconnect?.Invoke(closeStatus, statusDescription);
 }
Exemple #4
0
 public void RaiseOnDisconnecting(KL2_Server server) =>
 OnDisconnecting?.Invoke(server);