/// <summary>
/// Register a background task with the specified taskEntryPoint, name, trigger,
/// and condition (optional).
/// </summary>
/// <param name="taskEntryPoint">Task entry point for the background task.</param>
/// <param name="name">A name for the background task.</param>
/// <param name="trigger">The trigger for the background task.</param>
/// <param name="condition">An optional conditional event that must be true for the task to fire.</param>
public static BackgroundTaskRegistration RegisterBackgroundTask(String taskEntryPoint, String name, IBackgroundTrigger trigger, IBackgroundCondition condition)
{
var builder = new BackgroundTaskBuilder();
builder.Name = name;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
}
BackgroundTaskRegistration task = builder.Register();
UpdateBackgroundTaskStatus(name, true);
//
// Remove previous completion status from local settings.
//
var settings = ApplicationData.Current.LocalSettings;
settings.Values.Remove(name);
return task;
}
/*
* 在 Windows Phone 上，你必须在尝试注册任何后台任务之前调用 RequestAccessAsync
*/
/// <summary>
/// 注册后台任务
/// </summary>
/// <param name="taskEntryPoint">任务的入口点</param>
/// <param name="name">任务名称</param>
/// <param name="trigger">轮询时间</param>
/// <param name="condition">系统事件</param>
/// <returns></returns>
public static async Task<BackgroundTaskRegistration> RegisterBackgroundTask(String taskEntryPoint, String name, IBackgroundTrigger trigger, IBackgroundCondition condition)
{
BackgroundTaskRegistration task = null;
if (TaskRequiresBackgroundAccess(name))
{
await BackgroundExecutionManager.RequestAccessAsync();
}
var backgroundAccessStatus = await BackgroundExecutionManager.RequestAccessAsync();
if (backgroundAccessStatus == BackgroundAccessStatus.AllowedMayUseActiveRealTimeConnectivity ||
backgroundAccessStatus == BackgroundAccessStatus.AllowedWithAlwaysOnRealTimeConnectivity)
{
var builder = new BackgroundTaskBuilder();
builder.Name = name;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
builder.CancelOnConditionLoss = true;
}
task = builder.Register();
}
return task;
}
public static async Task<BackgroundTaskRegistration> RegisterBackgroundTask(String taskEntryPoint, String name, IBackgroundTrigger trigger, IBackgroundCondition condition)
{
//always unregister for now.
foreach (var bgt in BackgroundTaskRegistration.AllTasks)
{
bgt.Value.Unregister(true);
}
//in UWP, you have to ask for access. Just like in WP
var access = await BackgroundExecutionManager.RequestAccessAsync();
if (access == BackgroundAccessStatus.Denied)
{
throw new UnauthorizedAccessException();
}
var builder = new BackgroundTaskBuilder();
builder.Name = name;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
builder.CancelOnConditionLoss = true;
}
BackgroundTaskRegistration task = builder.Register();
return task;
}
// Register a background task with the specified taskEntryPoint, name, trigger,
// and condition (optional).
//
// taskEntryPoint: Task entry point for the background task.
// taskName: A name for the background task.
// trigger: The trigger for the background task.
// condition: Optional parameter. A conditional event that must be true for the task to fire.
//
public BackgroundTaskRegistration RegisterBackgroundTask(string taskEntryPoint,
string taskName,
IBackgroundTrigger trigger,
IBackgroundCondition condition)
{
foreach (var cur in BackgroundTaskRegistration.AllTasks)
{
if (cur.Value.Name == taskName)
{
//
// The task is already registered.
//
return (BackgroundTaskRegistration)(cur.Value);
}
}
var builder = new BackgroundTaskBuilder();
builder.Name = taskName;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
}
BackgroundTaskRegistration task = builder.Register();
return task;
}
public static BackgroundTaskRegistration RegisterBackGroundTask(string taskEntryPoint,
string taskName,
IBackgroundTrigger trigger,
IBackgroundCondition condition)
{
//Check if its alterady Registrated
foreach (var cur in BackgroundTaskRegistration.AllTasks)
{
if (cur.Value.Name == taskName)
{
return (BackgroundTaskRegistration)(cur.Value);
}
}
//Register the Task
var builder = new BackgroundTaskBuilder();
builder.Name = taskName;
builder.TaskEntryPoint = taskEntryPoint;
if (trigger != null)
{
builder.SetTrigger(trigger);
}
if (condition != null)
{
builder.AddCondition(condition);
}
BackgroundTaskRegistration task = builder.Register();
return task;
}
private async static Task<BackgroundTaskRegistration> RegisterBackgroundTask(Type taskEntryPoint, string taskName, IBackgroundTrigger trigger, IBackgroundCondition condition)
{
var status = await BackgroundExecutionManager.RequestAccessAsync();
if (status == BackgroundAccessStatus.Unspecified || status == BackgroundAccessStatus.Denied)
{
return null;
}
foreach (var cur in BackgroundTaskRegistration.AllTasks)
{
if (cur.Value.Name == taskName)
{
cur.Value.Unregister(true);
}
}
var builder = new BackgroundTaskBuilder
{
Name = taskName,
TaskEntryPoint = taskEntryPoint.FullName
};
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
}
return builder.Register(); ;
}
public async void Create(string backgroundTaskName, string backgroundTaskEntryPoint, int time, IBackgroundCondition backgroundCondition)
{
IBackgroundTrigger backgroundTrigger = new TimeTrigger((uint)time, false);
var task = BackgroundTaskHelper.RegisterBackgroundTask(backgroundTaskEntryPoint, backgroundTaskName, backgroundTrigger, backgroundCondition);
await task;
AttachProgressAndCompletedHandlers(task.Result);
}
private BackgroundTaskRegistration CreateTask(string taskEntryPoint, string name,
IBackgroundTrigger trigger, IBackgroundCondition condition = null)
{
var builder = new BackgroundTaskBuilder();
builder.Name = name;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
if (condition != null)
builder.AddCondition(condition);
var task = builder.Register();
return task;
}
public async static Task<BackgroundTaskRegistration> RegisterBackgroundTask(string taskEntryPoint, string name, IBackgroundTrigger trigger, IBackgroundCondition condition)
{
var builder = new BackgroundTaskBuilder { Name = name, TaskEntryPoint = taskEntryPoint };
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
}
BackgroundAccessStatus status = await BackgroundExecutionManager.RequestAccessAsync();
BackgroundTaskRegistration task = builder.Register();
return task;
}
public BackgroundTaskRegistration Register(string taskEntryPoint, string name,
IBackgroundTrigger trigger, IBackgroundCondition condition)
{
if (string.IsNullOrWhiteSpace(taskEntryPoint)) throw new ArgumentNullException(nameof(taskEntryPoint));
if (string.IsNullOrWhiteSpace(name)) throw new ArgumentNullException(nameof(name));
if (trigger == null) throw new ArgumentNullException(nameof(trigger));
if (condition == null) throw new ArgumentNullException(nameof(condition));
var existingTask = GetTask(name);
if (existingTask != null)
return existingTask;
var task = CreateTask(taskEntryPoint, name, trigger, condition);
return task;
}
/// <summary>
/// Register a background task with the specified taskEntryPoint, name, trigger,
/// and condition (optional).
/// </summary>
/// <param name="taskEntryPoint">Task entry point for the background task.</param>
/// <param name="name">A name for the background task.</param>
/// <param name="trigger">The trigger for the background task.</param>
/// <param name="condition">An optional conditional event that must be true for the task to fire.</param>
public static BackgroundTaskRegistration RegisterBackgroundTask(String taskEntryPoint, String name, IBackgroundTrigger trigger, IBackgroundCondition condition)
{
var builder = new BackgroundTaskBuilder();
builder.Name = name;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
}
BackgroundTaskRegistration task = builder.Register();
return task;
}
/// <summary>
/// Register a background task with the specified taskEntryPoint, name, trigger and condition (optional).
/// Unregisters previous task with the same entry and name.
/// </summary>
/// <param name="taskEntryPoint">Task entry point for the background task.</param>
/// <param name="taskName">A name for the background task.</param>
/// <param name="trigger">The trigger for the background task.</param>
/// <param name="condition">Optional parameter. A conditional event that must be true for the task to fire.</param>
/// <returns>Background task registration or NULL in case of error.</returns>
public static async Task <BackgroundTaskRegistration> RegisterBackgroundTaskAsync(
string taskEntryPoint,
string taskName,
IBackgroundTrigger trigger,
IBackgroundCondition condition = null)
{
// Check for existing registrations of this background task.
var task = BackgroundTaskRegistration.AllTasks
.FirstOrDefault(t => t.Value.Name.Equals(taskName));
// If the task already exists, first unregister, then register new task
if (!task.IsNull())
{
task.Value.Unregister(true);
}
// Check if background task registration is allowed
if (!await RequestBackgroundAccessAsync())
{
LogService.Log(MLogLevel.LOG_LEVEL_WARNING,
"Background tasks registration is not allowed");
return(null);
}
// Register the background task.
var builder = new BackgroundTaskBuilder
{
Name = taskName,
TaskEntryPoint = taskEntryPoint
};
// Set trigger when to start task
builder.SetTrigger(trigger);
// Add optional conditions for trigger
if (condition != null)
{
builder.AddCondition(condition);
}
// Register and return the task registration
return(builder.Register());
}
/// <summary>
/// Register a background task with the specified taskEntryPoint, name, trigger,
/// and condition (optional).
/// </summary>
/// <param name="taskEntryPoint">Task entry point for the background task.</param>
/// <param name="name">A name for the background task.</param>
/// <param name="trigger">The trigger for the background task.</param>
/// <param name="condition">An optional conditional event that must be true for the task to fire.</param>
public static BackgroundTaskRegistration RegisterBackgroundTask(String taskEntryPoint, String name, IBackgroundTrigger trigger, IBackgroundCondition condition)
{
if (TaskRequiresBackgroundAccess(name))
{
// If the user denies access, the task will not run.
var requestTask = BackgroundExecutionManager.RequestAccessAsync();
}
var builder = new BackgroundTaskBuilder();
builder.Name = name;
if (taskEntryPoint != null)
{
// If you leave the TaskEntryPoint at its default value, then the task runs
// inside the main process from OnBackgroundActivated rather than as a separate process.
builder.TaskEntryPoint = taskEntryPoint;
}
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
//
// If the condition changes while the background task is executing then it will
// be canceled.
//
builder.CancelOnConditionLoss = true;
}
BackgroundTaskRegistration task = builder.Register();
UpdateBackgroundTaskRegistrationStatus(name, true);
//
// Remove previous completion status.
//
TaskStatuses.Remove(name);
return task;
}
//
// Register a background task with the specified taskEntryPoint, name, trigger,
// and condition (optional).
//
// taskEntryPoint: Task entry point for the background task.
// taskName: A name for the background task.
// trigger: The trigger for the background task.
// condition: Optional parameter. A conditional event that must be true for the task to fire.
//
public static BackgroundTaskRegistration RegisterBackgroundTask(string taskEntryPoint,
string taskName,
IBackgroundTrigger trigger,
IBackgroundCondition condition)
{
//
// Check for existing registrations of this background task.
//
foreach (var cur in BackgroundTaskRegistration.AllTasks)
{
if (cur.Value.Name == taskName)
{
//
// The task is already registered.
//
return((BackgroundTaskRegistration)(cur.Value));
}
}
//
// Register the background task.
//
var builder = new BackgroundTaskBuilder
{
Name = taskName,
TaskEntryPoint = taskEntryPoint
};
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
}
BackgroundTaskRegistration task = builder.Register();
return(task);
}
/// <summary>
/// Registers a background task with the specified taskEntryPoint, name, trigger,
/// and condition (optional).
/// </summary>
/// <param name="taskEntryPoint">Task entry point for the background task.</param>
/// <param name="taskName">A name for the background task.</param>
/// <param name="trigger">The trigger for the background task.</param>
/// <param name="condition">Optional parameter. A conditional event that must be true for the task to fire.</param>
/// <returns>The registered background task.</returns>
public static BackgroundTaskRegistration RegisterBackgroundTask(
string taskEntryPoint, string taskName, IBackgroundTrigger trigger, IBackgroundCondition condition)
{
// Check for existing registrations of this background task.
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (task.Value.Name.Equals(taskName))
{
// The task is already registered.
return task.Value as BackgroundTaskRegistration;
}
}
// Register the background task.
var builder = new BackgroundTaskBuilder { Name = taskName, TaskEntryPoint = taskEntryPoint };
if (condition != null) builder.AddCondition(condition);
builder.SetTrigger(trigger);
return builder.Register();
}
public static async void UnRegisterBackgroundTask(Type taskEntryPoint,
string taskName,
IBackgroundTrigger trigger,
IBackgroundCondition condition)
{
var status = await BackgroundExecutionManager.RequestAccessAsync();
if (status == BackgroundAccessStatus.Unspecified || status == BackgroundAccessStatus.Denied)
{
return;
}
foreach (var cur in BackgroundTaskRegistration.AllTasks)
{
if (cur.Value.Name == taskName)
{
cur.Value.Unregister(true);
}
}
}
public static async Task <BackgroundTaskRegistration> RegisterBackgroundTask(Type taskEntryPoint,
string taskName,
IBackgroundTrigger trigger,
IBackgroundCondition condition)
{
var status = await BackgroundExecutionManager.RequestAccessAsync();
if (status == BackgroundAccessStatus.Unspecified || status == BackgroundAccessStatus.Denied)
{
return(null);
}
foreach (var cur in BackgroundTaskRegistration.AllTasks)
{
if (cur.Value.Name == taskName)
{
cur.Value.Unregister(true);
}
}
var builder = new BackgroundTaskBuilder
{
Name = taskName,
TaskEntryPoint = taskEntryPoint.FullName
};
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
}
BackgroundTaskRegistration task = builder.Register();
#if DEBUG
Debug.WriteLine($"Task {taskName} registered successfully.");
#endif
return(task);
}
private async Task <BackgroundTaskRegistration> RegisterBackgroundTask(string name,
TimeTrigger trigger,
IBackgroundCondition condition)
{
var access = await BackgroundExecutionManager.RequestAccessAsync();
//Check for existing registrations
foreach (var _task in BackgroundTaskRegistration.AllTasks)
{
if (_task.Value.Name == name)
{
//The task is already registered
//_task.Value.Unregister(true);
return((BackgroundTaskRegistration)(_task.Value));
}
}
//Register the task
var builder = new BackgroundTaskBuilder();
await BackgroundExecutionManager.RequestAccessAsync();
builder.Name = name;
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
}
try
{
BackgroundTaskRegistration task = builder.Register();
return(task);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
return(null);
}
//
// Register a background task with the specified taskEntryPoint, name, trigger,
// and condition (optional).
//
// taskEntryPoint: Task entry point for the background task.
// taskName: A name for the background task.
// trigger: The trigger for the background task.
// condition: Optional parameter. A conditional event that must be true for the task to fire.
//
public BackgroundTaskRegistration RegisterBackgroundTask(string taskEntryPoint,
string taskName,
IBackgroundTrigger trigger,
IBackgroundCondition condition)
{
CheckExistTask(taskName)?.Unregister(true);
// Register the background task.
var builder = new BackgroundTaskBuilder();
builder.Name = taskName;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
// Begin adding conditions.
SystemCondition internetCondition = new SystemCondition(SystemConditionType.InternetAvailable);
builder.AddCondition(internetCondition);
BackgroundTaskRegistration task = builder.Register();
return(task);
}
public static BackgroundTaskRegistration RegisterBackgroundTask(String taskEntryPoint,
String name,
IBackgroundTrigger trigger,
IBackgroundCondition condition)
{
var builder = new BackgroundTaskBuilder();
builder.Name = name;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
// If the condition changes while the background task is executing then it will
// be canceled.
builder.CancelOnConditionLoss = true;
}
return(builder.Register());
}
{ //注册后台任务方法封装
public static async Task <ApplicationTrigger> RegisterBackgroundTask(string taskEntryPoint,
string taskName,
IBackgroundTrigger trigger,
IBackgroundCondition condition)
{
var status = await BackgroundExecutionManager.RequestAccessAsync();
if (status == BackgroundAccessStatus.Unspecified || status == BackgroundAccessStatus.DeniedByUser)
{
return(null);
}
foreach (var cur in BackgroundTaskRegistration.AllTasks)
{
if (cur.Value.Name == taskName)
{
cur.Value.Unregister(true);
}
}
BackgroundTaskBuilder taskBuilder = new BackgroundTaskBuilder();
taskBuilder.Name = taskName;
taskBuilder.TaskEntryPoint = taskEntryPoint;
taskBuilder.SetTrigger(trigger);
if (condition is SystemCondition condition1)
{
taskBuilder.AddCondition(condition1);
}
var trigger2 = new ApplicationTrigger();
taskBuilder.SetTrigger(trigger2);
taskBuilder.Register();
await trigger2.RequestAsync();
return(trigger2);
}
/// <summary>
/// Register a background task with the specified taskEntryPoint, name, trigger,
/// and condition (optional).
/// </summary>
/// <param name="taskEntryPoint">Task entry point for the background task.</param>
/// <param name="name">A name for the background task.</param>
/// <param name="trigger">The trigger for the background task.</param>
/// <param name="condition">An optional conditional event that must be true for the task to fire.</param>
public static BackgroundTaskRegistration RegisterBackgroundTask(String taskEntryPoint, String name, IBackgroundTrigger trigger, IBackgroundCondition condition)
{
if (TaskRequiresBackgroundAccess(name))
{
// If the user denies access, the task will not run.
var requestTask = BackgroundExecutionManager.RequestAccessAsync();
}
var builder = new BackgroundTaskBuilder();
builder.Name = name;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
//
// If the condition changes while the background task is executing then it will
// be canceled.
//
builder.CancelOnConditionLoss = true;
}
BackgroundTaskRegistration task = builder.Register();
UpdateBackgroundTaskRegistrationStatus(name, true);
//
// Remove previous completion status.
//
var settings = ApplicationData.Current.LocalSettings;
settings.Values.Remove(name);
return task;
}
private async Task InitializeTileUpdateBackgroundTaskAsync()
{
var backgroundAccessStatus = await BackgroundExecutionManager.RequestAccessAsync();
var trigger = new Windows.ApplicationModel.Background.TimeTrigger(15,false);
var conditions = new IBackgroundCondition[]
{
new SystemCondition(SystemConditionType.InternetAvailable)
};
try
{
var task = RegisterBackgroundTask("TileUpdate",
typeof(LiveTiles.Background.TileUpdateBackgroundTask).FullName, trigger, conditions);
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine("{0}: {1}", "");
}
}
/// <summary>
/// Registers a background task with the specified taskEntryPoint, name, trigger,
/// and condition (optional).
/// </summary>
/// <param name="taskEntryPoint">Task entry point for the background task.</param>
/// <param name="taskName">A name for the background task.</param>
/// <param name="trigger">The trigger for the background task.</param>
/// <param name="condition">Optional parameter. A conditional event that must be true for the task to fire.</param>
/// <returns>The registered background task.</returns>
public static async Task <BackgroundTaskRegistration> RegisterBackgroundTask(String taskEntryPoint, String name, IBackgroundTrigger trigger, IBackgroundCondition condition)
{
BackgroundTaskRegistration task = null;
try
{
// Get permission for a background task from the user. If the user has already answered once,
// this does nothing and the user must manually update their preference via PC Settings.
BackgroundAccessStatus backgroundAccessStatus = await BackgroundExecutionManager.RequestAccessAsync();
switch (backgroundAccessStatus)
{
// BackgroundTask is allowed
case BackgroundAccessStatus.AlwaysAllowed:
case BackgroundAccessStatus.AllowedSubjectToSystemPolicy:
var builder = new BackgroundTaskBuilder();
builder.Name = name;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
// If the condition changes while the background task is executing then it will be canceled.
builder.CancelOnConditionLoss = true;
}
task = builder.Register();
break;
default:
Toast.ShowToast("You have denied Background access to this app");
break;
}
}
catch (Exception ex)
{
Toast.ShowToast(ex.ToString());
}
return(task);
}
internal async Task <BackgroundTaskRegistration> RegisterOutOfProcessBackgroundTask(string taskName, string taskEntryPoint, IBackgroundTrigger trigger, IBackgroundCondition condition = null, BackgroundTaskCompletedEventHandler taskCompleted = null)
{
if (IsDisposing)
{
return(null);
}
BackgroundExecutionManager.RemoveAccess();
await BackgroundExecutionManager.RequestAccessAsync();
var builder = new BackgroundTaskBuilder
{
Name = taskName, TaskEntryPoint = taskEntryPoint
};
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
}
var task = builder.Register();
if (taskCompleted != null)
{
task.Completed += taskCompleted;
}
return(task);
}
public BackgroundTaskFacade(string taskEntryPoint, string name, IBackgroundTrigger trigger, IBackgroundCondition condition,
BackgroundTaskRegistrationGroup group = null, bool requiresBackgroundAccess = false, OnProgressHandlerArgs OnProgressMethod = null, OnCompletedHandlerArgs OnCompleteMethod = null)
: this(RegisterBackgroundTask(taskEntryPoint, name, trigger, condition, group, requiresBackgroundAccess), OnProgressMethod, OnCompleteMethod)
{
}
private static BackgroundTaskRegistration RegisterBackgroundTask(string taskEntryPoint, string name, IBackgroundTrigger trigger, IBackgroundCondition condition)
{
foreach (var item in BackgroundTaskRegistration.AllTasks)
{
if (item.Value.Name == name)
{
return((BackgroundTaskRegistration)item.Value);
}
}
var builder = new BackgroundTaskBuilder();
builder.Name = name;
if (!string.IsNullOrWhiteSpace(taskEntryPoint))
{
builder.TaskEntryPoint = taskEntryPoint;
}
builder.SetTrigger(trigger);
if (null != condition)
{
builder.AddCondition(condition);
}
return(builder.Register());
}
/// <summary>
/// Register a background task with the specified taskEntryPoint, name, trigger,
/// and condition (optional).
/// </summary>
/// <param name="taskEntryPoint">Task entry point for the background task.</param>
/// <param name="name">A name for the background task.</param>
/// <param name="trigger">The trigger for the background task.</param>
/// <param name="condition">An optional conditional event that must be true for the task to fire.</param>
public static BackgroundTaskRegistration RegisterBackgroundTask(String taskEntryPoint, String name, IBackgroundTrigger trigger, IBackgroundCondition condition, BackgroundTaskRegistrationGroup group = null)
{
UnregisterBackgroundTasks(name);
if (TaskRequiresBackgroundAccess(name))
{
// If the user denies access, the task will not run.
var requestTask = BackgroundExecutionManager.RequestAccessAsync();
}
var builder = new BackgroundTaskBuilder();
builder.Name = name;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
builder.CancelOnConditionLoss = true;
}
BackgroundTaskRegistration task = builder.Register();
UpdateBackgroundTaskRegistrationStatus(name, true);
var settings = ApplicationData.Current.LocalSettings;
settings.Values.Remove(name);
return(task);
}
public static BackgroundTaskRegistration RegisterBackgroundTask(string taskEntryPoint,
string taskName,
IBackgroundTrigger trigger,
IBackgroundCondition condition)
{
//
// Check for existing registrations of this background task.
//
foreach (var cur in BackgroundTaskRegistration.AllTasks)
{
System.Diagnostics.Debug.WriteLine(cur.Value.Name);
if (cur.Value.Name == taskName)
{
System.Diagnostics.Debug.WriteLine("Task already registered " + taskName);
return (BackgroundTaskRegistration)(cur.Value);
}
}
System.Diagnostics.Debug.WriteLine("Registering new task " + taskName);
//
// Register the background task.
//
var builder = new BackgroundTaskBuilder();
builder.Name = taskName;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
}
BackgroundTaskRegistration task = null;
try
{
task = builder.Register();
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex);
}
return task;
}
/// <summary>
/// Register a background task with the specified taskEntryPoint, name, trigger,
/// and condition (optional).
/// </summary>
/// <param name="taskEntryPoint">Task entry point for the background task.</param>
/// <param name="name">A name for the background task.</param>
/// <param name="trigger">The trigger for the background task.</param>
/// <param name="condition">An optional conditional event that must be true for the task to fire.</param>
private BackgroundTaskRegistration RegisterBackgroundTaskAsync(string taskEntryPoint, string taskName, IBackgroundTrigger trigger, IBackgroundCondition condition = null)
{
if (string.IsNullOrWhiteSpace(taskEntryPoint))
{
throw new ArgumentNullException(nameof(taskEntryPoint));
}
if (string.IsNullOrWhiteSpace(taskName))
{
throw new ArgumentNullException(nameof(taskName));
}
if (trigger == null)
{
throw new ArgumentNullException(nameof(trigger));
}
try
{
// Remove if existing
this.Remove(taskName);
BackgroundTaskBuilder builder = new BackgroundTaskBuilder();
if (condition != null)
{
builder.AddCondition(condition);
// If the condition changes while the background task is executing then it will
// be canceled.
builder.CancelOnConditionLoss = true;
}
builder.Name = taskName;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
var registrationTask = builder.Register();
return(registrationTask);
}
catch (Exception ex)
{
Platform.Current.Logger.LogError(ex, "Error while trying to register task '{0}': {1}", taskName, ex.Message);
return(null);
}
}
public static void RegisterBackgroundTask(string taskEntryPoint, string taskName, IBackgroundTrigger trigger, IBackgroundCondition condition)
{
foreach (var cur in BackgroundTaskRegistration.AllTasks)
{
if (cur.Value.Name == taskName)
{
return;
}
}
BackgroundAccessStatus status = BackgroundExecutionManager.RequestAccessAsync().AsTask().Result;
if (status == BackgroundAccessStatus.AllowedWithAlwaysOnRealTimeConnectivity || status == BackgroundAccessStatus.AllowedMayUseActiveRealTimeConnectivity)
{
var builder = new BackgroundTaskBuilder();
builder.Name = taskName;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
}
builder.Register();
}
else
{
throw new Exception();
}
}
public static BackgroundTaskRegistration RegisterBackgroundTask(String taskEntryPoint, String name, IBackgroundTrigger trigger, IBackgroundCondition condition, BackgroundTaskRegistrationGroup group = null)
{
var builder = new BackgroundTaskBuilder();
builder.Name = name;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
//如果在后台任务执行时条件发生了变化，那么它将被取消。
builder.CancelOnConditionLoss = true;
}
if (group != null)
{
builder.TaskGroup = group;
}
BackgroundTaskRegistration task = builder.Register();
SampleBackgroundTaskRegistered = true;
//删除以前的完成状态。
var settings = ApplicationData.Current.LocalSettings;
settings.Values.Remove(name);
return(task);
}
private async Task <BackgroundTaskRegistration> RegisterBackgroundTask(Type EntryPoint, string name, IBackgroundTrigger trigger, IBackgroundCondition condition)
{
var status = await BackgroundExecutionManager.RequestAccessAsync();
if (status == BackgroundAccessStatus.DeniedByUser)
{
return(null);
}
foreach (var item in BackgroundTaskRegistration.AllTasks)
{
if (item.Value.Name == name)
{
item.Value.Unregister(true);
}
}
var builder = new BackgroundTaskBuilder {
Name = name, TaskEntryPoint = EntryPoint.FullName, IsNetworkRequested = true
};
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
}
BackgroundTaskRegistration task = builder.Register();
// await popup.Show(string.Format("----Register{0}-----", task.Name));
return(task);
}
/*
* 在 Windows Phone 上，你必须在尝试注册任何后台任务之前调用 RequestAccessAsync
*/
/// <summary>
/// 注册后台任务
/// </summary>
/// <param name="taskEntryPoint">任务的入口点</param>
/// <param name="name">任务名称</param>
/// <param name="trigger">轮询时间</param>
/// <param name="condition">系统事件</param>
/// <returns></returns>
public static async Task <BackgroundTaskRegistration> RegisterBackgroundTask(String taskEntryPoint, String name, IBackgroundTrigger trigger, IBackgroundCondition condition)
{
BackgroundTaskRegistration task = null;
if (TaskRequiresBackgroundAccess(name))
{
await BackgroundExecutionManager.RequestAccessAsync();
}
var backgroundAccessStatus = await BackgroundExecutionManager.RequestAccessAsync();
if (backgroundAccessStatus == BackgroundAccessStatus.AllowedMayUseActiveRealTimeConnectivity ||
backgroundAccessStatus == BackgroundAccessStatus.AllowedWithAlwaysOnRealTimeConnectivity)
{
var builder = new BackgroundTaskBuilder();
builder.Name = name;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
builder.CancelOnConditionLoss = true;
}
task = builder.Register();
}
return(task);
}
public static void RegisterBackgroundTask(String taskEntryPoint, String name, IBackgroundTrigger trigger, IBackgroundCondition condition,
BackgroundTaskCompletedEventHandler completeHandler
)
{
var builder = new BackgroundTaskBuilder();
builder.Name = name;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
builder.CancelOnConditionLoss = true;
}
BackgroundTaskRegistration task = builder.Register();
if (completeHandler != null)
{
task.Completed += completeHandler;
}
}
public static async Task <BackgroundTaskRegistration> RegisterBackgroundTask(string taskEntryPoint, string name,
IBackgroundTrigger trigger, IBackgroundCondition condition)
{
var builder = new BackgroundTaskBuilder {
Name = name, TaskEntryPoint = taskEntryPoint
};
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
}
BackgroundAccessStatus status = await BackgroundExecutionManager.RequestAccessAsync();
BackgroundTaskRegistration task = builder.Register();
return(task);
}
public static BackgroundTaskRegistration RegisterBackgroundTask(string taskEntryPoint, string name, IBackgroundTrigger trigger, IBackgroundCondition condition)
{
foreach (var cur in BackgroundTaskRegistration.AllTasks)
{
if (cur.Value.Name == name)
{
// The task is already registered.
return((BackgroundTaskRegistration)(cur.Value));
}
}
//Register new background task:
var builder = new BackgroundTaskBuilder();
builder.Name = name;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
}
BackgroundTaskRegistration task = builder.Register();
return(task);
}
RegisterBackgroundTask(string taskEntryPoint, string taskName, IBackgroundTrigger trigger, IBackgroundCondition condition)
{
var result = await BackgroundExecutionManager.RequestAccessAsync();
// Check for existing registrations of this background task.
foreach (var cur in BackgroundTaskRegistration.AllTasks)
{
if (cur.Value.Name == taskName)
{
// The task is already registered.
return((BackgroundTaskRegistration)(cur.Value));
}
}
// Register the background task.
var builder = new BackgroundTaskBuilder();
builder.Name = taskName;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
}
BackgroundTaskRegistration task = builder.Register();
return(task);
}
internal BackgroundTaskRegistration RegisterBackgroundTaskInAGroup(BackgroundTaskRegistrationGroup group, string taskName, IBackgroundTrigger trigger, string taskEntyPoint = null, IBackgroundCondition condition = null)
{
foreach (var taskKeyValue in group.AllTasks)
{
if (taskKeyValue.Value.Name == taskName)
{
return(taskKeyValue.Value);
}
}
var builder = new BackgroundTaskBuilder
{
Name = taskName,
TaskGroup = group,
TaskEntryPoint = taskEntyPoint // Entry point optional for in-process task
};
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
}
return(builder.Register());
}
/// <summary>
/// Register a background task with the specified taskEntryPoint, name, trigger,
/// and condition (optional).
/// </summary>
/// <param name="taskEntryPoint">Task entry point for the background task.</param>
/// <param name="name">A name for the background task.</param>
/// <param name="trigger">The trigger for the background task.</param>
/// <param name="condition">An optional conditional event that must be true for the task to fire.</param>
public static BackgroundTaskRegistration RegisterBackgroundTask(String taskEntryPoint, String name, IBackgroundTrigger trigger, IBackgroundCondition condition)
{
if (TaskRequiresBackgroundAccess(name))
{
// If the user denies access, the task will not run.
var requestTask = BackgroundExecutionManager.RequestAccessAsync();
}
var builder = new BackgroundTaskBuilder();
builder.Name = name;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
//
// If the condition changes while the background task is executing then it will
// be canceled.
//
builder.CancelOnConditionLoss = true;
}
BackgroundTaskRegistration task = builder.Register();
UpdateBackgroundTaskRegistrationStatus(name, true);
//
// Remove previous completion status.
//
var settings = ApplicationData.Current.LocalSettings;
settings.Values.Remove(name);
return(task);
}
/// <summary>
/// Register a background task with the specified taskEntryPoint, name, trigger,
/// and condition (optional).
/// </summary>
/// <param name="taskEntryPoint">Task entry point for the background task.</param>
/// <param name="name">A name for the background task.</param>
/// <param name="trigger">The trigger for the background task.</param>
/// <param name="condition">An optional conditional event that must be true for the task to fire.</param>
private BackgroundTaskRegistration RegisterBackgroundTaskAsync(string taskEntryPoint, string taskName, IBackgroundTrigger trigger, IBackgroundCondition condition = null)
{
if (string.IsNullOrWhiteSpace(taskEntryPoint))
throw new ArgumentNullException(nameof(taskEntryPoint));
if (string.IsNullOrWhiteSpace(taskName))
throw new ArgumentNullException(nameof(taskName));
if (trigger == null)
throw new ArgumentNullException(nameof(trigger));
try
{
// Remove if existing
this.Remove(taskName);
BackgroundTaskBuilder builder = new BackgroundTaskBuilder();
if (condition != null)
{
builder.AddCondition(condition);
// If the condition changes while the background task is executing then it will
// be canceled.
builder.CancelOnConditionLoss = true;
}
builder.Name = taskName;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
var registrationTask = builder.Register();
return registrationTask;
}
catch (Exception ex)
{
Platform.Current.Logger.LogError(ex, "Error while trying to register task '{0}': {1}", taskName, ex.Message);
return null;
}
}
public static BackgroundTaskRegistration RegisterBackgroundTask(String taskEntryPoint,
String name,
IBackgroundTrigger trigger,
IBackgroundCondition condition)
{
var builder = new BackgroundTaskBuilder();
builder.Name = name;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
// If the condition changes while the background task is executing then it will
// be canceled.
builder.CancelOnConditionLoss = true;
}
return builder.Register();
}
/// <summary>
/// Register a background task with the specified taskEntryPoint, name, trigger,
/// and condition (optional).
/// </summary>
/// <param name="taskEntryPoint">Task entry point for the background task.</param>
/// <param name="name">A name for the background task.</param>
/// <param name="trigger">The trigger for the background task.</param>
/// <param name="condition">An optional conditional event that must be true for the task to fire.</param>
private async Task<BackgroundTaskRegistration> RegisterBackgroundTask(String taskEntryPoint, String name, IBackgroundTrigger trigger, IBackgroundCondition condition)
{
if (TaskRequiresBackgroundAccess(name))
await BackgroundExecutionManager.RequestAccessAsync();
var builder = new BackgroundTaskBuilder();
builder.Name = name;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
//
// If the condition changes while the background task is executing then it will
// be canceled.
//
builder.CancelOnConditionLoss = true;
}
BackgroundTaskRegistration task = builder.Register();
this.IsRegister = true;
//
// Remove previous completion status from local settings.
//
var settings = ApplicationData.Current.LocalSettings;
settings.Values.Remove(name);
return task;
}
public static async Task RegisterBackgroundTaskAsync(string taskEntryPoint, string taskName, IBackgroundTrigger trigger, IBackgroundCondition condition)
{
var taskRegistered = false;
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (task.Value.Name == taskName)
{
//task.Value.Unregister(true);
taskRegistered = true;
break;
}
}
if (!taskRegistered)
{
var builder = new BackgroundTaskBuilder();
builder.Name = taskName;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
}
System.Diagnostics.Debug.WriteLine("task regiter");
var status = await BackgroundExecutionManager.RequestAccessAsync();
if (status == BackgroundAccessStatus.DeniedBySystemPolicy || status == BackgroundAccessStatus.DeniedByUser || status == BackgroundAccessStatus.Unspecified)
{
System.Diagnostics.Debug.WriteLine("Cant't register access status {0}", status);
}
BackgroundTaskRegistration task = builder.Register();
}
}
//Register background task for network changes
public static async Task <BackgroundTaskRegistration> RegisterBackgroundTask(String taskEntryPoint, String name, IBackgroundTrigger trigger, IBackgroundCondition condition)
{
if (TaskRequiresBackgroundAccess())
{
await BackgroundExecutionManager.RequestAccessAsync();
}
var builder = new BackgroundTaskBuilder();
builder.Name = name;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
BackgroundTaskRegistration task = builder.Register();
UpdateBackgroundTaskStatus(true);
return(task);
}
/// <summary>
/// Register a background task with the specified taskEntryPoint, name, trigger,
/// and condition (optional).
/// </summary>
/// <param name="taskEntryPoint">Task entry point for the background task.</param>
/// <param name="name">A name for the background task.</param>
/// <param name="trigger">The trigger for the background task.</param>
/// <param name="condition">An optional conditional event that must be true for the task to fire.</param>
public static BackgroundTaskRegistration RegisterBackgroundTask(String taskEntryPoint, String name, IBackgroundTrigger trigger, IBackgroundCondition condition, BackgroundTaskRegistrationGroup group = null)
{
if (TaskRequiresBackgroundAccess(name))
{
// If the user denies access, the task will not run.
var requestTask = BackgroundExecutionManager.RequestAccessAsync();
}
var builder = new BackgroundTaskBuilder();
builder.Name = name;
if (taskEntryPoint != null)
{
// If you leave the TaskEntryPoint at its default value, then the task runs
// inside the main process from OnBackgroundActivated rather than as a separate process.
builder.TaskEntryPoint = taskEntryPoint;
}
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
//
// If the condition changes while the background task is executing then it will
// be canceled.
//
builder.CancelOnConditionLoss = true;
}
if (group != null)
{
builder.TaskGroup = group;
}
BackgroundTaskRegistration task = builder.Register();
UpdateBackgroundTaskRegistrationStatus(name, true);
//
// Remove previous completion status.
//
TaskStatuses.Remove(name);
return(task);
}
/// <summary>
/// Register a background task with the specified taskEntryPoint, name, trigger,
/// and condition (optional).
/// </summary>
/// <param name="taskEntryPoint">Task entry point for the background task.</param>
/// <param name="name">A name for the background task.</param>
/// <param name="trigger">The trigger for the background task.</param>
/// <param name="condition">An optional conditional event that must be true for the task to fire.</param>
public static BackgroundTaskRegistration RegisterBackgroundTask(String taskEntryPoint, String name, IBackgroundTrigger trigger, IBackgroundCondition condition)
{
var builder = new BackgroundTaskBuilder();
builder.Name = name;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
}
BackgroundTaskRegistration task = builder.Register();
UpdateBackgroundTaskStatus(name, true);
//
// Remove previous completion status from local settings.
//
var settings = ApplicationData.Current.LocalSettings;
settings.Values.Remove(name);
return(task);
}
/// <summary>
/// Register a background task with the specified taskEntryPoint, name, trigger,
/// and condition (optional).
/// </summary>
/// <param name="taskEntryPoint">Task entry point for the background task.</param>
/// <param name="name">A name for the background task.</param>
/// <param name="trigger">The trigger for the background task.</param>
/// <param name="condition">An optional conditional event that must be true for the task to fire.</param>
public static BackgroundTaskRegistration RegisterBackgroundTask(String taskEntryPoint, String name, IBackgroundTrigger trigger, IBackgroundCondition condition)
{
var builder = new BackgroundTaskBuilder();
builder.Name = name;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
}
BackgroundTaskRegistration task = builder.Register();
return(task);
}
/// <summary>
/// Register a background task with the specified taskEntryPoint, name, trigger,
/// and condition (optional).
/// </summary>
/// <param name="taskName">A name for the background task.</param>
/// <param name="taskEntryPoint">Task entry point for the background task.</param>
/// <param name="trigger">The trigger for the background task.</param>
/// <param name="condition">An optional conditional event that must be true for the task to fire.</param>
public async static Task <IBackgroundTaskRegistration> RegisterBackGroundTaskAsync(string taskName, string taskEntryPoint, IBackgroundTrigger trigger, IBackgroundCondition condition)
{
var appHasPermission = await IsAppHasPermissionAsync();
if (!appHasPermission)
{
return(null);
}
var backgorundTaskRegistered = GetBackgroundTaskIfAlreadyRegistered(taskName);
if (backgorundTaskRegistered != null)
{
return(backgorundTaskRegistered);
}
BackgroundTaskBuilder backgorundBuilder = CreateBackgroundTask(taskName, taskEntryPoint);
backgorundBuilder.SetTrigger(trigger);
SetBackgroundTaskCondtion(condition, backgorundBuilder);
return(backgorundBuilder.Register());
}
private static async Task <BackgroundTaskRegistration> RegisterBackgroundTask(Type taskEntryPoint,
IBackgroundTrigger trigger,
IBackgroundCondition condition)
{
var status = await BackgroundExecutionManager.RequestAccessAsync();
if (status != BackgroundAccessStatus.AlwaysAllowed &&
status != BackgroundAccessStatus.AllowedSubjectToSystemPolicy)
{
ToastService.SendToast(ResourcesHelper.GetResString("BackgroundRegisterFailed"), TimeSpan.FromMilliseconds(5000));
return(null);
}
foreach (var cur in BackgroundTaskRegistration.AllTasks)
{
if (cur.Value.Name == NAME)
{
cur.Value.Unregister(true);
}
}
var builder = new BackgroundTaskBuilder
{
Name = NAME,
TaskEntryPoint = taskEntryPoint.FullName
};
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
}
BackgroundTaskRegistration task = builder.Register();
Debug.WriteLine($"===================Task {NAME} registered successfully===================");
return(task);
}
private static IBackgroundTaskRegistration RegisterBackgroundTask(string name, string entryPoint, IBackgroundTrigger trigger,
IBackgroundCondition[] conditions = null)
{
foreach (var task in BackgroundTaskRegistration.AllTasks.Values)
{
if (task.Name == name)
{
return task;
}
}
var builder = new BackgroundTaskBuilder
{
Name = name,
TaskEntryPoint = entryPoint
};
builder.SetTrigger(trigger);
if (conditions != null)
{
foreach (var condition in conditions)
{
builder.AddCondition(condition);
}
}
return builder.Register();
}
