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