Esempio n. 1
0
                public bool OnError(MediaPlayer mp, MediaError error, int extra)
                {
                    ProgressBar.Visibility = ViewStates.Gone;

                    // only show the resultView if we're active.
                    if (FragmentActive == true)
                    {
                        ResultView.Show(MessagesStrings.Error_Title,
                                        PrivateControlStylingConfig.Result_Symbol_Failed,
                                        MessagesStrings.Error_Watch_Playback,
                                        GeneralStrings.Retry);

                        ResultView.SetBounds(new System.Drawing.RectangleF(0, 0, NavbarFragment.GetFullDisplayWidth( ), this.Resources.DisplayMetrics.HeightPixels));
                    }

                    if (mp != null)
                    {
                        mp.Stop( );
                        mp.Reset( );
                    }

                    MediaControllerPrepared = false;

                    PlayerState = MediaPlayerState.None;

                    //SyncUI( );

                    return(true);
                }
Esempio n. 2
0
        private void SetState(MediaPlayerState state)
        {
            MediaPlayerState oldState = State;

            State = state;
            StateChanged?.Invoke(this, new StateChangedEventArgs(oldState, state));
        }
Esempio n. 3
0
    public void SetState(MediaPlayerState newState)
    {
        switch (newState)
        {
        case MediaPlayerState.Idle:
            _Player.Stop();
            foreach (RenderHeads.Media.AVProVideo.DisplayUGUI videoProjection in VideoProjections)
            {
                videoProjection.color = Color.clear;
            }
            break;

        case MediaPlayerState.Loading:
            foreach (RenderHeads.Media.AVProVideo.DisplayUGUI videoProjection in VideoProjections)
            {
                videoProjection.color = Color.clear;
            }
            break;

        case MediaPlayerState.Playing:
            foreach (RenderHeads.Media.AVProVideo.DisplayUGUI videoProjection in VideoProjections)
            {
                videoProjection.color = _CurrentColor;
                videoProjection.rectTransform.SetAsLastSibling();
            }
            break;
        }

        _PlayerState = newState;
    }
        private static MediaPlayerState BuildOne(IBMDSwitcherMediaPlayer props, AtemStateBuilderSettings updateSettings, bool hasClips)
        {
            var state = new MediaPlayerState();

            if (hasClips)
            {
                state.ClipStatus = new MediaPlayerState.ClipStatusState();
            }

            props.GetSource(out _BMDSwitcherMediaPlayerSourceType type, out uint index);
            state.Source.SourceType  = AtemEnumMaps.MediaPlayerSourceMap.FindByValue(type);
            state.Source.SourceIndex = index;

            if (state.ClipStatus != null)
            {
                props.GetPlaying(out int playing);
                state.ClipStatus.Playing = playing != 0;
                props.GetLoop(out int loop);
                state.ClipStatus.Loop = loop != 0;

                if (updateSettings.TrackMediaClipFrames)
                {
                    props.GetAtBeginning(out int atBegining);
                    state.ClipStatus.AtBeginning = atBegining != 0;
                    props.GetClipFrame(out uint clipFrame);
                    state.ClipStatus.ClipFrame = clipFrame;
                }
            }

            return(state);
        }
Esempio n. 5
0
                public void OnPrepared(MediaPlayer mp)
                {
                    Rock.Mobile.Util.Debug.WriteLine("OnPrepared - Audio ready to play");

                    // now that we know the media player is read, set the controller's player
                    MediaController.SetMediaPlayer(this);
                    MediaControllerPrepared = true;

                    // setup a seek listener
                    mp.SetOnSeekCompleteListener(this);

                    // log the series they tapped on.
                    MessageAnalytic.Instance.Trigger(MessageAnalytic.Listen, Name);

                    // if this is a new video, store the URL
                    if (MobileApp.Shared.Network.RockMobileUser.Instance.LastStreamingMediaUrl != MediaUrl)
                    {
                        MobileApp.Shared.Network.RockMobileUser.Instance.LastStreamingMediaUrl = MediaUrl;

                        PlayerState = MediaPlayerState.Playing;
                        mp.Start( );

                        SyncUI( );
                    }
                    else
                    {
                        // otherwise, resume where we left off
                        mp.SeekTo((int)MobileApp.Shared.Network.RockMobileUser.Instance.LastStreamingMediaPos);
                    }
                }
        private void SetCrossMediaByState(MediaPlayerState state)
        {
            switch (state)
            {
            case MediaPlayerState.Stopped:
                customMediaPlayer.Visibility = ViewStates.Gone;
                current_title = current_image = string.Empty;
                SaveCurrentPlayerData(null);
                break;

            case MediaPlayerState.Playing:
                customMediaPlayer.Visibility = ViewStates.Visible;
                SetSeekBarMaxProgress();
                playerPlayPause.SetImageResource(Resource.Drawable.pause_24px);
                break;

            case MediaPlayerState.Paused:
                customMediaPlayer.Visibility = ViewStates.Visible;
                SetSeekBarMaxProgress();
                playerPlayPause.SetImageResource(Resource.Drawable.play_24);
                break;

            case MediaPlayerState.Buffering:
            case MediaPlayerState.Loading:
                break;
            }
        }
Esempio n. 7
0
        private void UpdateTransportControls(MediaPlayerState state)
        {
            if (state == MediaPlayerState.Opening || state == MediaPlayerState.Buffering)
            {
                return;
            }

            if (CurrentTrack != null)
            {
                if (state == MediaPlayerState.Playing || state == MediaPlayerState.Opening)
                {
                    CurrentTrack.Playing = true;
                    PlayButtonVisibility = Visibility.Collapsed;
                    StopButtonVisibility = Visibility.Visible;
                }
                else
                {
                    CurrentTrack.Playing = false;
                    PlayButtonVisibility = Visibility.Visible;
                    StopButtonVisibility = Visibility.Collapsed;
                }

                PlayButtonIsEnabled = true;
            }

            RefreshBindings();
        }
Esempio n. 8
0
        private void SendPlayerState(MediaPlayerState playerState)
        {
            string   value    = Enum.GetName(typeof(MediaPlayerState), playerState);
            ValueSet valueSet = receivers[playerStatePrimaryKey].GetValueSet(value);

            Send(valueSet);
        }
Esempio n. 9
0
        public void TestPlaying()
        {
            var handler = CommandGenerator.CreateAutoCommandHandler <MediaPlayerClipStatusSetCommand, MediaPlayerClipStatusGetCommand>("Playing");

            AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.MediaPlayerClips, helper =>
            {
                var tested  = false;
                var players = GetMediaPlayers(helper);

                foreach (Tuple <uint, IBMDSwitcherMediaPlayer> player in players)
                {
                    tested = true;

                    AtemState stateBefore        = helper.Helper.BuildLibState();
                    MediaPlayerState playerState = stateBefore.MediaPlayers[(int)player.Item1];

                    for (int i = 0; i < 5; i++)
                    {
                        bool playing = i % 2 == 0;
                        playerState.ClipStatus.Playing = playing;

                        helper.SendAndWaitForChange(stateBefore, () => { player.Item2.SetPlaying(playing ? 1 : 0); });
                    }
                }
                Assert.True(tested);
            });
        }
Esempio n. 10
0
        public void TestSource()
        {
            AtemMockServerWrapper.Each(_output, _pool, SourceCommandHandler, DeviceTestCases.MediaPlayer, helper =>
            {
                var tested  = false;
                var players = GetMediaPlayers(helper);

                foreach (Tuple <uint, IBMDSwitcherMediaPlayer> player in players)
                {
                    tested = true;

                    AtemState stateBefore        = helper.Helper.BuildLibState();
                    MediaPlayerState playerState = stateBefore.MediaPlayers[(int)player.Item1];

                    for (int i = 0; i < 5; i++)
                    {
                        MediaPlayerSource type = playerState.Source.SourceType = stateBefore.MediaPool.Clips.Count > 0
                            ? Randomiser.EnumValue <MediaPlayerSource>()
                            : MediaPlayerSource.Still;
                        uint index = playerState.Source.SourceIndex = Randomiser.RangeInt(20) + 1;

                        helper.SendAndWaitForChange(stateBefore,
                                                    () => { player.Item2.SetSource(AtemEnumMaps.MediaPlayerSourceMap[type], index); });
                    }
                }
                Assert.True(tested);
            });
        }
Esempio n. 11
0
        public void TestClipFrame()
        {
            try
            {
                _pool.StateSettings.TrackMediaClipFrames = true;
                var handler = CommandGenerator.CreateAutoCommandHandler <MediaPlayerClipStatusSetCommand, MediaPlayerClipStatusGetCommand>("ClipFrame");
                AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.MediaPlayerClips, helper =>
                {
                    var tested  = false;
                    var players = GetMediaPlayers(helper);

                    foreach (Tuple <uint, IBMDSwitcherMediaPlayer> player in players)
                    {
                        tested = true;

                        AtemState stateBefore        = helper.Helper.BuildLibState();
                        MediaPlayerState playerState = stateBefore.MediaPlayers[(int)player.Item1];

                        for (int i = 0; i < 5; i++)
                        {
                            uint frame = playerState.ClipStatus.ClipFrame = Randomiser.RangeInt(40);

                            helper.SendAndWaitForChange(stateBefore, () => { player.Item2.SetClipFrame(frame); });
                        }
                    }

                    Assert.True(tested);
                });
            }
            finally
            {
                _pool.StateSettings.TrackMediaClipFrames = false;
            }
        }
Esempio n. 12
0
                public void OnSeekComplete(MediaPlayer mp)
                {
                    PlayerState = MediaPlayerState.Playing;
                    mp.Start( );

                    SyncUI( );
                }
Esempio n. 13
0
        protected override async void LoadState(object param, Dictionary <string, object> pageState)
        {
            base.LoadState(param, pageState);
            int           id   = (int)param;
            VideoDataItem item = VideoDataSource.GetItem(id);

            if (item != null)
            {
                OpenFile(item.File);
            }
            else if (pageState["fileToken"] != null)
            {
                StorageItemAccessList future = StorageApplicationPermissions.FutureAccessList;
                StorageFile           file   = await future.GetFileAsync(pageState["fileToken"] as string);

                future.Clear();
                OpenFile(file);
            }
            if (pageState != null)
            {
                MediaPlayerState state = pageState["MediaState"] as MediaPlayerState;
                if (state != null)
                {
                    MediaPlayer.RestorePlayerState(state);
                }
            }
        }
Esempio n. 14
0
 protected virtual async void OnPlaybackStateChanged(MediaPlayerState state)
 {
     await DispatcherHelper.RunAsync(
         () =>
     {
         PlaybackStateChanged?.Invoke(this, new PlaybackStateEventArgs(state));
     });
 }
Esempio n. 15
0
        private static void SendPlayerStateChanged(MediaPlayerState state)
        {
            MessageModel _sendData = new MessageModel();

            _sendData.Type          = MessageType.PlayerStateChanged;
            _sendData.Content       = CryptographicBuffer.ConvertStringToBinary(state.ToString(), BinaryStringEncoding.Utf8);
            _sendData.ContentLength = _sendData.Content.Capacity;
            SendData(_sendData);
        }
        private async void DidFinishPlaying(NSNotification obj)
        {
            var succesfullNext = await MediaManager.PlayNext();

            if (!succesfullNext)
            {
                State = MediaPlayerState.Stopped;
            }
        }
Esempio n. 17
0
 protected virtual void OnPlaybackStateChanged(MediaPlayerState state)
 {
     DispatcherHelper.RunAsync(() =>
     {
         var handler = PlaybackStateChanged;
         if (handler != null)
         {
             handler(this, new PlaybackStateEventArgs(state));
         }
     });
 }
        public Task Play(IMediaItem mediaItem)
        {
            var item = mediaItem.GetPlayerItem();

            Player.ActionAtItemEnd = AVPlayerActionAtItemEnd.None;
            Player.ReplaceCurrentItemWithPlayerItem(item);
            Player.Play();

            State = MediaPlayerState.Playing;
            return(Task.CompletedTask);
        }
Esempio n. 19
0
 public void TogglePlayPause()
 {
     if (State == MediaPlayerState.Playing)
     {
         State = MediaPlayerState.Paused;
     }
     else if (State == MediaPlayerState.Paused)
     {
         State = MediaPlayerState.Playing;
     }
 }
Esempio n. 20
0
 private void UpdateStatus(MediaPlayerState status)
 {
     if (CurrentState != status)
     {
         CurrentState = status;
         if (StatusChanged != null)
         {
             StatusChanged(this, CurrentState);
         }
     }
 }
Esempio n. 21
0
 private void UpdateTransportControls(MediaPlayerState state)
 {
     if (state == MediaPlayerState.Playing)
     {
         playButton.Content = "| |";     // Change to pause button
     }
     else
     {
         playButton.Content = ">";     // Change to play button
     }
 }
Esempio n. 22
0
 private void UpdateTransportControls(MediaPlayerState state)
 {
     if (state == MediaPlayerState.Playing)
     {
         Pause.Icon = new SymbolIcon(Symbol.Pause);    // Change to pause button
     }
     else
     {
         Pause.Icon = new SymbolIcon(Symbol.Play);   // Change to play button
     }
 }
Esempio n. 23
0
 private void UpdateTransportControls(MediaPlayerState state)
 {
     if (state == MediaPlayerState.Playing)
     {
         // Change to pause button
     }
     else
     {
         // Change to play button
     }
 }
Esempio n. 24
0
 private void UpdateStatus(MediaPlayerState status)
 {
     if (CurrentState != status)
     {
         CurrentState = status;
         if (StatusChanged != null)
         {
             StatusChanged(this, CurrentState);
         }
     }
 }
Esempio n. 25
0
                public void ServiceConnected(AudioServiceBinder binder)
                {
                    Rock.Mobile.Util.Debug.WriteLine("ServiceConnected.");
                    AudioServiceBinder = binder;

                    if (PlayerState == MediaPlayerState.WantsAutoplay)
                    {
                        StartAudio( );

                        PlayerState = MediaPlayerState.Preparing;
                    }
                }
Esempio n. 26
0
        public async void NotifyControllerStateChanged(MediaPlayerState state)
        {
            await DispatcherHelper.RunAsync(() =>
            {
                switch (state)
                {
                case MediaPlayerState.Closed:
                    CanPlay        = CanPause = false;
                    IsPlaying      = false;
                    PlaybackStatus = MediaPlaybackStatus.Closed;
                    SuspendAskPosition();
                    break;

                case MediaPlayerState.Opening:
                    CanPlay        = CanPause = false;
                    IsPlaying      = false;
                    PlaybackStatus = MediaPlaybackStatus.Changing;
                    break;

                case MediaPlayerState.Buffering:
                    CanPlay        = CanPause = false;
                    IsPlaying      = false;
                    PlaybackStatus = MediaPlaybackStatus.Changing;
                    break;

                case MediaPlayerState.Playing:
                    CanPause       = true;
                    CanPlay        = true;
                    IsPlaying      = true;
                    PlaybackStatus = MediaPlaybackStatus.Playing;
                    ResumeAskPosition();
                    break;

                case MediaPlayerState.Paused:
                    CanPause       = false;
                    CanPlay        = true;
                    IsPlaying      = false;
                    PlaybackStatus = MediaPlaybackStatus.Paused;
                    SuspendAskPosition();
                    break;

                case MediaPlayerState.Stopped:
                    PlaybackStatus = MediaPlaybackStatus.Stopped;
                    SuspendAskPosition();
                    break;

                default:
                    break;
                }
            });
        }
        private void SetupCurrentMediaPlayerState(MediaPlayerState currentPlayerState)
        {
            LabelPlayerStatus.Text = $"{currentPlayerState.ToString().ToUpper()}";

            if (currentPlayerState == MediaManager.Player.MediaPlayerState.Loading)
            {
                SliderSongPlayDisplay.Value = 0;
            }
            else if (currentPlayerState == MediaManager.Player.MediaPlayerState.Playing &&
                     CrossMediaManager.Current.Duration.Ticks > 0)
            {
                SliderSongPlayDisplay.Maximum = CrossMediaManager.Current.Duration.Ticks;
            }
        }
Esempio n. 28
0
        protected override void SaveState(Dictionary <string, object> pageState)
        {
            MediaPlayerState      state  = MediaPlayer.GetPlayerState();
            StorageItemAccessList future = StorageApplicationPermissions.FutureAccessList;

            future.Clear();
            string token = future.Add(file);

            pageState.Add("MediaState", state);
            pageState.Add("fileToken", token);
            base.SaveState(pageState);
            if (teardown)
            {
                MediaPlayer.Dispose();
            }
        }
Esempio n. 29
0
                public override void OnCreate(Bundle savedInstanceState)
                {
                    base.OnCreate(savedInstanceState);

                    Rock.Mobile.Util.Debug.WriteLine("OnCreate - Starting Audio Service");

                    // flag that we want to automatically start the audio.
                    // If this fragment is backgrounded and resumed, this will be false and we won't
                    // attempt to play a second time.
                    PlayerState = MediaPlayerState.WantsAutoplay;

                    // start our audio service
                    Activity.StartService(new Intent(Activity, typeof(AudioService)));

                    // create our connector that manages the interface between us and the service
                    AudioServiceConnection = new AudioServiceConnection(this);
                }
Esempio n. 30
0
        private void PlayerServiceOnMediaStateChanged(object sender, MediaPlayerState mediaPlayerState)
        {
            var icon = Symbol.Play;

            switch (mediaPlayerState)
            {
            case MediaPlayerState.Playing:
                icon = Symbol.Pause;
                _timer.Start();
                break;

            default:
                _timer.Stop();
                break;
            }
            PlayPauseIcon = new SymbolIcon(icon);
        }
Esempio n. 31
0
        protected virtual void OnStateChanged(MediaPlayerState e)
        {
            if (e != MediaPlayerState.None && e != MediaPlayerState.Stopped)
            {
                StartForeground(NotificationId, BuildNotification());
            }
            else
            {
                StopForeground(true);
            }
            var handler = StateChanged;

            if (handler != null)
            {
                handler(this, new PlaybackStateEventArgs(e));
            }
        }
        private void PlayPauseButton_Click(object sender, RoutedEventArgs e)
        {
            var loader = new Windows.ApplicationModel.Resources.ResourceLoader();
            ((Window.Current.Content as Frame).Content as MainPage).PlayPauseButtonOnLeft_Click(null, null);
            if (NowState == MediaPlayerState.Playing)
            {
                NowState = MediaPlayerState.Paused;
                ToolTipService.SetToolTip(PlayPauseButton, loader.GetString("PauseTip.Text"));
                var icon = new BitmapIcon();
                icon.UriSource = new Uri("ms-appx:///Assets/ButtonIcon/playsolid.png");
                PlayPauseButton.Content = icon;
                return;
            }

            if (NowState == MediaPlayerState.Paused || NowState == MediaPlayerState.Stopped)
            {
                NowState = MediaPlayerState.Playing;
                ToolTipService.SetToolTip(PlayPauseButton, loader.GetString("PlayTip.Text"));
                var icon = new BitmapIcon();
                icon.UriSource = new Uri("ms-appx:///Assets/ButtonIcon/pausesolid.png");
                PlayPauseButton.Content = icon;
                return;
            }

        }
        private async void BackgroundMediaPlayer_MessageReceivedFromBackground(object sender, MediaPlayerDataReceivedEventArgs e)
        {

            BackPlaybackChangedMessage message;
            if (MessageService.TryParseMessage(e.Data, out message))
            {
                if (message.CurrentSong != null)
                {
                    await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, new Windows.UI.Core.DispatchedHandler(() =>
                     {
                         CurrentSong = message.CurrentSong;
                         updateui();
                     }));
                }
                NowState = message.NowState;
            }
            UpdateArtworkMessage artwork;
            if (MessageService.TryParseMessage(e.Data, out artwork))
            {
                var stream = FileHelper.ToStream(artwork.ByteStream);
                await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, new Windows.UI.Core.DispatchedHandler(async () =>
                {
                    MainColor = await BitmapHelper.New(stream);
                    PlayPauseButton.Background = new SolidColorBrush(MainColor);
                }));
            }
            NowListMessage nowList;
            if (MessageService.TryParseMessage(e.Data, out nowList))
            {
                UpdateNowList(nowList);
            }
            FullFileDetailsMessage detail;
            if (MessageService.TryParseMessage(e.Data, out detail))
            {
                updatedetail(detail);
            }
        }
 public void setPlaybackControl(MediaPlayerState state)
 {
     var loader = new Windows.ApplicationModel.Resources.ResourceLoader();
     var t = (TextBlock)ToolTipService.GetToolTip(PlayPauseButton);
     switch (state)
     {
         case MediaPlayerState.Closed:
             break;
         case MediaPlayerState.Opening:
             break;
         case MediaPlayerState.Buffering:
             break;
         case MediaPlayerState.Playing:
             ProgressSlider.IsEnabled = true;
             (PlayPauseButton.FindName("PlayPauseSymbolLeft") as SymbolIcon).Symbol = Symbol.Pause;
             t.Text = loader.GetString("PauseTip.Text");
             break;
         case MediaPlayerState.Paused:
             (PlayPauseButton.FindName("PlayPauseSymbolLeft") as SymbolIcon).Symbol = Symbol.Play;
             t.Text = loader.GetString("PlayTip.Text");
             break;
         case MediaPlayerState.Stopped:
             ProgressSlider.IsEnabled = false;
             (PlayPauseButton.FindName("PlayPauseSymbolLeft") as SymbolIcon).Symbol = Symbol.Play;
             t.Text = loader.GetString("PlayTip.Text");
             break;
         default:
             break;
     }
 }
Esempio n. 35
0
 public VlcService(HistoryService historyService)
 {
     CurrentState = MediaPlayerState.Stopped;
     _historyService = historyService;
 }
                public void ServiceConnected( AudioServiceBinder binder )
                {
                    Rock.Mobile.Util.Debug.WriteLine( "ServiceConnected." );
                    AudioServiceBinder = binder;

                    if ( PlayerState == MediaPlayerState.WantsAutoplay )
                    {
                        StartAudio( );

                        PlayerState = MediaPlayerState.Preparing;
                    }
                }
        public void PlayPauseButtonOnLeft_Click(object sender, RoutedEventArgs e)
        {
            switch (NowState)
            {
                case MediaPlayerState.Closed:
                    break;
                case MediaPlayerState.Opening:
                    break;
                case MediaPlayerState.Buffering:
                    break;
                case MediaPlayerState.Playing:
                    MessageService.SendMessageToBackground(new ForePlaybackChangedMessage(PlaybackState.Paused));
                    NowState = MediaPlayerState.Paused;
                    break;
                case MediaPlayerState.Paused:
                    MessageService.SendMessageToBackground(new ForePlaybackChangedMessage(PlaybackState.Playing));
                    NowState = MediaPlayerState.Playing;
                    break;
                case MediaPlayerState.Stopped:
                    MessageService.SendMessageToBackground(new ForePlaybackChangedMessage(PlaybackState.Playing));
                    NowState = MediaPlayerState.Playing;
                    break;
                default:
                    break;
            }

        }
Esempio n. 38
0
 protected virtual void OnStateChanged(MediaPlayerState e)
 {
     if (e != MediaPlayerState.None && e != MediaPlayerState.Stopped)
         StartForeground(NotificationId, BuildNotification());
     else
         StopForeground(true);
     var handler = StateChanged;
     if (handler != null) handler(this, new PlaybackStateEventArgs(e));
 }
Esempio n. 39
0
 private void ChangeState(FileType type, MediaPlayerState state)
 {
     if (type == FileType.Audio)
     {
         AudioState = state;
     } else
     {
         VideoState = state;
     }
 }
Esempio n. 40
0
        private void player_StateChanged(object sender, MediaPlayerState e)
        {
            context.Post(new SendOrPostCallback((o) =>
            {
                switch (e)
                {
                    case MediaPlayerState.Opening:
                        break;
                    case MediaPlayerState.Buffering:
                        break;
                    case MediaPlayerState.Playing:
                        timer.Start();
                        playButton.Icon = new SymbolIcon(Symbol.Pause);
                        break;

                    case MediaPlayerState.Paused:
                    case MediaPlayerState.Stopped:
                    case MediaPlayerState.Closed:
                        timer.Stop();
                        playButton.Icon = new SymbolIcon(Symbol.Play);
                        break;
                    default:
                        break;
                }

                posSlider.Value = Player.Instance.RelativePosition;

            }), null);
        }
Esempio n. 41
0
 private void PlayerServiceOnMediaStateChanged(object sender, MediaPlayerState mediaPlayerState)
 {
     var icon = Symbol.Play;
     switch (mediaPlayerState)
     {
         case MediaPlayerState.Playing:
             icon = Symbol.Pause;
             _timer.Start();
             break;
         default:
             _timer.Stop();
             break;
     }
     PlayPauseIcon = new SymbolIcon(icon);
 }
Esempio n. 42
0
        void RefreshUi(MediaPlayerState currentState, string track)
        {
            Debug.WriteLine("MainPage.RefreshUi({0}, {1}) {2}", currentState, track, _mediaPlayerHandle.Id);

            txtCurrentTrack.Text = track ?? string.Empty;
            txtCurrentState.Text = currentState.ToString();

            playButton.Content = MediaPlayerState.Playing == currentState ? "| |" : ">";

            if (MediaPlayerState.Opening == currentState)
            {
                //prevButton.IsEnabled = false;
                playButton.IsEnabled = false;
                //nextButton.IsEnabled = false;
            }
            else
            {
                prevButton.IsEnabled = true;
                playButton.IsEnabled = true;
                nextButton.IsEnabled = true;
            }

            var needTimer = MediaPlayerState.Closed != currentState;

            if (needTimer == _timer.IsEnabled)
                return;

            if (needTimer)
                _timer.Start();
            else
                _timer.Stop();
        }
Esempio n. 43
0
 public PlaybackStateEventArgs(MediaPlayerState state)
 {
     State = state;
 }
Esempio n. 44
0
 protected virtual void OnPlaybackStateChanged(MediaPlayerState state)
 {
     DispatcherHelper.RunAsync(
         () =>
         {
             var handler = PlaybackStateChanged;
             if (handler != null)
             {
                 handler(this, new PlaybackStateEventArgs(state));
             }
         });
 }
 private void StopButton_Click(object sender, RoutedEventArgs e)
 {
     ((Window.Current.Content as Frame).Content as MainPage).StopButton_Click(null, null);
     NowState = MediaPlayerState.Stopped;
     var icon = new BitmapIcon();
     icon.UriSource = new Uri("ms-appx:///Assets/ButtonIcon/playsolid.png");
     PlayPauseButton.Content = icon;
 }
                public bool OnError( MediaPlayer mp, MediaError error, int extra )
                {
                    ProgressBar.Visibility = ViewStates.Gone;

                    // only show the resultView if we're active.
                    if( FragmentActive == true )
                    {
                        ResultView.Show( MessagesStrings.Error_Title, 
                            PrivateControlStylingConfig.Result_Symbol_Failed, 
                            MessagesStrings.Error_Watch_Playback,
                            GeneralStrings.Retry );
                        
                        ResultView.SetBounds( new System.Drawing.RectangleF( 0, 0, NavbarFragment.GetFullDisplayWidth( ), this.Resources.DisplayMetrics.HeightPixels ) );
                    }

                    if( mp != null )
                    {
                        mp.Stop( );
                        mp.Reset( );
                    }

                    MediaControllerPrepared = false;

                    PlayerState = MediaPlayerState.None;

                    //SyncUI( );

                    return true;
                }
 private void PlayPauseButton_Loaded(object sender, RoutedEventArgs e)
 {
     var loader = new Windows.ApplicationModel.Resources.ResourceLoader();
     var t = (TextBlock)ToolTipService.GetToolTip(PlayPauseButton);
     NowState = BackgroundMediaPlayer.Current.CurrentState;
     switch (NowState)
     {
         case MediaPlayerState.Closed:
             break;
         case MediaPlayerState.Opening:
             break;
         case MediaPlayerState.Buffering:
             break;
         case MediaPlayerState.Playing:
             t.Text = loader.GetString("PlayTip.Text");
             var icon = new BitmapIcon();
             icon.UriSource = new Uri("ms-appx:///Assets/ButtonIcon/pausesolid.png");
             PlayPauseButton.Content = icon;
             break;
         case MediaPlayerState.Paused:
             t.Text = loader.GetString("PauseTip.Text");
             var noci = new BitmapIcon();
             noci.UriSource = new Uri("ms-appx:///Assets/ButtonIcon/playsolid.png");
             PlayPauseButton.Content = noci;
             break;
         case MediaPlayerState.Stopped:
             break;
         default:
             break;
     }
 }
                public void OnSeekComplete( MediaPlayer mp )
                {
                    PlayerState = MediaPlayerState.Playing;
                    mp.Start( );

                    SyncUI( );
                }
        private async void BackgroundMediaPlayer_MessageReceivedFromBackground(object sender, MediaPlayerDataReceivedEventArgs e)
        {
            BackgroundConfirmFilesMessage confirming;
            if (MessageService.TryParseMessage(e.Data, out confirming))
            {
                await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
                {
                    LoadingFilesBar.IsIndeterminate = false;
                    LoadingFilesBar.Visibility = Visibility.Collapsed;
                });
            }
            BackPlaybackChangedMessage stateChangedMessage;
            if (MessageService.TryParseMessage(e.Data, out stateChangedMessage))
            {
                await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
                {

                    // If playback stopped then clear the UI
                    if (stateChangedMessage.CurrentSong == null)
                    {
                        playbackControl.setPlaybackControlDefault();

                    }
                    else
                    {
                        playbackControl.setPlaybackControl(stateChangedMessage.CurrentSong);
                        this.CurrentSong = stateChangedMessage.CurrentSong;
                        nowPlayingHub.Set(stateChangedMessage.CurrentSong);
                        if (NowLrcFrame.Content != null)
                        {
                            NowLrcFrame.Navigate(typeof(LrcPage), CurrentSong);
                        }
                    }
                    NowState = stateChangedMessage.NowState;
                    BackgroundMediaPlayer.Current.Volume = VolumeSlider.Value / 100.0;
                    var converter = ProgressSlider.ThumbToolTipValueConverter as ThumbToolTipConveter;
                    converter.sParameter = stateChangedMessage.CurrentSong.Duration.TotalSeconds;
                    ArtworkLoadingRing.IsActive = true;
                    ArtworkLoadingRing.Visibility = Visibility.Visible;
                });
            }
            FileNotFindMessage notfind;
            if (MessageService.TryParseMessage(e.Data, out notfind))
            {
                this.Dispatcher.RunAsync(CoreDispatcherPriority.High, new DispatchedHandler(() =>
                 {
                     FileErrPanel.Visibility = Visibility.Visible;
                     ErrPanelIn.Begin();
                     ThreadPoolTimer.CreateTimer((a) =>
                    {
                        this.Dispatcher.RunAsync(CoreDispatcherPriority.High, new DispatchedHandler(async () =>
                        {
                            ErrPanelOut.Begin();
                            await Task.Delay(256);
                            FileErrPanel.Visibility = Visibility.Collapsed;
                        }));
                    }, TimeSpan.FromSeconds(3));
                 }));
            }
            UpdateArtworkMessage updateartwork;
            if (MessageService.TryParseMessage(e.Data, out updateartwork))
            {
                IRandomAccessStream stream;
                stream = await FileHelper.ToRandomAccessStream(updateartwork.ByteStream);
                this.ArtworkStream = updateartwork.ByteStream;
                this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
                {
                    ArtworkLoadingRing.IsActive = false;
                    ArtworkLoadingRing.Visibility = Visibility.Collapsed;
                    BitmapImage image = new BitmapImage();
                    image.SetSource(stream);
                    PlayBackImage.Source = image;
                    PlayBackImage_ImageOpened(stream);
                });
            }
        }
                public void OnPrepared( MediaPlayer mp )
                {
                    Rock.Mobile.Util.Debug.WriteLine( "OnPrepared - Audio ready to play" );

                    // now that we know the media player is read, set the controller's player
                    MediaController.SetMediaPlayer( this );
                    MediaControllerPrepared = true;

                    // setup a seek listener
                    mp.SetOnSeekCompleteListener( this );

                    // log the series they tapped on.
                    MessageAnalytic.Instance.Trigger( MessageAnalytic.Listen, Name );

                    // if this is a new video, store the URL
                    if ( App.Shared.Network.RockMobileUser.Instance.LastStreamingMediaUrl != MediaUrl )
                    {
                        App.Shared.Network.RockMobileUser.Instance.LastStreamingMediaUrl = MediaUrl;

                        PlayerState = MediaPlayerState.Playing;
                        mp.Start( );

                        SyncUI( );
                    }
                    else
                    {
                        // otherwise, resume where we left off
                        mp.SeekTo( (int)App.Shared.Network.RockMobileUser.Instance.LastStreamingMediaPos );
                    }
                }
 public void StopButton_Click(object sender, RoutedEventArgs e)
 {
     MessageService.SendMessageToBackground(new ForePlaybackChangedMessage(PlaybackState.Stopped));
     NowState = MediaPlayerState.Stopped;
     CurrentSong = null;
 }
                public override View OnCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState)
                {
                    if (container == null)
                    {
                        // Currently in a layout without a container, so no reason to create our view.
                        return null;
                    }

                    RelativeLayout view = new RelativeLayout( Rock.Mobile.PlatformSpecific.Android.Core.Context );
                    view.LayoutParameters = new RelativeLayout.LayoutParams( ViewGroup.LayoutParams.MatchParent, ViewGroup.LayoutParams.MatchParent );
                    view.SetBackgroundColor( Android.Graphics.Color.Black );
                    view.SetOnTouchListener( this );

                    ProgressBar = new ProgressBar( Rock.Mobile.PlatformSpecific.Android.Core.Context );
                    ProgressBar.Indeterminate = true;
                    ProgressBar.SetBackgroundColor( Rock.Mobile.UI.Util.GetUIColor( 0 ) );
                    ProgressBar.LayoutParameters = new RelativeLayout.LayoutParams( ViewGroup.LayoutParams.WrapContent, ViewGroup.LayoutParams.WrapContent );
                    ( (RelativeLayout.LayoutParams)ProgressBar.LayoutParameters ).AddRule( LayoutRules.CenterInParent );
                    view.AddView( ProgressBar );

                    // setup our media controller for viewing the position of media
                    MediaController = new MediaController( Rock.Mobile.PlatformSpecific.Android.Core.Context );
                    MediaController.SetAnchorView( view );

                    ResultView = new UIResultView( view, new System.Drawing.RectangleF( 0, 0, NavbarFragment.GetFullDisplayWidth( ), this.Resources.DisplayMetrics.HeightPixels ), 
                        delegate 
                        { 
                            // we know we're bound, so now just retry.
                            ResultView.Hide( );
                            PlayerState = MediaPlayerState.Preparing; 
                            StartAudio( );
                            SyncUI( );
                        });

                    return view;
                }
Esempio n. 53
0
 void Instance_CurrentStateChanged(object sender, RoutedEventArgs e)
 {
     mediaState = Instance.CurrentState;
     switch (mediaState)
     {
         case MediaPlayerState.Playing:
             Debug.WriteLine("Media State Changed: Playing");
             StatusChanged?.Invoke(this, MediaState.Playing);
             dispatchTimer?.Start();
             break;
         case MediaPlayerState.Paused:
             Debug.WriteLine("Media State Changed: Paused");
             StatusChanged?.Invoke(this, MediaState.Paused);
             dispatchTimer?.Stop();
             break;
     }
 }
                public override void OnCreate( Bundle savedInstanceState )
                {
                    base.OnCreate( savedInstanceState );

                    Rock.Mobile.Util.Debug.WriteLine( "OnCreate - Starting Audio Service" );

                    // flag that we want to automatically start the audio.
                    // If this fragment is backgrounded and resumed, this will be false and we won't
                    // attempt to play a second time.
                    PlayerState = MediaPlayerState.WantsAutoplay;

                    // start our audio service
                    Activity.StartService( new Intent( Activity, typeof( AudioService ) ) );

                    // create our connector that manages the interface between us and the service
                    AudioServiceConnection = new AudioServiceConnection( this );
                }
Esempio n. 55
0
 public void Pause()
 {
     if (!_mp.IsPlaying)
         return;
     _mpState = MediaPlayerState.Pause;
     _mediaController.Hide();
     _mp.Pause();
 }
 public BackPlaybackChangedMessage(MediaPlayerState now, SongModel song)
 {
     CurrentSong = song;
     NowState = now;
 }
 private void UpdateTransportControls(MediaPlayerState state)
 {
     if (state == MediaPlayerState.Playing)
     {
         playButton.Content = "| |";     // Change to pause button
     }
     else
     {
         playButton.Content = ">";     // Change to play button
     }
 }
Esempio n. 58
0
 public void Start()
 {
     if (_wasRelease || _mp.IsPlaying)
         return;
     if (_state == PrepareState.None)
     {
         Prepare();
         _shouldStart = true;
         return;
     }
     if (_state == PrepareState.Preparing)
         _shouldStart = true;
     else
     {
         _mpState = MediaPlayerState.Playing;
         _mp.Start();
     }
 }
Esempio n. 59
0
 public void Stop()
 {
     if (!_mp.IsPlaying)
         return;
     _mpState = MediaPlayerState.Stop;
     _mediaController.Hide();
     _mp.Stop();
 }
Esempio n. 60
0
                public bool OnError( MediaPlayer mp, MediaError error, int extra )
                {
                    ProgressBar.Visibility = ViewStates.Gone;

                    ResultView.Show( MessagesStrings.Error_Title,
                        PrivateControlStylingConfig.Result_Symbol_Failed,
                        MessagesStrings.Error_Watch_Playback,
                        GeneralStrings.Retry );

                    ResultView.SetBounds( new System.Drawing.RectangleF( 0, 0, NavbarFragment.GetFullDisplayWidth( ), this.Resources.DisplayMetrics.HeightPixels ) );

                    mp.Stop( );
                    mp.Reset( );
                    //Activity.UnbindService( AudioServiceConnection );

                    PlayerState = MediaPlayerState.Stopped;

                    SyncUI( );

                    return true;
                }