Beispiel #1
0
        public void InvokeClientDisconnected(DisconnectArgs e)
        {
            EventHandler <DisconnectArgs> handler = ClientDisconnected;

            if (handler != null)
            {
                handler(this, e);
            }
        }
Beispiel #2
0
        /// <summary>
        /// Runs whenever the local client disconnects
        /// </summary>
        /// <param name="sender">Object that fired the event</param>
        /// <param name="e">Arguments associated with client disconnects</param>
        private void _clientDisconnected(object sender, DisconnectArgs e)
        {
            _client = null;

            if (_server == null)
            {
                btnServerStart.IsEnabled = true;
            }
            btnServerConnect.IsEnabled    = true;
            btnServerDisconnect.IsEnabled = false;

            txtSend.Text = "";
            txtSend_ChangeTextWithKeyboardFocus(); //See _sendMessage for details
            txtSend.IsEnabled = false;
        }
 public void InvokeClientDisconnected(DisconnectArgs e)
 {
     EventHandler<DisconnectArgs> handler = ClientDisconnected;
     if (handler != null) handler(this, e);
 }
Beispiel #4
0
 private void YTClient_OnDisconnectEvent(object sender, DisconnectArgs e)
 {
     Log(LogLevel.Info, "Disconnected from GoogleAPI!");
 }
Beispiel #5
0
        private void __InitializeObjects__()
        {
            //Initializing commands to function mappings
            msgHandlers = new Dictionary <string, Func <RequestResponseModel, Task> >()
            {
                //Handshake and initialization related responses
                { "Botapiauth.AuthenticateResponse", _onauthresponse_ },
                { "Botapichat.ConnectResponse", _onchatconnectresponse_ },
                { "Botapichat.DisconnectResponse", _onchatdisconnectresponse_ },

                //Async responses related to connection state
                { "Botapichat.ConnectEventRequest", _onchatconnectevent_ },
                { "Botapichat.DisconnectEventRequest", _onchatdisconnectevent_ },

                //General responses when server acknowledges a request
                { "Botapichat.SendMessageResponse", _onchatsendmessageresponse_ },
                { "Botapichat.SendWhisperResponse", _onchatsendwhisperresponse_ },
                { "Botapichat.BanUserResponse", _onbanuserresponse_ },
                { "Botapichat.UnbanUserResponse", _onunbanuserresponse_ },
                { "Botapichat.SendEmoteResponse", _onsendemoteresponse_ },
                { "Botapichat.KickUserResponse", _onkickuserresponse_ },
                { "Botapichat.SendSetModeratorResponse", _onsetmoderatorresponse_ },

                //Server events that require client action
                { "Botapichat.MessageEventRequest", _onchatmessageevent_ },
                { "Botapichat.UserUpdateEventRequest", _onuserupdateevent_ },
                { "Botapichat.UserLeaveEventRequest", _onuserleaveevent_ }
            };

            //Defining socket behaviour for listening
            socket.OnOpen += async(sender, args) =>
            {
                //Step 1: Authenticate with server using API key
                Debug.WriteLine("[SOCKET]Connected! Attempting to authenticate...");

                RequestResponseModel request = new RequestResponseModel()
                {
                    Command   = "Botapiauth.AuthenticateRequest",
                    RequestId = Interlocked.Exchange(ref requestID, requestID++),
                    Payload   = new Dictionary <string, object>()
                    {
                        { "api_key", APIKey }
                    }
                };
                await Task.Run(() => socket.Send(JsonConvert.SerializeObject(request)));

                //Continued in _onauthresponse_()
            };

            socket.OnMessage += async(sender, args) =>
            {
                RequestResponseModel msg = JsonConvert.DeserializeObject <RequestResponseModel>(args.Data);
                if (msg.Command.IsNullOrEmpty() || !msgHandlers.ContainsKey(msg.Command))
                {
                    Debug.WriteLine($"[ERROR]Command {msg.Command} not recognized!");
                    Debug.WriteLine($"[ERROR]Message payload: {args.Data}");
                }
                else
                {
                    await msgHandlers[msg.Command].Invoke(msg);
                }
            };

            socket.OnClose += async(sender, args) =>
            {
                lock (mutex)
                {
                    isConnected = false;
                    isReady     = false;
                }
                DisconnectArgs dargs = new DisconnectArgs(args.Code, args.Reason, args.WasClean);
                Task           t     = Task.Run(() => OnDisconnect?.Invoke(this, dargs));

                Debug.WriteLine($"[SOCKET]Disconnected with code {args.Code}. Reason: {args.Reason}");
                await t;
            };

            socket.OnError += (sender, args) =>
            {
                Debug.WriteLine($"[ERROR] {args.Message}");
                if (args.Exception != null)
                {
                    throw args.Exception;
                }
            };
        }