Example #1
0
        private void Controls_ButtonPressed(SystemMediaTransportControls sender,
                                            SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            switch (args.Button)
            {
            case SystemMediaTransportControlsButton.Play:
                manager.Play();
                break;

            case SystemMediaTransportControlsButton.Pause:
                manager.Pause();
                break;

            case SystemMediaTransportControlsButton.Next:
                manager.Next();
                break;

            case SystemMediaTransportControlsButton.Previous:
                manager.Previous();
                break;

            default:
                break;
            }
        }
Example #2
0
        // </SnippetSystemMediaTransportControlsStateChange>

        // <SnippetSystemMediaTransportControlsButtonPressed>
        async void SystemControls_ButtonPressed(SystemMediaTransportControls sender,
                                                SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            switch (args.Button)
            {
            case SystemMediaTransportControlsButton.Play:
                await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                {
                    mediaElement.Play();
                });

                break;

            case SystemMediaTransportControlsButton.Pause:
                await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                {
                    mediaElement.Pause();
                });

                break;

            default:
                break;
            }
        }
Example #3
0
        private void Transport_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            switch (args.Button)
            {
            case SystemMediaTransportControlsButton.Play:
                _mediaPlayer.Play();
                break;

            case SystemMediaTransportControlsButton.Pause:
                _mediaPlayer.Pause();
                break;

            case SystemMediaTransportControlsButton.Rewind:
                _mediaPlayer.StepBackwardOneFrame();
                break;

            case SystemMediaTransportControlsButton.FastForward:
                _mediaPlayer.StepForwardOneFrame();
                break;

            case SystemMediaTransportControlsButton.Previous:
                MovePrevious();
                break;

            case SystemMediaTransportControlsButton.Next:
                MoveNext();
                break;
            }
        }
Example #4
0
        private void Controls_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            try
            {
                switch (args.Button)
                {
                case SystemMediaTransportControlsButton.Play:
                    CurrentPlayer.Play();
                    break;

                case SystemMediaTransportControlsButton.Pause:
                    CurrentPlayer.Pause();
                    break;

                case SystemMediaTransportControlsButton.Next:
                    _manager.NextTrack();
                    break;

                case SystemMediaTransportControlsButton.Previous:
                    _manager.PreviousTrack();
                    break;
                }
            }
            catch (Exception ex)
            {
                _logService?.LogException(ex);
            }
        }
        private void _mtControls_ButtonPressed(object sender, SystemMediaTransportControlsButtonPressedEventArgs e)
        {
            switch (e.Button)
            {
            case SystemMediaTransportControlsButton.Play:
                Debug.WriteLine("UVC play button pressed");
                Play();
                break;

            case SystemMediaTransportControlsButton.Pause:
                Debug.WriteLine("UVC pause button pressed");
                Pause();
                break;

            case SystemMediaTransportControlsButton.Next:
                Debug.WriteLine("UVC next button pressed");
                MoveNext();
                break;

            case SystemMediaTransportControlsButton.Previous:
                Debug.WriteLine("UVC previous button pressed");
                MovePrevious();
                break;
            }
        }
Example #6
0
        /********        相关事件处理        ********/

        private static void SystemControls_ButtonPressed(SystemMediaTransportControls sender,
                                                         SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            switch (args.Button)
            {
            case SystemMediaTransportControlsButton.Play:
                Common.Invoke(() => Player.Play());
                break;

            case SystemMediaTransportControlsButton.Pause:
                Common.Invoke(() => Player.Pause());
                break;

            case SystemMediaTransportControlsButton.Previous:
                Common.Invoke(() => SongMovePrevious());
                break;

            case SystemMediaTransportControlsButton.Next:
                Common.Invoke(() => SongMoveNext());
                break;

            default:
                break;
            }
        }
Example #7
0
        /// <summary>
        /// Вызывается при нажатии кнопкок на панели управления аудио.
        /// </summary>
        private void Controls_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            if (!_isTaskRunning)
            {
                _player = BackgroundMediaPlayer.Current;
                if (!_taskRunningEvent.WaitOne(AppConstants.AudioTaskStartingTimeout))
                {
#if DEBUG
                    Debug.WriteLine("AudioTask start timeout exceeded!");
#endif
                    return;
                }
            }
            switch (args.Button)
            {
            case SystemMediaTransportControlsButton.Play:
                _manager.ResumePause();
                break;

            case SystemMediaTransportControlsButton.Pause:
                _manager.ResumePause();
                break;

            case SystemMediaTransportControlsButton.Next:
                _manager.NextTrack();
                break;

            case SystemMediaTransportControlsButton.Previous:
                _manager.PreviousTrack();
                break;
            }
        }
 private async void SystemMediaTransportControls_ButtonPressed(SystemMediaTransportControls sender,
                                                               SystemMediaTransportControlsButtonPressedEventArgs args)
 {
     if (args.Button == SystemMediaTransportControlsButton.Play)
     {
         await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
         {
             await Play();
         });
     }
     else if (args.Button == SystemMediaTransportControlsButton.Pause)
     {
         await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
         {
             await Pause();
         });
     }
     else if (args.Button == SystemMediaTransportControlsButton.Previous)
     {
         await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
         {
             await PreviousButton_Click();
         });
     }
     else if (args.Button == SystemMediaTransportControlsButton.Next)
     {
         await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
         {
             await NextButton_Click();
         });
     }
 }
Example #9
0
        private void systemMediaControls_ButtonPressed(SystemMediaTransportControls smtc,
                                                       SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            lock (commandLock)
            {
                switch (args.Button)
                {
                case SystemMediaTransportControlsButton.Play:
                case SystemMediaTransportControlsButton.Pause:

                    if (systemMediaControls.PlaybackStatus != MediaPlaybackStatus.Changing)
                    {
                        mbApiInterface.Player_PlayPause();
                    }

                    break;

                case SystemMediaTransportControlsButton.Stop:
                    mbApiInterface.Player_Stop();
                    break;

                case SystemMediaTransportControlsButton.Next:
                    mbApiInterface.Player_PlayNextTrack();
                    break;

                case SystemMediaTransportControlsButton.Rewind:
                case SystemMediaTransportControlsButton.Previous:
                    if (systemMediaControls.PlaybackStatus != MediaPlaybackStatus.Changing)
                    {
                        // restart song
                        if (DateTime.Now.Subtract(lastPrevious).TotalMilliseconds > PreviousDelay)
                        {
                            mbApiInterface.Player_Stop();
                            mbApiInterface.Player_PlayPause();
                            lastPrevious = DateTime.Now;
                            break;
                        }

                        // play previous track
                        if (DateTime.Now.Subtract(lastPrevious).TotalMilliseconds < PreviousDelay)
                        {
                            mbApiInterface.Player_Stop();
                            mbApiInterface.Player_PlayPreviousTrack();
                            lastPrevious = DateTime.Now;
                        }
                    }

                    break;

                // TODO: fix
                case SystemMediaTransportControlsButton.ChannelUp:
                    mbApiInterface.Player_SetVolume(mbApiInterface.Player_GetVolume() + 0.05F);
                    break;

                case SystemMediaTransportControlsButton.ChannelDown:
                    mbApiInterface.Player_SetVolume(mbApiInterface.Player_GetVolume() - 0.05F);
                    break;
                }
            }
        }
        private void Smtc_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            switch (args.Button)
            {
            case SystemMediaTransportControlsButton.Play:
                window.Dispatcher.Invoke(() => window.PlayPauseMethod());
                break;

            case SystemMediaTransportControlsButton.Pause:
                window.Dispatcher.Invoke(() => window.PlayPauseMethod());
                break;

            case SystemMediaTransportControlsButton.Next:
                window.Dispatcher.Invoke(() => window.NextTrackMethod());
                break;

            case SystemMediaTransportControlsButton.Previous:
                window.Dispatcher.Invoke(() => window.PreviousTrackMethod());
                break;

            case SystemMediaTransportControlsButton.Stop:
                window.Dispatcher.Invoke(() => window.StopMethod());
                break;

            default:
                break;
            }
        }
Example #11
0
        /// <summary>
        ///     This function controls the button events from UVC.
        ///     This code if not run in background process, will not be able to handle button pressed events when app is suspended.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        private void smtc_ButtonPressed(SystemMediaTransportControls sender,
                                        SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            switch (args.Button)
            {
            case SystemMediaTransportControlsButton.Play:
                Debug.WriteLine("UVC play button pressed");
                PlayPressed?.Invoke(this, null);
                break;

            case SystemMediaTransportControlsButton.Pause:
                Debug.WriteLine("UVC pause button pressed");
                PausePressed?.Invoke(this, null);
                break;

            case SystemMediaTransportControlsButton.Next:
                Debug.WriteLine("UVC next button pressed");
                NextPressed?.Invoke(this, null);
                break;

            case SystemMediaTransportControlsButton.Previous:
                Debug.WriteLine("UVC previous button pressed");
                PrevPressed?.Invoke(this, null);
                break;
            }
        }
        private void OnButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            string eventType = null;

            switch (args.Button)
            {
            case SystemMediaTransportControlsButton.Play:
                eventType = Events.ButtonPlay;
                break;

            case SystemMediaTransportControlsButton.Pause:
                eventType = Events.ButtonPause;
                break;

            case SystemMediaTransportControlsButton.Stop:
                eventType = Events.ButtonStop;
                break;

            case SystemMediaTransportControlsButton.Previous:
                eventType = Events.ButtonSkipPrevious;
                break;

            case SystemMediaTransportControlsButton.Next:
                eventType = Events.ButtonSkipNext;
                break;

            default:
                return;
            }

            manager.SendEvent(eventType, null);
        }
 private void MediaButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
 {
     switch (args.Button)
     {
         case SystemMediaTransportControlsButton.Play:
             BackgroundMediaPlayer.SendMessageToForeground(new ValueSet
             {
                 {"command", PlaybackCommand.Play.ToString()}
             });
             break;
         case SystemMediaTransportControlsButton.Pause:
         case SystemMediaTransportControlsButton.Stop:
             BackgroundMediaPlayer.SendMessageToForeground(new ValueSet
             {
                 {"command", PlaybackCommand.Pause.ToString()}
             });
             break;
         case SystemMediaTransportControlsButton.Previous:
             BackgroundMediaPlayer.SendMessageToForeground(new ValueSet
             {
                 {"command", PlaybackCommand.Previous.ToString()}
             });
             break;
         case SystemMediaTransportControlsButton.Next:
             BackgroundMediaPlayer.SendMessageToForeground(new ValueSet
             {
                 {"command", PlaybackCommand.Next.ToString()}
             });
             break;
     }
 }
Example #14
0
        //protected virtual void UpdateTimeline(SystemMediaTransportControlsTimelineProperties properties)
        //{
        //    var outputStream = this.PlaybackManager.CurrentStream;
        //    if (outputStream == null)
        //    {
        //        properties.StartTime = TimeSpan.FromMilliseconds(0);
        //        properties.EndTime = TimeSpan.FromMilliseconds(0);
        //        properties.MinSeekTime = TimeSpan.FromSeconds(0);
        //        properties.MaxSeekTime = TimeSpan.FromSeconds(0);
        //        properties.Position = TimeSpan.FromMilliseconds(0);

        //        this.TransportControls.IsFastForwardEnabled = false;
        //        this.TransportControls.IsRewindEnabled = false;
        //    }
        //    else
        //    {
        //        properties.StartTime = TimeSpan.FromMilliseconds(0);
        //        properties.EndTime = TimeSpan.FromMilliseconds(outputStream.Length);
        //        properties.MinSeekTime = TimeSpan.FromMilliseconds(0);
        //        properties.MaxSeekTime = TimeSpan.FromMilliseconds(outputStream.Length);
        //        properties.Position = TimeSpan.FromMilliseconds(outputStream.Position);

        //        this.TransportControls.IsFastForwardEnabled = true;
        //        this.TransportControls.IsRewindEnabled = true;
        //    }
        //}

        protected virtual void OnButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            var task = default(Task);

            switch (args.Button)
            {
            case SystemMediaTransportControlsButton.Play:
                task = this.Play();
                break;

            case SystemMediaTransportControlsButton.Pause:
                task = this.Pause();
                break;

            case SystemMediaTransportControlsButton.Next:
                task = this.Next();
                break;

            case SystemMediaTransportControlsButton.Previous:
                task = this.Previous();
                break;

            case SystemMediaTransportControlsButton.Stop:
                task = this.Stop();
                break;
            }
            this.RefreshState();
            Logger.Write(this, LogLevel.Debug, "Handled button press: {0}", Enum.GetName(typeof(SystemMediaTransportControlsButton), args.Button));
        }
Example #15
0
        /// <summary>
        ///     This function controls the button events from UVC.
        ///     This code if not run in background process, will not be able to handle button pressed events when app is suspended.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        private void systemmediatransportcontrol_ButtonPressed(SystemMediaTransportControls sender,
                                                               SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            switch (args.Button)
            {
            case SystemMediaTransportControlsButton.Play:
                Debug.WriteLine("UVC play button pressed");
                // If music is in paused state, for a period of more than 5 minutes,
                //app will get task cancellation and it cannot run code.
                //However, user can still play music by pressing play via UVC unless a new app comes in clears UVC.
                //When this happens, the task gets re-initialized and that is asynchronous and hence the wait
                if (!_backgroundtaskrunning)
                {
                    var result = TaskStarted.WaitOne(5000);
                    if (!result)
                    {
                        throw new Exception("Background Task didn't initialize in time");
                    }
                    StartPlayback();
                }
                else
                {
                    BackgroundMediaPlayer.Current.Play();
                }
                break;

            case SystemMediaTransportControlsButton.Pause:
                Debug.WriteLine("UVC pause button pressed");
                try
                {
                    BackgroundMediaPlayer.Current.Pause();
                }
                catch (Exception ex)
                {
                    Debug.WriteLine(ex.ToString());
                }
                break;

            case SystemMediaTransportControlsButton.Next:
                Debug.WriteLine("UVC next button pressed");
                SkipToNext();
                break;

            case SystemMediaTransportControlsButton.Previous:
                Debug.WriteLine("UVC previous button pressed");
                if (BackgroundMediaPlayer.Current.Position.TotalSeconds > 20)
                {
                    //StartPlayback();
                    BackgroundMediaPlayer.Current.Position = TimeSpan.Zero;
                    BackgroundMediaPlayer.Current.Play();
                }
                else
                {
                    SkipToPrevious();
                }

                break;
            }
        }
Example #16
0
        private void MediaTransportControlButtonPressed(SystemMediaTransportControls sender,
                                                        SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            //SaveText(4, Library.IsLoaded, args.Button.ToString());
            //lastPressedButton = args.Button;

            MediaTransportControlButtonPressed(args.Button);
        }
Example #17
0
        private void MediaTransportControlButtonPressed(SystemMediaTransportControls sender,
                                                        SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            MobileDebug.Service.WriteEventPair("MTCPressed", "Button", args.Button,
                                               "Song", library.CurrentPlaylist?.CurrentSong);

            MediaTransportControlButtonPressed(args.Button);
        }
Example #18
0
 async void smtc_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
 {
     try
     {
         await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => SystemControlsHandleButton(args.Button));
     }
     catch (Exception ex)
     {
         CreateError("System Media Button Pressed: " + args.Button + " Error Message: " + ex.Message);
     }
 }
Example #19
0
        //private void main_listview_PointerEntered(object sender, PointerRoutedEventArgs e)
        //{
        //    if (IsMusicListAutoShow)
        //    {
        //        main_listview.Background = myBrush;
        //    }
        //}

        //private void main_listview_PointerExited(object sender, PointerRoutedEventArgs e)
        //{
        //    if (IsMusicListAutoShow)
        //    {
        //        main_listview.Background = transParent;
        //    }
        //}
        private async void SystemControls_ButtonPressed(SystemMediaTransportControls sender,
                                                        SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            switch (args.Button)
            {
            case SystemMediaTransportControlsButton.Play:
                await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                {
                    main_mediaElement.AutoPlay = true;
                    main_mediaElement.Play();
                    play_button.Foreground = skyblue;
                    play_button.FontFamily = new FontFamily("Segoe MDL2 Assets");
                    play_button.Content    = "\uE769";
                    stop_button.Foreground = white;
                    IsMusicPlaying         = true;
                });

                break;

            case SystemMediaTransportControlsButton.Pause:
                await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                {
                    main_mediaElement.Pause();
                    play_button.Foreground = white;
                    play_button.FontFamily = new FontFamily("Segoe MDL2 Assets");
                    play_button.Content    = "\uE768";
                    IsMusicPlaying         = false;
                });

                break;

            case SystemMediaTransportControlsButton.Previous:
                await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                {
                    IsBackButtonClick = true;
                    SwitchMusic();
                });

                break;

            case SystemMediaTransportControlsButton.Next:
                await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                {
                    IsBackButtonClick = false;
                    SwitchMusic();
                });

                break;

            default:
                break;
            }
        }
Example #20
0
        async void SystemControls_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            Debug.WriteLine("MainPage SystemControls ButtonPressed: " + args.Button);

            try
            {
                await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => SystemControlsHandleButton(args.Button));
            }
            catch (Exception ex)
            {
                Debug.WriteLine("Main SystemControls ButtonPressed: {0}, failed: {1}", args.Button, ex.Message);
            }
        }
Example #21
0
 /// <summary>
 ///     Handle the buttons on the Universal Volume Control
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="args"></param>
 private void MediaTransportControlButtonPressed(SystemMediaTransportControls sender,
     SystemMediaTransportControlsButtonPressedEventArgs args)
 {
     switch (args.Button)
     {
         case SystemMediaTransportControlsButton.Play:
             BackgroundMediaPlayer.Current.Play();
             break;
         case SystemMediaTransportControlsButton.Pause:
             BackgroundMediaPlayer.Current.Pause();
             break;
     }
 }
        /// <summary>
        /// This function controls the button events from UVC.
        /// This code if not run in background process, will not be able to handle button pressed events when app is suspended.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        private async void smtc_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            switch (args.Button)
            {
            case SystemMediaTransportControlsButton.Play:
                Debug.WriteLine("UVC play button pressed");

                // When the background task has been suspended and the SMTC
                // starts it again asynchronously, some time is needed to let
                // the task startup process in Run() complete.

                // Wait for task to start.
                // Once started, this stays signaled until shutdown so it won't wait
                // again unless it needs to.
                bool result = backgroundTaskStarted.WaitOne(5000);
                if (!result)
                {
                    throw new Exception("Background Task didnt initialize in time");
                }

                await StartPlayback();

                break;

            case SystemMediaTransportControlsButton.Pause:
                Debug.WriteLine("UVC pause button pressed");
                try
                {
                    BackgroundMediaPlayer.Current.Pause();
                }
                catch (Exception ex)
                {
                    Debug.WriteLine(ex.ToString());
                }
                break;

            case SystemMediaTransportControlsButton.Next:
                Debug.WriteLine("UVC next button pressed");
                await SkipToNext();

                break;

            case SystemMediaTransportControlsButton.Previous:
                Debug.WriteLine("UVC previous button pressed");
                await SkipToPrevious();

                break;
            }

            UpdateUVCOnNewTrack(CurrentMix);
        }
        async void SystemControls_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            switch (args.Button)
            {
            case SystemMediaTransportControlsButton.Play:
            case SystemMediaTransportControlsButton.Pause:
                await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
                {
                    try
                    {
                        await webEntryPoint.InvokeScriptAsync("eval", new string[] { playPauseCommand });
                    }
                    catch (Exception ex)
                    {
                        //Throws exception on first press if nothing is playing, not sure why
                    }
                    updateMediaOverlay();
                });

                break;

            case SystemMediaTransportControlsButton.Next:
                await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
                {
                    try {
                        await webEntryPoint.InvokeScriptAsync("eval", new string[] { forwardCommand });
                    }
                    catch (Exception ex)
                    {
                        //Throws exception on first press if nothing is playing, not sure why
                    }
                });

                break;

            case SystemMediaTransportControlsButton.Previous:
                await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
                {
                    try {
                        await webEntryPoint.InvokeScriptAsync("eval", new string[] { backCommand });
                    }
                    catch (Exception ex)
                    {
                        //Throws exception on first press if nothing is playing, not sure why
                    }
                });

                injectNotification();
                break;
            }
        }
Example #24
0
        /// <summary>
        ///     Handle the buttons on the Universal Volume Control
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        private void MediaTransportControlButtonPressed(SystemMediaTransportControls sender,
                                                        SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            switch (args.Button)
            {
            case SystemMediaTransportControlsButton.Play:
                BackgroundMediaPlayer.Current.Play();
                break;

            case SystemMediaTransportControlsButton.Pause:
                BackgroundMediaPlayer.Current.Pause();
                break;
            }
        }
Example #25
0
        private void SystemMediaTransportControls_ButtonPressed(
            SystemMediaTransportControls sender,
            SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            switch (args.Button)
            {
            case SystemMediaTransportControlsButton.Play:
                this.PlayPressed?.Invoke(this, EventArgs.Empty);
                break;

            case SystemMediaTransportControlsButton.Pause:
                this.PausePressed?.Invoke(this, EventArgs.Empty);
                break;
            }
        }
Example #26
0
        private void _SMTC_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            switch (args.Button)
            {
            case SystemMediaTransportControlsButton.Play:
                WriteChromeNativeMessageToSTDIO(new JProperty("Command", "Play"));
                break;

            case SystemMediaTransportControlsButton.Pause:
                WriteChromeNativeMessageToSTDIO(new JProperty("Command", "Pause"));
                break;

            case SystemMediaTransportControlsButton.Stop:
                WriteChromeNativeMessageToSTDIO(new JProperty("Command", "Stop"));
                break;

            case SystemMediaTransportControlsButton.Record:
                WriteChromeNativeMessageToSTDIO(new JProperty("Command", "Record"));
                break;

            case SystemMediaTransportControlsButton.FastForward:
                WriteChromeNativeMessageToSTDIO(new JProperty("Command", "FastForward"));
                break;

            case SystemMediaTransportControlsButton.Rewind:
                WriteChromeNativeMessageToSTDIO(new JProperty("Command", "Rewind"));
                break;

            case SystemMediaTransportControlsButton.Next:
                WriteChromeNativeMessageToSTDIO(new JProperty("Command", "Next"));
                break;

            case SystemMediaTransportControlsButton.Previous:
                WriteChromeNativeMessageToSTDIO(new JProperty("Command", "Previous"));
                break;

            case SystemMediaTransportControlsButton.ChannelUp:
                WriteChromeNativeMessageToSTDIO(new JProperty("Command", "ChannelUp"));
                break;

            case SystemMediaTransportControlsButton.ChannelDown:
                WriteChromeNativeMessageToSTDIO(new JProperty("Command", "ChannelDown"));
                break;

            default:
                break;
            }
        }
Example #27
0
        /// <summary>
        /// This function controls the button events from UVC.
        /// This code if not run in background process, will not be able to handle button pressed events when app is suspended.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        private void AudioControlButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            switch (args.Button)
            {
            case SystemMediaTransportControlsButton.Play:
                Debug.WriteLine("UVC play button pressed");

                // When the background task has been suspended and the SMTC
                // starts it again asynchronously, some time is needed to let
                // the task startup process in Run() complete.

                // Wait for task to start.
                // Once started, this stays signaled until shutdown so it won't wait
                // again unless it needs to.
                bool result = _backgroundTaskStarted.WaitOne(5000);
                if (!result)
                {
                    throw new Exception("Background Task didnt initialize in time");
                }

                StartPlayback();
                break;

            case SystemMediaTransportControlsButton.Pause:
                Debug.WriteLine("UVC pause button pressed");
                try
                {
                    BackgroundMediaPlayer.Current.Pause();
                }
                catch (Exception ex)
                {
                    telemetry.TrackException(ex, new Dictionary <string, string> {
                        { "Scenario", "BackgroundAudioButtonPressed" }
                    });
                }
                break;

            case SystemMediaTransportControlsButton.Next:
                Debug.WriteLine("UVC next button pressed");
                SkipToNext();
                break;

            case SystemMediaTransportControlsButton.Previous:
                Debug.WriteLine("UVC previous button pressed");
                SkipToPrevious();
                break;
            }
        }
Example #28
0
        void systemControls_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            switch (args.Button)
            {
            case SystemMediaTransportControlsButton.Play:
                Play();
                break;

            case SystemMediaTransportControlsButton.Pause:
                Pause();
                break;

            default:
                break;
            }
        }
Example #29
0
        void systemControls_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            switch (args.Button)
            {
                case SystemMediaTransportControlsButton.Play:
                    Play();
                    break;

                case SystemMediaTransportControlsButton.Pause:
                    Pause();
                    break;

                default:
                    break;
            }
        }
Example #30
0
 private static void SystemControlsButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
 {
     switch (args.Button)
     {
         case SystemMediaTransportControlsButton.Play:
             BackgroundMediaPlayer.Current.Play();
             break;
         case SystemMediaTransportControlsButton.Pause:
             BackgroundMediaPlayer.Current.Pause();
             break;
         case SystemMediaTransportControlsButton.Stop:
             BackgroundMediaPlayer.Current.Pause();
             BackgroundMediaPlayer.Current.Position = TimeSpan.FromSeconds(0);
             break;
     }
 }
Example #31
0
 void mdcontrol_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
 {
     // 若果使用者按下了播放鍵
     if (args.Button == SystemMediaTransportControlsButton.Play)
     {
         Play();
     }
     // 若果使用者按下了暫停按鈕
     else if (args.Button == SystemMediaTransportControlsButton.Pause)
     {
         if (currentPlayer.CurrentState == MediaPlayerState.Playing)
         {
             Pause();
         }
     }
 }
Example #32
0
 void mdcontrol_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
 {
     // 如果用户按下了播放键
     if (args.Button == SystemMediaTransportControlsButton.Play)
     {
         Play();
     }
     // 如果用户按下了暂停按钮
     else if (args.Button == SystemMediaTransportControlsButton.Pause)
     {
         if (currentPlayer.CurrentState == MediaPlayerState.Playing)
         {
             Pause();
         }
     }
 }
Example #33
0
        /// <summary>
        /// This function controls the button events from UVC.
        /// This code if not run in background process, will not be able to handle button pressed events when app is suspended.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        void smtc_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            switch (args.Button)
            {
            case SystemMediaTransportControlsButton.Play:
                Debug.WriteLine("UVC play button pressed");

                // When the background task has been suspended and the SMTC
                // starts it again asynchronously, some time is needed to let
                // the task startup process in Run() complete.

                // Wait for task to start.
                // Once started, this stays signaled until shutdown so it won't wait
                // again unless it needs to.
                bool result = backgroundTaskStarted.WaitOne(5000);
                if (!result)
                {
                    throw new Exception("Background Task didnt initialize in time");
                }

                StartPlayback();
                break;

            case SystemMediaTransportControlsButton.Pause:
                Debug.WriteLine("UVC pause button pressed");
                try
                {
                    BackgroundMediaPlayer.Current.Pause();
                }
                catch (Exception ex) { Debug.WriteLine($"$#~>{ex.Message}"); if (Debugger.IsAttached)
                                       {
                                           Debugger.Break();
                                       }                                                                                                        /*else throw;*/
                                       MessageService.SendMessageToForeground(new ExceptionCaughtMessage(ex.Message)); }
                break;

            case SystemMediaTransportControlsButton.Next:
                Debug.WriteLine("UVC next button pressed");
                SkipToNext();
                break;

            case SystemMediaTransportControlsButton.Previous:
                Debug.WriteLine("UVC previous button pressed");
                SkipToPrevious();
                break;
            }
        }
        private void Smtc_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            switch (args.Button)
            {
            case SystemMediaTransportControlsButton.Play:
                break;

            case SystemMediaTransportControlsButton.Pause:
                break;

            case SystemMediaTransportControlsButton.Next:
                break;

            case SystemMediaTransportControlsButton.Previous:
                break;
            }
        }
        // System Media Transport Control
        private void medialControl_ButtonPressed(SystemMediaTransportControls sender,
                                                 SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            switch (args.Button)
            {
            case SystemMediaTransportControlsButton.Play:
                PlayMedia();
                break;

            case SystemMediaTransportControlsButton.Pause:
                PauseMedia();
                break;

            default:
                break;
            }
        }
 private async void OnButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
 {
     await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
     {
         switch (args.Button)
         {
             case SystemMediaTransportControlsButton.Play:
                 mediaPlayer.Play();
                 break;
             case SystemMediaTransportControlsButton.Pause:
                 mediaPlayer.Pause();
                 break;
             default:
                 break;
         }
     });
 }
        private void OnSystemMediaTransportControlButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            switch (args.Button)
            {
                case SystemMediaTransportControlsButton.Play:
                    Debug.WriteLine("UVC play button pressed");

                    if (!this.backgroundTaskRunning)
                    {
                        var result = this.backgroundTaskStarted.WaitOne(2000);

                        if (!result)
                        {
                            throw new Exception("Background Task did not initialize in time");
                        }
                    }

                    // TODO
                    BackgroundMediaPlayer.Current.Play();

                    break;
                case SystemMediaTransportControlsButton.Pause:
                    Debug.WriteLine("UVC pause button pressed");

                    try
                    {
                        // TODO
                        BackgroundMediaPlayer.Current.Pause();
                    }
                    catch (Exception ex)
                    {
                        // TODO: Must send exception to app and the app must report to Insights
                    }

                    break;
                case SystemMediaTransportControlsButton.Next:
                    Debug.WriteLine("UVC next button pressed");

                    break;
                case SystemMediaTransportControlsButton.Previous:
                    Debug.WriteLine("UVC previous button pressed");

                    break;
            }
        }
 private void OnButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
 {
     switch (args.Button)
     {
         case SystemMediaTransportControlsButton.Play:
             bool result = backgroundTaskStarted.WaitOne(5000);
             if (!result)
                 return;
             StartPlayback();
             break;
         case SystemMediaTransportControlsButton.Pause:
             BackgroundMediaPlayer.Current.Pause();
             break;
         case SystemMediaTransportControlsButton.Stop:
             BackgroundMediaPlayer.Shutdown();
             break;
     }
 }
 private void MediaTransportControlsOnButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
 {
     switch (args.Button)
     {
         case SystemMediaTransportControlsButton.Play:
         case SystemMediaTransportControlsButton.Pause:
             _eventAggregator.Publish(new PlayPauseMessage());
             break;
         case SystemMediaTransportControlsButton.Stop:
             _eventAggregator.Publish(new StopMessage());
             break;
         case SystemMediaTransportControlsButton.Next:
             _eventAggregator.Publish(new PlayNextMessage());
             break;
         case SystemMediaTransportControlsButton.Previous:
             _eventAggregator.Publish(new PlayPreviousMessage());
             break;
     }
 }
Example #40
0
 /// <summary>
 ///     This function controls the button events from UVC.
 ///     This code if not run in background process, will not be able to handle button pressed events when app is suspended.
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="args"></param>
 private void smtc_ButtonPressed(SystemMediaTransportControls sender,
     SystemMediaTransportControlsButtonPressedEventArgs args)
 {
     switch (args.Button)
     {
         case SystemMediaTransportControlsButton.Play:
             Debug.WriteLine("UVC play button pressed");
             PlayPressed?.Invoke(this, null);
             break;
         case SystemMediaTransportControlsButton.Pause:
             Debug.WriteLine("UVC pause button pressed");
             PausePressed?.Invoke(this, null);
             break;
         case SystemMediaTransportControlsButton.Next:
             Debug.WriteLine("UVC next button pressed");
             NextPressed?.Invoke(this, null);
             break;
         case SystemMediaTransportControlsButton.Previous:
             Debug.WriteLine("UVC previous button pressed");
             PrevPressed?.Invoke(this, null);
             break;
     }
 }
 void SystemControls_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
 {
 }
     // System Media Transport Control
     private void medialControl_ButtonPressed(SystemMediaTransportControls sender,
 SystemMediaTransportControlsButtonPressedEventArgs args)
     {
         switch (args.Button)
         {
             case SystemMediaTransportControlsButton.Play:
                 try
                 {
                     PlayMedia();
                 }
                 catch (Exception) 
                 {
                     networkStatus.Text = "S.M.T.C. Error 1";
                     streamStatus.Text = "Restart the App and notify the Developer";
                     networkStatus.Foreground = new SolidColorBrush(Colors.Red);
                     streamStatus.Foreground = new SolidColorBrush(Colors.Red);
                 }
                 break;
             case SystemMediaTransportControlsButton.Pause:
                 try
                 {
                     PauseMedia();
                 }
                 catch (Exception)
                 {
                     networkStatus.Text = "S.M.T.C. Error 2";
                     streamStatus.Text = "Restart the App and notify the Developer";
                     networkStatus.Foreground = new SolidColorBrush(Colors.Red);
                     streamStatus.Foreground = new SolidColorBrush(Colors.Red);
                 }
                 break;
             default:
                 break;
         }
     }
Example #43
0
        //System Media Transport Controls
        private async void SystemMediaControls_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs e)
        {
            switch (e.Button)
            {
                case SystemMediaTransportControlsButton.Play:
                    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                    {
                        PlayMedia();
                    });
                    break;

                case SystemMediaTransportControlsButton.Pause:
                    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                    {
                        PauseMedia();
                    });
                    break;

                case SystemMediaTransportControlsButton.Stop:
                    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                    {
                        StopMedia();
                    });
                    break;

                case SystemMediaTransportControlsButton.Next:
                    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                    {
                        NextMedia();
                    });
                    break;

                case SystemMediaTransportControlsButton.Previous:
                    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                    {
                        PreviousMedia();
                    });
                    break;
                default:
                    break;
            }
        }
Example #44
0
 /// <summary>
 /// This function controls the button events from UVC.
 /// This code if not run in background process, will not be able to handle button pressed events when app is suspended.
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="args"></param>
 private void systemmediatransportcontrol_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
 {
     switch (args.Button)
     {
         case SystemMediaTransportControlsButton.Play:
             Debug.WriteLine("UVC play button pressed");
             // If music is in paused state, for a period of more than 5 minutes, 
             //app will get task cancellation and it cannot run code. 
             //However, user can still play music by pressing play via UVC unless a new app comes in clears UVC.
             //When this happens, the task gets re-initialized and that is asynchronous and hence the wait
             if (!backgroundtaskrunning)
             {
                 bool result = BackgroundTaskStarted.WaitOne(3000);
                 if (!result)
                     throw new Exception("Background Task didnt initialize in time");
             }
             StartPlayback();
             break;
         case SystemMediaTransportControlsButton.Pause:
             Debug.WriteLine("UVC pause button pressed");
             try
             {
                 BackgroundMediaPlayer.Current.Pause();
             }
             catch (Exception ex)
             {
                 Debug.WriteLine(ex.ToString());
             }
             break;
         case SystemMediaTransportControlsButton.Next:
             Debug.WriteLine("UVC next button pressed");
             SkipToNext();
             break;
         case SystemMediaTransportControlsButton.Previous:
             Debug.WriteLine("UVC previous button pressed");
             SkipToPrevious();
             break;
     }
 }
Example #45
0
 async void mediaControls_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
 {
     switch (args.Button)
     {
         case SystemMediaTransportControlsButton.Play:
             await this.Resume();
             break;
         case SystemMediaTransportControlsButton.Pause:
             this.Pause();
             break;
         case SystemMediaTransportControlsButton.Next:
             ApplicationSettings.BackgroundTaskResumeSongTime.ReadReset();
             await PlayNextSong(false, true, SongChangedType.NextSong);
             break;
         case SystemMediaTransportControlsButton.Previous:
             ApplicationSettings.BackgroundTaskResumeSongTime.ReadReset();
             await PlayPreviousSong();
             break;
         default:
             throw new NotImplementedException();
     }
 }
        void systemMediaTransportControl_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            switch (args.Button)
            {
                case SystemMediaTransportControlsButton.Play:
                    if (!_backgroundtaskrunning)
                    {
                        bool result = _backgroundTaskStarted.WaitOne(2000);
                        if (!result)
                            throw new Exception("Background Task didnt initialize in time");
                    }
                    else
                    {
                        BackgroundMediaPlayer.Current.Play();
                    }

                    break;
                case SystemMediaTransportControlsButton.Pause:

                    try
                    {
                        BackgroundMediaPlayer.Current.Pause();
                    }
                    catch (Exception ex)
                    {

                    }
                    break;
                case SystemMediaTransportControlsButton.Next:
                    _queue.SkipToNext();
                    break;
                case SystemMediaTransportControlsButton.Previous:
                    _queue.SkipToPrevious();
                    break;
            }
        }
Example #47
0
 private async void Smtc_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
 {
     switch (args.Button)
     {
         case SystemMediaTransportControlsButton.Play:
             logger.LogMessage("BackgroundAudio: UVC play button pressed");
             await StartPlaybackAsync();
             break;
         case SystemMediaTransportControlsButton.Pause:
             logger.LogMessage("BackgroundAudio: UVC pause button pressed");
             mediaPlayer.Pause();
             break;
         case SystemMediaTransportControlsButton.Next:
             logger.LogMessage("BackgroundAudio: UVC next button pressed");
             SkipToNext();
             break;
         case SystemMediaTransportControlsButton.Previous:
             logger.LogMessage("BackgroundAudio: UVC previous button pressed");
             SkipToPrevious();
             break;
     }
 }
 private void Smtc_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
 {
     switch (args.Button)
     {
         case SystemMediaTransportControlsButton.Play:
             mediaPlayer.Play();
             break;
         case SystemMediaTransportControlsButton.Pause:
             mediaPlayer.Pause();
             break;
         case SystemMediaTransportControlsButton.Stop:
             mediaPlayer.Pause();
             break;
         case SystemMediaTransportControlsButton.Record:
             break;
         case SystemMediaTransportControlsButton.FastForward:
             break;
         case SystemMediaTransportControlsButton.Rewind:
             break;
         case SystemMediaTransportControlsButton.Next:
             Switch();
             break;
         case SystemMediaTransportControlsButton.Previous:
             Switch();
             break;
         case SystemMediaTransportControlsButton.ChannelUp:
             break;
         case SystemMediaTransportControlsButton.ChannelDown:
             break;
         default:
             break;
     }
 }
Example #49
0
        private void SMTC_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            //throw new NotImplementedException();
            switch (args.Button)
            {
                case SystemMediaTransportControlsButton.Next:
                    this.Playlist.Next();
                    BackgroundMediaPlayer.Current.SetUriSource(new Uri(Playlist.CurrentItem));
                    _smtc.DisplayUpdater.MusicProperties.Title = Playlist.Name;
                    _smtc.DisplayUpdater.Update();
                    break;
                case SystemMediaTransportControlsButton.Previous:
                    this.Playlist.Previous();
                    BackgroundMediaPlayer.Current.SetUriSource(new Uri(Playlist.CurrentItem));
                    _smtc.DisplayUpdater.MusicProperties.Title = Playlist.Name;
                    _smtc.DisplayUpdater.Update();
                    break;
                case SystemMediaTransportControlsButton.Pause:
                    BackgroundMediaPlayer.Current.Pause();
                    sender.PlaybackStatus = MediaPlaybackStatus.Paused;
                    break;
                case SystemMediaTransportControlsButton.Play:
                    BackgroundMediaPlayer.Current.Play();
                    break;

            }
        }
Example #50
0
        void SystemMediaTransportControlsOnButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            Debug.WriteLine("BackgroundAudioRun.SystemMediaTransportControlsOnButtonPressed() " + _id + " button " + args.Button);

            var mediaPlayerManager = _mediaPlayerManager;

            if (null == mediaPlayerManager)
                return;

            HandleSmtcButton(mediaPlayerManager, args.Button);
        }
        private async void systemMediaControls_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            // The system media transport control's ButtonPressed event may not fire on the app's UI thread.  XAML controls 
            // (including the MediaPlayerElement control in our page as well as the scenario page itself) typically can only be 
            // safely accessed and manipulated on the UI thread, so here for simplicity, we dispatch our entire event handling 
            // code to execute on the UI thread, as our code here primarily deals with updating the UI and the MediaPlayerElement.
            // 
            // Depending on how exactly you are handling the different button presses (which for your app may include buttons 
            // not used in this sample scenario), you may instead choose to only dispatch certain parts of your app's 
            // event handling code (such as those that interact with XAML) to run on UI thread.
            await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async () =>
            {
                // Because the handling code is dispatched asynchronously, it is possible the user may have
                // navigated away from this scenario page to another scenario page by the time we are executing here.
                // Check to ensure the page is still active before proceeding.
                if (isThisPageActive)
                {
                    switch (args.Button)
                    {
                        case SystemMediaTransportControlsButton.Play:
                            rootPage.NotifyUser("Play pressed", NotifyType.StatusMessage);
                            mediaPlayer.Play();
                            break;

                        case SystemMediaTransportControlsButton.Pause:
                            rootPage.NotifyUser("Pause pressed", NotifyType.StatusMessage);
                            mediaPlayer.Pause();
                            break;

                        case SystemMediaTransportControlsButton.Stop:
                            rootPage.NotifyUser("Stop pressed", NotifyType.StatusMessage);
                            mediaPlayer.Pause();
                            mediaPlayer.PlaybackSession.Position = TimeSpan.Zero;
                            break;

                        case SystemMediaTransportControlsButton.Next:
                            rootPage.NotifyUser("Next pressed", NotifyType.StatusMessage);
                            // range-checking will be performed in SetNewMediaItem()
                            await SetNewMediaItem(currentItemIndex + 1);
                            break;

                        case SystemMediaTransportControlsButton.Previous:
                            rootPage.NotifyUser("Previous pressed", NotifyType.StatusMessage);
                            // range-checking will be performed in SetNewMediaItem()
                            await SetNewMediaItem(currentItemIndex - 1);
                            break;

                            // Insert additional case statements for other buttons you want to handle in your app.
                            // Remember that you also need to first enable those buttons via the corresponding
                            // Is****Enabled property on the SystemMediaTransportControls object.
                    }
                }
            });
        }
Example #52
0
        async void SystemControls_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            Debug.WriteLine("MainPage SystemControls ButtonPressed: " + args.Button);

            try
            {
                await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => SystemControlsHandleButton(args.Button));
            }
            catch (Exception ex)
            {
                Debug.WriteLine("Main SystemControls ButtonPressed: {0}, failed: {1}", args.Button, ex.Message);
            }
        }
Example #53
0
        private void HandleSystemMediaTransportControlsButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            switch (args.Button)
            {
                case SystemMediaTransportControlsButton.Play:
                    Logger.Current.Init(LogType.AudioFunction);

                    Logger.Current.Log(new CallerInfo(), LogLevel.Info, "Play button pressed");

                    if (backgroundTaskState != BackgroundTaskState.Running)
                    {
                        bool success = backgroundTaskStarted.WaitOne(5000);
                        if (!success)
                        {
                            throw new Exception("BackgroundProccessLaunchFailed");
                        }
                    }

                    StartPlayback();

                    break;
                case SystemMediaTransportControlsButton.Pause:
                    Logger.Current.Init(LogType.AudioFunction);

                    Logger.Current.Log(new CallerInfo(), LogLevel.Info, "Pause button pressed");

                    BackgroundMediaPlayer.Current.Pause();
                    break;
                case SystemMediaTransportControlsButton.Next:
                    Logger.Current.Init(LogType.AudioFunction);

                    Logger.Current.Log(new CallerInfo(), LogLevel.Info, "Next button pressed");

                    SkipToNext();

                    break;
                case SystemMediaTransportControlsButton.Previous:
                    Logger.Current.Init(LogType.AudioFunction);

                    Logger.Current.Log(new CallerInfo(), LogLevel.Info, "Previous button pressed");
                    SkipToPrevious();

                    break;
                default:
                    Logger.Current.Init(LogType.AudioFunction);

                    Logger.Current.Log(new CallerInfo(), LogLevel.Warning, "Unexpected SMTC Button Pressed: {0}", args.Button.ToString());
                    break;
            }
        }
 private async void SystemMediaTransportControlsOnButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
 {
     switch (args.Button)
     {
         case SystemMediaTransportControlsButton.Pause:
         case SystemMediaTransportControlsButton.Play:
             _mediaService.Pause();
             break;
         case SystemMediaTransportControlsButton.Stop:
             Stop();
             break;
         case SystemMediaTransportControlsButton.Previous:
             if (Locator.MediaPlaybackViewModel.PlayingType == PlayingType.Music)
                 await Locator.MediaPlaybackViewModel.PlayPrevious();
             break;
         case SystemMediaTransportControlsButton.Next:
             if (Locator.MediaPlaybackViewModel.PlayingType == PlayingType.Music)
                 await Locator.MediaPlaybackViewModel.PlayNext();
             break;
     }
 }
 async void SystemControls_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
 {
     switch (args.Button)
     {
         case SystemMediaTransportControlsButton.Pause:
             await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
             {
                 if (base.IsActive)
                 {
                     if (MediaPlayer.InteractiveViewModel.IsPauseEnabled)
                     {
                         MediaPlayer.InteractiveViewModel.Pause();
                     }
                 }
             });
             break;
         case SystemMediaTransportControlsButton.Play:
             await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
             {
                 if (base.IsActive)
                 {
                     if (MediaPlayer.InteractiveViewModel.IsPlayResumeEnabled)
                     {
                         MediaPlayer.InteractiveViewModel.PlayResume();
                     }
                 }
             });
             break;
         case SystemMediaTransportControlsButton.Stop:
             await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
             {
                 if (base.IsActive)
                 {
                     if (MediaPlayer.InteractiveViewModel.IsStopEnabled)
                     {
                         MediaPlayer.InteractiveViewModel.Stop();
                     }
                 }
             });
             break;
         case SystemMediaTransportControlsButton.Previous:
             await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
             {
                 if (base.IsActive)
                 {
                     if (isPreviousTrackEnabled && PlaylistPlugin != null)
                     {
                         PlaylistPlugin.GoToPreviousPlaylistItem();
                     }
                 }
             });
             break;
         case SystemMediaTransportControlsButton.Next:
             await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
             {
                 if (base.IsActive)
                 {
                     if (IsNextTrackEnabled && PlaylistPlugin != null)
                     {
                         PlaylistPlugin.GoToNextPlaylistItem();
                     }
                 }
             });
             break;
         case SystemMediaTransportControlsButton.Rewind:
             await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
             {
                 if (base.IsActive)
                 {
                     if (MediaPlayer.InteractiveViewModel.IsRewindEnabled)
                     {
                         MediaPlayer.InteractiveViewModel.DecreasePlaybackRate();
                     }
                 }
             });
             break;
         case SystemMediaTransportControlsButton.FastForward:
             await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
             {
                 if (base.IsActive)
                 {
                     if (MediaPlayer.InteractiveViewModel.IsFastForwardEnabled)
                     {
                         MediaPlayer.InteractiveViewModel.IncreasePlaybackRate();
                     }
                 }
             });
             break;
     }
 }
        void SystemMediaControls_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs e)
        {
            switch (e.Button)
            {
                case SystemMediaTransportControlsButton.Play:
                    Play();
                    DisplayStatus(GetTimeStampedMessage("Play Pressed"));
                    break;

                case SystemMediaTransportControlsButton.Pause:
                    Pause();
                    DisplayStatus(GetTimeStampedMessage("Pause Pressed"));
                    break;

                case SystemMediaTransportControlsButton.Stop:
                    Stop();
                    DisplayStatus(GetTimeStampedMessage("Stop Pressed"));
                    break;

                default:
                    break;
            }
        }
        /// <summary>
        /// This function controls the button events from UVC.
        /// This code if not run in background process, will not be able to handle button pressed events when app is suspended.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        private void smtc_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            switch (args.Button)
            {
                case SystemMediaTransportControlsButton.Play:
                    Debug.WriteLine("UVC play button pressed");

                    // When the background task has been suspended and the SMTC
                    // starts it again asynchronously, some time is needed to let
                    // the task startup process in Run() complete.

                    // Wait for task to start. 
                    // Once started, this stays signaled until shutdown so it won't wait
                    // again unless it needs to.
                    bool result = backgroundTaskStarted.WaitOne(5000);
                    if (!result)
                        throw new Exception("Background Task didnt initialize in time");

                    StartPlayback();
                    break;
                case SystemMediaTransportControlsButton.Pause:
                    Debug.WriteLine("UVC pause button pressed");
                    try
                    {
                        BackgroundMediaPlayer.Current.Pause();
                    }
                    catch (Exception ex)
                    {
                        Debug.WriteLine(ex.ToString());
                    }
                    break;
                case SystemMediaTransportControlsButton.Next:
                    Debug.WriteLine("UVC next button pressed");
                    SkipToNext();
                    break;
                case SystemMediaTransportControlsButton.Previous:
                    Debug.WriteLine("UVC previous button pressed");
                    SkipToPrevious();
                    break;
            }
        }
Example #58
0
 private void SMTC_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
 {
     //throw new NotImplementedException();
 }
Example #59
0
        /// <summary>
        /// Handler for the system transport controls button.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void SystemMediaControls_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs e)
        {
            switch (e.Button)
            {
                case SystemMediaTransportControlsButton.Play:
                    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                    {
                        Scenario2MediaElement.Play();
                    });
                    break;

                case SystemMediaTransportControlsButton.Pause:
                    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                    {
                        Scenario2MediaElement.Pause();
                    });
                    break;

                case SystemMediaTransportControlsButton.Stop:
                    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                    {
                        Scenario2MediaElement.Stop();
                    });
                    break;

                default:
                    break;
            }
        }
        private async void ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            await MediaPlayer.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
            {
                switch (args.Button)
                {
                    case SystemMediaTransportControlsButton.Play:
                        PlayChannel(NowPlayingItem);
                        MediaPlayer.Play();
                        break;

                    case SystemMediaTransportControlsButton.Pause:
                        MediaPlayer.Pause();
                        break;

                    case SystemMediaTransportControlsButton.Stop:
                        MediaPlayer.Stop();
                        break;

                    case SystemMediaTransportControlsButton.Previous:
                        if (NowPlayingItem != null && NowPlayingItem.Previous != null)
                            PlayChannel(NowPlayingItem.Previous);
                        break;

                    case SystemMediaTransportControlsButton.Next:
                        if (NowPlayingItem != null && NowPlayingItem.Next != null)
                            PlayChannel(NowPlayingItem.Next);
                        break;
                }

            });
        }