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); }
private void RegisterAppBackgroundTask() { IBackgroundTaskRegistration taskRegistration; Guid taskRegistrationId = Settings.Current.ApplicationBackgroundTaskRegistrationId; if (BackgroundTaskRegistration.AllTasks.TryGetValue(taskRegistrationId, out taskRegistration)) { if (taskRegistration is BackgroundTaskRegistration lastTraskRegistration && lastTraskRegistration.Trigger is ApplicationTrigger) { appTrigger = (ApplicationTrigger)lastTraskRegistration.Trigger; return; } taskRegistration.Unregister(false); } appTrigger = new ApplicationTrigger(); BackgroundTaskBuilder builder = new BackgroundTaskBuilder { Name = applicationBackgroundTaskBuilderName, IsNetworkRequested = true, }; builder.SetTrigger(appTrigger); builder.AddCondition(new SystemCondition(SystemConditionType.FreeNetworkAvailable)); taskRegistration = builder.Register(); Settings.Current.ApplicationBackgroundTaskRegistrationId = taskRegistration.TaskId; }
private void CreatePoller() { foreach (var bgTask in BackgroundTaskRegistration.AllTasks) { if (bgTask.Value.Name == taskName) { bgTask.Value.Unregister(true); } } trigger = new ApplicationTrigger(); BackgroundTaskBuilder taskBuilderActive = new BackgroundTaskBuilder(); taskBuilderActive.Name = taskName; taskBuilderActive.TaskEntryPoint = taskEntryPoint; taskBuilderActive.SetTrigger(trigger); var registration = taskBuilderActive.Register(); var task = Task.Run(async() => { for (; ;) { await Task.Delay(5000); Debug.WriteLine("Hello World after 10 seconds"); await trigger.RequestAsync(); } }); }
private async void Start_Click(object sender, RoutedEventArgs e) { ApplicationData.Current.LocalSettings.Values["number"] = 6; // число для подсчета факториала var taskList = BackgroundTaskRegistration.AllTasks.Values; var task = taskList.FirstOrDefault(i => i.Name == taskName); if (task == null) { var taskBuilder = new BackgroundTaskBuilder(); taskBuilder.Name = taskName; taskBuilder.TaskEntryPoint = typeof(MyRuntimeComponent.MyBackgroundTask).ToString(); ApplicationTrigger appTrigger = new ApplicationTrigger(); taskBuilder.SetTrigger(appTrigger); task = taskBuilder.Register(); task.Progress += Task_Progress; task.Completed += Task_Completed; var taskParameters = new ValueSet(); taskParameters.Add("Message", "Заработало из фонового потока!"); await appTrigger.RequestAsync(taskParameters); startButton.IsEnabled = false; stopButton.IsEnabled = true; } }
private async void button_Click(object sender, RoutedEventArgs e) { var access = await BackgroundExecutionManager.RequestAccessAsync(); switch (access) { case BackgroundAccessStatus.Unspecified: break; case BackgroundAccessStatus.AllowedMayUseActiveRealTimeConnectivity: break; case BackgroundAccessStatus.AllowedWithAlwaysOnRealTimeConnectivity: break; case BackgroundAccessStatus.Denied: break; default: break; } var task = new BackgroundTaskBuilder { Name = "Test Task", TaskEntryPoint = typeof(BackgroundStuff.MyBackgroundTask).ToString() }; var trigger = new ApplicationTrigger(); task.SetTrigger(trigger); await trigger.RequestAsync(); }
/// <summary> /// Register the background task of the app. /// </summary> /// <returns></returns> public async Task RegisterAsync() { //Update the access to the execution manager. BackgroundExecutionManager.RemoveAccess(); var requestAccessStatus = await BackgroundExecutionManager.RequestAccessAsync(); //Create new background task. var builder = new BackgroundTaskBuilder { Name = "ChiotaBackgroundService", TaskEntryPoint = "RuntimeComponent.UWP.BackgroundTask" }; if (requestAccessStatus == BackgroundAccessStatus.AlwaysAllowed || requestAccessStatus == BackgroundAccessStatus.AllowedSubjectToSystemPolicy) { _trigger = new ApplicationTrigger(); //Set the triggers. builder.SetTrigger(_trigger); builder.AddCondition(new SystemCondition(SystemConditionType.InternetAvailable)); //Register the new task. var task = builder.Register(); task.Completed += TaskCompleted; await _trigger.RequestAsync(); } }
private void RegisterAppBackgroundTask() { IBackgroundTaskRegistration taskRegistration; Guid taskRegistrationId = Settings.Current.ApplicationBackgroundTaskRegistrationId; if (BackgroundTaskRegistration.AllTasks.TryGetValue(taskRegistrationId, out taskRegistration)) { if (taskRegistration is BackgroundTaskRegistration lastTraskRegistration && lastTraskRegistration.Trigger is ApplicationTrigger) { appTrigger = (ApplicationTrigger)lastTraskRegistration.Trigger; return; } taskRegistration.Unregister(false); } appTrigger = new ApplicationTrigger(); BackgroundTaskBuilder builder = new BackgroundTaskBuilder { Name = applicationBackgroundTaskBuilderName, }; builder.SetTrigger(appTrigger); taskRegistration = builder.Register(); Settings.Current.ApplicationBackgroundTaskRegistrationId = taskRegistration.TaskId; }
private async void ExecuteUpdateTileCommand(string value) { try { Busy = true; var number = default(int); if (!int.TryParse(value, out number)) { return; } await Task.Delay(2000); var trigger = new ApplicationTrigger(); var task = await BackgroundHelper.Register <MyUpdateBadgeTask>(trigger); task.Completed += (s, e) => { Busy = false; }; var allowed = await trigger.RequestAsync(); if (allowed != ApplicationTriggerResult.Allowed) { // it was not allowed to run Busy = false; } } catch { Busy = false; } }
public async Task isRegisteredAsync() { var taskRegistered = false; var taskName = "Run"; foreach (var task in BackgroundTaskRegistration.AllTasks) { if (task.Value.Name == taskName) { taskRegistered = true; break; } else { //If backroundtask is not registered then register it var builder = new BackgroundTaskBuilder(); var appTrigger = new ApplicationTrigger(); builder.Name = taskName; builder.TaskEntryPoint = "LocationBackgroundTask"; builder.SetTrigger(appTrigger); var result = await appTrigger.RequestAsync(); task = builder.Register(); } } }
/// <summary> /// Passes package file path and of file paths dependencies into the backgroundTask /// using a ValueSet. /// </summary> private async void showProgressInNotification() { permissionTextBlock.Text = "Check Your Notifications/Action Center 😉"; var thingsToPassOver = new ValueSet(); thingsToPassOver.Add("packagePath", packageInContext.Path); if (dependenciesAsString != null & dependenciesAsString.Count > 0) { int count = dependenciesAsString.Count(); for (int i = 0; i < count; i++) { thingsToPassOver.Add($"dependencies{i}", dependenciesAsString[i]); } thingsToPassOver.Add("installType", 1); } else { thingsToPassOver.Add("installType", 0); } PackageManager pkgManager = new PackageManager(); ApplicationTrigger appTrigger = new ApplicationTrigger(); var backgroundTask = RegisterBackgroundTask("installTask.install", "installTask", appTrigger); //backgroundTask.Completed += new BackgroundTaskCompletedEventHandler(OnCompleted); //backgroundTask.Progress += new BackgroundTaskProgressEventHandler(OnProgress); var result = await appTrigger.RequestAsync(thingsToPassOver); foreach (var task in BackgroundTaskRegistration.AllTasks) { if (task.Value.Name == "installTask") { AttachCompletedHandler(task.Value); } } }
private async void RegisterTask() { var taskRegistered = false; ApplicationTrigger trigger = null; var taskName = "SendGrats"; foreach (var task in BackgroundTaskRegistration.AllTasks) { if (task.Value.Name == taskName) { taskRegistered = true; break; } } if (!taskRegistered) { var builder = new BackgroundTaskBuilder() { Name = taskName, }; builder.AddCondition(new SystemCondition(SystemConditionType.InternetAvailable)); trigger = new ApplicationTrigger(); var x = await BackgroundExecutionManager.RequestAccessAsync(); builder.SetTrigger(trigger); builder.IsNetworkRequested = true; BackgroundTaskRegistration task = builder.Register(); task.Completed += new BackgroundTaskCompletedEventHandler(Task_Completed); await trigger.RequestAsync(); } }
public static async Task RegisterApplicationTrigger(Type backgroundTaskType) { var backgroundAccessStatus = await BackgroundExecutionManager.RequestAccessAsync(); if (backgroundAccessStatus == BackgroundAccessStatus.AllowedMayUseActiveRealTimeConnectivity || backgroundAccessStatus == BackgroundAccessStatus.AllowedWithAlwaysOnRealTimeConnectivity) { var appTrigger = new ApplicationTrigger(); string taskEntryPoint = backgroundTaskType.ToString(); var backgroundTaskBuilder = new BackgroundTaskBuilder { Name = backgroundTaskType.Name, TaskEntryPoint = taskEntryPoint }; backgroundTaskBuilder.SetTrigger(appTrigger); var task = BackgroundTaskRegistration.AllTasks.Values.FirstOrDefault(i => i.Name.Equals(backgroundTaskType.Name)); task?.Unregister(true); backgroundTaskBuilder.Register(); ValueSet message = new ValueSet { { "Command", "Init" } }; var result = await appTrigger.RequestAsync(message); if (result == ApplicationTriggerResult.Allowed) { Debug.WriteLine(string.Format("{0} called!", backgroundTaskType.Name)); } } }
private void RegisterListenerTask() { // Registering a background trigger if it is not already registered. It will start background advertising. // First get the existing tasks to see if we already registered for it if (taskRegistration == null) { ApplicationData.Current.LocalSettings.Values[CURRENTINRANGE_TAG] = ""; ApplicationData.Current.LocalSettings.Values[BTWatcherManager.taskName] = ""; // At this point we assume we haven't found any existing tasks matching the one we want to register // First, configure the task entry point, trigger and name ApplicationTrigger trigger = new ApplicationTrigger(); //SystemTrigger trigger = new SystemTrigger(SystemTriggerType.InternetAvailable, false); var builder = new BackgroundTaskBuilder(); builder.TaskEntryPoint = taskEntryPoint; builder.SetTrigger(trigger); builder.Name = taskName; // Now perform the registration. taskRegistration = builder.Register(); // For this scenario, attach an event handler to display the result processed from the background task taskRegistration.Completed += OnMessageListenerTaskCompleted; taskRegistration.Progress += OnMessageListenerTaskProgress; var ignored = trigger.RequestAsync(); MainPage.Current.UpdateDebugMessage(this, "RegisterListenerTask: " + taskRegistration.Name + " / " + taskRegistration.TaskId); } }
/// <summary> /// We proceed to register the task if it hasn't been registered yet. Otherwise, we fetch the registration /// and retrieve the ApplicationTrigger from there. /// </summary> private async void RegisterBackgroundTask() { try { if (!BackgroundTaskRegistration.AllTasks.Any(reg => reg.Value.Name == TileRegistrationName)) { // Configure task parameters BackgroundTaskBuilder builder = new BackgroundTaskBuilder(); builder.TaskEntryPoint = typeof(TileUpdateTask).FullName; builder.Name = TileRegistrationName; // Remember to set an ApplicationTrigger so we can run it on demand later this.backgroundTrigger = new ApplicationTrigger(); builder.SetTrigger(backgroundTrigger); builder.Register(); MessageDialog infoDialog = new MessageDialog("Background task successfully registered.", "Info"); await infoDialog.ShowAsync(); } else { // Fetch registration details and trigger if already existing var registration = BackgroundTaskRegistration.AllTasks.FirstOrDefault(reg => reg.Value.Name == TileRegistrationName).Value as BackgroundTaskRegistration; this.backgroundTrigger = registration.Trigger as ApplicationTrigger; MessageDialog infoDialog = new MessageDialog("Background task registration data successfully retrieved.", "Info"); await infoDialog.ShowAsync(); } } catch (Exception ex) { MessageDialog errorDialog = new MessageDialog("There was an error while trying to register the background task.", "Error"); errorDialog.ShowAsync(); } }
private async void RegisterTask(string taskName, string entryPoint) { bool taskRegistered = false; foreach (var task in BackgroundTaskRegistration.AllTasks) { if (task.Value.Name == taskName) { taskRegistered = true; break; } } if (!taskRegistered) { var builder = new BackgroundTaskBuilder(); var trigger = new ApplicationTrigger(); builder.Name = taskName; builder.TaskEntryPoint = entryPoint; builder.SetTrigger(trigger); BackgroundTaskRegistration task = builder.Register(); var result = await trigger.RequestAsync(); } }
/// <summary> /// Register for background tasks (Time zone trigger & time trigger) /// </summary> static async void ThreadProc() { Console.ForegroundColor = ConsoleColor.Cyan; Console.WriteLine("******************************************"); Console.WriteLine("**** Time zone trigger backgrond task ****"); Console.WriteLine("******************************************"); await BackgroundExecutionManager.RequestAccessAsync(); // Register a TimeZoneTrigger background task with name and trigger RegisterBackgroundTask("TimeZoneTriggerTest", new SystemTrigger(SystemTriggerType.TimeZoneChange, false)); Console.ForegroundColor = ConsoleColor.Green; Console.WriteLine("Registration completed for Time Zone change system event. Change the time zone to trigger the backgrond task"); Console.ForegroundColor = ConsoleColor.Cyan; Console.WriteLine("*************************************"); Console.WriteLine("**** Time trigger backgrond task ****"); Console.WriteLine("*************************************"); // Register a background TimeTrigger task with name and trigger RegisterBackgroundTask("TimerTriggerTest", new TimeTrigger(15, false)); Console.ForegroundColor = ConsoleColor.Green; Console.WriteLine("Registration completed for Time trigger event. The backgrond task runs every 15 mins"); Console.WriteLine("Pin the app to start and see how the tile is updated every time the task is triggered"); // just a test ApplicationTrigger trigger = new ApplicationTrigger(); if (trigger is ApplicationTrigger) { var result = await(trigger as ApplicationTrigger).RequestAsync(); // returns UnknownError } }
/// <summary> /// Initializes the singleton application object. This is the first line of authored code /// executed, and as such is the logical equivalent of main() or WinMain(). /// </summary> public App() { BackgroundNotificationTrigger = new ApplicationTrigger(); RegisterBackgroundTasks(); this.InitializeComponent(); this.Suspending += OnSuspending; }
public static ref ApplicationTrigger GetAppTrigger() { if (AppTrigger == null) { AppTrigger = new ApplicationTrigger(); } return(ref AppTrigger); }
private async Task RegisterCommandExecute() { _trigger = new ApplicationTrigger(); var task = await BackgroundTaskHelper.RegisterApplicationTrigger(typeof(BackgroundTask), _trigger); AttachProgressAndCompletedHandlers(task); Info += "Registered" + Environment.NewLine; }
private async void btnApplicationTrigger_Tapped(object sender, TappedRoutedEventArgs e) { var trigger = new ApplicationTrigger(); var reg = await RegisterBackgroundTask(typeof(TheBackgroundTask.TheTask).FullName, trigger.GetType().Name, trigger, null); var md = new ValueSet(); md.Add("command", txtForApplicationTrigger.Text); var res = await trigger.RequestAsync(md); }
public MainPage() { this.InitializeComponent(); //ReadConfiguration().GetAwaiter(); //DispatcherTimerSetup(); //RegisterBackgroundTask(); trigger = new ApplicationTrigger(); //uwpScheduler uwp = new uwpScheduler(); initializeSettings(); LocalDataStore.CreateLocalConfigurationSettings(); }
private void RegisterBackgroundTask(object sender, RoutedEventArgs e) { trigger = new ApplicationTrigger(); var task = SchedulerConfigurations.RegisterBackgroundTask(LocalDataStore.BackgroundTaskEntryPoint, LocalDataStore.BackgroundTriggerName, trigger, null); // AttachProgressAndCompletedHandlers(task); //SignalBackgroundTask(null, null); // UpdateUI(); }
public static void Init(WindowsPage page) { MessagingCenter.Subscribe <StartLongRunningTask>(page, nameof(StartLongRunningTask), async(message) => { var access = await BackgroundExecutionManager.RequestAccessAsync(); switch (access) { case Unspecified: return; case AllowedMayUseActiveRealTimeConnectivity: return; case AllowedWithAlwaysOnRealTimeConnectivity: return; case Denied: return; } var task = new BackgroundTaskBuilder { Name = BackServiceName, //TaskEntryPoint = "Matcha.BackgroundService.UWP.MatchaBackgrounService" }; var trigger = new ApplicationTrigger(); task.SetTrigger(trigger); //var condition = new SystemCondition(SystemConditionType.InternetAvailable); task.Register(); await trigger.RequestAsync(); }); MessagingCenter.Subscribe <StopLongRunningTask>(page, nameof(StopLongRunningTask), message => { var tasks = BackgroundTaskRegistration.AllTasks; foreach (var task in tasks) { // You can check here for the name string name = task.Value.Name; if (name == BackServiceName) { task.Value.Unregister(true); } } //BackgroundAggregatorService.Instance.Stop(); }); }
protected override void OnNavigatedTo(NavigationEventArgs e) { foreach (var task in BackgroundTaskRegistration.AllTasks) { if (task.Value.Name == WallpaperTaskConfig.WallpaperTaskName) { WallpaperTaskConfig.UpdateBackgroundTaskRegistrationStatus(WallpaperTaskConfig.WallpaperTaskName, true); break; } } trigger = new ApplicationTrigger(); }
/// <summary> /// Register a ApplicationTriggerTask. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private async void RegisterBackgroundTask(object sender, RoutedEventArgs e) { trigger = new ApplicationTrigger(); var task = BackgroundTaskSample.RegisterBackgroundTask(BackgroundTaskSample.SampleBackgroundTaskEntryPoint, BackgroundTaskSample.ApplicationTriggerTaskName, trigger, null); await task; AttachProgressAndCompletedHandlers(task.Result); UpdateUI(); }
private async Task RegisterTasks() { var status = await BackgroundExecutionManager.RequestAccessAsync(); if (status != BackgroundAccessStatus.Denied) { RegisterTask("timerTask", new TimeTrigger(240, false)); } RegisterTask("toastNotificationActionTask", new ToastNotificationActionTrigger()); RegisterTask("appTriggerTask", _bgTaskTrigger = new ApplicationTrigger()); }
/// <summary> /// Registration of background tasks /// </summary> public static async void RegistrBackgroundTaskAsync() { string myTaskName = "TDNReminder"; bool skip = false; BackgroundTaskBuilder taskBuilder; ApplicationTrigger trigger = new ApplicationTrigger(); if (BackgroundTaskRegistration.AllTasks.Any(i => i.Value.Name.Equals(myTaskName))) { skip = true; } foreach (var cur in BackgroundTaskRegistration.AllTasks) { if (cur.Value.Name == myTaskName) { return; } } if (!skip) { // Windows Phone app must call this to use trigger types (see MSDN) await BackgroundExecutionManager.RequestAccessAsync(); // register a new task taskBuilder = new BackgroundTaskBuilder { Name = "TDNReminder", TaskEntryPoint = "Reminder.Reminder" }; taskBuilder.SetTrigger(new SystemTrigger(SystemTriggerType.SessionConnected, false)); taskBuilder.SetTrigger(new SystemTrigger(SystemTriggerType.UserPresent, false)); taskBuilder.SetTrigger(new TimeTrigger(15, false)); taskBuilder.SetTrigger(trigger); taskBuilder.AddCondition(new SystemCondition(SystemConditionType.SessionConnected)); BackgroundTaskRegistration Reminder = taskBuilder.Register(); await trigger.RequestAsync(); } // -------------------------------------------------------------------------------- //myTaskName = "TDNCompleter"; //if (BackgroundTaskRegistration.AllTasks.Any(i => i.Value.Name.Equals(myTaskName))) // return; //// register a new task //taskBuilder = new BackgroundTaskBuilder { Name = myTaskName }; //taskBuilder.SetTrigger(new ToastNotificationActionTrigger()); //BackgroundTaskRegistration Completer = taskBuilder.Register(); }
public void RegisterTask() { runCount++; Debug.WriteLine("............................................................................................Datetime : " + DateTime.Now + " in RegisterTask ...............Run Count : " + runCount); taskTrigger = new ApplicationTrigger(); var task = SchedulerConfigurations.RegisterBackgroundTask(LocalDataStore.BackgroundTaskEntryPoint, LocalDataStore.BackgroundTriggerName, taskTrigger, null); // taskRunning = true; StartBackgroundTask(); }
public SettingsViewModel(IBackgroundService _backgroundService) { backgroundService = _backgroundService; // Create a new trigger applicationtrigger = new ApplicationTrigger(); localFolder = ApplicationData.Current.LocalFolder; _fences = new ObservableCollection <Fence>(); _locations = new ObservableCollection <Location>(); formatterLongTime = new DateTimeFormatter("{hour.integer}:{minute.integer(2)}:{second.integer(2)}", new[] { "en-US" }, "US", Windows.Globalization.CalendarIdentifiers.Gregorian, Windows.Globalization.ClockIdentifiers.TwentyFourHour); calendar = new Calendar(); }
public async Task <int> backTaskUpdateTiles() { if (isUpdateCompleted == true) { isUpdateCompleted = false; ApplicationTrigger trigger = new ApplicationTrigger(); var btr = await BackTaskReg.RegisterBackgroundTask("BackTaskUpdateTiles", "Taq.BackTask.BackTaskUpdateTiles", trigger); btr.Completed += Btr_Completed; var result = await trigger.RequestAsync(); } return(0); }
private async void RegisterTask(string taskName) { BackgroundTaskBuilder taskBuilder = new BackgroundTaskBuilder { Name = taskName, }; var trigger = new ApplicationTrigger(); taskBuilder.SetTrigger(trigger); var registration = taskBuilder.Register(); await trigger.RequestAsync(); }
private async void button_Click(object sender, RoutedEventArgs e) { var access = await BackgroundExecutionManager.RequestAccessAsync(); switch (access) { case BackgroundAccessStatus.Unspecified: break; case BackgroundAccessStatus.AllowedWithAlwaysOnRealTimeConnectivity: break; case BackgroundAccessStatus.AllowedMayUseActiveRealTimeConnectivity: break; case BackgroundAccessStatus.Denied: break; case BackgroundAccessStatus.AlwaysAllowed: break; case BackgroundAccessStatus.AllowedSubjectToSystemPolicy: break; case BackgroundAccessStatus.DeniedBySystemPolicy: break; case BackgroundAccessStatus.DeniedByUser: break; default: break; } var task = new BackgroundTaskBuilder { Name = "My Task", TaskEntryPoint = typeof(BackgroundComponent.Class1).ToString() }; var trigger = new ApplicationTrigger(); task.SetTrigger(trigger); var condition = new SystemCondition(SystemConditionType.InternetAvailable); task.Register(); await trigger.RequestAsync(); }
private static async Task <bool> RegisterAllBackgroundTasksAsyncHelper(bool runAppTrigger) { // Check for background registration permissions. var status = await BackgroundExecutionManager.RequestAccessAsync(); Debug.WriteLine("BackgroundExecutionManager.RequestAccessAsync returned status " + status); if (status == BackgroundAccessStatus.DeniedBySystemPolicy || status == BackgroundAccessStatus.DeniedByUser) { Debug.WriteLine("Cannot register background tasks. TODO: Notify user?"); return(false); } // TODO: Remove this after development //UnregisterAllBackgroundTasks(); // Background task parameters. ApplicationTrigger appTrigger = new ApplicationTrigger(); SystemTrigger sessionConnectedTrigger = new SystemTrigger(SystemTriggerType.SessionConnected, false); SystemCondition userPresentCondition = new SystemCondition(SystemConditionType.UserPresent); SystemCondition internetCondition = new SystemCondition(SystemConditionType.InternetAvailable); /** * App store update task registration */ // Trigger the task to run when the app launches. _ = RegisterBackgroundTask( CheckStoreUpdatesApp, CheckStoreUpdatesEntry, appTrigger, new[] { internetCondition } ); // Trigger the task to run when the user logs in, i.e. startup, logon. _ = RegisterBackgroundTask( CheckStoreUpdatesSession, CheckStoreUpdatesEntry, sessionConnectedTrigger, new[] { userPresentCondition, internetCondition } ); // Run background tasks that should start when the app is launched. if (runAppTrigger) { ApplicationTriggerResult result = await appTrigger.RequestAsync(); Debug.WriteLine("ApplicationTrigger result is" + result); } return(true); }
/// <summary> /// Invoked when this page is about to be displayed in a Frame. /// </summary> /// <param name="e">Event data that describes how this page was reached. The Parameter /// property is typically used to configure the page.</param> protected override void OnNavigatedTo(NavigationEventArgs e) { foreach (var task in BackgroundTaskRegistration.AllTasks) { if (task.Value.Name == BackgroundTaskSample.ApplicationTriggerTaskName) { AttachProgressAndCompletedHandlers(task.Value); BackgroundTaskSample.UpdateBackgroundTaskRegistrationStatus(BackgroundTaskSample.ApplicationTriggerTaskName, true); break; } } trigger = new ApplicationTrigger(); UpdateUI(); }
public static async Task<BackgroundTaskRegistration> RegisterApplicationTrigger(Type backgroundTaskType, ApplicationTrigger trigger) { try { var backgroundAccessStatus = await BackgroundExecutionManager.RequestAccessAsync(); if (backgroundAccessStatus == BackgroundAccessStatus.AllowedMayUseActiveRealTimeConnectivity || backgroundAccessStatus == BackgroundAccessStatus.AllowedWithAlwaysOnRealTimeConnectivity) { string taskEntryPoint = backgroundTaskType.ToString(); var backgroundTaskBuilder = new BackgroundTaskBuilder { Name = backgroundTaskType.Name, TaskEntryPoint = taskEntryPoint }; backgroundTaskBuilder.SetTrigger(trigger); var task = BackgroundTaskRegistration.AllTasks.Values.FirstOrDefault( i => i.Name.Equals(backgroundTaskType.Name)); task?.Unregister(true); var appTriggerTask = backgroundTaskBuilder.Register(); return appTriggerTask; } return null; } catch(Exception ex) { Debug.WriteLine(ex.Message); return null; } }
public MainPage() { this.InitializeComponent(); _trigger = new ApplicationTrigger(); }
private async Task<Tuple<bool, string>> TryRegisterUploadToOneDriveBackgroundTaskAsync() { bool isOk = false; string msg = string.Empty; string errorMsg = string.Empty; BackgroundAccessStatus backgroundAccessStatus = BackgroundAccessStatus.Unspecified; _uploadToOneDriveBkgTaskReg = null; UnregisterTaskIfAlreadyRegistered(); // I need to unregister and register anew coz I need to obtain the trigger 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. Task<BackgroundAccessStatus> requestAccess = null; await RunInUiThreadIdleAsync(() => requestAccess = BackgroundExecutionManager.RequestAccessAsync().AsTask()).ConfigureAwait(false); backgroundAccessStatus = await requestAccess.ConfigureAwait(false); // Regardless of the answer, register the background task. If the user later adds this application // to the lock screen, the background task will be ready to run. // Create a new background task builder BackgroundTaskBuilder bkgTaskBuilder = new BackgroundTaskBuilder { Name = ConstantData.ODU_BACKGROUND_TASK_NAME, TaskEntryPoint = ConstantData.ODU_BACKGROUND_TASK_ENTRY_POINT }; _uploadToOneDriveTrigger = new ApplicationTrigger(); bkgTaskBuilder.SetTrigger(_uploadToOneDriveTrigger); // bkgTaskBuilder.AddCondition(new SystemCondition(SystemConditionType.SessionDisconnected)); // NO! // Register the background task _uploadToOneDriveBkgTaskReg = bkgTaskBuilder.Register(); } catch (Exception ex) { errorMsg = ex.ToString(); backgroundAccessStatus = BackgroundAccessStatus.Denied; Logger.Add_TPL(ex.ToString(), Logger.ForegroundLogFilename); } switch (backgroundAccessStatus) { case BackgroundAccessStatus.Unspecified: msg = "Cannot run in background, enable it in the \"Battery Saver\" app"; break; case BackgroundAccessStatus.Denied: msg = string.IsNullOrWhiteSpace(errorMsg) ? "Cannot run in background, enable it in Settings - Privacy - Background apps" : errorMsg; break; default: msg = "Background task on"; isOk = true; break; } return Tuple.Create(isOk, msg); }
private async void ExecuteUpdateTileCommand(string value) { try { Busy = true; var number = default(int); if (!int.TryParse(value, out number)) return; await Task.Delay(2000); var trigger = new ApplicationTrigger(); var task = await BackgroundHelper.Register<MyUpdateBadgeTask>(trigger); task.Completed += (s,e)=> { Busy = false; }; var allowed = await trigger.RequestAsync(); if (allowed != ApplicationTriggerResult.Allowed) { // it was not allowed to run Busy = false; } } catch { Busy = false; } }
private async Task Register() { if (ExistingRegistration.Any()) return; // request access var access = BackgroundExecutionManager.GetAccessStatus(); switch (access) { case BackgroundAccessStatus.Unspecified: case BackgroundAccessStatus.Denied: { await new ContentDialog { Title = "Cannot register", Content = "Get Access: " + access.ToString(), PrimaryButtonText = "Close" }.ShowAsync(); return; } } // build task var task = new BackgroundTaskBuilder { Name = nameof(MyBackgroundTask), CancelOnConditionLoss = true, TaskEntryPoint = typeof(MyBackgroundTask).ToString(), }; task.SetTrigger(this._applicationTrigger = new ApplicationTrigger()); // register BackgroundTaskRegistration registration = null; try { registration = task.Register(); } catch (Exception ex) { this.ProgressText.Text = "Registration failed: " + ex.Message; return; } // report var dispatcher = this.Dispatcher; registration.Progress += async (s, e) => { await dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () => { this.ProgressText.Text = string.Format("Task progress: {0}", e.Progress); }); }; // handle complete registration.Completed += async (s, e) => { await dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () => { try { e.CheckResult(); this.ProgressText.Text = "Task completed."; } catch (Exception ex) { this.ProgressText.Text = string.Format("Task error {0}", ex.Message); } finally { UpdateButtons(); } }); }; }