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> /// 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; } }
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); } }