public static RegisterTaskStatus RegisterTaskWithTrigger(string taskName, IBackgroundTrigger trigger)
{
RegisterTaskStatus result = RegisterTaskStatus.Failed;
if (IsTaskRegistered(taskName))
{
result = RegisterTaskStatus.AlreadyRegistered;
}
else
{
try
{
BackgroundTaskBuilder builder = new BackgroundTaskBuilder();
builder.SetTrigger(trigger);
builder.Name = taskName;
builder.Register();
result = RegisterTaskStatus.Succeeded;
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
}
return(result);
}
/// <summary>
/// This method registers the specified Trigger (for example a 15 minute
/// timer) to start executing some app code identified by a LocalServer
/// COM entry point.
///
/// Note that the LocalServer task entry point must be defined with COM
/// before registering the entry point with BackgroundTaskBuilder.
///
/// This method returns either the already registered backgroudn task or
/// a newly created background task with the specified task name.
///
/// The BackgroundTaskBuilder may throw errors when invalid parameters
/// are passed in or the registration failed in the system for some
/// reason.
/// </summary>
public IBackgroundTaskRegistration RegisterBackgroundTaskWithSystem(IBackgroundTrigger trigger, Guid entryPointClsid, string taskName)
{
foreach (var registrationIterator in BackgroundTaskRegistration.AllTasks)
{
if (registrationIterator.Value.Name == taskName)
{
return(registrationIterator.Value);
}
}
BackgroundTaskBuilder builder = new BackgroundTaskBuilder();
builder.SetTrigger(trigger);
builder.SetTaskEntryPointClsid(entryPointClsid);
builder.Name = taskName;
BackgroundTaskRegistration registration;
try
{
registration = builder.Register();
}
catch (Exception)
{
registration = null;
}
return(registration);
}
async Task RegisterTaskAsync(
string taskName,
IBackgroundTrigger trigger,
Type taskType)
{
if (BackgroundTaskRegistration.AllTasks.Count > 0)
{
await DisplayMessageAsync("Error", "Task is already registered");
}
else
{
var allowed = await BackgroundExecutionManager.RequestAccessAsync();
if ((allowed != BackgroundAccessStatus.Denied) &&
(allowed != BackgroundAccessStatus.Unspecified))
{
foreach (var existingTask in BackgroundTaskRegistration.AllTasks.ToList())
{
existingTask.Value.Unregister(false);
}
}
BackgroundTaskBuilder builder = new BackgroundTaskBuilder();
builder.Name = taskName;
builder.TaskEntryPoint = taskType.FullName;
builder.SetTrigger(trigger);
builder.Register();
await DisplayMessageAsync("Registered", "Task is now registered");
}
}
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;
}
BackgroundTaskRegistration task = builder.Register();
return(task);
}
public static async void Create(String task, IBackgroundTrigger trigger)
{
_myTaskName = task;
_trigger = trigger;
// check if task is already registered
foreach (var cur in BackgroundTaskRegistration.AllTasks)
{
if (cur.Value.Name == _myTaskName)
{
#if DEBUG
await(new MessageDialog("Task already registered")).ShowAsync();
#endif
return;
}
}
await BackgroundExecutionManager.RequestAccessAsync();
// register a new task
BackgroundTaskBuilder taskBuilder = new BackgroundTaskBuilder {
Name = _myTaskName, TaskEntryPoint = _myTaskName
};
taskBuilder.SetTrigger(_trigger);
BackgroundTaskRegistration myFirstTask = taskBuilder.Register();
#if DEBUG
await(new MessageDialog("Task registered")).ShowAsync();
#endif
}
/// <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;
}
private async Task RegisterBackgroundTask(Type EntryPoint, string name, IBackgroundTrigger trigger, IBackgroundCondition condition)
{
var status = await BackgroundExecutionManager.RequestAccessAsync();
if (status == BackgroundAccessStatus.Unspecified || status == BackgroundAccessStatus.DeniedByUser)
{
return;
}
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 = false
};
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
}
builder.Register();
BackgroundTaskRegistration a = builder.Register();
Debug.WriteLine("---------Register---------");
a.Progress += A_Progress;
a.Completed += A_Completed;
return;
}
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;
}
public static IBackgroundTaskRegistration RegisterBackgroundTask(Type taskEntryPoint,
string taskName,
IBackgroundTrigger trigger,
IBackgroundCondition condition)
{
//
// Check for existing registrations of this background task.
//
var existingTask = BackgroundTaskRegistration.AllTasks.Values.FirstOrDefault(bt => bt.Name == taskName);
if (existingTask != null)
{
existingTask.Unregister(true);
}
//
// Register the background task.
//
var builder = new BackgroundTaskBuilder();
builder.Name = taskName;
builder.TaskEntryPoint = taskEntryPoint.FullName;
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
}
return(builder.Register());
}
public static BackgroundTaskRegistration RegisterBackgroundTask(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;
//SetTrigger()
builder.SetTrigger(trigger);
builder.AddCondition(new SystemCondition(SystemConditionType.UserPresent));
if (condition != null)
{
builder.AddCondition(condition);
}
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);
}
public static async Task <BackgroundTaskRegistration> RegisterBackgroundTask(string taskEntryPoint, string name,
IBackgroundTrigger trigger, IBackgroundCondition condition)
{
try
{
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);
}
catch (Exception)
{
return(null);
}
}
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(); ;
}
private BackgroundTaskRegistration RegisterTask(
Type taskType,
IBackgroundTrigger trigger,
SystemConditionType systemConditionType = SystemConditionType.Invalid)
{
var builder = new BackgroundTaskBuilder();
/// A string identifier for the background task.
builder.Name = taskType.Name;
/// The entry point of the task.
/// This HAS to be the full name of the background task: {Namespace}.{Class name}
builder.TaskEntryPoint = taskType.FullName;
/// The specific trigger event that will fire the task on our application.
builder.SetTrigger(trigger);
/// A condition for the task to run.
/// If specified, after the event trigger is fired, the OS will wait for
/// the condition situation to happen before executing the task.
if (systemConditionType != SystemConditionType.Invalid)
{
builder.AddCondition(new SystemCondition(systemConditionType));
}
/// Register the task and returns the registration output.
return(builder.Register());
}
public static async Task <BackgroundTaskRegistration> RegisterBackgroundTask(IBackgroundTrigger trigger)
{
var task = new BackgroundTaskBuilder
{
Name = "DynamicWall Process",
TaskEntryPoint = typeof(BackgroundComponent.Class1).ToString()
};
task.SetTrigger(trigger);
var Trigger = new ApplicationTrigger();
TimeTrigger hourlyTrigger = new TimeTrigger(60, false);
task.SetTrigger(hourlyTrigger);
var requestStatus = await Windows.ApplicationModel.Background.BackgroundExecutionManager.RequestAccessAsync();
if (requestStatus != BackgroundAccessStatus.AlwaysAllowed)
{
// Depending on the value of requestStatus, provide an appropriate response
// such as notifying the user which functionality won't work as expected
}
BackgroundTaskRegistration backtask = task.Register();
return(backtask);
}
public bool TryRegisterBackgroundTaskOnce(string name, string entryPoint, IBackgroundTrigger trigger, out IBackgroundTaskRegistration registeredTask)
{
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (task.Value.Name == name)
{
registeredTask = task.Value;
return(true);
}
}
var taskBuilder = new BackgroundTaskBuilder
{
Name = name,
TaskEntryPoint = entryPoint
};
taskBuilder.SetTrigger(trigger);
try
{
registeredTask = taskBuilder.Register();
}
catch (Exception e)
{
DebugLogger.LogException(e);
registeredTask = null;
return(false);
}
return(true);
}
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());
}
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 async Task <BackgroundTaskRegistration> RegisterBackgroundTask(Type taskEntryPoint,
string taskName,
IBackgroundTrigger trigger,
IBackgroundCondition condition)
{
var status = await BackgroundExecutionManager.RequestAccessAsync();
if (status == BackgroundAccessStatus.Unspecified || status == BackgroundAccessStatus.DeniedBySystemPolicy || status == BackgroundAccessStatus.DeniedByUser)
{
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();
return(task);
}
public void RegisterBGTask(BGTaskKey key, IBackgroundTrigger trigger, IEnumerable <SystemConditionType> condition)
{
var taskRegistered = false;
foreach (var tsk in BackgroundTaskRegistration.AllTasks)
{
if (tsk.Value.Name == key.GetTaskName())
{
taskRegistered = true;
break;
}
}
if (taskRegistered)
{
return;
}
var builder = new BackgroundTaskBuilder()
{
Name = key.GetTaskName(),
TaskEntryPoint = key.GetTaskEnty()
};
builder.SetTrigger(trigger);
foreach (var con in condition)
{
builder.AddCondition(new SystemCondition(con));
}
BackgroundTaskRegistration task = builder.Register();
}
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);
}
//
// 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)
{
foreach (var cur in BackgroundTaskRegistration.AllTasks)
{
if (cur.Value.Name == taskName)
{
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);
}
private async Task <IBackgroundTaskRegistration> RegisterTaskP(string name, string entrypoint,
IBackgroundTrigger trigger, bool removeIfRegistered)
{
var taskRegistration = GetTask(name);
if (taskRegistration != null)
{
if (removeIfRegistered)
{
taskRegistration.Unregister(true);
}
else
{
return(taskRegistration);
}
}
await BackgroundExecutionManager.RequestAccessAsync();
var taskBuilder = new BackgroundTaskBuilder
{
Name = name,
TaskEntryPoint = entrypoint
};
taskBuilder.SetTrigger(trigger);
return(taskBuilder.Register());
}
// Adapted from Microsoft documentation
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
};
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
}
var task = builder.Register();
return(task);
}
public static BackgroundTaskRegistration RegisterBackgroundTask(string taskEntryPoint,
string taskName,
IBackgroundTrigger trigger)
{
//
// 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);
BackgroundTaskRegistration task = builder.Register();
return(task);
}
public IAsyncOperation<IBackgroundTaskRegistration> RegisterTask(string name, string entrypoint,
IBackgroundTrigger trigger, bool removeIfRegistered)
{
return RegisterTaskP(
name,
entrypoint,
trigger,
removeIfRegistered).AsAsyncOperation();
}
public static void RegisterBackgroundTask(IBackgroundTrigger trigger)
{
var builder = new BackgroundTaskBuilder();
builder.Name = "DownloadCompleteTrigger";
builder.SetTrigger(trigger);
BackgroundTaskRegistration task = builder.Register();
}
public IAsyncOperation <IBackgroundTaskRegistration> RegisterTask(string name, string entrypoint,
IBackgroundTrigger trigger, bool removeIfRegistered)
{
return(RegisterTaskP(
name,
entrypoint,
trigger,
removeIfRegistered).AsAsyncOperation());
}
public static BackgroundTaskRegistration registerBackgroundTask(string name, IBackgroundTrigger trigger)
{
var builder = new BackgroundTaskBuilder();
builder.Name = name;
builder.SetTrigger(trigger);
return(builder.Register());
}
public static async Task <IBackgroundTrigger> SetTrigger(Triggers trigger, uint time)
{
IBackgroundTrigger ntrigger = null;
switch (trigger)
{
case Triggers.TimeTrigger:
ntrigger = new TimeTrigger(time, false);
break;
}
return(ntrigger);
}
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;
}
public static void RegisterTask(string taskName, string taskEntryPoint, IBackgroundTrigger trigger)
{
var existingTaskRegistrations = BackgroundTaskRegistration.AllTasks.Where(t => t.Value.Name == taskName);
if (existingTaskRegistrations.Count() == 0)
{
foreach (var item in BackgroundTaskRegistration.AllTasks)
{
var task = item.Value;
if (task.Name == taskName)
{
task.Unregister(true);
}
}
try
{
// Create a new background task builder.
var taskBuilder = new BackgroundTaskBuilder();
// Associate the SmsReceived trigger with the background task builder.
taskBuilder.SetTrigger(trigger);
// Specify the background task to run when the trigger fires.
taskBuilder.TaskEntryPoint = taskEntryPoint;
// Name the background task.
taskBuilder.Name = taskName;
// Register the background task.
var taskRegistration = taskBuilder.Register();
Debug.WriteLine(taskName + " registered " + taskRegistration.TaskId);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
else
{
foreach (var taskRegistration in existingTaskRegistrations)
{
var task = taskRegistration.Value;
var settings = Windows.Storage.ApplicationData.Current.LocalSettings;
var status = settings.Values[task.TaskId.ToString()];
Debug.WriteLine(taskName + " last status" + ": " + status);
}
}
}
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="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>
/// <param name="recreateIfExist">
/// Recreates task if it already registered.
/// </param>
/// <returns>
/// The <see cref="Task"/>.
/// </returns>
public static async Task <BackgroundTaskRegistration> Register(
string taskEntryPoint,
string taskName,
IBackgroundTrigger trigger,
IBackgroundCondition[] condition,
bool recreateIfExist = false)
{
var registered = BackgroundTaskRegistration.AllTasks.FirstOrDefault(cur => cur.Value.Name == taskName).Value as BackgroundTaskRegistration;
if (registered != null && !recreateIfExist)
{
return(registered);
}
if (registered != null)
{
if (ApplicationData.Current.LocalSettings.Values.ContainsKey(registered.TaskId.ToString()))
{
ApplicationData.Current.LocalSettings.Values.Remove(registered.TaskId.ToString());
}
registered.Unregister(true);
}
var access = await BackgroundExecutionManager.RequestAccessAsync();
var builder = new BackgroundTaskBuilder {
Name = taskName
};
if (!string.IsNullOrEmpty(taskEntryPoint))
{
builder.TaskEntryPoint = taskEntryPoint;
}
builder.SetTrigger(trigger);
if (condition != null)
{
foreach (var backgroundCondition in condition)
{
builder.AddCondition(backgroundCondition);
}
builder.CancelOnConditionLoss = true;
}
return(builder.Register());
}
//
// 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 async Task <BackgroundTaskRegistration> RegisterBackgroundTask(string taskEntryPoint,
string taskName,
IBackgroundTrigger trigger,
IBackgroundCondition condition)
{
//
// Check for existing registrations of this background task.
//
var isNewVersion = await CheckAppVersion();
foreach (var cur in BackgroundTaskRegistration.AllTasks)
{
if (cur.Value.Name == taskName)
{
//
// The task is already registered.
//
if (!isNewVersion)
{
return((BackgroundTaskRegistration)(cur.Value));
}
else
{
cur.Value.Unregister(false);
}
}
}
//
// 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);
}
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;
}
/// <summary>
/// Registers background task
/// </summary>
/// <param name="trigger">Task trigger</param>
/// <param name="taskName">Task name</param>
/// <param name="taskEntryPoint">Task entry point</param>
/// <returns>Asynchronous task</returns>
private async static Task RegisterBackgroundTaskAsync(IBackgroundTrigger trigger, String taskName, String taskEntryPoint)
{
BackgroundAccessStatus result = await BackgroundExecutionManager.RequestAccessAsync();
if (result != BackgroundAccessStatus.Denied)
{
await RemoveBackgroundTaskAsync(taskName);
// Register task
BackgroundTaskBuilder myTaskBuilder = new BackgroundTaskBuilder();
myTaskBuilder.SetTrigger(trigger);
myTaskBuilder.TaskEntryPoint = taskEntryPoint;
myTaskBuilder.Name = taskName;
BackgroundTaskRegistration myTask = myTaskBuilder.Register();
}
}
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;
}
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;
}
/// <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;
}
public static async Task<BackgroundTaskRegistration> RegisterBackgroundTasksAsync(Type backgroundTaskType, IBackgroundTrigger trigger)
{
try
{
string taskEntryPoint = backgroundTaskType.ToString();
if (!IsBackgroundTaskAlreadyRegistered(backgroundTaskType.Name))
{
// Already registered
Debug.WriteLine("Already registered", "Debug");
return null;
}
// Request access
var access = await BackgroundExecutionManager.RequestAccessAsync();
// If denied
if (access == BackgroundAccessStatus.Denied)
{
Debug.WriteLine("Access Denied, check your capabilities", "Debug");
return null;
}
// Construct the background task
var builder = new BackgroundTaskBuilder
{
Name = backgroundTaskType.Name,
TaskEntryPoint = taskEntryPoint
};
// Set trigger
builder.SetTrigger(trigger);
// And register the background task
BackgroundTaskRegistration task = builder.Register();
return task;
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return null;
}
}
/// <summary>
/// Registers a background task if it doesn't already exist.
/// </summary>
public static void RegisterBackgroundTask(Type backgroundTaskType, IBackgroundTrigger trigger, params IBackgroundCondition[] conditions)
{
bool alreadyRegistered = BackgroundTaskRegistration.AllTasks.Any(kvp => kvp.Value.Name == backgroundTaskType.Name);
if (!alreadyRegistered)
{
BackgroundTaskBuilder sessionStartedTaskBuilder = new BackgroundTaskBuilder();
sessionStartedTaskBuilder.Name = backgroundTaskType.Name;
sessionStartedTaskBuilder.TaskEntryPoint = backgroundTaskType.FullName;
sessionStartedTaskBuilder.SetTrigger(trigger);
foreach (IBackgroundCondition condition in conditions)
{
sessionStartedTaskBuilder.AddCondition(condition);
}
var sessionRegistration = sessionStartedTaskBuilder.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;
}
//modified from from: http://msdn.microsoft.com/en-us/library/windows/apps/xaml/jj553413.aspx
//
// 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,
params IBackgroundCondition[] conditions)
{
//
// 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 (conditions != null)
{
foreach (var condition in conditions)
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 RegisterBackgroundTask(string taskName, string taskEntryPoint,
IBackgroundTrigger trigger)
{
var backgroundAccessStatus = await BackgroundExecutionManager.RequestAccessAsync();
if (backgroundAccessStatus == BackgroundAccessStatus.AllowedSubjectToSystemPolicy)
{
if (BackgroundTaskRegistration.AllTasks.Any(task => task.Value.Name == taskName))
{
Debug.WriteLine($"Task {taskName} already registred");
return;
}
var taskBuilder = new BackgroundTaskBuilder
{
Name = taskName,
TaskEntryPoint = taskEntryPoint,
IsNetworkRequested = true
};
taskBuilder.SetTrigger(trigger);
var registration = taskBuilder.Register();
Debug.WriteLine($"Task {taskName} registred");
}
}
/// <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<IBackgroundTaskRegistration> RegisterTaskP(string name, string entrypoint,
IBackgroundTrigger trigger, bool removeIfRegistered)
{
var taskRegistration = GetTask(name);
if (taskRegistration != null)
{
if (removeIfRegistered)
{
taskRegistration.Unregister(true);
}
else
{
return taskRegistration;
}
}
var status = await BackgroundExecutionManager.RequestAccessAsync();
var taskBuilder = new BackgroundTaskBuilder
{
Name = name,
TaskEntryPoint = entrypoint
};
taskBuilder.SetTrigger(trigger);
return taskBuilder.Register();
}
private void RegisterBackgroundTask(Type type, IBackgroundTrigger trigger)
{
// If the task is already registered. then don't register it again.
foreach (IBackgroundTaskRegistration task in BackgroundTaskRegistration.AllTasks.Values)
{
if (task.Name == type.Name)
{
return;
}
}
var builder = new BackgroundTaskBuilder();
builder.Name = type.Name;
builder.TaskEntryPoint = type.FullName;
builder.SetTrigger(trigger);
BackgroundTaskRegistration taskRegistration = builder.Register();
}
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;
}
}
/// <summary>
/// Registers background task
/// </summary>
/// <param name="trigger">Task trigger</param>
/// <param name="taskName">Task name</param>
/// <param name="taskEntryPoint">Task entry point</param>
/// <returns>Asynchronous task</returns>
private async static Task RegisterBackgroundTaskAsync(IBackgroundTrigger trigger, String taskName, String taskEntryPoint)
{
BackgroundAccessStatus result = await BackgroundExecutionManager.RequestAccessAsync();
if (result != BackgroundAccessStatus.Denied)
{
await RemoveBackgroundTaskAsync(taskName);
// Register task
BackgroundTaskBuilder myTaskBuilder = new BackgroundTaskBuilder();
myTaskBuilder.SetTrigger(trigger);
myTaskBuilder.TaskEntryPoint = taskEntryPoint;
myTaskBuilder.Name = taskName;
BackgroundTaskRegistration myTask = myTaskBuilder.Register();
}
}
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;
}
/// <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;
}
}
private void RegisterTask(string name, IBackgroundTrigger trigger)
{
var taskName = name;
var builder = new BackgroundTaskBuilder
{
Name = taskName,
TaskEntryPoint = "UwpDeepDive.Bg.AppBgTask"
};
builder.SetTrigger(trigger);
builder.AddCondition(new SystemCondition(SystemConditionType.InternetAvailable));
builder.AddCondition(new SystemCondition(SystemConditionType.UserPresent));
var task = builder.Register();
task.Completed += Task_Completed;
}
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();
}
