public void MediaStateChanged(MediaPlaybackState playbackState)
{
switch (playbackState)
{
case MediaPlaybackState.None:
break;
case MediaPlaybackState.Opening:
break;
case MediaPlaybackState.Buffering:
break;
case MediaPlaybackState.Playing:
//WORKAROUND: reactive value changed only after real value changed.
if (!IsVideosFlyoutVisible)
{
IsVideosFlyoutVisible = true;
}
IsVideosFlyoutVisible = false;
break;
case MediaPlaybackState.Paused:
break;
default:
break;
}
IsShowReleaseInfo = playbackState == MediaPlaybackState.Paused;
}
/// <summary>
/// Adjust the UI according to play/pause state
/// </summary>
/// <param name="state">The current playing state</param>
public async void SetActionState(MediaPlaybackState state)
{
if (state == MediaPlaybackState.Playing)
{
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
uiUpdateTimer.Start();
bool manualClick = Play.FocusState == FocusState.Keyboard;
Play.Visibility = Visibility.Collapsed;
Pause.Visibility = Visibility.Visible;
if (manualClick)
{
Pause.Focus(FocusState.Programmatic);
}
});
}
else
{
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
uiUpdateTimer.Stop();
bool manualClick = Pause.FocusState == FocusState.Keyboard;
Play.Visibility = Visibility.Visible;
Pause.Visibility = Visibility.Collapsed;
if (manualClick)
{
Play.Focus(FocusState.Programmatic);
}
});
}
}
public override PlaybackState GetState()
{
MediaPlaybackState state = player.PlaybackSession.PlaybackState;
if (ended && (state == MediaPlaybackState.Paused || state == MediaPlaybackState.None))
{
return(PlaybackState.Stopped);
}
else if (state == MediaPlaybackState.Opening || state == MediaPlaybackState.Buffering)
{
return(PlaybackState.Buffering);
}
else if (state == MediaPlaybackState.None)
{
return(PlaybackState.None);
}
else if (state == MediaPlaybackState.Paused)
{
return(PlaybackState.Paused);
}
else if (state == MediaPlaybackState.Playing)
{
return(PlaybackState.Playing);
}
return(PlaybackState.None);
}
public static MediaPlaybackState GetState(MediaPlaybackState state)
{
if (state == MediaPlaybackState.Opening)
{
return(MediaPlaybackState.Buffering);
}
return(state);
}
internal void PostMediaStateChangedEvent(MediaPlaybackState oldValue, MediaPlaybackState newValue)
{
LogEventStart(nameof(MediaStateChanged));
Library.GuiContext.EnqueueInvoke(() =>
{
MediaStateChanged?.Invoke(this, new MediaStateChangedEventArgs(oldValue, newValue));
LogEventDone(nameof(MediaStateChanged));
});
}
public void OnStateChange(MediaPlaybackState state)
{
Debug.WriteLine("OnStateChange");
JObject obj = new JObject();
obj.Add("state", (int)state);
SendEvent(Events.PlaybackState, obj);
}
private static bool IsToastActive(Music music, MediaPlaybackState state)
{
lock (CurrentToastMap)
{
return(CurrentToastMap.ContainsKey(new ToastKey {
Music = music, State = state
}));
}
}
protected void UpdateState(MediaPlaybackState state)
{
if (prevState == state)
{
return;
}
manager.OnStateChange(state);
prevState = state;
}
private void SetKeepDisplayWithCurrentState(MediaPlaybackState state)
{
if (state == MediaPlaybackState.Paused || state == MediaPlaybackState.None)
{
ExitKeepDisplay();
}
else
{
SetKeepDisplayIfEnable();
}
}
public override MediaPlaybackState GetState()
{
MediaPlaybackState state = player.PlaybackSession.PlaybackState;
if (ended && Utils.IsPaused(state))
{
state = MediaPlaybackState.None;
}
return(Utils.GetState(state));
}
private void OnPlaybackChanged(object sender, MediaPlaybackState e)
{
if (e == MediaPlaybackState.Playing)
{
_screensaverService.StartTimer();
}
else
{
_screensaverService.StopTimer();
}
}
private void OnPlaybackStateChanged(object sender, MediaPlaybackState e)
{
if (e == MediaPlaybackState.Paused)
{
PauseTimer();
}
else if (e == MediaPlaybackState.Opening || e == MediaPlaybackState.Playing)
{
PlayTimer();
}
}
private void UpdateTransportControls(MediaPlaybackState state)
{
nextButton.IsEnabled = true;
prevButton.IsEnabled = true;
if (state == MediaPlaybackState.Playing)
{
playButtonSymbol.Symbol = Symbol.Pause;
}
else
{
playButtonSymbol.Symbol = Symbol.Play;
}
}
private static ToastContent BuildToastContent(Music music, MediaPlaybackState state, NotificationDisplayMode display)
{
ToastButton controlButton = null;
switch (state)
{
case MediaPlaybackState.Paused:
controlButton = BuildToastButton("Play");
break;
case MediaPlaybackState.Playing:
controlButton = BuildToastButton("Pause");
break;
}
var toastContent = new ToastContent()
{
Visual = new ToastVisual()
{
BindingGeneric = new ToastBindingGeneric()
{
Children =
{
new AdaptiveText()
{
Text = music.GetToastText()
},
new AdaptiveProgressBar()
{
Value = new BindableProgressBarValue("MediaControlPosition"),
ValueStringOverride = MusicDurationConverter.ToTime(music.Duration),
Title = new BindableString("Lyrics"),
Status = new BindableString("MediaControlPositionTime")
}
}
}
},
Actions = new ToastActionsCustom()
{
Buttons =
{
controlButton, BuildToastButton("Next")
}
},
ActivationType = ToastActivationType.Background,
Launch = "Launch",
Audio = SlientToast,
Scenario = display == NotificationDisplayMode.Reminder || state == MediaPlaybackState.Paused ? ToastScenario.Reminder : ToastScenario.Default
};
return(toastContent);
}
private void ToggleMediaPlaybackState()
{
MediaPlayer mediaPlayer = musicPlayer.MediaPlayer;
MediaPlaybackState currState = mediaPlayer.PlaybackSession.PlaybackState;
if (currState == MediaPlaybackState.Playing)
{
mediaPlayer.Pause();
}
else if (currState == MediaPlaybackState.Paused || currState == MediaPlaybackState.None)
{
mediaPlayer.Play();
}
}
private OcSynthState PlayerStateToSynthState(MediaPlaybackState state)
{
if (state == MediaPlaybackState.Buffering || state == MediaPlaybackState.Opening || state == MediaPlaybackState.Playing)
{
return(OcSynthState.Busy);
}
else if (state == MediaPlaybackState.Paused)
{
return(OcSynthState.Paused);
}
else
{
return(OcSynthState.Ready);
}
}
private void UpdateTransportControls(MediaPlaybackState state)
{
Debug.WriteLine($"Enabling Prev/Next Buttons");
nextBtn.IsEnabled = true;
previousBtn.IsEnabled = true;
if (state == MediaPlaybackState.Playing)
{
playButtonSymbol.Symbol = Symbol.Pause;
Debug.WriteLine($"Media playing");
}
else
{
playButtonSymbol.Symbol = Symbol.Play;
Debug.WriteLine($"Media paused");
}
}
public void HandleNewState(MediaPlaybackState newState)
{
if (_currentState != newState)
{
if (newState == MediaPlaybackState.Playing)
{
PlayStart = DateTimeOffset.Now;
}
else if (newState == MediaPlaybackState.Paused)
{
TrackDuration(DateTimeOffset.Now);
PlayStart = default; // reset
}
_currentState = newState;
}
}
public static async Task ShowToast(Music music, MediaPlaybackState state)
{
if (!App.Inited)
{
return;
}
if (music == null ||
Settings.settings.NotificationSend == NotificationSendMode.Never ||
(state != MediaPlaybackState.Playing && state != MediaPlaybackState.Paused))
{
return;
}
NotificationDisplayMode display = Settings.settings.NotificationDisplay;
if (Window.Current.Visible && (display == NotificationDisplayMode.Normal || display == NotificationDisplayMode.Quick))
{
return;
}
if (IsToastActive(music, state))
{
return;
}
Helper.Print("show toast");
ToastNotification toast = await BuildToast(music, state, display);
lock (CurrentToastMap)
{
HideToast();
CurrentToastMap.TryAdd(new ToastKey {
Music = music, State = state
}, toast);
try
{
lock (Notifier)
{
Notifier.Show(toast);
Helper.Print("show toast, music: {0}, state: {1}", music.Name, state);
}
}
catch (Exception)
{
// 通知已发布
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MediaPlayerDialogAudioOutputAdapter"/> class.
/// </summary>
public MediaPlayerDialogAudioOutputAdapter()
{
this.mediaPlayer = new MediaPlayer()
{
AudioCategory = MediaPlayerAudioCategory.Speech,
Volume = 1.0,
};
this.mediaPlayer.PlaybackSession.PlaybackStateChanged += (session, _) =>
{
if (this.lastPlaybackState == MediaPlaybackState.Playing &&
session.PlaybackState != MediaPlaybackState.Playing)
{
this.OutputEnded?.Invoke();
}
this.lastPlaybackState = session.PlaybackState;
};
}
private static async Task <ToastNotification> BuildToast(Music music, MediaPlaybackState state, NotificationDisplayMode display)
{
string toastTag = null;
switch (state)
{
case MediaPlaybackState.Paused:
toastTag = ToastTagPlaying;
break;
case MediaPlaybackState.Playing:
toastTag = ToastTagPaused;
break;
}
var toastContent = BuildToastContent(music, state, display);
// Create the toast notification
ToastNotification toast = new ToastNotification(toastContent.GetXml())
{
Tag = toastTag,
Group = ToastGroup,
Data = new NotificationData()
{
SequenceNumber = 0
},
ExpiresOnReboot = true
};
if (Settings.settings.ShowLyricsInNotification)
{
await LyricsHelper.SetLyrics();
toast.Data.Values["Lyrics"] = LyricsHelper.GetLyrics();
}
if (display == NotificationDisplayMode.Quick)
{
toast.ExpirationTime = DateTime.Now.AddSeconds(Math.Min(10, music.Duration));
}
//toast.Dismissed += (sender, args) => HideToast("Dismissed");
toast.Data.Values["MediaControlPosition"] = MediaHelper.Progress.ToString();
toast.Data.Values["MediaControlPositionTime"] = MusicDurationConverter.ToTime(MediaHelper.Position);
return(toast);
}
/// <summary>
/// 更改音乐播放控件的显示状态
/// </summary>
/// <param name="state">播放器的播放状态</param>
private async void ChangeMusicPlayerVisibility(MediaPlaybackState state)
{
if (state == MediaPlaybackState.None)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
musicInfoGrid.Visibility = Visibility.Collapsed;
noneMusicStackPanel.Visibility = Visibility.Visible;
});
}
else
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
musicInfoGrid.Visibility = Visibility.Visible;
noneMusicStackPanel.Visibility = Visibility.Collapsed;
});
}
}
static void SyncState(MediaPlaybackState state)
{
if (previousState == state)
{
return;
}
previousState = state;
trackedPosition = 0;
Debug.WriteLine("Playback state:" + state);
switch (state)
{
case MediaPlaybackState.None:
Playlist.CurrentPlaylist.State.IsStreaming = false;
Playlist.CurrentPlaylist.State.IsPlaying = false;
Playlist.CurrentPlaylist.State.IsLoading = false;
break;
case MediaPlaybackState.Buffering:
Playlist.CurrentPlaylist.State.IsStreaming = true;
Playlist.CurrentPlaylist.State.IsPlaying = false;
Playlist.CurrentPlaylist.State.IsLoading = false;
break;
case MediaPlaybackState.Opening:
Playlist.CurrentPlaylist.State.IsStreaming = true;
Playlist.CurrentPlaylist.State.IsPlaying = false;
Playlist.CurrentPlaylist.State.IsLoading = true;
break;
case MediaPlaybackState.Paused:
Playlist.CurrentPlaylist.State.IsStreaming = false;
Playlist.CurrentPlaylist.State.IsPlaying = false;
Playlist.CurrentPlaylist.State.IsLoading = false;
break;
case MediaPlaybackState.Playing:
Playlist.CurrentPlaylist.State.IsStreaming = false;
Playlist.CurrentPlaylist.State.IsPlaying = true;
Playlist.CurrentPlaylist.State.IsLoading = false;
break;
}
}
protected void UpdateCurrentTrack(int index, IPromise promise)
{
if (queue.Count == 0)
{
Reset();
promise.Reject("queue", "The queue is empty");
return;
}
else if (index < 0)
{
index = 0;
}
else if (index >= queue.Count)
{
index = queue.Count - 1;
}
Track previous = GetCurrentTrack();
double position = GetPosition();
MediaPlaybackState oldState = GetState();
Debug.WriteLine("Updating current track...");
Track track = queue[index];
currentTrack = index;
Load(track, promise);
if (Utils.IsPlaying(oldState))
{
Play();
}
else if (Utils.IsPaused(oldState))
{
Pause();
}
manager.OnTrackUpdate(previous, position, track, true);
}
internal void SendOnMediaStateChanged(MediaPlaybackState oldValue, MediaPlaybackState newValue) => Connector?.OnMediaStateChanged(this, oldValue, newValue);
private void PlayerService_PlaybackStateChanged(object sender, MediaPlaybackState e)
{
OnPropertyChanged(nameof(AutomationName));
}
public CurrentStateChangedMessage(MediaPlaybackState state)
{
State = state;
}
private void PlaybackSession_PlaybackStateChanged(MediaPlaybackSession sender, object args)
{
CurrentState = sender.PlaybackState;
StateChanged?.Invoke(this, CurrentState);
}
public void SetPlaybackState(MediaPlaybackState state)
{
switch (state)
{
case MediaPlaybackState.None:
PlaybackStatus = MediaPlaybackStatus.Closed;
break;
case MediaPlaybackState.Opening:
PlaybackStatus = MediaPlaybackStatus.Changing;
break;
case MediaPlaybackState.Buffering:
PlaybackStatus = MediaPlaybackStatus.Changing;
break;
case MediaPlaybackState.Playing:
PlaybackStatus = MediaPlaybackStatus.Playing;
break;
case MediaPlaybackState.Paused:
PlaybackStatus = MediaPlaybackStatus.Paused;
break;
default:
break;
}
}
public static MediaPlaybackState DefinedOrDefault(this MediaPlaybackState state)
{
return(Enum.IsDefined(typeof(MediaPlaybackState), state) ? state : MediaPlaybackState.Unknown);
}
private void PlayerService_PlaybackStateChanged(object sender, MediaPlaybackState e)
{
OnPropertyChanged(nameof(IsCurrentlyPlaying));
}
/// <inheritdoc /> public void OnMediaStateChanged(MediaEngine sender, MediaPlaybackState oldValue, MediaPlaybackState newValue) => Parent?.PostMediaStateChangedEvent(oldValue, newValue);
private void UpdateTransportControls(MediaPlaybackState state)
{
nextButton.IsEnabled = true;
prevButton.IsEnabled = true;
if (state == MediaPlaybackState.Playing)
{
playButtonSymbol.Symbol = Symbol.Pause;
}
else
{
playButtonSymbol.Symbol = Symbol.Play;
}
}
