Пример #1
0
 private void cmdTrennen_Click(System.Object sender, System.EventArgs e)
 {
     if (client.IsConnected)
     {
         client.LeaveChannel(txtChannel1.Text);
     }
     client.Disconnect();
     backgroundWorker1.CancelAsync();
     backgroundWorker1.Dispose();
 }
        public Task Disconnect()
        {
            foreach (var joinedChannel in client.JoinedChannels)
            {
                client.LeaveChannel(joinedChannel);
            }

            client.Disconnect();

            return(Task.CompletedTask);
        }
Пример #3
0
 public async Task StopAsync(CancellationToken cancellationToken)
 {
     isShuttingDown = true;
     if (_twitchClient != null && _twitchClient.IsConnected)
     {
         _twitchClient.Disconnect();
     }
     if (_twitchPubSub != null)
     {
         _twitchPubSub.Disconnect();
     }
     if (_timer != null)
     {
         _timer.Dispose();
     }
     //if (_streamStatusCheck != null)
     //{
     //    _streamStatusCheck.Dispose();
     //}
     //if (_followerChatReminder != null)
     //{
     //    _followerChatReminder.Dispose();
     //}
     //if (_discordChatReminder != null)
     //{
     //    _discordChatReminder.Dispose();
     //}
     //if (_questionChatReminder != null)
     //{
     //    _questionChatReminder.Dispose();
     //}
     //if (_primeChatReminder != null)
     //{
     //    _primeChatReminder.Dispose();
     //}
     if (_alertHubConnection != null)
     {
         if (_alertHubConnection.State == HubConnectionState.Connected)
         {
             await _alertHubConnection.StopAsync();
         }
         await _alertHubConnection.DisposeAsync();
     }
     if (_chatHubConnection != null)
     {
         if (_chatHubConnection.State == HubConnectionState.Connected)
         {
             await _chatHubConnection.StopAsync();
         }
         await _chatHubConnection.DisposeAsync();
     }
     if (_overlayHubConnection != null)
     {
         if (_overlayHubConnection.State == HubConnectionState.Connected)
         {
             await _overlayHubConnection.StopAsync();
         }
         await _overlayHubConnection.DisposeAsync();
     }
 }
Пример #4
0
        private void ResetConnection_Tick(object sender, EventArgs e)
        {
            //This works around an issue with Twitch where the IRC Client gets randomly disconnected.,

            client.Disconnect();
            client.Connect();
        }
Пример #5
0
 private void OnApplicationQuit()
 {
     if (client != null && client.IsConnected)
     {
         client.Disconnect();
     }
 }
Пример #6
0
        private void btnDisconnect_Click(object sender, EventArgs e)
        {
            Client.Disconnect();
            btnConnect.Enabled    = true;
            btnDisconnect.Enabled = false;
            edtMessage.Enabled    = false;
            btnSend.Enabled       = false;
            webChat.Navigate("about:blank");
            tmStream.Enabled = false;

            lbEmotes.Enabled        = false;
            btnSendEmotes.Enabled   = false;
            speCount.Enabled        = false;
            btnPower.Enabled        = false;
            btnPowerJ.Enabled       = false;
            btnPowerKursive.Enabled = false;
            btnSend.Enabled         = false;
            edtMessage.Enabled      = false;

            edtUser.Enabled    = true;
            edtChannel.Enabled = true;
            edtOauth.Enabled   = true;

            pbChannelIcon.Image = null;
            lblStatus.Text      = "-";
            lblViewers.Text     = "-";
            lblGame.Text        = "-";
            lblLink.Text        = "-";
            lblName.Text        = "-";
            RichLog.Clear();
            lblLink.Enabled = false;
        }
Пример #7
0
 private void Stop()
 {
     ButtonText    = "Start";
     ButtonCommand = new DelegateCommand(Start);
     Running       = false;
     _client.Disconnect();
 }
Пример #8
0
        public async Task Disconnect()
        {
            _twitchClient.OnDisconnected += TwitchClientOnOnDisconnected;
            _twitchClient.Disconnect();

            await _disconnectionCompletionTask.Task;
        }
 private void TwitchClient_OnMessageSent(object sender, OnMessageSentArgs e)
 {
     if (_twitchClient.IsConnected)
     {
         _twitchClient.Disconnect();
     }
 }
Пример #10
0
        // Call bot to disconnect
        internal void Disconnect()
        {
            consoleMessage[5] = "Disconnecting";
            Program.SendToConsole(consoleMessage);

            client.Disconnect();
        }
Пример #11
0
        public void Stop()
        {
            if (kernel.Started)
            {
                kernel.Stop();
            }
            Unsubscribe();

            tryToReconnect = false;
            if (client.IsConnected)
            {
                client.Disconnect();
            }

            try
            {
                listeningToChannelPoints = false;
                pubsubIsConnected        = false;
                pubsub.Disconnect();
            }
            catch
            {
            }

            broadcastSubscription?.Unsubscribe();
        }
Пример #12
0
        private async Task UpdatePassword(string password)
        {
            _logger.LogInformation(
                $"{DateTime.UtcNow.ToString(CultureInfo.CurrentUICulture)}: Updating the Twitch bot password");
            var creds = new ConnectionCredentials(_config[Constants.CONFIG_TWITCH_USERNAME], password);

            try
            {
                // IF CONNECTED, DISCONNECT
                if (_twitchClient.IsConnected)
                {
                    _logger.LogInformation($"{DateTime.UtcNow.ToString(CultureInfo.CurrentUICulture)}: Disconnecting from Twitch");
                    _twitchClient.Disconnect();
                    _logger.LogInformation($"{DateTime.UtcNow.ToString(CultureInfo.CurrentUICulture)}: Disconnected from Twitch");
                }

                // UPDATE THE CLIENT CREDS
                _twitchClient.SetConnectionCredentials(creds);

                // RECONNECT TO TWITCH
                _twitchClient.Reconnect();
                _logger.LogInformation($"{DateTime.UtcNow.ToString(CultureInfo.CurrentUICulture)}: Updated the Twitch bot password");
            }
            catch (Exception ex)
            {
                _logger.LogError($"{DateTime.UtcNow.ToString(CultureInfo.CurrentUICulture)}: An exception occured: {ex.Message}");
            }

            _logger.LogInformation(
                $"{DateTime.UtcNow.ToString(CultureInfo.CurrentUICulture)}: Updated the Twitch bot password");
            await Task.CompletedTask;
        }
Пример #13
0
            internal async Task <string> OnApiRequest(JObject request, ILambdaContext context)
            {
                var jArray = JArray.Parse(request["Records"].ToString());

                var sqsMessages = jArray.ToObject <List <Message> >();

                _Logger.LogInformation($"Received SQS Messages: {sqsMessages.ToJsonString()}");

                var client = new TwitchClient(new WebSocketClient(new ClientOptions
                {
                    MessagesAllowedInPeriod = 750,
                    ThrottlingPeriod        = TimeSpan.FromSeconds(30)
                }));

                client.Initialize(new ConnectionCredentials(TwitchInfos.UserName, TwitchInfos.Token), "Nerdtastic");
                client.Connect();
                foreach (var sqsMessage in sqsMessages)
                {
                    var streamResponse = JObject.Parse(sqsMessage.Body).ToObject <StreamEventResponse>();
                    //log in as our bot
                    //send the message to the user.

                    if (streamResponse.Whisper)
                    {
                        client.SendWhisper(streamResponse.UserName, streamResponse.Response);
                    }
                    else
                    {
                        client.SendMessage(new JoinedChannel(streamResponse.Channel), streamResponse.Response);
                    }
                }
                client.Disconnect();

                return("Jobs done - fix me");
            }
Пример #14
0
 public void DisconnectFromChat()
 {
     if (IsActive)
     {
         client.Disconnect();
     }
 }
Пример #15
0
 public void Disconnect()
 {
     if (client.IsConnected)
     {
         client.Disconnect();
     }
 }
        public void ClientReconnectsOk()
        {
            var client           = new TwitchClient(_mockClient);
            var pauseConnected   = new ManualResetEvent(false);
            var pauseReconnected = new ManualResetEvent(false);

            Assert.Raises <OnReconnectedEventArgs>(
                h => client.OnReconnected += h,
                h => client.OnReconnected -= h,
                () =>
            {
                client.OnConnected += (s, e) =>
                {
                    pauseConnected.Set();
                    client.Disconnect();
                };

                client.OnDisconnected += (s, e) => { client.Reconnect(); };
                client.OnReconnected  += (s, e) => { pauseReconnected.Set(); };

                client.Initialize(new Models.ConnectionCredentials(TWITCH_BOT_USERNAME, "OAuth"));
                client.Connect();
                ReceivedTwitchConnected();

                Assert.True(pauseConnected.WaitOne(5000));
                Assert.True(pauseReconnected.WaitOne(60000));
            });
        }
Пример #17
0
 internal void Disconnect()
 {
     Console.WriteLine("[Bot]: Disconnecting...");
     points.Save();
     usersManager.Save();
     client.Disconnect();
 }
Пример #18
0
 public void Stop()
 {
     TwitchClient.Disconnect();
     Active = false;
     TokenSource.Cancel();
     SendingThread.Join();
 }
Пример #19
0
 private void Reconnect()
 {
     if (_twitch.IsConnected)
     {
         _twitch.Disconnect();
     }
     _twitch.Connect();
 }
Пример #20
0
 internal void Disconnect()
 {
     twitchClient.Disconnect();
     if (_botTimer is not null)
     {
         _botTimer.Dispose();
     }
 }
Пример #21
0
 private async Task DisconnectAsync()
 {
     Messages.Clear();
     _client.Disconnect();
     IsConnected               = false;
     connectionLight.Fill      = Brushes.Red;
     channelEntryBox.IsEnabled = true;
 }
 /// <summary>
 /// Disconnects from Twitch.
 /// </summary>
 public void Stop()
 {
     botClient.Disconnect();
     userClient.Disconnect();
     followerService.StopService();
     liveStreamMonitor.StopService();
     IsConnected = false;
 }
Пример #23
0
 private void disconnect_Click(object sender, RoutedEventArgs e)
 {
     client.LeaveChannel(channel);
     client.Disconnect();
     client = null;
     Chat.Items.Insert(0, "Disconnecting...");
     controlListMemory();
 }
 internal void Disconnect()
 {
     CloseExcel();
     client.Disconnect();
     monitor.Stop();
     fservice.Stop();
     Console.WriteLine("Disconnecting...");
 }
Пример #25
0
 private void Disconnect()
 {
     Logger.Instance.LogMessage(TracingLevel.INFO, "TwitchChat: Attempting to disconnect");
     if (client != null && client.IsConnected)
     {
         client.Disconnect();
     }
 }
Пример #26
0
 public Task StopAsync(CancellationToken cancellationToken)
 {
     if (_Client != null)
     {
         _Client.Disconnect();
     }
     return(Task.CompletedTask);
 }
Пример #27
0
        public Task StopAsync(CancellationToken cancellationToken)
        {
            _logger.LogDebug("Chat update service is stopping.");

            _client.Disconnect();

            return(Task.CompletedTask);
        }
Пример #28
0
        /// <summary>
        /// Connects a TwitchClient to a specified twitch chat, and listens for chat events
        /// </summary>
        public void GetChat()
        {
            //if a connection is already esablished prior to trying to connecting another channel,
            //disconnect client and reset credentials
            try
            {
                client.Disconnect();
                client      = null;
                credentials = null;
            }
            catch (Exception)
            {
            }

            //sets the channel name that the client will connect to
            channel_name = channelInput.Text.ToLower();

            //creates client credentials from access tokens and bot username
            credentials = new ConnectionCredentials(BOT_CHANNEL_NAME, BOT_ACCESS_TOKEN);

            //creates new empty client
            client = new TwitchClient();

            //subs to log event to display client logs in the output window
            client.OnLog += Client_OnLog;

            //initialize client using credentials, and tell it what channel it will be going to.
            client.Initialize(credentials, channel_name);

            //subscribe to any events we want our bot to listen for

            //subs to new chat messsage
            client.OnMessageReceived += MyMessageRecieved;

            client.OnWhisperReceived += WhisperRecieved;

            //subs to client connected
            client.OnConnected += Client_OnConnected;

            //subs to chat commands
            client.OnChatCommandReceived += Client_OnChatCommandReceived;

            //conencts client to specified twitch channel
            client.Connect();
        }
Пример #29
0
        internal void Disconnect()
        {
            form.ExecuteAction(() =>
            {
                form.DebugRichTextBox.AppendText("[Bot]: Disonnecting and closing application\n");
            });

            client.Disconnect();
        }
Пример #30
0
 public void BotStop()
 {
     client.Disconnect();
     isConnected = false;
     window.Dispatcher.Invoke((Action)(() =>
     {//this refer to form in WPF application
         window.BotStopped();
     }));
 }