private void PositionChanged(MediaPlaybackSession sender, object args)
{
if (sender.Position >= sender.NaturalDuration && playbackList.CurrentItemIndex == playbackList.Items.Count - 1)
{
IsCurrentlyPlaying = false;
}
}
private async void PlaybackSession_PlaybackStateChanged(MediaPlaybackSession sender, object args)
{
await AssociatedObject.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
CurrentPlaybackState = AssociatedObject.MediaPlayer.PlaybackSession.PlaybackState;
});
}
private static void GetMinMaxRates(MediaPlaybackSession sender, out double minRate, out double maxRate)
{
minRate = -256.0;
bool foundMinRate = false;
for (; !foundMinRate; minRate = minRate / 2.0)
{
foundMinRate = sender.IsSupportedPlaybackRateRange(minRate, 1);
if (-0.25 < minRate)
{
foundMinRate = true;
minRate = 0;
}
}
maxRate = 256.0;
bool foundMaxRate = false;
for (; !foundMaxRate; maxRate = maxRate / 2.0)
{
foundMaxRate = sender.IsSupportedPlaybackRateRange(1, maxRate);
if (maxRate < 1.0)
{
foundMaxRate = true;
maxRate = 1;
}
}
}
private void MediaPlayer_PlaybackSession_SupportedPlaybackRatesChanged(MediaPlaybackSession sender, object args)
{
double minRate, maxRate;
GetMinMaxRates(sender, out minRate, out maxRate);
logView.Log($"MediaPlayer_PlaybackSession_SupportedPlaybackRatesChanged, MinRate: {minRate}, MaxRate: {maxRate}", LogViewLoggingLevel.Information);
}
private void PlaybackSession_PlaybackStateChanged(MediaPlaybackSession sender, object args)
{
switch (sender.PlaybackState)
{
case MediaPlaybackState.Buffering:
case MediaPlaybackState.Opening:
//show pause
IsPlaying = true;
MediaTransportControls.PlaybackStatus = MediaPlaybackStatus.Changing;
break;
case MediaPlaybackState.Paused:
case MediaPlaybackState.None:
//show play
IsPlaying = false;
MediaTransportControls.PlaybackStatus = MediaPlaybackStatus.Paused;
break;
case MediaPlaybackState.Playing:
//show pause
IsPlaying = true;
MediaTransportControls.PlaybackStatus = MediaPlaybackStatus.Playing;
break;
}
IsPlayingChanged?.Invoke(this, new NepAppMediaPlayerManagerIsPlayingEventArgs(IsPlaying));
}
public AudioController()
{
App.Startup();
#region Rpc
_acRpcServer = new AudioControllerRpcServer(this);
_achRpcClient = new AudioControllerHandlerRpcClient();
_audioControllerHandler = _achRpcClient.Service;
#endregion
_stateMachine = BuildStateMachine();
_mediaEnvironment.RegisterDefaultCodecs();
_playModeManager = IoC.Get<IPlayModeManager>();
_mediaPlayer = BackgroundMediaPlayer.Current;
_mediaPlayer.AutoPlay = false;
_mediaPlayer.MediaOpened += mediaPlayer_MediaOpened;
_mediaPlayer.MediaFailed += mediaPlayer_MediaFailed;
_mediaPlayer.MediaEnded += mediaPlayer_MediaEnded;
_playbackSession = _mediaPlayer.PlaybackSession;
_playbackSession.PlaybackStateChanged += playbackSession_PlaybackStateChanged;
_playbackSession.NaturalDurationChanged += playbackSession_NaturalDurationChanged;
_playbackSession.SeekCompleted += playbackSession_SeekCompleted;
_mtService = new MediaTransportService(_mediaPlayer.SystemMediaTransportControls);
_mtService.IsEnabled = _mtService.IsPauseEnabled = _mtService.IsPlayEnabled = true;
_mtService.ButtonPressed += _mtService_ButtonPressed;
NotifyReady();
}
private async void PlaybackSession_PositionChanged(MediaPlaybackSession sender, object o)
{
if (_soundPosList == null)
{
//Dbg.d("_soundPosList == null " + (_soundPosList == null));
return;
}
int par = paragraphBySoundPos(sender.Position.TotalMilliseconds);
if (par < 0 || par == _curParagraph)
{
//Dbg.d("par " + par + " _curParagraph " + _curParagraph);
return;
}
_curParagraph = par;
_chapter.Paragraph = par;
//Dbg.d("_curParagraph " + _curParagraph);
//if (AppData.Settings.ScrollMode != Settings.Scroll.None)
scrollToPar(par);
if (AppData.Settings.AudioPlayMode == Settings.AudioPlayModeType.None ||
AppData.Settings.AudioPlayMode == Settings.AudioPlayModeType.Paragraph)
{
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
MyPlayer.MediaPlayer.Pause();
});
}
}
private void PlaybackSession_PlaybackStateChanged(MediaPlaybackSession sender, object args)
{
switch (sender.PlaybackState)
{
case MediaPlaybackState.None:
CurrentState.Value = MediaElementState.Closed;
break;
case MediaPlaybackState.Opening:
CurrentState.Value = MediaElementState.Opening;
break;
case MediaPlaybackState.Buffering:
CurrentState.Value = MediaElementState.Buffering;
break;
case MediaPlaybackState.Playing:
CurrentState.Value = MediaElementState.Playing;
break;
case MediaPlaybackState.Paused:
CurrentState.Value = MediaElementState.Paused;
break;
default:
break;
}
}
private async void PlaybackSession_PositionChanged(MediaPlaybackSession sender, object args)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
MediaPlayerViewModel.UpdatePosition();
});
}
private async void MediaPlayer_PlaybackSession_PlaybackStateChanged(MediaPlaybackSession sender, object args)
{
Log($"PlaybackSession_PlaybackStateChanged, PlaybackState: {sender.PlaybackState}");
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
switch (sender.PlaybackState)
{
case MediaPlaybackState.None:
case MediaPlaybackState.Opening:
case MediaPlaybackState.Buffering:
PlayButton.IsEnabled = false;
PauseButton.IsEnabled = false;
break;
case MediaPlaybackState.Playing:
PlayButton.IsEnabled = false;
PauseButton.IsEnabled = true;
break;
case MediaPlaybackState.Paused:
PlayButton.IsEnabled = true;
PauseButton.IsEnabled = false;
break;
default:
break;
}
});
}
private void MediaPlayer_PlaybackSession_PositionChanged(MediaPlaybackSession sender, object args)
{
if (logPositionChanged)
{
logView.Log("PlaybackSession_PositionChanged, Position: " + sender.Position, LogViewLoggingLevel.Verbose);
}
}
private async void OnPlaybackStateChanged(MediaPlaybackSession sender, object args)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
switch (sender.PlaybackState)
{
case MediaPlaybackState.Opening:
case MediaPlaybackState.Buffering:
case MediaPlaybackState.Playing:
if (_request == null)
{
_request = new DisplayRequest();
_request.RequestActive();
}
break;
default:
if (_request != null)
{
_request.RequestRelease();
_request = null;
}
break;
}
});
}
private async void PlaybackSession_BufferingProgressChanged(MediaPlaybackSession sender, object args)
{
await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
PlayerLoadText.Text = sender.BufferingProgress.ToString("p");
});
}
private async void PlaybackSession_BufferingEnded(MediaPlaybackSession sender, object args)
{
await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
PlayerLoading.Visibility = Visibility.Collapsed;
});
}
private async void PlaybackSession_PositionChangedAsync(MediaPlaybackSession sender, object args)
{
if (Math.Abs((state.Position - sender.Position).TotalMilliseconds) < 200)
{
return;
}
try
{
state.Position = sender.Position;
await state.Save(((App)Application.Current).ApplicationStateFile);
}
catch { }
if (isUpdatingPosition)
{
return;
}
isUpdatingPosition = true;
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
sldPosition.Value = sender.Position.TotalSeconds;
tblPosition.Text = ApplicationState.ConvertToString(sender.Position);
});
isUpdatingPosition = false;
}
private void OnPlaybackStateChanged(MediaPlaybackSession sender, object args)
{
if (sender.PlaybackState == MediaPlaybackState.Playing && sender.PlaybackRate != _playbackRate)
{
sender.PlaybackRate = _playbackRate;
}
switch (sender.PlaybackState)
{
case MediaPlaybackState.Playing:
_transport.PlaybackStatus = MediaPlaybackStatus.Playing;
break;
case MediaPlaybackState.Paused:
_transport.PlaybackStatus = MediaPlaybackStatus.Paused;
break;
case MediaPlaybackState.None:
_transport.PlaybackStatus = MediaPlaybackStatus.Stopped;
break;
}
//else if (sender.PlaybackState == MediaPlaybackState.Paused && sender.Position == sender.NaturalDuration && _playlist.CurrentItem == _playlist.Items.LastOrDefault())
//{
// Clear();
//}
//else
//{
// Debugger.Break();
//}
PlaybackStateChanged?.Invoke(this, args);
}
/**
* シークが完了したときの処理
* - フレームサムネイルを作成
*/
private async void PBS_SeekCompletedForExtractFrames(MediaPlaybackSession session, object args)
{
if (mSpan == 0 || !mGettingFrame)
{
return;
}
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
var mediaPlayer = session.MediaPlayer;
extractFrame(mediaPlayer);
if (mFrame < mFrameCount - 1)
{
mFrame++;
session.Position = TimeSpan.FromMilliseconds(mOffset + mSpan *mFrame);
}
else
{
// OK, Movie is ready now!
mGettingFrame = false;
PlaybackSession.Position = TimeSpan.FromMilliseconds(0);
MediaPlayer.IsVideoFrameServerEnabled = CTX.CustomDrawing;
mSlider.Value = 0;
CTX.TotalRange = session.NaturalDuration.TotalMilliseconds;
CTX.MoviePrepared = true;
}
});
}
private async void PlaybackSession_PlaybackStateChanged(MediaPlaybackSession sender, object args)
{
if (sender is MediaPlaybackSession playbackSession && playbackSession.NaturalVideoHeight != 0)
{
if (playbackSession.PlaybackState == MediaPlaybackState.Playing)
{
if (!_isRequestActive)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
_displayRequest.RequestActive();
_isRequestActive = true;
});
}
}
else
{
if (_isRequestActive)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
_displayRequest.RequestRelease();
_isRequestActive = false;
});
}
}
}
}
private void MediaPlayerElement_CurrentStateChanged(object sender, RoutedEventArgs e)
{
MediaPlaybackSession playbackSession = sender as MediaPlaybackSession;
if (playbackSession != null && playbackSession.NaturalVideoHeight != 0)
{
if (playbackSession.PlaybackState == MediaPlaybackState.Playing)
{
if (appDisplayRequest == null)
{
// This call creates an instance of the DisplayRequest object
appDisplayRequest = new DisplayRequest();
appDisplayRequest.RequestActive();
}
}
else // PlaybackState is Buffering, None, Opening or Paused
{
if (appDisplayRequest != null)
{
// Deactivate the displayr request and set the var to null
appDisplayRequest.RequestRelease();
appDisplayRequest = null;
}
}
}
}
private async void Player_PositionChanged(MediaPlaybackSession sender, object args)
{
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () =>
{
WatchTime = (int)sender.Position.TotalSeconds;
});
}
// <SnippetBufferingProgressChanged>
private async void PlaybackSession_BufferingProgressChanged(MediaPlaybackSession sender, object args)
{
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
bufferingProgressBar.Value = sender.BufferingProgress;
});
}
private void OnBufferingProgressChanged(MediaPlaybackSession sender, object args)
{
Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
_downloadProgressIndicator.Maybe(p => p.Value = (double)args);
});
}
private async void mediaPlayer_PlaybackStateChanged(MediaPlaybackSession sender, object e)
{
// UI updates must happen on dispatcher thread
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
if (!isThisPageActive)
{
return;
}
// For the design of this sample, the general idea is that if user is playing
// media when Next/Previous is invoked, we will automatically start playing
// the new item once it has loaded. Whereas if the user has paused or stopped
// media playback when Next/Previous is invoked, we won't automatically start
// playing the new item. In other words, we maintain the user's intent to
// play or not play across changing the media. This is most easily handled
// using the AutoPlay property of the MediaPlayer.
if (mediaPlayer.PlaybackSession.PlaybackState == MediaPlaybackState.Playing)
{
mediaPlayer.AutoPlay = true;
}
else if (mediaPlayer.PlaybackSession.PlaybackState == MediaPlaybackState.None ||
mediaPlayer.PlaybackSession.PlaybackState == MediaPlaybackState.Paused)
{
mediaPlayer.AutoPlay = false;
}
// Update the playback status tracked by SystemMediaTransportControls. See comments
// in SyncPlaybackStatusToMediaPlayerState()'s body for why this is important.
SyncPlaybackStatusToMediaPlayerState();
});
}
private void PlaybackSession_PlaybackStateChanged(MediaPlaybackSession sender, object args)
{
_scheduler.Schedule(() =>
{
SetKeepDisplayWithCurrentState(sender.PlaybackState);
});
}
/**
* 再生状態が変化した
* - CTX.IsPlaying の更新
*/
private async void PBS_PlaybackStateChanged(MediaPlaybackSession session, object args)
{
if (mGettingFrame)
{
return;
}
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
switch (session.PlaybackState)
{
case MediaPlaybackState.None:
case MediaPlaybackState.Buffering:
case MediaPlaybackState.Opening:
CTX.MoviePrepared = false;
CTX.IsPlaying = false;
break;
case MediaPlaybackState.Paused:
default:
CTX.IsPlaying = false;
updateSliderPosition(session.Position.TotalMilliseconds);
break;
case MediaPlaybackState.Playing:
CTX.IsPlaying = true;
break;
}
});
}
private void PlaybackSession_SeekCompleted(MediaPlaybackSession sender, object args)
{
OnPlaybackPositionChanged(new PlaybackPositionChangedEventArgs()
{
Time = _mediaPlayer.PlaybackSession.Position
});
}
private void PlaybackSession_PlaybackStateChanged(MediaPlaybackSession sender, object args)
{
switch (sender.PlaybackState)
{
case MediaPlaybackState.Playing:
PlayerState = PlaybackState.Playing;
break;
case MediaPlaybackState.Paused:
PlayerState = PlaybackState.Paused;
break;
default:
PlayerState = PlaybackState.Other;
Position = 0;
Duration = 0;
break;
}
if (CloudService.Instance.State == ServiceState.Connected &&
CloudService.Instance.ParticipationType == ParticipationType.Host)
{
CloudService.Instance.SendStatusUpdate(GetStatus());
}
}
private void PlaybackSession_PositionChanged(MediaPlaybackSession sender, object args)
{
_ = _dispatcherQueue.TryEnqueue(() =>
{
VideoPosition = sender.Position;
});
}
private async void PlaybackSession_PlaybackStateChanged(MediaPlaybackSession sender, object args)
{
await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
switch (sender.PlaybackState)
{
case MediaPlaybackState.None:
break;
case MediaPlaybackState.Opening:
PlayerLoading.Visibility = Visibility.Visible;
PlayerLoadText.Text = "加载中";
break;
case MediaPlaybackState.Buffering:
PlayerLoading.Visibility = Visibility.Visible;
break;
case MediaPlaybackState.Playing:
BottomBtnPlay.Visibility = Visibility.Collapsed;
BottomBtnPause.Visibility = Visibility.Visible;
break;
case MediaPlaybackState.Paused:
BottomBtnPlay.Visibility = Visibility.Visible;
BottomBtnPause.Visibility = Visibility.Collapsed;
break;
default:
break;
}
});
}
private void PlaybackSession_PlaybackStateChanged(MediaPlaybackSession sender, object args)
{
switch (sender.PlaybackState)
{
case MediaPlaybackState.None:
showPasue = false;
showPlay = true;
break;
case MediaPlaybackState.Opening:
showPasue = false;
showPlay = true;
break;
case MediaPlaybackState.Buffering:
showPasue = false;
showPlay = true;
break;
case MediaPlaybackState.Playing:
showPasue = true;
showPlay = false;
break;
case MediaPlaybackState.Paused:
showPasue = false;
showPlay = true;
break;
default:
break;
}
}
private void OnPlaybackStateChanged(MediaPlaybackSession sender, object args)
{
var state = (MediaPlaybackState)args;
switch (state)
{
case MediaPlaybackState.Opening:
case MediaPlaybackState.Paused:
case MediaPlaybackState.None:
CancelControlsVisibilityTimer();
VisualStateManager.GoToState(this, "PlayState", false);
VisualStateManager.GoToState(this, "Normal", false);
break;
case MediaPlaybackState.Playing:
ResetControlsVisibilityTimer();
VisualStateManager.GoToState(this, "PauseState", false);
VisualStateManager.GoToState(this, "Normal", false);
break;
case MediaPlaybackState.Buffering:
VisualStateManager.GoToState(this, "Buffering", false);
break;
}
}
public PlaybackSessionViewModel(MediaPlaybackSession playbackSession, CoreDispatcher dispatcher)
{
this.player = playbackSession.MediaPlayer;
this.playbackSession = playbackSession;
this.dispatcher = dispatcher;
playbackSession.PlaybackStateChanged += PlaybackSession_PlaybackStateChanged;
}
private async void PlaybackSession_PlaybackStateChanged(MediaPlaybackSession sender, object args)
{
if (disposed) return;
await dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
if (disposed) return;
RaisePropertyChanged("PlaybackState");
});
}
private void playbackSession_NaturalDurationChanged(MediaPlaybackSession sender, object args)
{
_audioControllerHandler.OnNaturalDurationChanged(_playbackSession.NaturalDuration);
}
private void playbackSession_SeekCompleted(MediaPlaybackSession sender, object args)
{
var taskComp = Interlocked.Exchange(ref _seekTaskCompletion, null);
if (taskComp != null)
taskComp.SetResult(null);
}
private async void mediaPlayer_PlaybackStateChanged(MediaPlaybackSession sender, object e)
{
// UI updates must happen on dispatcher thread
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
if (!isThisPageActive)
{
return;
}
// For the design of this sample, the general idea is that if user is playing
// media when Next/Previous is invoked, we will automatically start playing
// the new item once it has loaded. Whereas if the user has paused or stopped
// media playback when Next/Previous is invoked, we won't automatically start
// playing the new item. In other words, we maintain the user's intent to
// play or not play across changing the media. This is most easily handled
// using the AutoPlay property of the MediaPlayer.
if (mediaPlayer.PlaybackSession.PlaybackState == MediaPlaybackState.Playing)
{
mediaPlayer.AutoPlay = true;
}
else if (mediaPlayer.PlaybackSession.PlaybackState == MediaPlaybackState.None ||
mediaPlayer.PlaybackSession.PlaybackState == MediaPlaybackState.Paused)
{
mediaPlayer.AutoPlay = false;
}
// Update the playback status tracked by SystemMediaTransportControls. See comments
// in SyncPlaybackStatusToMediaPlayerState()'s body for why this is important.
SyncPlaybackStatusToMediaPlayerState();
});
}
private void playbackSession_PlaybackStateChanged(MediaPlaybackSession sender, object args)
{
Execute.BeginOnUIThread(OnPlaybackStateChanged);
}
private void MediaPlayer_PlaybackSession_BufferingStarted(MediaPlaybackSession sender, object args)
{
Log("PlaybackSession_BufferingStarted");
}
private void MediaPlayer_PlaybackSession_BufferingProgressChanged(MediaPlaybackSession sender, object args)
{
Log($"PlaybackSession_BufferingProgressChanged, BufferingProgress: {sender.BufferingProgress}");
}
// private void MediaPlayer_PlaybackSession.PositionChanged(MediaPlaybackSession sender, object args)
// {
// LogOnUI("PlaybackSession_PositionChanged, Position: " + sender.Position);
// }
private void MediaPlayer_PlaybackSession_SeekCompleted(MediaPlaybackSession sender, object args)
{
Log($"PlaybackSession_SeekCompleted, Position: {sender.Position}");
}
private void MediaPlayer_PlaybackSession_PlaybackStateChanged(MediaPlaybackSession sender, object args)
{
Log($"PlaybackSession_PlaybackStateChanged, PlaybackState: {sender.PlaybackState}");
}
private void MediaPlayer_PlaybackSession_NaturalVideoSizeChanged(MediaPlaybackSession sender, object args)
{
Log($"PlaybackSession_NaturalVideoSizeChanged, NaturalVideoWidth: {sender.NaturalVideoWidth}, NaturalVideoHeight: {sender.NaturalVideoHeight}");
}
private void MediaPlayer_PlaybackSession_NaturalDurationChanged(MediaPlaybackSession sender, object args)
{
Log($"PlaybackSession_NaturalDurationChanged, NaturalDuration: {sender.NaturalDuration}");
}
private void MediaPlayer_PlaybackSession_DownloadProgressChanged(MediaPlaybackSession sender, object args)
{
Log($"PlaybackSession_DownloadProgressChanged, DownloadProgress: {sender.DownloadProgress}");
}
private void PlaybackSession_PlaybackStateChanged(MediaPlaybackSession sender, object args)
{
CurrentState = sender.PlaybackState;
StateChanged?.Invoke(this, CurrentState);
}
/// <summary>
/// MediaPlayer state changed event handlers.
/// Note that we can subscribe to events even if Media Player is playing media in background
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
///
private async void PlaybackSession_PlaybackStateChanged(MediaPlaybackSession sender, object args)
{
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
var currentState = sender.PlaybackState;
// Update state label
txtCurrentState.Text = currentState.ToString();
// Update controls
UpdateTransportControls(currentState);
});
}
