//
// Handles background task cancellation.
//
private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
//
// Indicate that the background task is canceled.
//
}
/// <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...");
}
//
// Handles background task cancellation.
//
private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
//
// Indicate that the background task is canceled.
//
Debug.WriteLine("Background " + sender.Task.Name + " Cancel Requested...");
}
private void TaskInstance_Canceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
_clock.Dispose();
_timer2.Cancel();
_timer3.Cancel();
_deferral.Complete();
}
private void TaskInstance_Canceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
var properties = new Dictionary<string, string>();
properties.Add("Reason", reason.ToString());
StartupTask.WriteTelemetryEvent("AppServicesBackgroundTask_Canceled", properties);
serviceDeferral.Complete();
}
private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
_cancelRequested = true;
_cancelReason = reason;
Debug.WriteLine($"Background '{sender.Task.Name}' Cancel Requested...");
}
private void TaskInstance_Canceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
if (this.deferral != null)
{
this.deferral.Complete();
}
}
private void TaskInstance_Canceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
this.SendToForeground(CommunicationConstants.BackgroundTaskStopped);
try
{
ApplicationSettings.BackgroundTaskResumeSongTime.Save(BackgroundMediaPlayer.Current.Position.TotalSeconds);
/*
//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;
*/
this.mediaControls.ButtonPressed -= mediaControls_ButtonPressed;
playlistManager = null;
BackgroundMediaPlayer.Shutdown(); // shutdown media pipeline
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
if (_deferral != null)
_deferral.Complete();
}
private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
if (_cts != null)
{
_cts.Cancel();
_cts = null;
}
}
private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
//
// Indicate that the background task is canceled.
//
_cancelRequested = true;
_cancelReason = reason;
}
private void canceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
deferral.Complete();
deferral = null;
timer.Tick -= timerTick;
timer = null;
controller = null;
}
private void OnTaskCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
if (this.serviceDeferral != null)
{
//Complete the service deferral
this.serviceDeferral.Complete();
}
}
private void TaskInstance_Canceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
BackgroundMediaPlayer.Shutdown();
if (deferral != null)
{
deferral.Complete();
}
}
private void TaskInstance_Canceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
if (mDeferral != null)
{
mDeferral.Complete();
}
CurrentOperation.PhoneCallTaskDeferral = null;
}
/// <summary>
/// Called when the background task is canceled by the app or by the system.
/// </summary>
/// <param name="sender"></param>
/// <param name="reason"></param>
private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
ApplicationData.Current.LocalSettings.Values["TaskCancelationReason"] = reason.ToString();
ApplicationData.Current.LocalSettings.Values["SampleCount"] = _sampleCount;
ApplicationData.Current.LocalSettings.Values["IsBackgroundTaskActive"] = false;
// Complete the background task (this raises the OnCompleted event on the corresponding BackgroundTaskRegistration).
_deferral.Complete();
}
private void OnTaskCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
Debug.WriteLine("App service closed due to an unexpected failure; Cleaning up");
if (this.serviceDeferral != null)
{
//Complete the service deferral
this.serviceDeferral.Complete();
}
}
private void OnTaskCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
System.Diagnostics.Debug.WriteLine("Task cancelled, clean up");
if (this.serviceDeferral != null)
{
//Complete the service deferral
this.serviceDeferral.Complete();
}
}
private void TaskInstance_Canceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
if (_deferral != null)
{
_deferral.Complete();
}
Current.RTCTaskDeferral = null;
}
private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
LiveTile.UpdateSecondaryTile("--");
System.Diagnostics.Debug.WriteLine("Background " + sender.Task.Name + " Cancel Requested because " + reason);
if (!reason.Equals(BackgroundTaskCancellationReason.Abort))
{
ToastHelper.PopToast("Background Cancelled", "Background Task Cancelled, reason: " + reason + ", please re-start the applications.");
}
}
private async void TaskInstance_Canceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
var properties = new Dictionary<string, string>();
properties.Add("Reason", reason.ToString());
WriteTelemetryEvent("App_Shutdown", properties);
await s_radioManager.Dispose();
deferral.Complete();
}
//
// Handles background task cancellation.
//
private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
//
// Indicate that the background task is canceled.
//
var settings = Windows.Storage.ApplicationData.Current.LocalSettings;
settings.Values[sender.Task.TaskId.ToString()] = "Canceled";
Debug.WriteLine("Background " + sender.Task.Name + " Cancel Requested...");
}
private void OnCanceled(IBackgroundTaskInstance taskInstance, BackgroundTaskCancellationReason reason)
{
cancelReason = reason;
cancelRequested = true;
ApplicationData.Current.LocalSettings.Values["TaskCancelationReason"] = cancelReason.ToString();
ApplicationData.Current.LocalSettings.Values["IsBackgroundTaskActive"] = false;
// Complete the background task (this raises the OnCompleted event on the corresponding BackgroundTaskRegistration).
deferral.Complete();
}
/// <summary>
/// Called when the background task is canceled by the app or by the system.
/// </summary>
/// <param name="sender"></param>
/// <param name="reason"></param>
private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
ApplicationData.Current.LocalSettings.Values["TaskCancelationReason"] = reason.ToString();
ApplicationData.Current.LocalSettings.Values["SampleCount"] = SampleCount;
ApplicationData.Current.LocalSettings.Values["IsBackgroundTaskActive"] = false;
if (null != Accelerometer)
{
Accelerometer.ReadingChanged -= new TypedEventHandler<Accelerometer, AccelerometerReadingChangedEventArgs>(ReadingChanged);
Accelerometer.ReportInterval = 0;
}
// Complete the background task (this raises the OnCompleted event on the corresponding BackgroundTaskRegistration).
Deferral.Complete();
}
/// <summary>
/// Complete the deferral when the task is cancelled.
/// </summary>
/// <param name="sender">the background task instance</param>
/// <param name="reason">the cancellation reason</param>
private void OnTaskCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
_canceled = true;
if (_action != null && _action.Status == AsyncStatus.Started)
{
_action.Cancel();
}
if (this.backgroundTaskDeferral != null)
{
// Complete the service deferral.
this.backgroundTaskDeferral.Complete();
this.backgroundTaskDeferral = null;
}
}
private void TaskInstance_Canceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
lock (Locker)
{
try
{
if ((sender.TriggerDetails as AppServiceTriggerDetails)?.AppServiceConnection is AppServiceConnection DisConnection)
{
try
{
DisConnection.RequestReceived -= Connection_RequestReceived;
if (ServiceAndClientConnections.FirstOrDefault((Pair) => Pair.Server == DisConnection || Pair.Client == DisConnection) is ServerAndClientPair ConnectionPair)
{
if (ConnectionPair.Server == DisConnection)
{
ConnectionPair.Server = null;
}
else
{
ServiceAndClientConnections.Remove(ConnectionPair);
ConnectionPair.Client = null;
ConnectionPair.Server?.SendMessageAsync(new ValueSet {
{ "ExecuteType", "Execute_Exit" }
}).AsTask().ConfigureAwait(false).GetAwaiter().GetResult();
}
}
}
finally
{
DisConnection.Dispose();
}
}
}
catch (Exception ex)
{
Debug.WriteLine($"Error thrown in CommuniteService: {ex.Message}");
}
finally
{
Deferral.Complete();
}
}
}
private void TaskInstance_Canceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
switch (reason)
{
case BackgroundTaskCancellationReason.Abort:
//app unregistered background task (amoung other reasons).
break;
case BackgroundTaskCancellationReason.Terminating:
//system shutdown
break;
case BackgroundTaskCancellationReason.LoggingOff:
break;
case BackgroundTaskCancellationReason.ServicingUpdate:
break;
case BackgroundTaskCancellationReason.IdleTask:
break;
case BackgroundTaskCancellationReason.Uninstall:
break;
case BackgroundTaskCancellationReason.ConditionLoss:
break;
case BackgroundTaskCancellationReason.SystemPolicy:
break;
case BackgroundTaskCancellationReason.ExecutionTimeExceeded:
break;
case BackgroundTaskCancellationReason.ResourceRevocation:
break;
case BackgroundTaskCancellationReason.EnergySaver:
break;
default:
throw new ArgumentOutOfRangeException(nameof(reason), reason, null);
}
this.m_backgroundTaskDeferral.Complete();
}
private void TaskInstance_Canceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
try
{
if ((sender.TriggerDetails as AppServiceTriggerDetails)?.AppServiceConnection is AppServiceConnection DisConnection)
{
try
{
DisConnection.RequestReceived -= Connection_RequestReceived;
lock (Locker)
{
if (PairedConnections.TryRemove(DisConnection, out AppServiceConnection ServerConnection))
{
Task.WaitAny(ServerConnection.SendMessageAsync(new ValueSet {
{ "ExecuteType", "Execute_Exit" }
}).AsTask(), Task.Delay(2000));
}
else if (PairedConnections.FirstOrDefault((Con) => Con.Value == DisConnection).Key is AppServiceConnection ClientConnection)
{
if (PairedConnections.TryRemove(ClientConnection, out _))
{
Task.WaitAny(ClientConnection.SendMessageAsync(new ValueSet {
{ "ExecuteType", "FullTrustProcessExited" }
}).AsTask(), Task.Delay(2000));
ClientConnection.Dispose();
}
}
}
}
finally
{
DisConnection.Dispose();
}
}
}
catch (Exception ex)
{
Debug.WriteLine($"Error was threw in CommunicateService: {ex.Message}");
}
finally
{
Deferral.Complete();
}
}
/// <summary>
/// Вызывается при отмене фоновой задачи.
/// </summary>
private void TaskInstance_Canceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
#if DEBUG
Debug.WriteLine("AudioTask cancel requested.");
#endif
SendMessageToForeground(AppConstants.PlayerTaskRunning, false);
SettingsHelper.Set(AppConstants.PlayerTaskRunning, false);
_isTaskRunning = false;
BackgroundMediaPlayer.MessageReceivedFromForeground -= OnMessageReceivedFromForeground;
_player.CurrentStateChanged -= Player_CurrentStateChanged;
_manager.TrackChanged -= Manager_TrackChanged;
_controls.ButtonPressed -= Controls_ButtonPressed;
_manager = null;
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
{
systemmediatransportcontrol.ButtonPressed -= systemmediatransportcontrol_ButtonPressed;
systemmediatransportcontrol.PropertyChanged -= systemmediatransportcontrol_PropertyChanged;
BackgroundMediaPlayer.Shutdown(); // shutdown media pipeline
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
deferral.Complete(); // signals task completion.
Debug.WriteLine("MyBackgroundAudioTask Cancel complete...");
}
public void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
Debug.WriteLine("BackgroundAudioRun.OnCanceled() " + _id + " reason " + reason);
try
{
var mediaPlayerManager = _mediaPlayerManager;
if (null == mediaPlayerManager)
{
BackgroundSettings.Position = null;
}
else
{
var mediaPlayer = _mediaPlayerManager.MediaPlayer;
if (null != mediaPlayer && mediaPlayer.CanSeek)
{
var position = mediaPlayer.Position;
BackgroundSettings.Position = position;
}
else
{
BackgroundSettings.Position = null;
}
}
}
catch (Exception ex)
{
Debug.WriteLine("BackgroundAudioRun.OnCanceled() position store failed: " + ex.ExtendedMessage());
}
_completionSource.TrySetResult(null);
try
{
Cancel();
}
catch (Exception ex)
{
Debug.WriteLine("BackgroundAudioRun.OnCanceled() cancel failed: " + ex.ExtendedMessage());
}
}
private void TaskInstance_Canceled(IBackgroundTaskInstance sender,
BackgroundTaskCancellationReason reason)
{
_isClosing = true;
if (_timer != null)
{
_timer.Dispose();
_timer = null;
}
// if (_handler != null)
{
// _handler.Dispose();
// _handler = null;
}
sender.GetDeferral().Complete();
}
/// <summary>
/// This happens when an app closes its connection normally.
/// </summary>
private async void OnTaskCancelled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
System.Diagnostics.Debug.WriteLine("MessageRelay was cancelled, removing " + _thisConnectionGuid + " from the list of active connections.");
RemoveConnection(_thisConnectionGuid);
if (Connections.Count == 1)
{
// Last open connection is the fulltrust process, lets close it
// This should be done better and handle fulltrust process crashes
var value = new ValueSet() { { "Arguments", "Terminate" } };
await SendMessageAsync(Connections.Single(), value);
}
if (_backgroundTaskDeferral != null)
{
_backgroundTaskDeferral.Complete();
_backgroundTaskDeferral = null;
}
}
//volatile bool _cancelRequested = false;
private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
#if LOG_STEP
var tbtLogC = await ApplicationData.Current.LocalFolder.CreateFileAsync("TbtCancelled.txt", CreationCollisionOption.ReplaceExisting);
using (var s = await tbtLogC.OpenStreamForWriteAsync())
{
var sw = new StreamWriter(s);
var ct = DateTime.Now;
sw.WriteLine("Background task cancellation time: " + ct.ToString());
sw.Flush();
}
#endif
//
// Indicate that the background task is canceled.
//
//_cancelRequested = true;
deferral.Complete();
}
/// <summary>
/// Periodically check if there's a new message and if there is, send it over the socket
/// </summary>
/// <param name="timer"></param>
private async void PeriodicTimerCallback(ThreadPoolTimer timer)
{
if (!cancelRequested)
{
string message = (string)ApplicationData.Current.LocalSettings.Values["SendMessage"];
if (!string.IsNullOrEmpty(message))
{
try
{
// Make sure that the connection is still up and there is a message to send
if (socket != null)
{
writer.WriteUInt32((uint)message.Length);
writer.WriteString(message);
await writer.StoreAsync();
ApplicationData.Current.LocalSettings.Values["SendMessage"] = null;
}
else
{
cancelReason = BackgroundTaskCancellationReason.ConditionLoss;
deferral.Complete();
}
}
catch (Exception ex)
{
ApplicationData.Current.LocalSettings.Values["TaskCancelationReason"] = ex.Message;
ApplicationData.Current.LocalSettings.Values["SendMessage"] = null;
deferral.Complete();
}
}
}
else
{
// Timer clean up
periodicTimer.Cancel();
//
// Write to LocalSettings to indicate that this background task ran.
//
ApplicationData.Current.LocalSettings.Values["TaskCancelationReason"] = cancelReason.ToString();
}
}
private void TaskInstance_Canceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
//a few reasons that you may be interested in.
switch (reason)
{
case BackgroundTaskCancellationReason.Abort:
//app unregistered background task (amoung other reasons).
break;
case BackgroundTaskCancellationReason.Terminating:
//system shutdown
break;
case BackgroundTaskCancellationReason.ConditionLoss:
break;
case BackgroundTaskCancellationReason.SystemPolicy:
break;
}
http.Dispose();
_defferal.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)
{
SendBackgroundTaskIsStopping();
try
{
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());
}
deferral.Complete(); // signals task completion.
Debug.WriteLine("MyBackgroundAudioTask Cancel complete...");
}
public static CancellationReason ConvertCancellationReason(this BackgroundTaskCancellationReason reason)
{
switch (reason)
{
case BackgroundTaskCancellationReason.Abort:
return(CancellationReason.Abort);
case BackgroundTaskCancellationReason.Terminating:
return(CancellationReason.Terminating);
case BackgroundTaskCancellationReason.LoggingOff:
return(CancellationReason.LoggingOff);
case BackgroundTaskCancellationReason.ServicingUpdate:
return(CancellationReason.ServicingUpdate);
case BackgroundTaskCancellationReason.IdleTask:
return(CancellationReason.IdleTask);
case BackgroundTaskCancellationReason.Uninstall:
return(CancellationReason.Uninstall);
case BackgroundTaskCancellationReason.ConditionLoss:
return(CancellationReason.ConditionLoss);
case BackgroundTaskCancellationReason.SystemPolicy:
return(CancellationReason.SystemPolicy);
case BackgroundTaskCancellationReason.ExecutionTimeExceeded:
return(CancellationReason.ExecutionTimeExceeded);
case BackgroundTaskCancellationReason.ResourceRevocation:
return(CancellationReason.ResourceRevocation);
case BackgroundTaskCancellationReason.EnergySaver:
return(CancellationReason.EnergySaver);
default:
throw new ArgumentOutOfRangeException(nameof(reason), reason, null);
}
}
/// <summary>
/// 后台任务取消的event handler
/// </summary>
/// <param name="sender"></param>
/// <param name="reason">取消原因</param>
private void TaskInstance_Canceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
Debug.WriteLine("BackgroundAudioTask " + sender.Task.TaskId + " Cancel Requested...");
try
{
backgroundTaskStarted.Reset();
//保存前后台任务状态和歌曲播放信息
BackgroundAudioSettingsHelper.SetValue(BackgroundAudioSettingsConstants.TRACK_INDEX, playbackList.CurrentItemIndex);
BackgroundAudioSettingsHelper.SetValue(BackgroundAudioSettingsConstants.POSITION, BackgroundMediaPlayer.Current.Position.ToString());
BackgroundAudioSettingsHelper.SetValue(BackgroundAudioSettingsConstants.BACKGROUND_TASK_STATE, BackgroundTaskState.Canceled.ToString());
BackgroundAudioSettingsHelper.SetValue(BackgroundAudioSettingsConstants.APP_STATE, Enum.GetName(typeof(AppState), foregroundAppState));
//清空播放列表
if (playbackList != null)
{
//playbackList.CurrentItemChanged -= PlaybackList_CurrentItemChanged;
playbackList = null;
}
//取消注册时间
BackgroundMediaPlayer.MessageReceivedFromForeground -= BackgroundMediaPlayer_MessageReceivedFromForeground;
smtc.ButtonPressed -= Smtc_ButtonPressed;
smtc.PropertyChanged -= Smtc_PropertyChanged;
//发送后台任务停止消息给前台
MessageService.SendMessageToForeground(new BackgroundAudioTaskStopedMessage());
//关闭后台播放器
BackgroundMediaPlayer.Shutdown();
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString() + " " + ex.Message);
}
finally
{
deferral.Complete();
Debug.WriteLine("BackgroundAudioTask Cancel Completed");
}
}
private void OnAppServicesCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
AppServiceTriggerDetails appService = sender.TriggerDetails as AppServiceTriggerDetails;
try
{
CurrentConnectionIndex = int.Parse(appService.AppServiceConnection.AppServiceName);
AppServiceDeferral = AppServiceDeferrals[CurrentConnectionIndex];
AppServiceDeferrals.Remove(CurrentConnectionIndex);
if (AppServiceDeferral != null)
{
AppServiceDeferral.Complete();
AppServiceDeferral = null;
}
}
catch (Exception Ex)
{
Debug.WriteLine("OnAppServicesCanceled error: " + Ex.Message);
}
}
private void TaskInstance_Canceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
//a few reasons that you may be interested in.
switch (reason)
{
case BackgroundTaskCancellationReason.Abort:
//app unregistered background task (amoung other reasons).
break;
case BackgroundTaskCancellationReason.Terminating:
//system shutdown
break;
case BackgroundTaskCancellationReason.ConditionLoss:
break;
case BackgroundTaskCancellationReason.SystemPolicy:
break;
}
deferral.Complete();
}
/// <summary>
/// Method executed on sudden background task cancellation i.e. launching another music player
/// </summary>
/// <param name="sender">Background task instance</param>
/// <param name="reason">Reason for cancellation</param>
private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
try
{
backgroundTaskStarted.Reset();
if (currentPlaylist != null)
{
currentPlaylist = null;
}
systemMediaTransportControl.ButtonPressed -= MediaTransportControlButtonPressed;
BackgroundMediaPlayer.Shutdown(); // shutdown media pipeline
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
taskDeferral.Complete(); // signals task completion.
}
private async void OnTaskCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
if (this.persistenceLayer != null)
{
this.persistenceLayer.Save();
}
if (this.synchronizationManager != null)
{
await this.synchronizationManager.SaveAsync();
}
await LogService.SaveAsync();
ReportStatus(BackgroundExecutionStatus.Cancelled);
if (this.deferral != null)
{
this.deferral.Complete();
}
}
/// <summary>
/// Executes the task canceled action.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="reason">The reason.</param>
private void OnTaskCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
Debug.WriteLine("Background Audio Task " + sender.Task.TaskId + " cancelling");
Debug.WriteLine("Background Audio Task cancel reason: {0}", reason);
try
{
// Unsubscribe event handlers
this.systemMediaTransportControl.ButtonPressed -= this.OnSystemMediaTransportControlButtonPressed;
this.systemMediaTransportControl.PropertyChanged -= this.OnSystemMediaTransportControlPropertyChanged;
BackgroundMediaPlayer.Shutdown();
}
catch (Exception ex)
{
// TODO: Must send exception to app and the app must report to Insights
}
this.deferral.Complete();
Debug.WriteLine("Background Audio Task canceled");
}
private void TaskInstance_Canceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
_AppTriggerDeferral?.Complete();
_SyncDeferral?.Complete();
_ToastDeferral?.Complete();
_ExExecSession.Revoked -= ExExecSession_Revoked;
_ExExecSession.Dispose();
_ExExecSession = null;
ToastHelper.ShowMessage($"{sender.Task.Name} has been canceled", reason.ToString());
//switch (sender.Task.Name)
//{
// case "SyncNotifications":
// case "SyncNotificationsApp":
// _SyncDeferral?.Complete();
// _SyncAppDeferral?.Complete();
// break;
// case "ToastNotificationBackgroundTask":
// _ToastActionDeferral?.Complete();
// break;
//}
}
/// <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
AppSettingsHelper.Write(PlayerConstants.Position,
BackgroundMediaPlayer.Current.Position.ToString());
AppSettingsHelper.Write(PlayerConstants.BackgroundTaskState,
PlayerConstants.BackgroundTaskCancelled);
AppSettingsHelper.Write(PlayerConstants.AppState,
Enum.GetName(typeof(ForegroundAppStatus), _foregroundAppState));
_backgroundtaskrunning = false;
//unsubscribe event handlers
_systemmediatransportcontrol.ButtonPressed -= systemmediatransportcontrol_ButtonPressed;
_systemmediatransportcontrol.PropertyChanged -= systemmediatransportcontrol_PropertyChanged;
if (_queueManager != null)
{
AppSettingsHelper.Write(PlayerConstants.CurrentTrack, QueueManager.CurrentTrack.Id);
QueueManager.TrackChanged -= playList_TrackChanged;
_queueManager = null;
}
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 void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
try
{
BackgroundMediaPlayer.Current.Pause();
BackgroundMediaPlayer.MessageReceivedFromForeground -= MessageReceivedFromForeground;
if (shutdown)
{
ApplicationSettingsHelper.SaveSettingsValue(AppConstants.Position, TimeSpan.Zero.ToString());
}
else
{
ApplicationSettingsHelper.SaveSettingsValue(AppConstants.Position, BackgroundMediaPlayer.Current.Position.ToString());
}
nowPlayingManager.RemoveHandlers();
nowPlayingManager = null;
ApplicationSettingsHelper.SaveSettingsValue(AppConstants.BackgroundTaskState, AppConstants.BackgroundTaskCancelled);
ApplicationSettingsHelper.SaveSettingsValue(AppConstants.AppState, Enum.GetName(typeof(ForegroundTaskStatus), foregroundTaskStatus));
backgroundTaskStatus = false;
//unsubscribe event handlers
systemControls.ButtonPressed -= HandleButtonPressed;
systemControls.PropertyChanged -= HandlePropertyChanged;
if (!shutdown)
{
BackgroundMediaPlayer.Shutdown(); // shutdown media pipeline
}
}
catch (Exception ex)
{
NextPlayerDataLayer.Diagnostics.Logger.SaveBG("Audio Player OnCanceled " + "\n" + "Message: " + ex.Message + "\n" + "Link: " + ex.HelpLink);
NextPlayerDataLayer.Diagnostics.Logger.SaveToFileBG();
}
deferral.Complete(); // signals task completion.
}
/// <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(BackgroundAudioConstants.CurrentTrack, Playlist.CurrentTrackIndex);
ApplicationSettingsHelper.SaveSettingsValue(BackgroundAudioConstants.Position, BackgroundMediaPlayer.Current.Position.ToString());
ApplicationSettingsHelper.SaveSettingsValue(BackgroundAudioConstants.Time, BackgroundMediaPlayer.Current.NaturalDuration.ToString());
ApplicationSettingsHelper.SaveSettingsValue(BackgroundAudioConstants.BackgroundTaskState, BackgroundAudioConstants.BackgroundTaskCancelled);
ApplicationSettingsHelper.SaveSettingsValue(BackgroundAudioConstants.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.ResetCollection((int)ResetType.NormalReset);
playlistManager = null;
// Send message to foreground task (if it's around) that this task was cancelled :(
ValueSet message = new ValueSet {
{ BackgroundAudioConstants.BackgroundTaskCancelled, "" }
};
BackgroundMediaPlayer.SendMessageToForeground(message);
BackgroundMediaPlayer.Shutdown(); // shutdown media pipeline
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
deferral?.Complete(); // signals task completion.
Debug.WriteLine("MyBackgroundAudioTask Cancel 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>
void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
// You get some time here to save your state before process and resources are reclaimed
Debug.WriteLine("Bgt " + sender.Task.TaskId + " Cancel Requested...");
try
{
// immediately set not running
backgroundTaskStarted.Reset();
// save state
AppSettingsHelper.SaveVal(ApplicationSettingsConstants.TrackId, GetCurrentTrackId() == null ? null : GetCurrentTrackId().ToString());
AppSettingsHelper.SaveVal(ApplicationSettingsConstants.Position, BackgroundMediaPlayer.Current.Position.ToString());
AppSettingsHelper.SaveVal(ApplicationSettingsConstants.BackgroundTaskState, BackgroundTaskState.Canceled.ToString());
AppSettingsHelper.SaveVal(ApplicationSettingsConstants.AppState, Enum.GetName(typeof(AppState), foregroundAppState));
// unsubscribe from list changes
if (_mpl != null)
{
_mpl.CurrentItemChanged -= PlaybackList_CurrentItemChanged;
_mpl = null;
}
// 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.Message}"); if (Debugger.IsAttached)
{
Debugger.Break();
} /*else throw;*/
MessageService.SendMessageToForeground(new ExceptionCaughtMessage(ex.Message)); }
deferral.Complete(); // signals task completion.
Debug.WriteLine("Bgt Cancel 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
{
TaskStarted.Reset();
if (_queueManager != null)
{
QueueManager.TrackChanged -= playList_TrackChanged;
_queueManager = null;
}
_appSettingsHelper.Write(PlayerConstants.BackgroundTaskState,
PlayerConstants.BackgroundTaskCancelled);
_backgroundtaskrunning = false;
//unsubscribe event handlers
_systemmediatransportcontrol.ButtonPressed -= systemmediatransportcontrol_ButtonPressed;
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...");
}
QueueManager.ErrorHandler -= QueueManager_ErrorHandler;
TileUpdateManager.CreateTileUpdaterForApplication("App").Clear();
}
/// <summary>
/// Associate the cancellation handler with the background task
/// </summary>
private void OnCentennialAppServicesCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
AppServiceTriggerDetails appService = sender.TriggerDetails as AppServiceTriggerDetails;
this.currentConnectionIndex = Int32.Parse(appService.AppServiceConnection.AppServiceName);
this.connection = connections[this.currentConnectionIndex];
this.connection.Dispose();
connections.Remove(this.currentConnectionIndex);
this.appServiceDeferral = appServiceDeferrals[this.currentConnectionIndex];
appServiceDeferrals.Remove(this.currentConnectionIndex);
this.centennialAppServiceDeferral = centennialAppServiceDeferrals[this.currentConnectionIndex];
centennialAppServiceDeferrals.Remove(this.currentConnectionIndex);
if (this.appServiceDeferral != null)
{
this.appServiceDeferral.Complete();
this.appServiceDeferral = null;
}
if (this.centennialAppServiceDeferral != null)
{
this.centennialAppServiceDeferral.Complete();
this.centennialAppServiceDeferral = null;
}
}
/// <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();
// unsubscribe from list changes
if (_playbackList != null)
{
_playbackList.CurrentItemChanged -= PlaybackListCurrentItemChanged;
_playbackList = null;
}
// remove handlers for MediaPlayer
BackgroundMediaPlayer.Current.CurrentStateChanged -= MediaPlayerStateChanged;
BackgroundMediaPlayer.Current.MediaEnded -= MediaPlayerMediaEnded;
// unsubscribe event handlers
BackgroundMediaPlayer.MessageReceivedFromForeground -= MessageReceivedFromForeground;
smtc.ButtonPressed -= AudioControlButtonPressed;
smtc.PropertyChanged -= AudioControlPropertyChanged;
BackgroundMediaPlayer.Shutdown(); // shutdown media pipeline
}
catch (Exception ex)
{
telemetry.TrackException(ex, new Dictionary <string, string> {
{ "Scenario", "BackgroundAudioCancel" }
});
}
_deferral.Complete(); // signals task completion.
Debug.WriteLine("MyBackgroundAudioTask Cancel 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("BackgroundAudioTask " + sender.Task.TaskId + " Cancel Requested...");
try
{
// immediately set not running
backgroundTaskStarted.Reset();
// save state
ApplicationSettingsHelper.SaveSettingsValue(ApplicationSettingsConstants.TrackId, GetCurrentTrackId() == null ? null : GetCurrentTrackId().ToString());
//ApplicationSettingsHelper.SaveSettingsValue(ApplicationSettingsConstants.Position, BackgroundMediaPlayer.Current.Position.ToString());
ApplicationSettingsHelper.SaveSettingsValue(ApplicationSettingsConstants.BackgroundTaskState, BackgroundTaskState.Canceled.ToString());
ApplicationSettingsHelper.SaveSettingsValue(ApplicationSettingsConstants.AppState, Enum.GetName(typeof(AppState), foregroundAppState));
// unsubscribe from list changes
if (playbackList != null)
{
playbackList.CurrentItemChanged -= PlaybackList_CurrentItemChanged;
playbackList = null;
}
// 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("BackgroundAudioTask Cancel complete...");
}
private void OnAppServicesCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
_appServiceDeferral.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(BackgroundAudioConstants.CurrentTrack, Playlist.CurrentTrackIndex);
ApplicationSettingsHelper.SaveSettingsValue(BackgroundAudioConstants.Position, BackgroundMediaPlayer.Current.Position.ToString());
ApplicationSettingsHelper.SaveSettingsValue(BackgroundAudioConstants.Time, BackgroundMediaPlayer.Current.NaturalDuration.ToString());
ApplicationSettingsHelper.SaveSettingsValue(BackgroundAudioConstants.BackgroundTaskState, BackgroundAudioConstants.BackgroundTaskCancelled);
ApplicationSettingsHelper.SaveSettingsValue(BackgroundAudioConstants.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.ResetCollection((int)ResetType.NormalReset);
playlistManager = null;
// Send message to foreground task (if it's around) that this task was cancelled :(
ValueSet message = new ValueSet { { BackgroundAudioConstants.BackgroundTaskCancelled, "" } };
BackgroundMediaPlayer.SendMessageToForeground(message);
BackgroundMediaPlayer.Shutdown(); // shutdown media pipeline
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
deferral?.Complete(); // signals task completion.
Debug.WriteLine("MyBackgroundAudioTask Cancel complete...");
}
private void TaskInstance_Canceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
_cancellationTokenSource.Cancel();
}
/// <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.TrackId, GetCurrentTrackId() == null ? null : GetCurrentTrackId().ToString());
ApplicationSettingsHelper.SaveSettingsValue(ApplicationSettingsConstants.Position, BackgroundMediaPlayer.Current.Position.ToString());
ApplicationSettingsHelper.SaveSettingsValue(ApplicationSettingsConstants.BackgroundTaskState, BackgroundTaskState.Canceled.ToString());
ApplicationSettingsHelper.SaveSettingsValue(ApplicationSettingsConstants.AppState, Enum.GetName(typeof(AppState), foregroundAppState));
// unsubscribe from list changes
if (playbackList != null)
{
playbackList.CurrentItemChanged -= PlaybackList_CurrentItemChanged;
playbackList = null;
}
// 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...");
}
private void TaskInstance_Canceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
// Maybe do something...
}
private void OnTaskCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
_taskDeferral?.Complete();
}
private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
m_cancelRequested = true;
Debug.WriteLine("EdpBackgroundTask " + sender.Task.Name + " Cancel Requested...");
}
private void OnTaskCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
Debug.WriteLine("Task cancelled, clean up");
serviceDeferral?.Complete();
}
