private async void SendPlaybackNotification(string type, PlaybackProgressEventArgs e)
        {
            var user = e.Users.FirstOrDefault();

            if (user != null && !GetOptions().IsEnabledToMonitorUser(type, user.Id.ToString("N")))
            {
                return;
            }

            var item = e.MediaInfo;

            if (e.Item != null && e.Item.IsThemeMedia)
            {
                // Don't report theme song or local trailer playback
                return;
            }

            var notification = new NotificationRequest
            {
                NotificationType = type
            };

            if (e.Item != null)
            {
                notification.Variables["ItemName"] = GetItemName(e.Item);
            }
            else
            {
                notification.Variables["ItemName"] = item.Name;
            }

            notification.Variables["UserName"]   = user == null ? "Unknown user" : user.Name;
            notification.Variables["AppName"]    = e.ClientName;
            notification.Variables["DeviceName"] = e.DeviceName;

            await SendNotification(notification, null).ConfigureAwait(false);
        }
Esempio n. 2
0
        void _sessionManager_PlaybackProgress(object sender, PlaybackProgressEventArgs e)
        {
            string key = e.DeviceId + "-" + e.Users[0].Id.ToString("N") + "-" + e.Item.Id.ToString("N");

            if (playback_trackers != null && playback_trackers.ContainsKey(key))
            {
                try
                {
                    PlaybackTracker tracker = playback_trackers[key];
                    DateTime        now     = DateTime.Now;
                    if (now.Subtract(tracker.LastUpdated).TotalSeconds > 20) // update every 20 seconds
                    {
                        tracker.LastUpdated = now;
                        _logger.LogInformation("Processing playback tracker : {Key}", key);
                        List <string> event_log = tracker.ProcessProgress(e);
                        if (event_log.Count > 0)
                        {
                            _logger.LogDebug("ProcessProgress : {Events}", string.Join("", event_log));
                        }
                        if (tracker.TrackedPlaybackInfo != null)
                        {
                            _repository.UpdatePlaybackAction(tracker.TrackedPlaybackInfo);
                        }
                    }
                }
                catch (Exception exp)
                {
                    playback_trackers.Remove(key);
                    throw new Exception("Error saving playback state: " + exp.Message);
                }
            }
            else
            {
                _logger.LogDebug("Playback progress did not have a tracker : {Key}", key);
            }
        }
Esempio n. 3
0
        void _sessionManager_PlaybackStart(object sender, PlaybackProgressEventArgs e)
        {
            var item = e.MediaInfo;

            if (item == null)
            {
                //_logger.Warn("PlaybackStart reported with null media info.");
                return;
            }

            if (e.Users.Count == 0)
            {
                return;
            }

            var username = e.Users.First().Name;

            CreateLogEntry(new ActivityLogEntry
            {
                Name          = string.Format(_localization.GetLocalizedString("UserStartedPlayingItemWithValues"), username, item.Name),
                Type          = "PlaybackStart",
                ShortOverview = string.Format(_localization.GetLocalizedString("AppDeviceValues"), e.ClientName, e.DeviceName)
            });
        }
Esempio n. 4
0
    private async void PlaybackStart(object?sender, PlaybackProgressEventArgs e)
    {
        foreach (var user in e.Users)
        {
            var userConfig = GetUserConfig(user.Id);
            if (userConfig == null)
            {
                _logger.LogDebug("{Username}: No configuration", user.Username);
                continue;
            }

            if (string.IsNullOrEmpty(userConfig.CmdPlaybackStart))
            {
                _logger.LogDebug("{Username}: No configured PlaybackStart command", user.Username);
                continue;
            }

            _logger.LogInformation("{Username}: Running command \"{CmdPlaybackStart}\"", user.Username, userConfig.CmdPlaybackStart);

            try
            {
                var command = Command.Run(
                    userConfig.CmdPlaybackStart.Split(" ")[0],
                    userConfig.CmdPlaybackStart.Split(" ")[1..],
Esempio n. 5
0
        async void _device_PlaybackProgress(object sender, PlaybackProgressEventArgs e)
        {
            try
            {
                var info = StreamParams.ParseFromUrl(e.MediaInfo.Url, _libraryManager);

                if (info.Item != null)
                {
                    var progress = GetProgressInfo(e.MediaInfo, info);

                    await _sessionManager.OnPlaybackProgress(progress).ConfigureAwait(false);
                }
            }
            catch (Exception ex)
            {
                _logger.ErrorException("Error reporting progress", ex);
            }
        }
Esempio n. 6
0
        public string buildJson_Playback(PluginConfiguration.Hook hooks, SessionInfo sessionInfo, PlaybackProgressEventArgs playbackData, string trigger)
        {
            if ((trigger == "Paused" || trigger == "Resumed") && string.IsNullOrEmpty(sessionInfo.NowPlayingItem.ToString()))
            {
                return("_redundant_");
            }

            string playbackTicks = (string.IsNullOrEmpty(playbackData.PlaybackPositionTicks.ToString())) ? sessionInfo.PlayState.PositionTicks.ToString() : playbackData.PlaybackPositionTicks.ToString();

            string msgPlayback = buildJson_BaseItem(hooks.removeQuotes, hooks.msgHook, sessionInfo.FullNowPlayingItem);

            return(msgPlayback.Replace("{Event}", testString(hooks.removeQuotes, trigger, true)).
                   Replace("{ServerID}", testString(hooks.removeQuotes, _appHost.SystemId, true)).
                   Replace("{ServerName}", testString(hooks.removeQuotes, _appHost.FriendlyName, true)).

                   Replace("{UserID}", testString(hooks.removeQuotes, sessionInfo.UserId.ToString(), true)).
                   Replace("{UserName}", testString(hooks.removeQuotes, sessionInfo.UserName, true)).

                   Replace("{AppName}", testString(hooks.removeQuotes, sessionInfo.AppName, true)).
                   Replace("{DeviceID}", testString(hooks.removeQuotes, sessionInfo.DeviceId.ToString(), true)).
                   Replace("{DeviceName}", testString(hooks.removeQuotes, sessionInfo.DeviceName, true)).
                   Replace("{DeviceIP}", testString(hooks.removeQuotes, sessionInfo.RemoteEndPoint.ToString(), true)).

                   Replace("{SessionID}", testString(hooks.removeQuotes, sessionInfo.Id, true)).
                   Replace("{SessionPlaybackPositionTicks}", testString(hooks.removeQuotes, playbackTicks, false)).
                   Replace("{TimeStamp}", testString(hooks.removeQuotes, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"), true)));
        }
        /// <summary>
        /// Let Trakt.tv know the user has started to watch something
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void KernelPlaybackStart(object sender, PlaybackProgressEventArgs e)
        {
            try
            {
                _logger.Info("Playback Started");

                if (e.Users == null || !e.Users.Any() || e.Item == null)
                {
                    _logger.Error("Event details incomplete. Cannot process current media");
                    return;
                }

                // Since MB3 is user profile friendly, I'm going to need to do a user lookup every time something starts
                var traktUser = UserHelper.GetTraktUser(e.Users.FirstOrDefault());

                if (traktUser == null)
                {
                    _logger.Info("Could not match user with any stored credentials");
                    return;
                }

                _logger.Debug(traktUser.LinkedMbUserId + " appears to be monitoring " + e.Item.Path);

                var video = e.Item as Video;

                try
                {
                    if (video is Movie)
                    {
                        _logger.Debug("Send movie status update");
                        await
                        _traktApi.SendMovieStatusUpdateAsync(video as Movie, MediaStatus.Watching, traktUser).
                        ConfigureAwait(false);
                    }
                    else if (video is Episode)
                    {
                        _logger.Debug("Send episode status update");
                        await
                        _traktApi.SendEpisodeStatusUpdateAsync(video as Episode, MediaStatus.Watching, traktUser).
                        ConfigureAwait(false);
                    }
                }
                catch (Exception ex)
                {
                    _logger.ErrorException("Exception handled sending status update", ex);
                }

                var playEvent = new ProgressEvent
                {
                    UserId        = e.Users.First().Id,
                    ItemId        = e.Item.Id,
                    LastApiAccess = DateTime.UtcNow
                };

                _progressEvents.Add(playEvent);
            }
            catch (Exception ex)
            {
                _logger.ErrorException("Error sending watching status update", ex, null);
            }
        }
Esempio n. 8
0
 private async void OnSessionManagerPlaybackStart(object sender, PlaybackProgressEventArgs e)
 {
     await SendData(true).ConfigureAwait(false);
 }
Esempio n. 9
0
        private async void OnPlaybackStart(object sender, PlaybackProgressEventArgs e)
        {
            await PlaybackEvent(HookEvent.Play, e.Item, e.Session, e.Users);

            SetDeviceState(e.DeviceId, DeviceState.Playing);
        }
Esempio n. 10
0
 private void OnSessionManagerPlaybackStart(object sender, PlaybackProgressEventArgs e)
 {
     SendData(true);
 }
Esempio n. 11
0
 private void OnSessionManagerPlaybackProgress(object sender, PlaybackProgressEventArgs e)
 {
     SendData(!e.IsAutomated);
 }
Esempio n. 12
0
        public static void PlaybackStarted(object sender, PlaybackProgressEventArgs e)
        {
            try
            {
                if (e.MediaInfo.RunTimeTicks != null &&
                    (e.Item.MediaType == MediaType.Video && e.MediaInfo.RunTimeTicks.Value < IntroOrVideoBackDrop))
                {
                    return;
                }

                string sceneName = string.Empty;
                var    config    = new PluginConfiguration();

                var profile = config.SavedDeviceProfiles.Find(p =>
                                                              p.Name.Equals(e.DeviceName) && e.ClientName.Equals(p.AppName));

                if (ScheduleAllowScene(profile, config))
                {
                    switch (e.MediaInfo.Type)
                    {
                    case "Movie":
                        sceneName = profile.MoviesPlaybackStarted;
                        break;

                    case "TvChannel":
                        sceneName = profile.LiveTvPlaybackStarted;
                        break;

                    case "Series":
                        sceneName = profile.SeriesPlaybackStarted;
                        break;

                    case "Season":
                        sceneName = profile.SeriesPlaybackStarted;
                        break;

                    case "Episode":
                        //var info = EpisodeStopEventTimers.Find(
                        //    t => t.DeviceName == e.DeviceName && t.AppName == e.ClientName);
                        //if (info != null)
                        //{
                        //    EpisodeStopEventTimers.RemoveAll(t => t.DeviceName == info.DeviceName && t.AppName == info.AppName);
                        //    break;
                        //}
                        sceneName = profile.SeriesPlaybackStarted;
                        break;

                    case "Album":
                        sceneName = profile.MusicPlaybackStarted;
                        break;

                    case "Artist":
                        sceneName = profile.MusicPlaybackStarted;
                        break;

                    case "Audio":
                        sceneName = profile.MusicPlaybackStarted;
                        break;

                    default:
                        sceneName = string.Empty;
                        break;
                    }
                }
                else
                {
                    return;
                }
                if (sceneName.Equals(string.Empty))
                {
                    return;
                }
                RunScene(sceneName, config);
            }
            catch { }
        }
Esempio n. 13
0
        private static void PlaybackUnPaused(PlaybackProgressEventArgs e, PluginConfiguration config)
        {
            try
            {
                string sceneName = string.Empty;
                var    profile   = config.SavedDeviceProfiles.Find(p => p.Name.Equals(e.DeviceName) && e.ClientName.Equals(p.AppName));

                if (ScheduleAllowScene(profile, config))
                {
                    switch (e.MediaInfo.Type)
                    {
                    case "Movie":
                        sceneName = profile.MoviesPlaybackUnPaused;
                        break;

                    case "TvChannel":
                        sceneName = profile.LiveTvPlaybackUnPaused;
                        break;

                    case "Series":
                        sceneName = profile.SeriesPlaybackUnPaused;
                        break;

                    case "Season":
                        sceneName = profile.SeriesPlaybackUnPaused;
                        break;

                    case "Episode":
                        sceneName = profile.SeriesPlaybackUnPaused;
                        break;

                    case "Album":
                        sceneName = profile.MusicPlaybackUnPaused;
                        break;

                    case "Artist":
                        sceneName = profile.MusicPlaybackUnPaused;
                        break;

                    case "Audio":
                        sceneName = profile.MusicPlaybackUnPaused;
                        break;

                    default:
                        sceneName = string.Empty;
                        break;
                    }
                }
                else
                {
                    return;
                }

                if (sceneName.Equals(string.Empty))
                {
                    return;
                }
                RunScene(sceneName, config);
            }
            catch { }
        }
        public async System.Threading.Tasks.Task StartPlaybackTimer(PlaybackProgressEventArgs e)
        {
            _logger.Info("StartPlaybackTimer : Entered");
            await System.Threading.Tasks.Task.Delay(20000);

            try
            {
                var session = _sessionManager.GetSession(e.DeviceId, e.ClientName, "");
                if (session != null)
                {
                    string event_playing_id = e.Item.Id.ToString("N");
                    string event_user_id    = e.Users[0].Id.ToString("N");

                    string session_playing_id = "";
                    if (session.NowPlayingItem != null)
                    {
                        session_playing_id = session.NowPlayingItem.Id.ToString("N");
                    }
                    string session_user_id = "";

                    _logger.Info("session.RemoteEndPoint : " + session.RemoteEndPoint);

                    if (session.UserId != null)
                    {
                        session_user_id = ((Guid)session.UserId).ToString("N");
                    }

                    string play_method = "na";
                    if (session.PlayState != null && session.PlayState.PlayMethod != null)
                    {
                        play_method = session.PlayState.PlayMethod.Value.ToString();
                    }
                    if (session.PlayState != null && session.PlayState.PlayMethod == MediaBrowser.Model.Session.PlayMethod.Transcode)
                    {
                        if (session.TranscodingInfo != null)
                        {
                            string video_codec = "direct";
                            if (session.TranscodingInfo.IsVideoDirect == false)
                            {
                                video_codec = session.TranscodingInfo.VideoCodec;
                            }
                            string audio_codec = "direct";
                            if (session.TranscodingInfo.IsAudioDirect == false)
                            {
                                audio_codec = session.TranscodingInfo.AudioCodec;
                            }
                            play_method += " (v:" + video_codec + " a:" + audio_codec + ")";
                        }
                    }

                    string item_name = GetItemName(e.Item);
                    string item_id   = e.Item.Id.ToString("N");
                    string item_type = e.MediaInfo.Type;

                    _logger.Info("StartPlaybackTimer : event_playing_id   = " + event_playing_id);
                    _logger.Info("StartPlaybackTimer : event_user_id      = " + event_user_id);
                    _logger.Info("StartPlaybackTimer : session_playing_id = " + session_playing_id);
                    _logger.Info("StartPlaybackTimer : session_user_id    = " + session_user_id);
                    _logger.Info("StartPlaybackTimer : play_method        = " + play_method);
                    _logger.Info("StartPlaybackTimer : e.ClientName       = " + e.ClientName);
                    _logger.Info("StartPlaybackTimer : e.DeviceName       = " + e.DeviceName);
                    _logger.Info("StartPlaybackTimer : ItemName           = " + item_name);
                    _logger.Info("StartPlaybackTimer : ItemId             = " + item_id);
                    _logger.Info("StartPlaybackTimer : ItemType           = " + item_type);

                    PlaybackInfo play_info = new PlaybackInfo();
                    play_info.Id             = Guid.NewGuid().ToString("N");
                    play_info.Date           = DateTime.Now;
                    play_info.ClientName     = e.ClientName;
                    play_info.DeviceName     = e.DeviceName;
                    play_info.PlaybackMethod = play_method;
                    play_info.UserId         = event_user_id;
                    play_info.ItemId         = item_id;
                    play_info.ItemName       = item_name;
                    play_info.ItemType       = item_type;

                    if (event_playing_id == session_playing_id && event_user_id == session_user_id)
                    {
                        _logger.Info("StartPlaybackTimer : All matches, playback registered");

                        // update tracker with playback info
                        string key = e.DeviceId + "-" + e.Users[0].Id.ToString("N") + "-" + e.Item.Id.ToString("N");
                        if (playback_trackers.ContainsKey(key))
                        {
                            _logger.Info("Playback tracker found, adding playback info : " + key);
                            PlaybackTracker tracker = playback_trackers[key];
                            tracker.TrackedPlaybackInfo = play_info;

                            _logger.Info("Saving playback tracking activity in DB");
                            _repository.AddPlaybackAction(tracker.TrackedPlaybackInfo);
                        }
                        else
                        {
                            _logger.Info("Playback trackler not found : " + key);
                        }
                    }
                    else
                    {
                        _logger.Info("StartPlaybackTimer : Details do not match for play item");
                    }
                }
                else
                {
                    _logger.Info("StartPlaybackTimer : session Not Found");
                }
            }
            catch (Exception exception)
            {
                _logger.Info("StartPlaybackTimer : Error = " + exception.Message + "\n" + exception.StackTrace);
            }
            _logger.Info("StartPlaybackTimer : Exited");
        }
Esempio n. 15
0
        private void PlaybackStart(object sender, PlaybackProgressEventArgs e)
        {
            // ReSharper disable once ComplexConditionExpression
            if (e.MediaInfo.RunTimeTicks != null && (e.Item.MediaType == MediaType.Video && e.MediaInfo.RunTimeTicks.Value < IntroOrVideoBackDrop))
            {
                return;
            }

            if (e.IsPaused)
            {
                return;
            }

            var config = Plugin.Instance.Configuration;

            //No profile, move on
            if (!config.SaveSmartThingsProfiles.Exists(p => p.DeviceName.Equals(e.DeviceName) && p.AppName.Equals(e.ClientName)))
            {
                return;
            }

            logger.Info("Samsung Smart Things Reports Playback Started");

            var profile = config.SaveSmartThingsProfiles.FirstOrDefault(p => p.DeviceName.Equals(e.DeviceName) &&
                                                                        p.AppName.Equals(e.ClientName));

            logger.Info($"Samsung Smart Things Found Profile Device: { e.DeviceName }");

            if (!ScheduleAllowScene(profile))
            {
                logger.Info($"Samsung Smart Things profile not allowed to run at this time: { profile?.DeviceName }");
                return;
            }

            var sceneName = string.Empty;

            switch (e.MediaInfo.Type)
            {
            case "Movie":
                sceneName = profile?.MoviesPlaybackStarted;
                break;

            case "TvChannel":
                sceneName = profile?.LiveTvPlaybackStarted;
                break;

            case "Series":
                sceneName = profile?.TvPlaybackStarted;
                break;

            case "Season":
                sceneName = profile?.TvPlaybackStarted;
                break;

            case "Episode":
                sceneName = profile?.TvPlaybackStarted;
                break;
            }

            logger.Info($"Samsung Smart Things Reports { e.MediaInfo.Type } will trigger Playback Started Scene on { e.DeviceName }");

            RunScene(sceneName, config, "PlaybackStarted");
        }
Esempio n. 16
0
 void _sessionManager_PlaybackProgress(object sender, PlaybackProgressEventArgs e)
 {
     SendData(!e.IsAutomated);
 }
Esempio n. 17
0
 void _sessionManager_PlaybackStart(object sender, PlaybackProgressEventArgs e)
 {
     SendData(true);
 }
Esempio n. 18
0
        /// <summary>
        /// Add playback progress data.
        /// </summary>
        /// <param name="dataObject">The data object.</param>
        /// <param name="playbackProgressEventArgs">The playback progress event args.</param>
        /// <returns>The modified data object.</returns>
        public static Dictionary <string, object> AddPlaybackProgressData(this Dictionary <string, object> dataObject, PlaybackProgressEventArgs playbackProgressEventArgs)
        {
            dataObject[nameof(playbackProgressEventArgs.PlaybackPositionTicks)] = playbackProgressEventArgs.PlaybackPositionTicks ?? 0;
            dataObject["PlaybackPosition"] = TimeSpan.FromTicks(playbackProgressEventArgs.PlaybackPositionTicks ?? 0).ToString(@"hh\:mm\:ss", CultureInfo.InvariantCulture);
            dataObject[nameof(playbackProgressEventArgs.MediaSourceId)] = playbackProgressEventArgs.MediaSourceId;
            dataObject[nameof(playbackProgressEventArgs.IsPaused)]      = playbackProgressEventArgs.IsPaused;
            dataObject[nameof(playbackProgressEventArgs.IsAutomated)]   = playbackProgressEventArgs.IsAutomated;
            dataObject[nameof(playbackProgressEventArgs.DeviceId)]      = playbackProgressEventArgs.DeviceId;
            dataObject[nameof(playbackProgressEventArgs.DeviceName)]    = playbackProgressEventArgs.DeviceName;
            dataObject[nameof(playbackProgressEventArgs.ClientName)]    = playbackProgressEventArgs.ClientName;

            return(dataObject);
        }
Esempio n. 19
0
        public async Task StartPlaybackTimer(PlaybackProgressEventArgs e)
        {
            _logger.LogInformation("StartPlaybackTimer : Entered");
            await Task.Delay(20000);

            try
            {
                var session = _sessionManager.GetSession(e.DeviceId, e.ClientName, "");
                if (session != null)
                {
                    string event_playing_id = e.Item.Id.ToString("N");

                    string event_user_id     = e.Users[0].Id.ToString("N");
                    long   event_user_id_int = e.Users[0].InternalId;

                    string session_playing_id = "";
                    if (session.NowPlayingItem != null)
                    {
                        session_playing_id = session.NowPlayingItem.Id.ToString("N");
                    }
                    string session_user_id = "";

                    _logger.LogInformation("session.RemoteEndPoint : {RemoteEndPoint}", session.RemoteEndPoint);

                    if (session.UserId != Guid.Empty)
                    {
                        session_user_id = session.UserId.ToString("N");
                    }

                    string play_method = "na";
                    if (session.PlayState != null && session.PlayState.PlayMethod != null)
                    {
                        play_method = session.PlayState.PlayMethod.Value.ToString();
                    }
                    if (session.PlayState != null && session.PlayState.PlayMethod == MediaBrowser.Model.Session.PlayMethod.Transcode)
                    {
                        if (session.TranscodingInfo != null)
                        {
                            string video_codec = "direct";
                            if (session.TranscodingInfo.IsVideoDirect == false)
                            {
                                video_codec = session.TranscodingInfo.VideoCodec;
                            }
                            string audio_codec = "direct";
                            if (session.TranscodingInfo.IsAudioDirect == false)
                            {
                                audio_codec = session.TranscodingInfo.AudioCodec;
                            }
                            play_method += " (v:" + video_codec + " a:" + audio_codec + ")";
                        }
                    }

                    string item_name = GetItemName(e.Item);
                    string item_id   = e.Item.Id.ToString("N");
                    string item_type = e.MediaInfo.Type;

                    _logger.LogInformation("StartPlaybackTimer : event_playing_id     = {EventPlayingId}", event_playing_id);
                    _logger.LogInformation("StartPlaybackTimer : event_user_id        = {EventUserId}", event_user_id);
                    _logger.LogInformation("StartPlaybackTimer : event_user_id_int    = {EventUserIdInternal}", event_user_id_int);
                    _logger.LogInformation("StartPlaybackTimer : session_playing_id   = {SessionPlayingId}", session_playing_id);
                    _logger.LogInformation("StartPlaybackTimer : session_user_id      = {SessionUserId}", session_user_id);
                    _logger.LogInformation("StartPlaybackTimer : play_method          = {PlayMethod}", play_method);
                    _logger.LogInformation("StartPlaybackTimer : e.ClientName         = {ClientName}", e.ClientName);
                    _logger.LogInformation("StartPlaybackTimer : e.DeviceName         = {DeviceName}", e.DeviceName);
                    _logger.LogInformation("StartPlaybackTimer : ItemName             = {ItemName}", item_name);
                    _logger.LogInformation("StartPlaybackTimer : ItemId               = {ItemId}", item_id);
                    _logger.LogInformation("StartPlaybackTimer : ItemType             = {ItemType}", item_type);

                    PlaybackInfo play_info = new PlaybackInfo
                    {
                        Id             = Guid.NewGuid().ToString("N"),
                        Date           = DateTime.Now,
                        ClientName     = e.ClientName,
                        DeviceName     = e.DeviceName,
                        PlaybackMethod = play_method,
                        UserId         = event_user_id,
                        ItemId         = item_id,
                        ItemName       = item_name,
                        ItemType       = item_type
                    };

                    if (event_playing_id == session_playing_id && event_user_id == session_user_id)
                    {
                        _logger.LogInformation("StartPlaybackTimer : All matches, playback registered");

                        // update tracker with playback info
                        string key = e.DeviceId + "-" + e.Users[0].Id.ToString("N") + "-" + e.Item.Id.ToString("N");
                        if (playback_trackers.ContainsKey(key))
                        {
                            _logger.LogInformation("Playback tracker found, adding playback info : {Key}", key);
                            PlaybackTracker tracker = playback_trackers[key];
                            tracker.TrackedPlaybackInfo = play_info;

                            _logger.LogInformation("Saving playback tracking activity in DB");
                            _repository.AddPlaybackAction(tracker.TrackedPlaybackInfo);
                        }
                        else
                        {
                            _logger.LogInformation("Playback trackler not found : {Key}", key);
                        }
                    }
                    else
                    {
                        _logger.LogInformation("StartPlaybackTimer : Details do not match for play item");
                    }
                }
                else
                {
                    _logger.LogInformation("StartPlaybackTimer : session Not Found");
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "StartPlaybackTimer : Unexpected error occurred");
            }
            _logger.LogInformation("StartPlaybackTimer : Exited");
        }
Esempio n. 20
0
        /// <summary>
        /// Let Trakt.tv know the user has started to watch something
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void KernelPlaybackStart(object sender, PlaybackProgressEventArgs e)
        {
            try
            {
                _logger.Info("Playback Started");

                if (e.Users == null || !e.Users.Any() || e.Item == null)
                {
                    _logger.Error("Event details incomplete. Cannot process current media");
                    return;
                }

                // Since MB3 is user profile friendly, I'm going to need to do a user lookup every time something starts
                var traktUser = UserHelper.GetTraktUser(e.Users.FirstOrDefault());

                if (traktUser == null)
                {
                    _logger.Info("Could not match user with any stored credentials");
                    return;
                }
                // Still need to make sure it's a trakt monitored location before sending notice to trakt.tv
                if (traktUser.TraktLocations == null)
                {
                    _logger.Info("User does not have any locations configured to monitor");
                    return;
                }

                var locations = traktUser.TraktLocations.Where(location => _fileSystem.ContainsSubPath(location, e.Item.Path))
                                .Where(location => e.Item is Episode || e.Item is Movie)
                                .ToList();

                if (locations.Any())
                {
                    _logger.Debug(traktUser.LinkedMbUserId + " appears to be monitoring " + e.Item.Path);

                    foreach (var video in locations.Select(location => e.Item as Video))
                    {
                        try
                        {
                            if (video is Movie)
                            {
                                _logger.Debug("Send movie status update");
                                await
                                _traktApi.SendMovieStatusUpdateAsync(video as Movie, MediaStatus.Watching, traktUser).
                                ConfigureAwait(false);
                            }
                            else if (video is Episode)
                            {
                                _logger.Debug("Send episode status update");
                                await
                                _traktApi.SendEpisodeStatusUpdateAsync(video as Episode, MediaStatus.Watching, traktUser).
                                ConfigureAwait(false);
                            }
                        }
                        catch (Exception ex)
                        {
                            _logger.ErrorException("Exception handled sending status update", ex);
                        }


                        var playEvent = new ProgressEvent
                        {
                            UserId        = e.Users.First().Id,
                            ItemId        = e.Item.Id,
                            LastApiAccess = DateTime.UtcNow
                        };

                        _progressEvents.Add(playEvent);
                    }
                }
                else
                {
                    _logger.Debug(traktUser.LinkedMbUserId + " does not appear to be monitoring " + e.Item.Path);
                }
            }
            catch (Exception ex)
            {
                _logger.ErrorException("Error sending watching status update", ex, null);
            }
        }
Esempio n. 21
0
        async void _device_PlaybackProgress(object sender, PlaybackProgressEventArgs e)
        {
            try
            {
                var info = GetProgressInfo(e.MediaInfo);

                await _sessionManager.OnPlaybackProgress(info).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                _logger.ErrorException("Error reporting progress", ex);
            }
        }
        private void PlaybackProgress(object sender, PlaybackProgressEventArgs e)
        {
            var config = Plugin.Instance.Configuration;

            if (config.SavedHueEmbyProfiles.Exists(p => p.DeviceName.Equals(e.Session.DeviceName)))
            {
                var profile = config.SavedHueEmbyProfiles.FirstOrDefault(p => p.DeviceName.Equals(e.Session.DeviceName));
                if (profile?.MediaItemCredits != null)
                {
                    if (e.MediaInfo.Type.Equals("Movie") &&
                        e.Session.PlayState.PositionTicks > (e.Item.RunTimeTicks - (profile?.MediaItemCreditLength * 10000000)))
                    {
                        PlaybackCredits(e, profile, config);
                        return;
                    }
                }
            }

            //No paused Session and no flagged sessions paused, move on
            // ReSharper disable once ComplexConditionExpression
            if (!SessionManager.Sessions.Any(s => s.PlayState.IsPaused) && !PausedSessionsIds.Any())
            {
                return;
            }

            foreach (var session in SessionManager.Sessions)
            {
                //if (session.Id != e.Session.Id) continue;
                switch (session.PlayState.IsPaused)
                {
                case true:
                    //We don't have a profile for this paused session device, move on
                    if (!config.SavedHueEmbyProfiles.Exists(p => p.DeviceName.Equals(session.DeviceName)))
                    {
                        continue;
                    }
                    // We've already flagged this session, move on
                    if (PausedSessionsIds.Exists(s => s.SessionId.Equals(session.Id)))
                    {
                        continue;
                    }

                    PausedSessionsIds.Add(new PausedSession()
                    {
                        SessionId = session.Id,
                        PausedAt  = DateTime.Now
                    });

                    PlaybackPaused(e, config, session,
                                   config.SavedHueEmbyProfiles.FirstOrDefault(p =>
                                                                              p.DeviceName.Equals(session.DeviceName)));


                    break;

                case false:

                    if (PausedSessionsIds.Exists(s => s.SessionId.Equals(session.Id)))
                    {
                        if (PausedSessionsIds.FirstOrDefault(s => s.SessionId == session.Id)?.PausedAt.AddSeconds(5) < DateTime.Now)
                        {
                            PausedSessionsIds.RemoveAll(s => s.SessionId.Equals(session.Id));
                            PlaybackUnPaused(e, config, config.SavedHueEmbyProfiles.FirstOrDefault(p => p.DeviceName.Equals(session.DeviceName)));
                        }
                    }

                    break;
                }
            }
        }
Esempio n. 23
0
 private async void OnSessionManagerPlaybackProgress(object sender, PlaybackProgressEventArgs e)
 {
     await SendData(!e.IsAutomated).ConfigureAwait(false);
 }
Esempio n. 24
0
 private void _recording_PlaybackProgress(object sender, PlaybackProgressEventArgs e)
 {
     slider.Value = (int)(e.ProgressPercentage * 100);
 }
Esempio n. 25
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 private void KernelPlaybackProgress(object sender, PlaybackProgressEventArgs e)
 {
 }
Esempio n. 26
0
 void _sessionManager_PlaybackProgress(object sender, PlaybackProgressEventArgs e)
 {
     SendData(false);
 }
Esempio n. 27
0
        /// <summary>
        /// Let Trakt.tv know the user has started to watch something
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void KernelPlaybackStart(object sender, PlaybackProgressEventArgs e)
        {
            try
            {
                _logger.LogInformation("Playback Started");

                if (e.Users == null || !e.Users.Any() || e.Item == null)
                {
                    _logger.LogError("Event details incomplete. Cannot process current media");
                    return;
                }

                foreach (var user in e.Users)
                {
                    // Since Emby is user profile friendly, I'm going to need to do a user lookup every time something starts
                    var traktUser = UserHelper.GetTraktUser(user);

                    if (traktUser == null)
                    {
                        _logger.LogInformation("Could not match user with any stored credentials");
                        continue;
                    }

                    if (!traktUser.Scrobble)
                    {
                        continue;
                    }

                    if (!_traktApi.CanSync(e.Item, traktUser))
                    {
                        continue;
                    }

                    _logger.LogDebug(traktUser.LinkedMbUserId + " appears to be monitoring " + e.Item.Path);

                    var video           = e.Item as Video;
                    var progressPercent = video.RunTimeTicks.HasValue && video.RunTimeTicks != 0 ?
                                          (float)(e.PlaybackPositionTicks ?? 0) / video.RunTimeTicks.Value * 100.0f : 0.0f;

                    try
                    {
                        if (video is Movie movie)
                        {
                            _logger.LogDebug("Send movie status update");
                            await _traktApi.SendMovieStatusUpdateAsync(
                                movie,
                                MediaStatus.Watching,
                                traktUser,
                                progressPercent).ConfigureAwait(false);
                        }
                        else if (video is Episode episode)
                        {
                            _logger.LogDebug("Send episode status update");
                            await _traktApi.SendEpisodeStatusUpdateAsync(
                                episode,
                                MediaStatus.Watching,
                                traktUser,
                                progressPercent).ConfigureAwait(false);
                        }
                    }
                    catch (Exception ex)
                    {
                        _logger.LogError(ex, "Exception handled sending status update");
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error sending watching status update");
            }
        }
Esempio n. 28
0
 private void embyPlaybackStart(object obj, PlaybackProgressEventArgs e)
 {
     _logger.Debug("EMBY PLAYBACK STARTED");
     _logger.Debug("Obj: " + _json.SerializeToString(obj));
     _logger.Debug("Event: " + _json.SerializeToString(e));
 }