private void ZapTimerElapsed(object sender, EventArgs eventArgs)
        {
            // Zap to channel
            int number;

            if (!int.TryParse(ChannelNumberOrIndex, out number) || number < 1)
            {
                return;
            }

            IWorkflowManager  workflowManager = ServiceRegistration.Get <IWorkflowManager>();
            SlimTvClientModel model           = workflowManager.GetModel(SlimTvClientModel.MODEL_ID) as SlimTvClientModel;

            if (model == null)
            {
                return;
            }

            SlimTvClientSettings settings = ServiceRegistration.Get <ISettingsManager>().Load <SlimTvClientSettings>();

            if (settings.ZapByChannelIndex)
            {
                // Channel index starts by 0, user enters 1 based numbers
                number--;
                _ = model.TuneByIndex(number);
            }
            else
            {
                _ = model.TuneByChannelNumber(number);
            }

            ClearZapTimer();
        }
        private void ZapTimerElapsed(object sender, EventArgs eventArgs)
        {
            // Zap to channel
            int number;

            if (!int.TryParse(ChannelNumberOrIndex, out number))
            {
                return;
            }

            ClearZapTimer();

#if DEBUG_FOCUS
            ServiceRegistration.Get <MediaPortal.Common.Logging.ILogger>().Debug("EPG: ChannelZapModel goto {0}", number);
#endif
            SlimTvClientSettings settings        = ServiceRegistration.Get <ISettingsManager>().Load <SlimTvClientSettings>();
            IWorkflowManager     workflowManager = ServiceRegistration.Get <IWorkflowManager>();
            if (workflowManager.CurrentNavigationContext.WorkflowModelId == SlimTvMultiChannelGuideModel.MODEL_ID)
            {
                SlimTvMultiChannelGuideModel guide = workflowManager.GetModel(SlimTvMultiChannelGuideModel.MODEL_ID) as SlimTvMultiChannelGuideModel;
                if (guide == null)
                {
                    return;
                }
                if (settings.ZapByChannelIndex)
                {
                    // Channel index starts by 0, user enters 1 based numbers
                    number--;
                    guide.GoToChannelIndex(number);
                }
                else
                {
                    guide.GoToChannelNumber(number);
                }
                return;
            }
            SlimTvClientModel model = workflowManager.GetModel(SlimTvClientModel.MODEL_ID) as SlimTvClientModel;
            if (model == null)
            {
                return;
            }

            // Special case "0", we use it for "zap back" to tune previous watched channel
            if (number == 0)
            {
                _ = model.ZapBack();
                return;
            }

            if (settings.ZapByChannelIndex)
            {
                // Channel index starts by 0, user enters 1 based numbers
                number--;
                _ = model.TuneByIndex(number);
            }
            else
            {
                _ = model.TuneByChannelNumber(number);
            }
        }
Example #3
0
        public static async Task TuneChannel(IChannel channel)
        {
            IWorkflowManager  workflowManager = ServiceRegistration.Get <IWorkflowManager>();
            SlimTvClientModel model           = workflowManager.GetModel(SlimTvClientModel.MODEL_ID) as SlimTvClientModel;

            if (model != null)
            {
                await model.Tune(channel);

                // Always switch to fullscreen
                workflowManager.NavigatePush(Consts.WF_STATE_ID_FULLSCREEN_VIDEO);
            }
        }
        protected void TuneChannelByProgram(IProgram program)
        {
            IChannel channel;

            if (_tvHandler.ProgramInfo.GetChannel(program, out channel))
            {
                IWorkflowManager  workflowManager = ServiceRegistration.Get <IWorkflowManager>();
                SlimTvClientModel model           = workflowManager.GetModel(SlimTvClientModel.MODEL_ID) as SlimTvClientModel;
                if (model != null)
                {
                    model.Tune(channel);
                    // Always switch to fullscreen
                    workflowManager.NavigatePush(Consts.WF_STATE_ID_FULLSCREEN_VIDEO);
                }
            }
        }
        protected async Task TuneChannelByProgram(IProgram program)
        {
            var result = await _tvHandler.ProgramInfo.GetChannelAsync(program);

            if (result.Success)
            {
                IWorkflowManager  workflowManager = ServiceRegistration.Get <IWorkflowManager>();
                SlimTvClientModel model           = workflowManager.GetModel(SlimTvClientModel.MODEL_ID) as SlimTvClientModel;
                if (model != null)
                {
                    await model.Tune(result.Result);

                    // Always switch to fullscreen
                    workflowManager.NavigatePush(result.Result.MediaType == MediaType.Radio ? Consts.WF_STATE_ID_FULLSCREEN_AUDIO : Consts.WF_STATE_ID_FULLSCREEN_VIDEO);
                }
            }
        }
        protected void ShowProgramActions(IProgram program)
        {
            if (program == null)
            {
                return;
            }

            ILocalization loc = ServiceRegistration.Get <ILocalization>();

            _programActions = new ItemsList();
            // if program is over already, there is nothing to do.
            if (program.EndTime < DateTime.Now)
            {
                _programActions.Add(new ListItem(Consts.KEY_NAME, loc.ToString("[SlimTvClient.ProgramOver]")));
            }
            else
            {
                // Check if program is currently running.
                bool isRunning = DateTime.Now >= program.StartTime && DateTime.Now <= program.EndTime;
                if (isRunning)
                {
                    _programActions.Add(new ListItem(Consts.KEY_NAME, loc.ToString("[SlimTvClient.WatchNow]"))
                    {
                        Command = new MethodDelegateCommand(() =>
                        {
                            IChannel channel;
                            if (_tvHandler.ProgramInfo.GetChannel(program, out channel))
                            {
                                IWorkflowManager workflowManager = ServiceRegistration.Get <IWorkflowManager>();
                                SlimTvClientModel model          = workflowManager.GetModel(SlimTvClientModel.MODEL_ID) as SlimTvClientModel;
                                if (model != null)
                                {
                                    model.Tune(channel);
                                }
                            }
                        })
                    });
                }

                if (_tvHandler.ScheduleControl != null)
                {
                    RecordingStatus recordingStatus;
                    if (_tvHandler.ScheduleControl.GetRecordingStatus(program, out recordingStatus) && recordingStatus != RecordingStatus.None)
                    {
                        if (isRunning)
                        {
                            _programActions.Add(
                                new ListItem(Consts.KEY_NAME, loc.ToString("[SlimTvClient.WatchFromBeginning]"))
                            {
                                Command = new MethodDelegateCommand(() => _tvHandler.WatchRecordingFromBeginning(program))
                            });
                        }

                        _programActions.Add(
                            new ListItem(Consts.KEY_NAME, loc.ToString("[SlimTvClient.DeleteSchedule]"))
                        {
                            Command = new MethodDelegateCommand(() =>
                            {
                                if (_tvHandler.ScheduleControl.RemoveScheduleForProgram(program, ScheduleRecordingType.Once))
                                {
                                    UpdateRecordingStatus(program, RecordingStatus.None);
                                }
                            }
                                                                )
                        });
                    }
                    else
                    {
                        _programActions.Add(
                            new ListItem(Consts.KEY_NAME, loc.ToString(isRunning ? "[SlimTvClient.RecordNow]" : "[SlimTvClient.CreateSchedule]"))
                        {
                            Command = new MethodDelegateCommand(() =>
                            {
                                ISchedule schedule;
                                if (_tvHandler.ScheduleControl.CreateSchedule(program, ScheduleRecordingType.Once, out schedule))
                                {
                                    UpdateRecordingStatus(program, RecordingStatus.Scheduled);
                                }
                            }
                                                                )
                        });
                    }
                }
            }

            // Add list entries for extensions
            foreach (KeyValuePair <Guid, TvExtension> programExtension in _programExtensions)
            {
                TvExtension extension = programExtension.Value;
                // First check if this extension applies for the selected program
                if (!extension.Extension.IsAvailable(program))
                {
                    continue;
                }

                _programActions.Add(
                    new ListItem(Consts.KEY_NAME, loc.ToString(extension.Caption))
                {
                    Command = new MethodDelegateCommand(() => extension.Extension.ProgramAction(program))
                });
            }

            IScreenManager screenManager = ServiceRegistration.Get <IScreenManager>();

            screenManager.ShowDialog(_programActionsDialogName);
        }