private void SendMessage(string constants)// SendMessage(constants,"") { var value = new ValueSet(); value.Add(constants, ""); BackgroundMediaPlayer.SendMessageToBackground(value); }
/// <summary> /// Отправляет сообщение фоновому процессу проигрывателя. /// </summary> /// <param name="message">Сообщение для отправки.</param> private void SendMessageToBackground(ValueSet message) { if (IsTaskRunning) { BackgroundMediaPlayer.SendMessageToBackground(message); } }
/// <summary> /// Handles background task cancellation. Task cancellation happens due to: /// 1. Another Media app comes into foreground and starts playing music /// 2. Resource pressure. Your task is consuming more CPU and memory than allowed. /// In either case, save state so that if foreground app resumes it can know where to start. /// </summary> private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason) { // You get some time here to save your state before process and resources are reclaimed Debug.WriteLine("MyBackgroundAudioTask " + sender.Task.TaskId + " Cancel Requested..."); try { // immediately set not running backgroundTaskStarted.Reset(); //save state ApplicationSettingsHelper.SaveSettingsValue(ApplicationSettingsConstants.BackgroundTaskState, BackgroundTaskState.Canceled.ToString()); // unsubscribe event handlers BackgroundMediaPlayer.MessageReceivedFromForeground -= BackgroundMediaPlayer_MessageReceivedFromForeground; smtc.ButtonPressed -= smtc_ButtonPressed; smtc.PropertyChanged -= smtc_PropertyChanged; BackgroundMediaPlayer.Shutdown(); // shutdown media pipeline } catch (Exception ex) { Debug.WriteLine(ex.ToString()); } deferral.Complete(); // signals task completion. Debug.WriteLine("MyBackgroundAudioTask Cancel complete..."); }
void SendMessage(string key, string value) { BackgroundMediaPlayer.SendMessageToForeground(new ValueSet { { key, value } }); }
private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason) { try { ApplicationSettingsHelper.SaveSettingsValue(SharedStrings.BACKGROUND_AUDIO_CURRENT_TRACK, Playlist.CurrentTrackName); ApplicationSettingsHelper.SaveSettingsValue(SharedStrings.BACKGROUND_AUDIO_POSITION, BackgroundMediaPlayer.Current.Position.ToString()); ApplicationSettingsHelper.SaveSettingsValue(SharedStrings.BACKGROUND_AUDIO_STATE, SharedStrings.BACKGROUND_AUDIO_CANCELLED); ApplicationSettingsHelper.SaveSettingsValue(SharedStrings.BACKGROUND_AUDIO_APP_STATE, Enum.GetName(typeof(ForegroundAppStatus), foregroundAppState)); backgroundTaskRunning = false; if (transportControl != null) { transportControl.ButtonPressed -= transportControl_ButtonPressed; transportControl.PropertyChanged -= transportControl_PropertyChanged; } Playlist.TrackChanged -= playList_TrackChanged; playlistManager.ClearPlaylist(); playlistManager = null; BackgroundMediaPlayer.Shutdown(); } catch (Exception ex) { Debug.WriteLine("CoffeeBackgroundAudioTask.OnCanceled: " + ex.ToString()); } if (deferral != null) { deferral.Complete(); deferral = null; } }
async private void ResetBackgroundAudio() { BackgroundMediaPlayer.Shutdown(); await Task.Delay(TimeSpan.FromSeconds(2)); StartBackgroundAudioTask(); }
private void StartBackgroundAudioTask() { AddMediaPlayerEventHandlers(); bool success = false; IAsyncAction taskInitResult = Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { success = taskInitialized.WaitOne(2000); if (success) { ValueSet message = new ValueSet(); message.Add(SharedStrings.BACKGROUND_AUDIO_START_PLAYBACK, "0"); BackgroundMediaPlayer.SendMessageToBackground(message); status.Log(LocalizableStrings.BACKGROUND_AUDIO_TASK_INVOKED); } else { status.Log(SharedStrings.BACKGROUND_AUDIO_STARTUP_TIMEOUT); } }); if (success) { taskInitResult.Completed = new AsyncActionCompletedHandler(taskInitResult_Completed); } }
private void ResetAfterLostBackground() { BackgroundMediaPlayer.Shutdown(); _isMyBackgroundTaskRunning = false; backgroundAudioTaskStarted.Reset(); audioPlayer.CanGoPrevious = false; audioPlayer.CanGoNext = false; ApplicationSettingsHelper.SaveSettingsValue(ApplicationSettingsConstants.BackgroundTaskState, BackgroundTaskState.Unknow.ToString()); audioPlayer.IsPlaying = true; try { BackgroundMediaPlayer.MessageReceivedFromBackground += BackgroundMediaPlayer_MessageReceivedFromBackground; } catch (Exception ex) { if (ex.HResult == RPC_S_SERVER_UNAVAILABLE) { throw new Exception("Failed to get a MediaPlayer instance."); } else { throw; } } }
/// <summary> /// Handles background task cancellation. Task cancellation happens due to : /// 1. Another Media app comes into foreground and starts playing music /// 2. Resource pressure. Your task is consuming more CPU and memory than allowed. /// In either case, save state so that if foreground app resumes it can know where to start. /// </summary> private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason) { // You get some time here to save your state before process and resources are reclaimed Debug.WriteLine("MyBackgroundAudioTask " + sender.Task.TaskId + " Cancel Requested..."); try { if (_queueManager != null) { QueueManager.TrackChanged -= playList_TrackChanged; _queueManager = null; } _appSettingsHelper.Write(PlayerConstants.BackgroundTaskState, PlayerConstants.BackgroundTaskCancelled); _backgroundtaskrunning = false; //unsubscribe event handlers _systemmediatransportcontrol.ButtonPressed -= systemmediatransportcontrol_ButtonPressed; _systemmediatransportcontrol.PropertyChanged -= systemmediatransportcontrol_PropertyChanged; BackgroundMediaPlayer.Shutdown(); // shutdown media pipeline } catch (Exception ex) { Debug.WriteLine(ex.ToString()); } if (_deferral != null) { _deferral.Complete(); // signals task completion. Debug.WriteLine("AudioPlayer Cancel complete..."); } }
private static void QueryForBackgroundTask() { ValueSet message = new ValueSet(); message.Add(Constants.BackgroundTaskQuery, null); BackgroundMediaPlayer.SendMessageToBackground(message); }
/// <summary> /// Handles background task cancellation. Task cancellation happens due to: /// 1. Another Media app comes into foreground and starts playing music /// 2. Resource pressure. Your task is consuming more CPU and memory than allowed. /// In either case, save state so that if foreground app resumes it can know where to start. /// </summary> private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason) { // You get some time here to save your state before process and resources are reclaimed Debug.WriteLine("MyBackgroundAudioTask " + sender.Task.TaskId + " Cancel Requested..."); try { // immediately set not running TaskStarted.Reset(); // Dispose _playerWrapper.Dispose(); _smtcWrapper.Dispose(); _foregroundMessenger.Dispose(); // shutdown media pipeline BackgroundMediaPlayer.Shutdown(); } catch (Exception ex) { Debug.WriteLine(ex.ToString()); } _settingsUtility.Write(ApplicationSettingsConstants.BackgroundTaskState, BackgroundTaskState.Canceled); _deferral.Complete(); // signals task completion. Debug.WriteLine("MyBackgroundAudioTask Cancel complete..."); }
public static void StopPlayback() { ValueSet message = new ValueSet(); message.Add(Constants.StopPlayback, null); BackgroundMediaPlayer.SendMessageToBackground(message); }
public static void PauseCurrentSong() { ValueSet message = new ValueSet(); message.Add(Constants.PauseTrack, null); BackgroundMediaPlayer.SendMessageToBackground(message); }
public void SendMessage(string constants, object value) { var message = new ValueSet(); message.Add(constants, value); BackgroundMediaPlayer.SendMessageToBackground(message); }
private static void SendMessageToBackground(string name, object parameter) { var valueSet = new ValueSet(); valueSet.Add(name, parameter); BackgroundMediaPlayer.SendMessageToBackground(valueSet); }
public async void PlaySong(QueueSong song) { if (song == null || song.Song == null) { CurtainPrompt.ShowError("Song seems to be empty..."); return; } Insights.Track( "Play Song", new Dictionary <string, string> { { "Name", song.Song.Name }, { "ArtistName", song.Song.ArtistName }, { "ProviderId", song.Song.ProviderId } }); if (_isShutdown) { await AddMediaPlayerEventHandlers(); } _appSettings.Write("RadioId", null); _appSettings.Write("RadioMode", false); _appSettings.Write(PlayerConstants.CurrentTrack, song.Id); var message = new ValueSet { { PlayerConstants.StartPlayback, null } }; BackgroundMediaPlayer.SendMessageToBackground(message); RaiseEvent(TrackChanged); }
private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason) { SaveText(DateTime.Now.Ticks, "Cancel", id, reason); BackgroundMediaPlayer.Shutdown(); deferral.Complete(); }
/// <summary> /// Called when IMediaPlayer [status changed]. /// </summary> /// <param name="sender">The sender.</param> /// <param name="eventArgs">The <see cref="EventArgs"/> instance containing the event data.</param> private void OnStatusChanged(object sender, EventArgs eventArgs) { if (this.mediaPlayer.Status == PlayerStatus.PLAYING) { //ThreadPool.RunOnUIThread( // async () => // { if (BackgroundMediaPlayer.Current.CurrentState == MediaPlayerState.Paused) { BackgroundMediaPlayer.Current.Play(); } else { //var file = this.trackMediaHelper.GetFileByMediaType(this.viewModel.CurrentTrack, TrackMediaType.AUDIO); //this.mediaPlayer.Duration = file.Duration; //this.viewModel.RaisePropertyChanged("Duration"); var fileUri = ""; //await this.trackMediaHelper.GetAuthenticatedUri(file); BackgroundMediaPlayer.SendMessageToBackground(new ValueSet { { "SetSource", fileUri.ToString() } }); } // }); } else if (this.mediaPlayer.Status == PlayerStatus.PAUSED) { //ThreadPool.RunOnUIThread( // async () => // { BackgroundMediaPlayer.Current.Pause(); // }); } }
public void SendMessageToBackground(String x, String y) { ValueSet valueSet = new ValueSet(); valueSet.Add(x, y); BackgroundMediaPlayer.SendMessageToBackground(valueSet); }
private void Taskcompleted(BackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs args) { SaveText(DateTime.Now.Ticks, "Complete", id, sender.Name); BackgroundMediaPlayer.Shutdown(); deferral.Complete(); }
/// <summary> /// Handles background task cancellation. Task cancellation happens due to : /// 1. Another Media app comes into foreground and starts playing music /// 2. Resource pressure. Your task is consuming more CPU and memory than allowed. /// In either case, save state so that if foreground app resumes it can know where to start. /// </summary> private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason) { // You get some time here to save your state before process and resources are reclaimed Debug.WriteLine("MyBackgroundAudioTask " + sender.Task.TaskId + " Cancel Requested..."); try { //save state ApplicationSettingsHelper.SaveSettingsValue(Constants.CurrentTrack, Playlist.CurrentTrackName); ApplicationSettingsHelper.SaveSettingsValue(Constants.Position, BackgroundMediaPlayer.Current.Position.ToString()); ApplicationSettingsHelper.SaveSettingsValue(Constants.BackgroundTaskState, Constants.BackgroundTaskCancelled); ApplicationSettingsHelper.SaveSettingsValue(Constants.AppState, Enum.GetName(typeof(ForegroundAppStatus), foregroundAppState)); backgroundtaskrunning = false; //unsubscribe event handlers systemmediatransportcontrol.ButtonPressed -= systemmediatransportcontrol_ButtonPressed; systemmediatransportcontrol.PropertyChanged -= systemmediatransportcontrol_PropertyChanged; Playlist.TrackChanged -= playList_TrackChanged; //clear objects task cancellation can happen uninterrupted playlistManager.ClearPlaylist(); playlistManager = null; BackgroundMediaPlayer.Shutdown(); // shutdown media pipeline } catch (Exception ex) { Debug.WriteLine(ex.ToString()); } deferral.Complete(); // signals task completion. Debug.WriteLine("MyBackgroundAudioTask Cancel complete..."); }
/// <summary> /// Performs the work of a background task. The system calls this method when the associated /// background task has been triggered. /// </summary> /// <param name="taskInstance"> /// An interface to an instance of the background task. The system creates this instance when the /// task has been triggered to run. /// </param> public void Run(IBackgroundTaskInstance taskInstance) { Debug.WriteLine("Background Audio Task " + taskInstance.Task.Name + " starting"); this.systemMediaTransportControl = SystemMediaTransportControls.GetForCurrentView(); this.systemMediaTransportControl.IsEnabled = true; this.systemMediaTransportControl.IsPauseEnabled = true; this.systemMediaTransportControl.IsPlayEnabled = true; this.systemMediaTransportControl.IsNextEnabled = true; this.systemMediaTransportControl.IsPreviousEnabled = true; // Wire up system media control events this.systemMediaTransportControl.ButtonPressed += this.OnSystemMediaTransportControlButtonPressed; this.systemMediaTransportControl.PropertyChanged += this.OnSystemMediaTransportControlPropertyChanged; // Wire up background task events taskInstance.Canceled += this.OnTaskCanceled; taskInstance.Task.Completed += this.OnTaskcompleted; // Initialize message channel BackgroundMediaPlayer.MessageReceivedFromForeground += this.OnMessageReceivedFromForeground; // Notify foreground that we have started playing BackgroundMediaPlayer.SendMessageToForeground(new ValueSet() { { "BackgroundTaskStarted", "" } }); this.backgroundTaskStarted.Set(); this.backgroundTaskRunning = true; this.deferral = taskInstance.GetDeferral(); }
protected override async void OnNavigatedTo(NavigationEventArgs e) { SystemNavigationManager.GetForCurrentView().AppViewBackButtonVisibility = AppViewBackButtonVisibility.Collapsed; DisplayInformation.AutoRotationPreferences = DisplayOrientations.Portrait; await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { try { if (BackgroundMediaPlayer.Current.PlaybackSession.PlaybackState == MediaPlaybackState.Paused | BackgroundMediaPlayer.Current.PlaybackSession.PlaybackState == MediaPlaybackState.None) { (Radio.Icon as BitmapIcon).UriSource = uriMute; } if (BackgroundMediaPlayer.Current.PlaybackSession.PlaybackState == MediaPlaybackState.Playing) { (Radio.Icon as BitmapIcon).UriSource = uriSound; } } catch (Exception) { (Radio.Icon as BitmapIcon).UriSource = uriMute; BackgroundMediaPlayer.Shutdown(); } }); BackgroundMediaPlayer.Current.CurrentStateChanged += radioPlayer_CurrentStateChanged; }
private void ResetAfterLostBackground() { BackgroundMediaPlayer.Shutdown(); _isMyBackgroundTaskRunning = false; backgroundAudioTaskStarted.Reset(); //prevButton.IsEnabled = true; //nextButton.IsEnabled = true; ApplicationSettingsHelper.SaveSettingsValue(ApplicationSettingsConstants.BackgroundTaskState, BackgroundTaskState.Unknown.ToString()); Pause.Icon = new SymbolIcon(Symbol.Pause); try { BackgroundMediaPlayer.MessageReceivedFromBackground += BackgroundMediaPlayer_MessageReceivedFromBackground; } catch (Exception ex) { if (ex.HResult == RPC_S_SERVER_UNAVAILABLE) { throw new Exception("Failed to get a MediaPlayer instance."); } else { throw; } } }
private void SendMessageToBackground(PlayQueueConstantFGMessageId messageId, object value) { var message = new ValueSet(); message.Add(PlayQueueMessageHelper.FGMessageIdToMessageString(messageId), value); BackgroundMediaPlayer.SendMessageToBackground(message); }
/// <summary> /// The background task did exist, but it has disappeared. Put the foreground back into an initial state. Unfortunately, /// any attempts to unregister things on BackgroundMediaPlayer.Current will fail with the RPC error once the background task has been lost. /// </summary> private void ResetAfterLostBackground() { BackgroundMediaPlayer.Shutdown(); _isMyBackgroundTaskRunning = false; backgroundAudioTaskStarted.Reset(); PreviousButtonIsEnabled = true; NextButtonIsEnabled = true; StopButtonVisibility = Visibility.Collapsed; PlayButtonVisibility = Visibility.Visible; PlayButtonIsEnabled = true; RefreshBindings(); ApplicationSettingsHelper.SaveSettingsValue(ApplicationSettingsConstants.BackgroundTaskState, BackgroundTaskState.Unknown.ToString()); try { BackgroundMediaPlayer.MessageReceivedFromBackground += BackgroundMediaPlayer_MessageReceivedFromBackground; } catch (Exception ex) { if (ex.HResult == RPC_S_SERVER_UNAVAILABLE) { throw new Exception("Failed to get a MediaPlayer instance."); } else { throw; } } }
/// <summary> /// Sends message to background informing app has resumed /// Subscribe to MediaPlayer events /// </summary> void ForegroundApp_Resuming(object sender, object e) { ApplicationSettingsHelper.SaveSettingsValue(Constants.AppState, Constants.ForegroundAppActive); // Verify if the task was running before if (IsMyBackgroundTaskRunning) { //if yes, reconnect to media play handlers AddMediaPlayerEventHandlers(); //send message to background task that app is resumed, so it can start sending notifications ValueSet messageDictionary = new ValueSet(); messageDictionary.Add(Constants.AppResumed, DateTime.Now.ToString()); BackgroundMediaPlayer.SendMessageToBackground(messageDictionary); if (BackgroundMediaPlayer.Current.CurrentState == MediaPlayerState.Playing) { playButton.Content = "| |"; // Change to pause button } else { playButton.Content = ">"; // Change to play button } txtCurrentTrack.Text = CurrentTrack; } else { playButton.Content = ">"; // Change to play button txtCurrentTrack.Text = ""; } }
/// <summary> /// The background task did exist, but it has disappeared. Put the foreground back into an initial state. Unfortunately, /// any attempts to unregister things on BackgroundMediaPlayer.Current will fail with the RPC error once the background task has been lost. /// </summary> private void ResetAfterLostBackground() { backgroundAudioTaskStarted.Reset(); BackgroundMediaPlayer.Shutdown(); try { BackgroundMediaPlayer.MessageReceivedFromBackground -= BackgroundPlayerMessageReceivedFromBackground; BackgroundMediaPlayer.MessageReceivedFromBackground += BackgroundPlayerMessageReceivedFromBackground; } catch (Exception ex) { if (ex.HResult == RPC_S_SERVER_UNAVAILABLE) { telemetry.TrackException(ex, new Dictionary <string, string> { { "Scenario", "ResetPlayerServerUnavailable" } }); throw new Exception("Failed to get a MediaPlayer instance."); } else { throw; } } }
private void HandleTaskInstanceCanceled(IBackgroundTaskInstance taskInstance, BackgroundTaskCancellationReason reason) { PlayQueueManager.Current.Disconnect(); TileUpdateManager.CreateTileUpdaterForApplication("App").Clear(); Logger.Current.Log(new CallerInfo(), LogLevel.Info, "AudioPlayer Background Task Completed id:{0} reason:{1}", taskInstance.Task.TaskId, reason.ToString()); ApplicationSettings.PutSettingsValue(ApplicationSettings.IS_BACKGROUND_PROCESS_ACTIVE, false); if (ApplicationSettings.GetSettingsValue <bool>(ApplicationSettings.IS_FOREGROUND_PROCESS_ACTIVE, false)) { PlayQueueManager.Current.SendMessageToForeground(PlayQueueConstantBGMessageId.BackgroundEnded); } backgroundTaskState = BackgroundTaskState.Stopped; PlayQueueManager.Current.TrackChanged -= HandlePlayQueueTrackChanged; BackgroundMediaPlayer.Current.CurrentStateChanged -= HandleBackgroundMediaPlayerCurrentStateChanged; taskInstance.Task.Completed -= HandleTaskInstanceTaskCompleted; taskInstance.Canceled -= HandleTaskInstanceCanceled; BackgroundMediaPlayer.Shutdown(); Logger.Current.Flush(); backgroundTaskDefferal.Complete(); }
private async void ToggleSwitch_Toggled(object sender, RoutedEventArgs e) { ToggleSwitch toggleSwitch = sender as ToggleSwitch; if (toggleSwitch != null) { await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { if (toggleSwitch.IsOn) { if (BackgroundMediaPlayer.Current.CurrentState != MediaPlayerState.Playing) { var message = new ValueSet { { "Play", urlRadio } }; BackgroundMediaPlayer.SendMessageToBackground(message); } } else { BackgroundMediaPlayer.Current.Pause(); } }); } }
public void OnActivated(BackgroundMediaPlayer mediaPlayer) { _codecManager = new CodecManager(); _codecManager.RegisterDefaultCodecs(); this.mediaPlayer = mediaPlayer; smtc = mediaPlayer.SystemMediaTransportControls; ConfigureSystemMediaTransportControls(); mediaPlayer.MediaOpened += MediaPlayer_MediaOpened; mediaPlayer.MediaEnded += MediaPlayer_MediaEnded; mediaPlayer.CurrentStateChanged += MediaPlayer_CurrentStateChanged; Switch(); }