private void MessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
ValueSet valueSet = e.Data;
foreach (string key in valueSet.Keys)
{
switch (key)
{
case "Title":
Titolo = valueSet[key].ToString();
break;
case "Artist":
Artista = valueSet[key].ToString();
break;
case "Play":
Debug.WriteLine("Starting Playback");
Play(valueSet[key].ToString());
break;
}
}
}
private void BackgroundMediaPlayerOnMessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
systemmediatransportcontrol.DisplayUpdater.Type = MediaPlaybackType.Music;
systemmediatransportcontrol.DisplayUpdater.MusicProperties.Title = e.Data["Title"].ToString();
systemmediatransportcontrol.DisplayUpdater.MusicProperties.Artist = e.Data["Artist"].ToString();
systemmediatransportcontrol.DisplayUpdater.Update();
}
private void OnMessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
foreach (var valuePair in e.Data)
{
switch (valuePair.Key)
{
case "SetSource":
Debug.WriteLine("Setting source to '{0}'", valuePair.Value);
try
{
BackgroundMediaPlayer.Current.SetUriSource(new Uri(valuePair.Value.ToString()));
}
catch (Exception ex)
{
Debug.WriteLine("Unable to set player source: {0}", ex.Message);
// TODO: Must send exception to app and the app must report to Insights
}
break;
case "StartPlayback": // Foreground App process has signalled that it is ready for playback
Debug.WriteLine("Starting Playback");
BackgroundMediaPlayer.Current.Play();
break;
}
}
}
/// <summary>
/// Raised when a message is recieved from the foreground app
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void BackgroundMediaPlayer_MessageReceivedFromForeground(object sender,
MediaPlayerDataReceivedEventArgs e)
{
var message = MessageHelper.ParseMessage(e.Data);
if (message is AppSuspendedMessage)
{
AppSuspended?.Invoke(this, null);
}
else if (message is AppResumedMessage)
{
AppResumed?.Invoke(this, null);
}
else if (message is StartPlaybackMessage)
{
StartPlayback?.Invoke(this, null);
}
else if (message is SkipNextMessage)
{
SkipToNext?.Invoke(this, null);
}
else if (message is SkipPreviousMessage)
{
SkipToPrev?.Invoke(this, null);
}
else
{
var changedMessage = message as TrackChangedMessage;
if (changedMessage != null)
{
TrackChanged?.Invoke(this, changedMessage.QueueId);
}
else
{
var playlistMessage = message as UpdatePlaylistMessage;
if (playlistMessage != null)
{
UpdatePlaylist?.Invoke(this, playlistMessage.Tracks);
}
else
{
var addMessage = message as AddToPlaylistMessage;
if (addMessage != null)
{
AddToPlaylist?.Invoke(addMessage.Tracks, addMessage.Position);
}
else
{
var updateMessage = message as UpdateUrlMessage;
if (updateMessage != null)
{
TrackUpdateUrl?.Invoke(this, updateMessage);
}
}
}
}
}
}
private void BackgroundMediaPlayer_MessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
string tag, content;
AudioRpc.DestructMessage(e.Data, out tag, out content);
if (tag == AudioRpc.RpcMessageTagAudioController)
_dispatcher.Receive(JsonConvert.DeserializeObject<RpcPacket>(content, AudioRpc.JsonSettings));
}
/// <summary>
/// Fires when a message is recieved from the foreground app
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void BackgroundMediaPlayer_MessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
foreach (string key in e.Data.Keys)
{
switch (key.ToLower())
{
case Constants.AppSuspended:
Debug.WriteLine("App suspending"); // App is suspended, you can save your task state at this point
foregroundAppState = ForegroundAppStatus.Suspended;
ApplicationSettingsHelper.SaveSettingsValue(Constants.CurrentTrack, Playlist.CurrentTrackName);
ApplicationSettingsHelper.SaveSettingsValue(Constants.BackgroundTaskState, Constants.BackgroundTaskRunning);
break;
case Constants.AppResumed:
Debug.WriteLine("App resuming"); // App is resumed, now subscribe to message channel
foregroundAppState = ForegroundAppStatus.Active;
break;
case Constants.StartPlayback: //Foreground App process has signalled that it is ready for playback
Debug.WriteLine("Starting Playback");
StartPlayback();
break;
case Constants.SkipNext: // User has chosen to skip track from app context.
Debug.WriteLine("Skipping to next");
SkipToNext();
break;
case Constants.SkipPrevious: // User has chosen to skip track from app context.
Debug.WriteLine("Skipping to previous");
SkipToPrevious();
break;
}
}
}
async private void BackgroundMessageRecieved(object sender, MediaPlayerDataReceivedEventArgs e)
{
await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
media.Stop();
});
}
void BackgroundMediaPlayer_MessageReceivedFromBackground(object sender, MediaPlayerDataReceivedEventArgs e)
{
TrackChangedMessage trackChangedMessage;
if (MessageService.TryParseMessage(e.Data, out trackChangedMessage))
{
Logger.LogInfo(this, "Received TrackChangedMessage from Background");
Debug.WriteLine("ShellViewModel.BackgroundMediaPlayer_MessageReceivedFromBackground: Received TrackChangedMessage from Background");
var track = GetTrackFromStreamURL(trackChangedMessage.TrackId.ToString());
if (track != null)
{
TrackHistoryService.AddTrackHistory(new TrackHistoryToAdd()
{
UserID = App.User.id, TrackID = (int)track.id
});
}
}
BackgroundAudioTaskStartedMessage backgroundAudioTaskStartedMessage;
if (MessageService.TryParseMessage(e.Data, out backgroundAudioTaskStartedMessage))
{
backgroundAudioTaskStarted.Set();
return;
}
PlaybackListEmptyMessage playbackListEmptyMessage;
if (MessageService.TryParseMessage(e.Data, out playbackListEmptyMessage))
{
App.PlaylistManager.StopPlayer();
return;
}
}
private void MessageRecieved(object sender, MediaPlayerDataReceivedEventArgs e)
{
var episode = e.Data.ToObject <Episode>();
confirmations[episode] = true;
signal.Release();
confirmations.Clear();
}
/// <summary>
/// Вызывается при получении сообщения от задачи переднего плана.
/// </summary>
private async void MessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
foreach (string key in e.Data.Keys)
{
_operationCompleted.WaitOne();
_operationCompleted.Reset();
switch (key)
{
case UPDATE_PLAYLIST:
await _manager.Update();
break;
case PLAYER_SHUFFLE_MODE:
await _manager.UpdateShuffleMode();
break;
case PLAYER_REPEAT_MODE:
_manager.UpdateRepeatMode();
break;
case PLAYER_TRACK_ID:
_manager.PlayTrackFromID((int)e.Data[key]);
break;
case PLAYER_PLAY_PAUSE:
_manager.PlayResume();
break;
case PLAYER_NEXT_TRACK:
_manager.NextTrack();
break;
case PLAYER_PREVIOUS_TRACK:
_manager.PreviousTrack();
break;
case APP_RUNNING:
_isAppRunning = (bool)e.Data[key];
break;
case UPDATE_LAST_FM:
await _manager.UpdateLastFm();
break;
case PLAYER_SCROBBLE_MODE:
_manager.UpdateScrobbleMode();
break;
}
_operationCompleted.Set();
}
}
private void BackgroundMediaPlayer_MessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
foreach (var item in e.Data)
{
if (item.Key == "uri")
{
// BackgroundMediaPlayer.Current.(e.Data["uri"] as string);
}
}
}
void OnMessageReceivedFromBackground(object sender, MediaPlayerDataReceivedEventArgs mediaPlayerDataReceivedEventArgs)
{
//Debug.WriteLine("MediaPlayerHandle.OnMessageReceivedFromBackground()");
if (!_subscriptionHandle.IsSubscribed)
{
return;
}
_notificationQueue.Submit(mediaPlayerDataReceivedEventArgs.Data);
}
void BackgroundMediaPlayerOnMessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs mediaPlayerDataReceivedEventArgs)
{
//Debug.WriteLine("BackgroundAudioRun.BackgroundMediaPlayerOnMessageReceivedFromForeground() " + _id);
if (_completionSource.Task.IsCompleted)
{
return;
}
_notificationQueue.Submit(mediaPlayerDataReceivedEventArgs.Data);
}
private async void OnMessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
var data = e.Data;
var episode = e.Data.ToObject<Episode>();
if (episode != null)
{
BackgroundMediaPlayer.SendMessageToForeground(episode.ToValueSet());
await PlayEpisodeAsync(episode);
UpdateSystemControls(episode);
}
}
void BackgroundMediaPlayer_MessageReceivedFromBackground(object sender, MediaPlayerDataReceivedEventArgs e)
{
foreach (string key in e.Data.Keys)
{
switch (key)
{
case AppConstants.SongIndex:
DispatcherHelper.CheckBeginInvokeOnUI(() =>
{
CurrentSongIndex = Int32.Parse(e.Data[key].ToString());
try
{
SongItem song = Library.Current.NowPlayingList.ElementAt(CurrentSongIndex);
SetCover(song.Path);
Artist = song.Artist;
Title = song.Title;
}
catch (System.IndexOutOfRangeException ex)
{
SetDefaultCover();
Artist = "-";
Title = "-";
NextPlayerDataLayer.Diagnostics.Logger.Save("Main Page MesRecFromBG SongIndex IndexOutOfRangeException" + "\n"
+ ex.Message + "\n"
+ "NPList Count " + Library.Current.NowPlayingList.Count + " index " + CurrentSongIndex);
NextPlayerDataLayer.Diagnostics.Logger.SaveToFile();
}
catch (Exception ex)
{
SetDefaultCover();
Artist = "-";
Title = "-";
NextPlayerDataLayer.Diagnostics.Logger.Save("Main Page MesRecFromBG SongIndex" + "\n"
+ ex.Message + "\n"
+ "NPList Count " + Library.Current.NowPlayingList.Count + " index " + CurrentSongIndex);
NextPlayerDataLayer.Diagnostics.Logger.SaveToFile();
}
});
break;
//case AppConstants.PlayerClosed://! mozna usunac
// DispatcherHelper.CheckBeginInvokeOnUI(() =>
// {
// RemoveMediaPlayerEventHandlers();
// });
// break;
case AppConstants.BackgroundTaskStarted:
SererInitialized.Set();
break;
}
}
}
private void OnBackgroundMessage(object sender, MediaPlayerDataReceivedEventArgs e)
{
BackgroundAudioTaskStartedMessage backgroundAudioTaskStartedMessage;
if (MessageService.TryParseMessage(e.Data, out backgroundAudioTaskStartedMessage))
{
// StartBackgroundAudioTask is waiting for this signal to know when the task is up and running
// and ready to receive messages
Debug.WriteLine("BackgroundAudioTask started");
backgroundAudioTaskStarted.Set();
return;
}
}
private void BackgroundMediaPlayer_MessageReceivedFromBackground(object sender,
MediaPlayerDataReceivedEventArgs e)
{
foreach (var key in e.Data.Keys)
{
switch (key)
{
case PlayerConstants.Trackchanged:
RaiseEvent(TrackChanged);
break;
}
}
}
private async void OnMessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
var data = e.Data;
var episode = e.Data.ToObject <Episode>();
if (episode != null)
{
BackgroundMediaPlayer.SendMessageToForeground(episode.ToValueSet());
await PlayEpisodeAsync(episode);
UpdateSystemControls(episode);
}
}
async void HandleBackgroundMediaPlayerMessageReceivedFromBackground(object sender, MediaPlayerDataReceivedEventArgs e)
{
foreach (string key in e.Data.Keys)
{
switch (key)
{
case PlayQueueMessageHelper.BackgroundStarted:
BackgroundInitialized.Set();
break;
case PlayQueueMessageHelper.SeekComplete:
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
isScrubInProgress = false;
CurrentTime = BackgroundMediaPlayer.Current.Position;
});
break;
case PlayQueueMessageHelper.TrackChanged:
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
if (!isScrubInProgress)
{
CurrentTime = BackgroundMediaPlayer.Current.Position;
}
else
{
CurrentTime = TimeSpan.Zero;
}
FullTime = BackgroundMediaPlayer.Current.NaturalDuration;
CurrentPlaybackQueueEntryId = DebugHelper.CastAndAssert<int>(e.Data[key]);
});
break;
case PlayQueueMessageHelper.TrackPlayed:
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
UpdateHistory();
});
break;
case PlayQueueMessageHelper.PlayQueueFinished:
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
ResetPlayerToStart();
IsActive = false;
IsPlaying = false;
CurrentTime = TimeSpan.Zero;
});
break;
}
}
}
private void MessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
ValueSet valueSet = e.Data;
foreach (string key in valueSet.Keys)
{
switch (key)
{
case "Play":
Debug.WriteLine("Starting Playback");
Play(valueSet[key].ToString());
break;
}
}
}
/// <summary>
/// Вызывается при получении сообщения от процесса переднего плана.
/// </summary>
private async void OnMessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
if (!_isTaskRunning)
{
_player = BackgroundMediaPlayer.Current;
if (!_taskRunningEvent.WaitOne(AppConstants.AudioTaskStartingTimeout))
{
#if DEBUG
Debug.WriteLine("AudioTask start timeout exceeded!");
#endif
return;
}
}
foreach (string key in e.Data.Keys)
{
switch (key)
{
case AppConstants.PlayerNewPlaylist:
await _manager.Update(true);
break;
case AppConstants.PlayerNextTrack:
_manager.NextTrack();
break;
case AppConstants.PlayerPreviousTrack:
_manager.PreviousTrack();
break;
case AppConstants.PlayerPauseResume:
_manager.ResumePause();
break;
case AppConstants.PlayerCurrentTrackID:
_manager.PlayTrackFromID((int)e.Data[key]);
break;
case AppConstants.PlayerShuffleMode:
await _manager.UpdateShuffleMode();
break;
case AppConstants.PlayerRepeatMode:
_manager.UpdateRepeatMode();
break;
}
}
}
private void BackgroundMediaPlayer_MessageReceivedFromBackground(
object sender, MediaPlayerDataReceivedEventArgs e)
{
if (e.Data.Keys.Contains(PlayerConstants.Trackchanged))
{
Debug.WriteLine(PlayerConstants.Trackchanged);
RaiseEvent(TrackChanged);
}
else if (e.Data.Keys.Contains(PlayerConstants.Error))
{
Debug.WriteLine(PlayerConstants.Error);
ShowUnAuthError(e.Data);
}
}
/// <summary>
/// Mensajes recibidos desde UI.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void MessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
ValueSet valueSet = e.Data;
foreach (string key in valueSet.Keys)
{
switch (key)
{
case "Play":
Play(valueSet[key].ToString(), valueSet["Title"].ToString());
break;
case "Pause":
Pause();
break;
}
}
}
private void OnMessageReceivedFromBackground(object sender, MediaPlayerDataReceivedEventArgs e)
{
var valueset = e.Data;
string key = valueset[MessageService.MessageId] as string;
if (key == MessageService.BackgroundMediaPlayerActivatedMessageKey)
{
Proxy = new MusicPlayerClientProxy(this);
PlayerActivated(this, null);
}
else if (key == MessageService.BackgroundMediaPlayerUserMessageKey)
{
MessageType type = EnumHelper.Parse <MessageType>(valueset[MessageService.MessageType] as string);
MessageReceived(this, new MessageReceivedEventArgs(type, valueset[MessageService.MessageContent] as string));
}
}
private static void MessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
try
{
ValueSet valueSet = e.Data;
foreach (string key in valueSet.Keys)
{
if (MessageReceivedSwitchCase(key, valueSet))
{
return;
}
}
}
catch { }
}
private void MessageReceivedFromBackground(object sender, MediaPlayerDataReceivedEventArgs e)
{
foreach (var key in e.Data.Keys)
{
switch (key)
{
case TASK_RUNNING:
_taskStarted.Set();
_isTaskRunning = true;
break;
case PLAYER_TRACK_ID:
TrackChanged?.Invoke(this, new TrackChangedEventArgs((int)e.Data[key]));
break;
}
}
}
private async void OnBackgroundMessageReceived(object sender, MediaPlayerDataReceivedEventArgs e)
{
try
{
String fileName = String.Format("{0}\\{1}", System.IO.Directory.GetCurrentDirectory(), "alert.wav");
// BackgroundMediaPlayer.Current.AutoPlay = false;
var istorage = await StorageFile.GetFileFromPathAsync(fileName);
// BackgroundMediaPlayer.Current.MediaEnded += OnMediaPlayed;
BackgroundMediaPlayer.Current.SetFileSource(istorage);
BackgroundMediaPlayer.Current.Play();
System.Diagnostics.Debug.WriteLine("File path to write details - {0}", fileName);
}
catch (Exception ex)
{
}
}
private void MessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
foreach (var command in e.Data)
{
switch (command.Key)
{
case "id":
_nowPlayingId = command.Value.ToString();
GetNowPlaying();
break;
case "title":
BackgroundMediaPlayer.Current.SystemMediaTransportControls.DisplayUpdater.MusicProperties.Artist = command.Value.ToString();
BackgroundMediaPlayer.Current.SystemMediaTransportControls.DisplayUpdater.Update();
break;
}
}
}
/// <summary>
/// Raised when a message is recieved from the foreground app
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void BackgroundMediaPlayer_MessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
AppSuspendedMessage appSuspendedMessage;
if (MessageService.TryParseMessage(e.Data, out appSuspendedMessage))
{
Debug.WriteLine("App suspending"); // App is suspended, you can save your task state at this point
foregroundAppState = AppState.Suspended;
return;
}
AppResumedMessage appResumedMessage;
if (MessageService.TryParseMessage(e.Data, out appResumedMessage))
{
Debug.WriteLine("App resuming"); // App is resumed, now subscribe to message channel
foregroundAppState = AppState.Active;
return;
}
StartPlaybackMessage startPlaybackMessage;
if (MessageService.TryParseMessage(e.Data, out startPlaybackMessage))
{
//Foreground App process has signalled that it is ready for playback
Debug.WriteLine("Starting Playback");
StartPlayback();
return;
}
UpdateStreamURLMessage updateStreamURLMessage;
if (MessageService.TryParseMessage(e.Data, out updateStreamURLMessage))
{
CreateMediaSource(updateStreamURLMessage.streamURL);
return;
}
StopPlaybackMessage stopPlaybackMessage;
if (MessageService.TryParseMessage(e.Data, out stopPlaybackMessage))
{
//BackgroundMediaPlayer.Current.Position = BackgroundMediaPlayer.Current.
}
}
private void MessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
Debug.WriteLine("MessageFromForeground");
ValueSet valueSet = e.Data;
foreach (string key in valueSet.Keys)
{
switch (key)
{
case "Play":
Debug.WriteLine("Starting Playback");
Play(valueSet[key].ToString(), valueSet["Title"].ToString(), valueSet["Artist"].ToString());
break;
case "Pause":
BackgroundMediaPlayer.Current.Pause();
break;
}
}
}
/// <summary>
/// Raised when a message is recieved from the foreground app
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
async void MessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
StartPlaybackMessage startPlaybackMessage;
if (MessageService.TryParseMessage(e.Data, out startPlaybackMessage))
{
//Foreground App process has signalled that it is ready for playback
Debug.WriteLine("Starting Playback");
StartPlayback();
return;
}
SkipNextMessage skipNextMessage;
if (MessageService.TryParseMessage(e.Data, out skipNextMessage))
{
// User has chosen to skip track from app context.
Debug.WriteLine("Skipping to next");
SkipToNext();
return;
}
SkipPreviousMessage skipPreviousMessage;
if (MessageService.TryParseMessage(e.Data, out skipPreviousMessage))
{
// User has chosen to skip track from app context.
Debug.WriteLine("Skipping to previous");
SkipToPrevious();
return;
}
TrackChangedMessage trackChangedMessage;
if (MessageService.TryParseMessage(e.Data, out trackChangedMessage))
{
if (trackChangedMessage.AudioTrack != null)
{
await ChangeTrack(trackChangedMessage.AudioTrack);
return;
}
}
}
/// <summary>
/// Fires when a message is recieved from the foreground app
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void BackgroundMediaPlayer_MessageReceivedFromForeground(object sender,
MediaPlayerDataReceivedEventArgs e)
{
foreach (var key in e.Data.Keys)
{
switch (key.ToLower())
{
case PlayerConstants.LastFmLoginChanged:
QueueManager.UpdateScrobblerInstance();
break;
case PlayerConstants.StartStation:
QueueManager.StartRadioStation();
break;
case PlayerConstants.AppSuspended:
Debug.WriteLine("App suspending");
// App is suspended, you can save your task state at this point
_appSettingsHelper.Write(PlayerConstants.CurrentTrack, QueueManager.CurrentTrack.Id);
break;
case PlayerConstants.AppResumed:
Debug.WriteLine("App resuming"); // App is resumed, now subscribe to message channel
break;
case PlayerConstants.StartPlayback:
//Foreground App process has signalled that it is ready for playback
Debug.WriteLine("Starting Playback");
StartPlayback();
break;
case PlayerConstants.SkipNext: // User has chosen to skip track from app context.
Debug.WriteLine("Skipping to next");
SkipToNext();
break;
case PlayerConstants.SkipPrevious: // User has chosen to skip track from app context.
Debug.WriteLine("Skipping to previous");
SkipToPrevious();
break;
}
}
}
async void BackgroundMediaPlayer_MessageReceivedFromBackground(object sender, MediaPlayerDataReceivedEventArgs e)
{
foreach (var item in e.Data)
{
Debug.WriteLine("received: " + item);
switch (item.Key)
{
case CommunicationConstants.PlaybackNewSong:
await dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
if (CurrentSongChanged != null)
CurrentSongChanged(this, new CurrentSongChangedEventArgs(
(SongChangedType)Enum.Parse(typeof(SongChangedType), (string)item.Value)));
});
break;
case CommunicationConstants.BackgroundTaskStarted:
isBackgroundTaskRunningEvent.Set();
isBackgroundTaskRunning = true;
if (item.Value != null && ((string)item.Value) != "")
await dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
if (CurrentSongChanged != null)
CurrentSongChanged(this, new CurrentSongChangedEventArgs(SongChangedType.None));
});
break;
case CommunicationConstants.BackgroundTaskStopped:
isBackgroundTaskRunningEvent.Reset();
isBackgroundTaskRunning = false;
await dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
this.IsPlaying = false;
NotifyPropertyChanged("IsPlaying");
});
break;
case null:
Debug.WriteLine("WTF");
break;
default:
throw new NotImplementedException();
}
}
}
/// <summary>
/// Fires when a message is recieved from the foreground app
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void BackgroundMediaPlayer_MessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
foreach (string key in e.Data.Keys)
{
switch (key)
{
//New management
case Constants.BackgroundTaskQuery:
//Basically a ping to make sure that the background task is running
ValueSet message = new ValueSet();
message.Add(Constants.BackgroundTaskIsRunning, "");
BackgroundMediaPlayer.SendMessageToForeground(message);
break;
case Constants.StartPlaying:
if (e.Data[key] != null)
{
//If it's not null, then the playlist changed and we need to recache it
_currentCachedPlaylist = null;
}
BeginPlaying();
break;
case Constants.ClearCache:
_currentCachedPlaylist = null;
BeginPlaying(false);
break;
case Constants.PlayTrack:
Play();
break;
case Constants.PauseTrack:
Pause();
break;
case Constants.StopPlayback:
StopPlayback();
break;
}
}
}
/// <summary>
/// Raised when a message is recieved from the foreground app
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void BackgroundMediaPlayer_MessageReceivedFromForeground(object sender,
MediaPlayerDataReceivedEventArgs e)
{
var message = MessageHelper.ParseMessage(e.Data);
if (message is AppSuspendedMessage)
AppSuspended?.Invoke(this, null);
else if (message is AppResumedMessage)
AppResumed?.Invoke(this, null);
else if (message is StartPlaybackMessage)
StartPlayback?.Invoke(this, null);
else if (message is SkipNextMessage)
SkipToNext?.Invoke(this, null);
else if (message is SkipPreviousMessage)
SkipToPrev?.Invoke(this, null);
else
{
var changedMessage = message as TrackChangedMessage;
if (changedMessage != null)
TrackChanged?.Invoke(this, changedMessage.QueueId);
else
{
var playlistMessage = message as UpdatePlaylistMessage;
if (playlistMessage != null)
UpdatePlaylist?.Invoke(this, playlistMessage.Tracks);
else
{
var addMessage = message as AddToPlaylistMessage;
if (addMessage != null)
AddToPlaylist?.Invoke(addMessage.Tracks, addMessage.Position);
else
{
var updateMessage = message as UpdateUrlMessage;
if (updateMessage != null)
TrackUpdateUrl?.Invoke(this, updateMessage);
}
}
}
}
}
/// <summary>
/// Вызывается при получении сообщения от фоновой задачи проигрывателя.
/// </summary>
private void MessageReceivedFromBackground(object sender, MediaPlayerDataReceivedEventArgs e)
{
foreach (var key in e.Data.Keys)
{
switch (key)
{
case PlayerConstants.TASK_RUNNING:
taskStarted.Set();
isTaskRunning = true;
break;
case PlayerConstants.CURRENT_TRACK_ID:
if (TrackIDChanged != null)
{
TrackIDChanged(this, (int)e.Data[key]);
}
break;
}
}
}
private void BackgroundMediaPlayer_MessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
Debug.WriteLine("f**k");
// 接收消息
ValueSet val = e.Data;
if (val.ContainsKey("action"))
{
string msg = val["action"] as string;
if (msg.Equals("play")) //播放
{
isFirstPlaying = true;
Play();
isFirstPlaying = false;
}
else //暂停
{
Pause();
}
}
}
async void BackgroundMediaPlayer_MessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
foreach (string key in e.Data.Keys)
{
switch (key.ToLower())
{
case "play":
String url =e.Data[key].ToString();
await PlayHLS(new Uri(url, UriKind.RelativeOrAbsolute));
break;
case "stop":
BackgroundMediaPlayer.Current.Pause();
break;
case "wakup_background_player":
break;
default:
break;
}
}
}
/// <summary>
/// Вызывается при получении нового сообщения от фонового процесса проигрывателя.
/// </summary>
private void OnNewMessageReceived(object sender, MediaPlayerDataReceivedEventArgs e)
{
foreach (string key in e.Data.Keys)
{
switch (key)
{
case AppConstants.PlayerTaskRunning:
IsTaskRunning = (bool)e.Data[key];
_taskStartedEvent.Set();
break;
case AppConstants.PlayerCurrentTrackID:
CurrentTrackID = (int)e.Data[key];
TrackIDChanged(this, CurrentTrackID);
break;
case AppConstants.PlayerBufferingStarted:
//PlayerStateChanged(this, CurrentState);
break;
case AppConstants.PlayerBufferingEnded:
//PlayerStateChanged(this, CurrentState);
break;
case AppConstants.PlayerMediaOpened:
//PlayerStateChanged(this, CurrentState);
break;
case AppConstants.PlayerMediaEnded:
//PlayerStateChanged(this, CurrentState);
break;
case AppConstants.PlayerMediaFailed:
break;
case AppConstants.PlayerPauseResume:
//PlayerStateChanged(this, CurrentState);
break;
}
}
}
private async void BackgroundMediaPlayer_MessageReceived(object sender, MediaPlayerDataReceivedEventArgs e)
{
try
{
if (!NeedsDispatcher())
{
Handle(e.Data);
}
else
{
await CoreApplication.MainView.CoreWindow.Dispatcher.
RunAsync(CoreDispatcherPriority.Normal, () => { Handle(e.Data); });
}
}
catch (Exception exc1)
{
string currentReceivedPrimaryKey = GetPrimaryKey(e.Data);
string primaryData = e.Data[currentReceivedPrimaryKey].ToString();
MobileDebug.Service.WriteEvent("ReceiveFail1", exc1, currentReceivedPrimaryKey, primaryData);
}
}
/// <summary>
/// Fires when a message is recieved from the foreground app
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void BackgroundMediaPlayer_MessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
foreach (string key in e.Data.Keys)
{
switch (key.ToLower())
{
case Constants.AppSuspended:
Debug.WriteLine("App suspending"); // App is suspended, you can save your task state at this point
foregroundAppState = ForegroundAppStatus.Suspended;
break;
case Constants.AppResumed:
Debug.WriteLine("App resuming"); // App is resumed, now subscribe to message channel
foregroundAppState = ForegroundAppStatus.Active;
break;
case Constants.StartPlayback: //Foreground App process has signalled that it is ready for playback
Debug.WriteLine("Starting Playback");
StartPlayback();
break;
}
}
}
async void BackgroundMediaPlayer_MessageReceivedFromBackground(object sender, MediaPlayerDataReceivedEventArgs e)
{
ValueSet valueSet = e.Data;
foreach (string key in valueSet.Keys)
{
switch (key)
{
case "Exited":
Debug.WriteLine("BackgroundMediaPlayer_MessageReceivedFromBackground() - Exited message recieved");
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
_mediaPlayer = null;
PlayButton.Background = this.Resources["PlayImageBrush"] as Brush;
Buffering.Text = "";
});
break;
default:
break;
}
}
}
/// <summary>
/// Fires when a message is recieved from the foreground app
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void BackgroundMediaPlayer_MessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
foreach (string key in e.Data.Keys)
{
switch (key.ToLower())
{
case Constants.AppSuspended:
Debug.WriteLine("App suspending"); // App is suspended, you can save your task state at this point
foregroundAppState = ForegroundAppStatus.Suspended;
break;
case Constants.AppResumed:
Debug.WriteLine("App resuming"); // App is resumed, now subscribe to message channel
foregroundAppState = ForegroundAppStatus.Active;
break;
case Constants.StartPlayback: //Foreground App process has signalled that it is ready for playback
Debug.WriteLine("Starting Playback");
StartPlayback();
break;
}
}
}
/// <summary>
/// This event is raised when a message is recieved from BackgroundAudioTask
/// </summary>
async void BackgroundPlayerMessageReceivedFromBackground(object sender, MediaPlayerDataReceivedEventArgs e)
{
TrackChangedMessage trackChangedMessage;
if (MessageService.TryParseMessage(e.Data, out trackChangedMessage))
{
// When foreground app is active change track based on background message
await _dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
CurrentTrack = trackChangedMessage.AudioTrack;
if (TrackChanged != null)
{
TrackChanged(this, CurrentTrack);
}
});
return;
}
BackgroundAudioTaskStartedMessage backgroundAudioTaskStartedMessage;
if (MessageService.TryParseMessage(e.Data, out backgroundAudioTaskStartedMessage))
{
// StartBackgroundAudioTask is waiting for this signal to know when the task is up and running
// and ready to receive messages
backgroundAudioTaskStarted.Set();
return;
}
TrackEndedMessage trackEndedMessage;
if (MessageService.TryParseMessage(e.Data, out trackEndedMessage))
{
// Do nothing for now
}
}
/// <summary>
/// This event is raised when a message is recieved from BackgroundAudioTask
/// </summary>
private async void BackgroundMediaPlayer_MessageReceivedFromBackground(object sender,
MediaPlayerDataReceivedEventArgs e)
{
var message = MessageHelper.ParseMessage(e.Data);
if (message is TrackChangedMessage)
{
var trackChangedMessage = message as TrackChangedMessage;
CurrentQueueTrack = PlaybackQueue.FirstOrDefault(p => p.Id == trackChangedMessage.QueueId);
// When foreground app is active change track based on background message
await _dispatcherUtility.RunAsync(
() => { TrackChanged?.Invoke(sender, trackChangedMessage.QueueId); });
return;
}
if (message is BackgroundAudioTaskStartedMessage)
{
// StartBackgroundAudioTask is waiting for this signal to know when the task is up and running
// and ready to receive messages
Debug.WriteLine("BackgroundAudioTask started");
_backgroundAudioTaskStarted.Set();
}
}
/// <summary>
/// Fires when a message is recieved from the foreground app
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void BackgroundMediaPlayer_MessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
foreach (string key in e.Data.Keys)
{
switch (key.ToLower())
{
case BackgroundAudioConstants.PingBackground:
Debug.WriteLine("Received Ping from foreground"); // App is suspended, you can save your task state at this point
ValueSet message = new ValueSet();
message.Add(BackgroundAudioConstants.PingBackground, DateTime.Now.ToString());
BackgroundMediaPlayer.SendMessageToForeground(message);
break;
case BackgroundAudioConstants.AppSuspended:
Debug.WriteLine("App suspending"); // App is suspended, you can save your task state at this point
foregroundAppState = ForegroundAppStatus.Suspended;
ApplicationSettingsHelper.SaveSettingsValue(BackgroundAudioConstants.CurrentTrack, Playlist.CurrentTrackIndex);
break;
case BackgroundAudioConstants.AppResumed:
Debug.WriteLine("App resuming"); // App is resumed, now subscribe to message channel
foregroundAppState = ForegroundAppStatus.Active;
break;
case BackgroundAudioConstants.StartPlayback: //Foreground App process has signalled that it is ready for playback
Debug.WriteLine("Starting Playback");
StartPlayback();
break;
case BackgroundAudioConstants.UpdatePlaylist:
Debug.WriteLine("Updating playlist...");
Playlist.UpdatePlaylist();
break;
case BackgroundAudioConstants.ResetPlaylist:
var arg = new object();
if (e.Data.TryGetValue(BackgroundAudioConstants.ResetPlaylist, out arg))
{
Playlist.ResetCollection((int)arg);
}
break;
case BackgroundAudioConstants.AddTrack:
object track = new object();
if (e.Data.TryGetValue(BackgroundAudioConstants.AddTrack, out track))
{
// We should have the newest playlist with the new track already. If so, just repopulate the playlist.
Playlist.AddTracks(AudioBackgroundInterface.DeserializeAudioTracks(track.ToString()) as List<BackgroundTrackItem>);
}
break;
case BackgroundAudioConstants.PlayTrack: //Foreground App process has signalled that it is ready for playback
Debug.WriteLine("Starting Playback");
Object obj = new Object();
if (e.Data.TryGetValue(BackgroundAudioConstants.PlayTrack, out obj))
{
string s = obj as string;
if (!string.IsNullOrEmpty(s))
{
int t = Convert.ToInt32(s);
Playlist.PlayTrack(t);
}
}
break;
case BackgroundAudioConstants.RestorePlaylist: //Foreground App process updated List Track
Debug.WriteLine("Restoring ListTrack");
Playlist.PopulatePlaylist();
var currentTrack =
ApplicationSettingsHelper.ReadSettingsValue(BackgroundAudioConstants.CurrentTrack);
if (currentTrack == null)
{
break;
}
Playlist.CurrentTrack = (int)currentTrack;
break;
case BackgroundAudioConstants.SkipNext: // User has chosen to skip track from app context.
Debug.WriteLine("Skipping to next");
SkipToNext();
break;
case BackgroundAudioConstants.SkipPrevious: // User has chosen to skip track from app context.
Debug.WriteLine("Skipping to previous");
SkipToPrevious();
break;
}
}
}
/// <summary>
/// This event fired when a message is recieved from Background Process
/// </summary>
async void BackgroundMediaPlayer_MessageReceivedFromBackground(object sender, MediaPlayerDataReceivedEventArgs e)
{
foreach (string key in e.Data.Keys)
{
switch (key)
{
case Constants.Trackchanged:
//When foreground app is active change track based on background message
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
}
);
break;
case Constants.BackgroundTaskStarted:
//Wait for Background Task to be initialized before starting playback
Debug.WriteLine("Background Task started");
SererInitialized.Set();
break;
}
}
}
async void BackgroundMediaPlayer_MessageReceivedFromBackground(object sender, MediaPlayerDataReceivedEventArgs e)
{
TrackChangedMessage trackChangedMessage;
if (MessageService.TryParseMessage(e.Data, out trackChangedMessage))
{
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.High, () =>
{
if (trackChangedMessage.TrackId == null)
{
return;
}
CurrentTrack = AsyncHelper.RunSync(() => GetTrackById(trackChangedMessage.TrackId));
});
return;
}
BackgroundAudioTaskStartedMessage backgroundAudioTaskStartedMessage;
if (MessageService.TryParseMessage(e.Data, out backgroundAudioTaskStartedMessage))
{
Debug.WriteLine("BackgroundAudioTask started");
backgroundAudioTaskStarted.Set();
}
}
async void BackgroundMediaPlayer_MessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
foreach (var item in e.Data)
{
switch (item.Key)
{
case CommunicationConstants.TogglePlayPause:
if (BackgroundMediaPlayer.Current.CurrentState == MediaPlayerState.Playing)
this.Pause();
else
await this.Resume();
break;
case CommunicationConstants.GetInfo:
SendToForeground(CommunicationConstants.BackgroundTaskStarted);
break;
case CommunicationConstants.PlaybackNewSong:
var type = (SongChangedType)Enum.Parse(typeof(SongChangedType), (string)item.Value);
switch (type)
{
case SongChangedType.NewPlayback:
case SongChangedType.SkipToSong:
ApplicationSettings.BackgroundTaskResumeSongTime.ReadReset();
await PlayCurrentSong(true, type);
break;
case SongChangedType.NextSong:
ApplicationSettings.BackgroundTaskResumeSongTime.ReadReset();
await PlayNextSong(false, true, type);
break;
case SongChangedType.PreviousSong:
ApplicationSettings.BackgroundTaskResumeSongTime.ReadReset();
await PlayPreviousSong();
break;
}
break;
default:
throw new NotImplementedException();
}
}
}
/// <summary>
/// Fires when a message is recieved from the foreground app
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void BackgroundMediaPlayer_MessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
foreach (string key in e.Data.Keys)
{
switch (key.ToLower())
{
case Constants.AppSuspended:
Debug.WriteLine("App suspending"); // App is suspended, you can save your task state at this point
foregroundAppState = ForegroundAppStatus.Suspended;
ApplicationSettingsHelper.SaveSettingsValue(Constants.CurrentTrack, Playlist.CurrentTrackName);
break;
case Constants.AppResumed:
Debug.WriteLine("App resuming"); // App is resumed, now subscribe to message channel
foregroundAppState = ForegroundAppStatus.Active;
break;
case Constants.StartPlayback: //Foreground App process has signalled that it is ready for playback
Debug.WriteLine("Starting Playback");
StartPlayback();
break;
case Constants.SkipNext: // User has chosen to skip track from app context.
Debug.WriteLine("Skipping to next");
SkipToNext();
break;
case Constants.SkipPrevious: // User has chosen to skip track from app context.
Debug.WriteLine("Skipping to previous");
SkipToPrevious();
break;
}
}
}
/// <summary>
/// Raised when a message is recieved from the foreground app
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void BackgroundMediaPlayer_MessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
AppSuspendedMessage appSuspendedMessage;
if (MessageService.TryParseMessage(e.Data, out appSuspendedMessage))
{
Debug.WriteLine("App suspending"); // App is suspended, you can save your task state at this point
foregroundAppState = AppState.Suspended;
var currentTrackId = GetCurrentTrackId();
ApplicationSettingsHelper.SaveSettingsValue(ApplicationSettingsConstants.TrackId, currentTrackId?.ToString());
return;
}
AppResumedMessage appResumedMessage;
if (MessageService.TryParseMessage(e.Data, out appResumedMessage))
{
Debug.WriteLine("App resuming"); // App is resumed, now subscribe to message channel
foregroundAppState = AppState.Active;
return;
}
StartPlaybackMessage startPlaybackMessage;
if (MessageService.TryParseMessage(e.Data, out startPlaybackMessage))
{
//Foreground App process has signalled that it is ready for playback
Debug.WriteLine("Starting Playback");
StartPlayback();
return;
}
SkipNextMessage skipNextMessage;
if (MessageService.TryParseMessage(e.Data, out skipNextMessage))
{
// User has chosen to skip track from app context.
Debug.WriteLine("Skipping to next");
SkipToNext();
return;
}
SkipPreviousMessage skipPreviousMessage;
if (MessageService.TryParseMessage(e.Data, out skipPreviousMessage))
{
// User has chosen to skip track from app context.
Debug.WriteLine("Skipping to previous");
SkipToPrevious();
return;
}
TrackChangedMessage trackChangedMessage;
if (MessageService.TryParseMessage(e.Data, out trackChangedMessage))
{
var index = playbackList.Items.ToList().FindIndex(i => (string)i.Source.CustomProperties[TrackIdKey] == trackChangedMessage.TrackId);
Debug.WriteLine("Skipping to track " + index);
smtc.PlaybackStatus = MediaPlaybackStatus.Changing;
playbackList.MoveTo((uint)index);
return;
}
UpdatePlaylistMessage updatePlaylistMessage;
if (MessageService.TryParseMessage(e.Data, out updatePlaylistMessage))
{
CreatePlaybackList(updatePlaylistMessage.PlayList);
return;
}
}
void backgroundMediaPlayer_MessageReceivedFromBackground(object sender, MediaPlayerDataReceivedEventArgs e)
{
DebugService.Add("Player: MessageReceivedFromBackground");
BackgroundServiceIsAlive backgroundServiceIsAlive;
if (MessageService.TryParseMessage(e.Data, out backgroundServiceIsAlive))
{
isBackgroundTaskRunning = true;
DebugService.Add("Player: BackgroundAudioTask is alive");
}
BackgroundAudioTaskStartedMessage backgroundAudioTaskStartedMessage;
if (MessageService.TryParseMessage(e.Data, out backgroundAudioTaskStartedMessage))
{
// StartBackgroundAudioTask is waiting for this signal to know when the task is up and running
// and ready to receive messages
DebugService.Add("Player: BackgroundAudioTask started");
isBackgroundTaskRunning = true;
return;
}
}
/// <summary>
/// Fires when a message is recieved from the foreground app
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void BackgroundMediaPlayer_MessageReceivedFromForeground(object sender,
MediaPlayerDataReceivedEventArgs e)
{
foreach (var key in e.Data.Keys)
{
switch (key.ToLower())
{
case PlayerConstants.LastFmLoginChanged:
QueueManager.UpdateScrobblerInstance();
break;
case PlayerConstants.StartStation:
QueueManager.StartRadioStation();
break;
case PlayerConstants.AppSuspended:
Debug.WriteLine("App suspending");
// App is suspended, you can save your task state at this point
_appSettingsHelper.Write(PlayerConstants.CurrentTrack, QueueManager.CurrentTrack.Id);
break;
case PlayerConstants.AppResumed:
Debug.WriteLine("App resuming"); // App is resumed, now subscribe to message channel
break;
case PlayerConstants.StartPlayback:
//Foreground App process has signalled that it is ready for playback
Debug.WriteLine("Starting Playback");
StartPlayback();
break;
case PlayerConstants.SkipNext: // User has chosen to skip track from app context.
Debug.WriteLine("Skipping to next");
SkipToNext();
break;
case PlayerConstants.SkipPrevious: // User has chosen to skip track from app context.
Debug.WriteLine("Skipping to previous");
SkipToPrevious();
break;
}
}
}
private void onMessageReceivedFromBackground(object sender, MediaPlayerDataReceivedEventArgs e)
{
if (e.Data.ContainsKey(Keys.IsBackgroundTaskRunning))
{
logger.LogMessage("Foreground playback manager: MessageReceivedFromBackground: Background Task started.");
backgroundAudioInitializedEvent.Set();
}
}
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);
});
}
}
/// <summary>
/// Fires when a message is received from the foreground app
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void onMessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
int navigationAmount = 0;
NavigationInterval navigationInterval = NavigationInterval.Unspecified;
foreach (string key in e.Data.Keys)
{
switch (key)
{
case Keys.StartPlayback:
logger.LogMessage("BackgroundAudioTask: Starting Playback");
await audioManager.StartPlaybackAsync();
break;
case Keys.SkipToNext:
logger.LogMessage("BackgroundAudioTask: Skipping to next");
audioManager.SkipToNext();
break;
case Keys.SkipToPrevious:
logger.LogMessage("BackgroundAudioTask: Skipping to previous");
audioManager.SkipToPrevious();
break;
case Keys.PausePlayback:
logger.LogMessage("BackgroundAudioTask: Trying to pause playback");
audioManager.PausePlayback();
break;
case Keys.SchedulePause:
logger.LogMessage("BackgroundAudioTask: Scheduling the pause");
audioManager.SchedulePause();
break;
case Keys.PlaylistUpdated:
logger.LogMessage("BackgroundAudioTask: Playlist updated");
await audioManager.LoadPlaylistAsync();
break;
case Keys.NavigationAmount:
navigationAmount = (int)e.Data[Keys.NavigationAmount];
logger.LogMessage($"BackgroundAudioTask: Obtained navigation amount {navigationAmount}");
break;
case Keys.NavigationInterval:
navigationInterval = (NavigationInterval)e.Data[Keys.NavigationInterval];
logger.LogMessage($"BackgroundAudioTask: Obtained navigation interval {navigationInterval}");
break;
}
}
if (navigationAmount != 0 && navigationInterval != NavigationInterval.Unspecified)
{
audioManager.Navigate(navigationAmount, navigationInterval);
}
}
private async void BackgroundMediaPlayer_MessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
var data = e.Data.ToList();
var path = data[0].Value.ToString();
if (path.Contains("http://"))
{
mediaplayer.SetUriSource(new Uri(path));
}
else
{
var file = await Windows.Storage.StorageFile.GetFileFromPathAsync(path);
mediaplayer.SetFileSource(file);
}
}
/// <summary>
/// Fires when a message is recieved from the foreground app
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void BackgroundMediaPlayer_MessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
foreach (string key in e.Data.Keys)
{
switch (key.ToLower())
{
case Constants.AppSuspended:
Debug.WriteLine("App suspending"); // App is suspended, you can save your task state at this point
foregroundAppState = ForegroundAppStatus.Suspended;
ApplicationSettingsHelper.SaveSettingsValue(Constants.CurrentTrack, "Teset" /*Playlist.CurrentTrackName*/);
break;
case Constants.AppResumed:
Debug.WriteLine("App resuming"); // App is resumed, now subscribe to message channel
foregroundAppState = ForegroundAppStatus.Active;
break;
case Constants.StartPlayback: //Foreground App process has signalled that it is ready for playback
Debug.WriteLine("Starting Playback");
//StartPlayback();
break;
case Constants.SkipNext: // User has chosen to skip track from app context.
Debug.WriteLine("Skipping to next");
//SkipToNext();
break;
case Constants.SkipPrevious: // User has chosen to skip track from app context.
Debug.WriteLine("Skipping to previous");
//SkipToPrevious();
break;
case Constants.AddTrack:
var en = e.Data.Values.GetEnumerator();
en.MoveNext();
//Playlist.Tracks.Add(en.Current.ToString());
currentMediaPath = en.Current.ToString();
BackgroundMediaPlayer.Current.AutoPlay = false;
BackgroundMediaPlayer.Current.SetUriSource(new Uri(currentMediaPath));
BackgroundMediaPlayer.Current.Play();
systemmediatransportcontrol.PlaybackStatus = MediaPlaybackStatus.Playing;
systemmediatransportcontrol.DisplayUpdater.Type = MediaPlaybackType.Music;
systemmediatransportcontrol.DisplayUpdater.MusicProperties.Title = "Test 1234567890 123456789";
systemmediatransportcontrol.DisplayUpdater.Update();
break;
}
}
}
/// <summary>
/// This event is raised when a message is recieved from BackgroundAudioTask
/// </summary>
async void BackgroundMediaPlayer_MessageReceivedFromBackground(object sender, MediaPlayerDataReceivedEventArgs e)
{
TrackChangedMessage trackChangedMessage;
if(MessageService.TryParseMessage(e.Data, out trackChangedMessage))
{
// When foreground app is active change track based on background message
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
// If playback stopped then clear the UI
if(trackChangedMessage.TrackId == null)
{
playlistView.SelectedIndex = -1;
albumArt.Source = null;
txtCurrentTrack.Text = string.Empty;
prevButton.IsEnabled = false;
nextButton.IsEnabled = false;
return;
}
var songIndex = playlistView.GetSongIndexById(trackChangedMessage.TrackId);
var song = playlistView.Songs[songIndex];
// Update list UI
playlistView.SelectedIndex = songIndex;
// Update the album art
albumArt.Source = albumArtCache[song.AlbumArtUri.ToString()];
// Update song title
txtCurrentTrack.Text = song.Title;
// Ensure track buttons are re-enabled since they are disabled when pressed
prevButton.IsEnabled = true;
nextButton.IsEnabled = true;
});
return;
}
BackgroundAudioTaskStartedMessage backgroundAudioTaskStartedMessage;
if(MessageService.TryParseMessage(e.Data, out backgroundAudioTaskStartedMessage))
{
// StartBackgroundAudioTask is waiting for this signal to know when the task is up and running
// and ready to receive messages
Debug.WriteLine("BackgroundAudioTask started");
backgroundAudioTaskStarted.Set();
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);
}
}
