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