Example #1
0
        /// <summary>
        /// Checks which users are live, along with who has gone offline.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void Tick(object sender, ElapsedEventArgs e)
        {
            if (ticking == true)
            {
                return;
            }
            ticking = true;
            List <string> liveUsers = new List <string>();
            var           s         = await GetStreams();

            if (s != null)
            {
                for (int i = 0; i < s.Length; i++)
                {
                    liveUsers.Add(s[i].UserName);
                    // User is/was live.
                    if (LiveStreams.ContainsKey(s[i].UserName))
                    {
                        // It's the same stream.
                        if (LiveStreams[s[i].UserName].Id == s[i].Id)
                        {
                            LiveStreams[s[i].UserName] = s[i];
                            // Invoke event.
                            OnStreamArgs onStreamUpdateArgs = new OnStreamArgs(s[i].UserName, s[i]);
                            OnStreamUpdate?.Invoke(this, onStreamUpdateArgs);
                            continue;
                        }
                        // Different stream.
                        else
                        {
                            if (LiveStreams.TryRemove(s[i].UserName, out Stream v))
                            {
                                if (LiveStreams.TryAdd(s[i].UserName, s[i]))
                                {
                                    // Invoke event.
                                    OnStreamArgs onStreamOnlineArgs = new OnStreamArgs(s[i].UserName, s[i]);
                                    OnStreamOnline?.Invoke(this, onStreamOnlineArgs);
                                }
                            }
                        }
                    }
                    // User was not live before.
                    else
                    {
                        if (LiveStreams.TryAdd(s[i].UserName, s[i]))
                        {
                            // Invoke event.
                            OnStreamArgs oso = new OnStreamArgs(s[i].UserName, s[i]);
                            OnStreamOnline?.Invoke(this, oso);
                        }
                    }
                }

                Cleanup(liveUsers);
            }
            ticking = false;

            SaveLoadService.Save(monitoredUsersFilename, LiveStreams);
        }
Example #2
0
        private void _checkOnlineStreams()
        {
            var liveStreamers = _getLiveStreamers().Result;

            foreach (var channel in _channelIds)
            {
                var currentStream = liveStreamers.Where(x => x.Channel.Id == channel).FirstOrDefault();
                if (currentStream == null)
                {
                    //offline
                    if (_statuses[channel] != null)
                    {
                        var channelName = _statuses[channel].Channel.Name;
                        //have gone offline
                        _statuses[channel] = null;

                        if (!_isStartup || (_isStartup && _invokeEventsOnStart))
                        {
                            OnStreamOffline?.Invoke(this,
                                                    new OnStreamOfflineArgs {
                                ChannelId = channel, Channel = channelName, CheckIntervalSeconds = CheckIntervalSeconds
                            });
                        }
                    }
                }
                else
                {
                    var channelName = currentStream.Channel.Name;
                    //online
                    if (_statuses[channel] == null)
                    {
                        //have gone online
                        if (!_isStartup || (_isStartup && _invokeEventsOnStart))
                        {
                            OnStreamOnline?.Invoke(this,
                                                   new OnStreamOnlineArgs {
                                ChannelId = channel, Channel = channelName, Stream = currentStream, CheckIntervalSeconds = CheckIntervalSeconds
                            });
                        }
                    }
                    else
                    {
                        //stream updated
                        if (!_isStartup || (_isStartup && _invokeEventsOnStart))
                        {
                            OnStreamUpdate?.Invoke(this,
                                                   new OnStreamUpdateArgs {
                                ChannelId = channel, Channel = channelName, Stream = currentStream, CheckIntervalSeconds = CheckIntervalSeconds
                            });
                        }
                    }
                    _statuses[channel] = currentStream;
                }
            }
        }
Example #3
0
        private void HandleLiveStreamUpdate(string channel, Stream liveStream, bool callEvents)
        {
            var wasAlreadyLive = LiveStreams.ContainsKey(channel);

            LiveStreams[channel] = liveStream;

            if (!callEvents)
            {
                return;
            }

            if (!wasAlreadyLive)
            {
                OnStreamOnline?.Invoke(this, new OnStreamOnlineArgs {
                    Channel = channel, Stream = liveStream
                });
            }
            else
            {
                OnStreamUpdate?.Invoke(this, new OnStreamUpdateArgs {
                    Channel = channel, Stream = liveStream
                });
            }
        }
Example #4
0
        public UnityLiveStreamMonitor(ITwitchAPI api, int checkIntervalSeconds = 60, bool checkStatusOnStart = true, bool invokeEventsOnStart = false) : base(api, checkIntervalSeconds, checkStatusOnStart, invokeEventsOnStart)
        {
            ThreadDispatcher.EnsureCreated();

            base.OnStreamOnline         += ((object sender, OnStreamOnlineArgs e) => { ThreadDispatcher.Enqueue(() => OnStreamOnline?.Invoke(sender, e)); });
            base.OnStreamOffline        += ((object sender, OnStreamOfflineArgs e) => { ThreadDispatcher.Enqueue(() => OnStreamOffline?.Invoke(sender, e)); });
            base.OnStreamUpdate         += ((object sender, OnStreamUpdateArgs e) => { ThreadDispatcher.Enqueue(() => OnStreamUpdate?.Invoke(sender, e)); });
            base.OnStreamMonitorStarted += ((object sender, OnStreamMonitorStartedArgs e) => { ThreadDispatcher.Enqueue(() => OnStreamMonitorStarted?.Invoke(sender, e)); });
            base.OnStreamMonitorEnded   += ((object sender, OnStreamMonitorEndedArgs e) => { ThreadDispatcher.Enqueue(() => OnStreamMonitorEnded?.Invoke(sender, e)); });
            base.OnStreamsSet           += ((object sender, OnStreamsSetArgs e) => { ThreadDispatcher.Enqueue(() => OnStreamsSet?.Invoke(sender, e)); });
        }
Example #5
0
        public UnityFollowerService(ITwitchAPI api, int checkIntervalSeconds = 60, bool checkStatusOnStart = true, bool invokeEventsOnStart = false) : base(api, checkIntervalSeconds, checkStatusOnStart, invokeEventsOnStart)
        {
            _threadDispatcher = new GameObject("ThreadDispatcher");
            _threadDispatcher.AddComponent <ThreadDispatcher>();
            UnityEngine.Object.DontDestroyOnLoad(_threadDispatcher);

            base.OnStreamOnline         += ((object sender, OnStreamOnlineArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnStreamOnline?.Invoke(sender, e)); });
            base.OnStreamOffline        += ((object sender, OnStreamOfflineArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnStreamOffline?.Invoke(sender, e)); });
            base.OnStreamUpdate         += ((object sender, OnStreamUpdateArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnStreamUpdate?.Invoke(sender, e)); });
            base.OnStreamMonitorStarted += ((object sender, OnStreamMonitorStartedArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnStreamMonitorStarted?.Invoke(sender, e)); });
            base.OnStreamMonitorEnded   += ((object sender, OnStreamMonitorEndedArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnStreamMonitorEnded?.Invoke(sender, e)); });
            base.OnStreamsSet           += ((object sender, OnStreamsSetArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnStreamsSet?.Invoke(sender, e)); });
        }
Example #6
0
        /// <summary>
        /// Runs the server
        /// </summary>
        public void Start(object state)
        {
            NetBuffer         buffer = new NetBuffer(bufferSize);
            CancellationToken cts    = (CancellationToken)state;

            while (true)
            {
                // Listen for a new connection
                server.Listen(1);
                using (Socket socket = server.Accept())
                {
                    // Attempt pairing with the new client
                    socket.Receive(buffer);
                    // Receive the dimensions of the image
                    uint requestedWidth  = buffer.GetUInt(0);
                    uint requestedHeight = buffer.GetUInt(4);

                    // Dimesions are too large
                    if (requestedHeight > MAX_DIMENSION_SIZE || requestedWidth > MAX_DIMENSION_SIZE)
                    {
                        socket.Send(buffer.Reset().Write(DIMENSIONS_TOO_LARGE));
                        continue;
                    }

                    // Sends the dimensions to client to verify
                    socket.Send(buffer);
                    socket.Receive(buffer);
                    // Dimensions mismatch
                    if (requestedHeight != buffer.GetUInt(4) || requestedWidth != buffer.GetUInt(0))
                    {
                        socket.Send(buffer.Write(DIMENSIONS_MISMATCH));
                        continue;
                    }

                    StreamImage     image      = new StreamImage((int)requestedWidth, (int)requestedHeight);
                    IndexCompressor compressor = new IndexCompressor(requestedWidth, requestedHeight, 0x01000000);

                    // Initialize image
                    socket.Send(buffer.Reset().Write(REQUEST_IMAGE));

                    int  x     = 0;
                    int  y     = 0;
                    bool ended = false;

                    do
                    {
                        socket.Receive(buffer);

                        int i = 0;
                        while (i < buffer.Length - sizeof(int))
                        {
                            image.SetPixel(x, y, buffer.GetInt(i));
                            i += sizeof(int);
                            x++;
                            if (x >= requestedWidth)
                            {
                                x = 0;
                                y++;
                            }
                        }

                        if (buffer.GetUInt(i) == END_OF_IMAGE)
                        {
                            ended = true;
                        }
                        else
                        {
                            image.SetPixel(x, y, buffer.GetInt(i));
                            x++;
                            if (x >= requestedWidth)
                            {
                                x = 0;
                                y++;
                            }
                        }
                    } while (!ended);
                    OnConnectionAstablished?.Invoke(image.Width, image.Height, image.image, this);
                    socket.Send(buffer.Reset().Write(PAIR_SUCCESSFUL));

                    IIndexable pixel = new RISPImagePixel();
                    // Start streaming loop
                    while (true)
                    {
                        try
                        {
                            socket.Receive(buffer);

                            if (buffer.GetULong(0) == TERMINATE_CONNECTION)
                            {
                                break;
                            }

                            int index = 0;
                            RISPImagePixel[] diffrences = new RISPImagePixel[buffer.Length / sizeof(ulong)];
                            while (index < buffer.Length)
                            {
                                ulong compressedValue = buffer.GetULong(index);
                                compressor.Decompress(compressedValue, ref pixel);

                                RISPImagePixel iPixel = (RISPImagePixel)pixel;
                                System.Console.WriteLine(iPixel.color.ToString("X"));
                                diffrences[index / sizeof(ulong)] = iPixel;
                                image.SetPixel((int)iPixel.x, (int)iPixel.y, new RGB((int)iPixel.color));

                                index += sizeof(ulong);
                            }
                            // Call stream updates
                            if (diffrences.Length > 0)
                            {
                                OnStreamUpdate?.Invoke(diffrences, this);
                            }
                        }
                        catch (SocketException)
                        {
                            break;
                        }
                    }
                }
            }
        }
Example #7
0
        public UnityLiveStreamMonitor(ITwitchAPI api, int checkIntervalSeconds = 60, int maxStreamRequestCountPerRequest = 100) : base(api, checkIntervalSeconds, maxStreamRequestCountPerRequest)
        {
            ThreadDispatcher.EnsureCreated();

            base.OnStreamOnline   += ((object sender, OnStreamOnlineArgs e) => { ThreadDispatcher.Enqueue(() => OnStreamOnline?.Invoke(sender, e)); });
            base.OnStreamOffline  += ((object sender, OnStreamOfflineArgs e) => { ThreadDispatcher.Enqueue(() => OnStreamOffline?.Invoke(sender, e)); });
            base.OnStreamUpdate   += ((object sender, OnStreamUpdateArgs e) => { ThreadDispatcher.Enqueue(() => OnStreamUpdate?.Invoke(sender, e)); });
            base.OnServiceStarted += ((object sender, OnServiceStartedArgs e) => { ThreadDispatcher.Enqueue(() => OnServiceStarted?.Invoke(sender, e)); });
            base.OnServiceStopped += ((object sender, OnServiceStoppedArgs e) => { ThreadDispatcher.Enqueue(() => OnServiceStopped?.Invoke(sender, e)); });
            base.OnChannelsSet    += ((object sender, OnChannelsSetArgs e) => { ThreadDispatcher.Enqueue(() => OnChannelsSet?.Invoke(sender, e)); });
        }