async void MainPage_Loaded(object sender, RoutedEventArgs e) { var promise = await BackgroundExecutionManager.RequestAccessAsync(); if (promise == BackgroundAccessStatus.Denied) { MessageDialog warningDialog = new MessageDialog("Background execution is disabled. Please re-enable in the Battery Saver app to allow this app to function", "Background GPS"); await warningDialog.ShowAsync(); } else { var defaultSensor = Windows.Devices.Sensors.Accelerometer.GetDefault(); if (defaultSensor != null) { var deviceUseTrigger = new DeviceUseTrigger(); deviceUseTask = RegisterBackgroundTask("BackgroundGps.Engine.BackgroundGpsTask", "GpsTask", deviceUseTrigger, null); try { DeviceTriggerResult r = await deviceUseTrigger.RequestAsync(defaultSensor.DeviceId); System.Diagnostics.Debug.WriteLine(r); //Allowed } catch (Exception ex) { System.Diagnostics.Debug.WriteLine(ex); } } } }
public static IAsyncOperation<BackgroundTaskRegistration> RegisterTaskAsync() { return AsyncInfo.Run(async (cancellationToken) => { if (IsTaskRegistered()) return _current; await BackgroundExecutionManager.RequestAccessAsync(); //http://msdn.microsoft.com/en-us/library/windows/apps/windows.applicationmodel.background.timetrigger.aspx IBackgroundTrigger trigger = new TimeTrigger(6*60, false); //6 hours // Builds the background task. BackgroundTaskBuilder builder = new BackgroundTaskBuilder(); builder.Name = FriendlyName; builder.TaskEntryPoint = typeof(BackgroundDemoTask).FullName; builder.SetTrigger(trigger); SystemCondition condition = new SystemCondition(SystemConditionType.InternetAvailable); builder.AddCondition(condition); // Registers the background task, and get back a BackgroundTaskRegistration object // representing the registered task. _current = builder.Register(); return _current; }); }
void Task_Completed(BackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs args) { if (deferral != null) { deferral.Complete(); } }
public static void Register() { foreach (var iter in BackgroundTaskRegistration.AllTasks) { IBackgroundTaskRegistration mytask = iter.Value; if (mytask.Name == "ExampleBackgroundTask") { mytask.Unregister(true); break; } } var builder = new BackgroundTaskBuilder(); PushNotificationTrigger trigger = new PushNotificationTrigger(); builder.SetTrigger(trigger); builder.Name = "ExampleBackgroundTask"; builder.TaskEntryPoint = "Usergrid.Notifications.ExampleBackgroundTask"; ExampleBackgroundTask.task = builder.Register(); task.Progress += task_Progress; task.Completed += task_Completed; }
public static void UnregisterTask() { if (IsTaskRegistered()) { _current.Unregister(true); _current = null; } }
private async void OnProgress(BackgroundTaskRegistration sender, BackgroundTaskProgressEventArgs args) { // Serialize UI update to the the main UI thread. await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { ShowErrorDialog(CommonData.LastMessage,"Got message"); }); }
void OnProgress(BackgroundTaskRegistration sender, BackgroundTaskProgressEventArgs args) { Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { if (this.mediaElement.Visibility == Visibility.Collapsed) { this.mediaElement.Visibility = Visibility.Visible; this.mediaElement.Play(); } this.txtTaskRunning.Text = "Running"; this.progressBar.Value = args.Progress; }); }
public static bool IsTaskRegistered() { if (_current == null) { foreach (var cur in BackgroundTaskRegistration.AllTasks) { if (cur.Value.Name == FriendlyName) { // The task is already registered. _current = (BackgroundTaskRegistration)(cur.Value); } } } return _current != null; }
public static async Task<BackgroundTaskRegistration> RegisterLogsUploadTask() { if (LogsUploadTask != null) { return LogsUploadTask; } if (Log.IsDebugEnabled) Log.Debug("Registering LogsUpload background task."); var accessStatus = await SetUpAccess(); if (accessStatus == BackgroundAccessStatus.Denied) return null; var result = RegisterBackgroundTask(typeof(LogsUploadTask).FullName, "LinquaLogsUpload", new TimeTrigger(LogsUploadTaskIntervalMinutes, false), new SystemCondition(SystemConditionType.InternetAvailable)); LogsUploadTask = result; if (Log.IsDebugEnabled) Log.Debug("Background task registered. TaskId: {0}", result.TaskId); return result; }
private static void BgTask_Progress(BackgroundTaskRegistration sender, BackgroundTaskProgressEventArgs args) { LogMessage("BgTask Progress: " + args.Progress, NotifyType.StatusMessage); }
private void CancelSyncWithDevice() { if (isSyncing) { backgroundSyncTaskRegistration.Unregister(true); backgroundSyncTaskRegistration = null; // We are canceling the task, so we are no longer syncing. If the task is registered but never run, // the cancel completion is never called isSyncing = false; } }
private async void OnTaskCompleted(BackgroundTaskRegistration task, BackgroundTaskCompletedEventArgs args) { await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { rootPage.NotifyUser("Background task completed", NotifyType.StatusMessage); }); }
private static void BgTask_Completed(BackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs args) { LogMessage("BgTask Completed", NotifyType.StatusMessage); }
/// <summary> /// Starts the sensor background task. /// </summary> /// <param name="deviceId">Device Id for the sensor to be used by the task.</param> /// <param name="e"></param> /// <returns>True if the task is started successfully.</returns> private async Task<bool> StartSensorBackgroundTaskAsync(String deviceId) { bool started = false; // Make sure only 1 task is running. FindAndCancelExistingBackgroundTask(); // Register the background task. var backgroundTaskBuilder = new BackgroundTaskBuilder() { Name = SampleConstants.Scenario1_TaskName, TaskEntryPoint = SampleConstants.Scenario1_TaskEntryPoint }; backgroundTaskBuilder.SetTrigger(_deviceUseTrigger); _deviceUseBackgroundTaskRegistration = backgroundTaskBuilder.Register(); // Make sure we're notified when the task completes or if there is an update. _deviceUseBackgroundTaskRegistration.Completed += new BackgroundTaskCompletedEventHandler(OnBackgroundTaskCompleted); try { // Request a DeviceUse task to use the accelerometer. DeviceTriggerResult deviceTriggerResult = await _deviceUseTrigger.RequestAsync(deviceId); switch (deviceTriggerResult) { case DeviceTriggerResult.Allowed: rootPage.NotifyUser("Background task started", NotifyType.StatusMessage); started = true; break; case DeviceTriggerResult.LowBattery: rootPage.NotifyUser("Insufficient battery to run the background task", NotifyType.ErrorMessage); break; case DeviceTriggerResult.DeniedBySystem: // The system can deny a task request if the system-wide DeviceUse task limit is reached. rootPage.NotifyUser("The system has denied the background task request", NotifyType.ErrorMessage); break; default: rootPage.NotifyUser("Could not start the background task: " + deviceTriggerResult, NotifyType.ErrorMessage); break; } } catch (InvalidOperationException) { // If toggling quickly between 'Disable' and 'Enable', the previous task // could still be in the process of cleaning up. rootPage.NotifyUser("A previous background task is still running, please wait for it to exit", NotifyType.ErrorMessage); FindAndCancelExistingBackgroundTask(); } return started; }
/// <summary> /// This is the background task completion handler. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private async void OnBackgroundTaskCompleted(BackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs e) { // Dispatch to the UI thread to display the output. await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { // An exception may be thrown if an error occurs in the background task. try { e.CheckResult(); if (ApplicationData.Current.LocalSettings.Values.ContainsKey("TaskCancelationReason")) { string cancelationReason = (string)ApplicationData.Current.LocalSettings.Values["TaskCancelationReason"]; rootPage.NotifyUser("Background task was stopped, reason: " + cancelationReason, NotifyType.StatusMessage); } } catch (Exception ex) { rootPage.NotifyUser("Exception in background task: " + ex.Message, NotifyType.ErrorMessage); } _refreshTimer.Stop(); }); // Unregister the background task and let the remaining task finish until completion. if (null != _deviceUseBackgroundTaskRegistration) { _deviceUseBackgroundTaskRegistration.Unregister(false); _deviceUseBackgroundTaskRegistration = null; } }
private void Taskcompleted(BackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs args) { BackgroundMediaPlayer.Shutdown(); _deferral.Complete(); }
private async void RegTask_Completed(BackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs args) { string json = await readStringFromLocalFile("parking.json"); ParkingResult[] result = JsonConvert.DeserializeObject<ParkingResult[]>(json); foreach(var parking in result) { if (parking.parkingStatus == null) continue; points.Add(new PointOfInterest() { DisplayName = parking.name, FreePlaces = parking.parkingStatus.availableCapacity, Location = new Geopoint(new BasicGeoposition() { Latitude = parking.latitude, Longitude = parking.longitude }), ParkingResult = parking }); } await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, RefreshUI); }
/// <summary> /// Handle background task completion. /// </summary> /// <param name="task">The task that is reporting completion.</param> /// <param name="e">Arguments of the completion report.</param> private async void OnBackgroundTaskCompleted(BackgroundTaskRegistration task, BackgroundTaskCompletedEventArgs eventArgs) { // We get the advertisement(s) processed by the background task if (ApplicationData.Current.LocalSettings.Values.Keys.Contains(taskName)) { string backgroundMessage = (string) ApplicationData.Current.LocalSettings.Values[taskName]; // Serialize UI update to the main UI thread await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { // Display these information on the list ReceivedAdvertisementListBox.Items.Add(backgroundMessage); }); } }
private void OnBackgroundTaskCompleted(BackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs args) { args.CheckResult(); // TODO: What kind of errors does this report? Debug.WriteLine(sender); // BackgroundTaskRegistration string instanceIdString = args.InstanceId.ToString(); if (!ApplicationData.Current.LocalSettings.Values.ContainsKey(instanceIdString)) { // This task didn't schedule a download. return; } Guid transferGuid = (Guid)ApplicationData.Current.LocalSettings.Values[instanceIdString]; Debug.WriteLine("Background task completed! Last download was {0}", transferGuid); }
/// <summary> /// Updates the UI with the progress of the sync /// </summary> /// <param name="sender"></param> /// <param name="args"></param> private async void OnSyncWithDeviceProgress(BackgroundTaskRegistration sender, BackgroundTaskProgressEventArgs args) { await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, new DispatchedHandler(() => { SyncProgressBar.Value = args.Progress; })); }
private void Completed(BackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs args) { defferal.Complete(); }
/// <summary> /// Indicate that the background task is completed. /// </summary> private void Taskcompleted(BackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs args) { logger.LogMessage($"Background Audio Task {sender.TaskId} Completed..."); Dispose(); }
/// <summary> /// Registers for background task that will write to the device. /// </summary> private void SetupBackgroundTask() { // Create background task to write var backgroundTaskBuilder = new BackgroundTaskBuilder(); backgroundTaskBuilder.Name = SyncBackgroundTaskInformation.Name; backgroundTaskBuilder.TaskEntryPoint = SyncBackgroundTaskInformation.TaskEntryPoint; backgroundTaskBuilder.SetTrigger(syncBackgroundTaskTrigger); backgroundSyncTaskRegistration = backgroundTaskBuilder.Register(); // Make sure we're notified when the task completes or if there is an update backgroundSyncTaskRegistration.Completed += new BackgroundTaskCompletedEventHandler(OnSyncWithDeviceCompleted); backgroundSyncTaskRegistration.Progress += new BackgroundTaskProgressEventHandler(OnSyncWithDeviceProgress); }
/// <summary> /// This is the click handler for the 'Disable' button. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void ScenarioDisable(object sender, RoutedEventArgs e) { Window.Current.VisibilityChanged -= new WindowVisibilityChangedEventHandler(VisibilityChanged); ScenarioEnableButton.IsEnabled = true; ScenarioDisableButton.IsEnabled = false; _refreshTimer.Stop(); if (null != _deviceUseBackgroundTaskRegistration) { // Cancel and unregister the background task from the current app session. _deviceUseBackgroundTaskRegistration.Unregister(true); _deviceUseBackgroundTaskRegistration = null; } else { // Cancel and unregister the background task from the previous app session. FindAndCancelExistingBackgroundTask(); } rootPage.NotifyUser("Background task was canceled", NotifyType.StatusMessage); }
/// <summary> /// Reopen the device after the background task is done syncing. Notify the UI of how many bytes we wrote to the device. /// </summary> /// <param name="sender"></param> /// <param name="args"></param> private async void OnSyncWithDeviceCompleted(BackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs args) { // Exception may be thrown if an error occurs during running the background task args.CheckResult(); await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, new DispatchedHandler(async () => { // Reopen the device once the background task is completed await EventHandlerForDevice.Current.OpenDeviceAsync(syncDeviceInformation, syncDeviceSelector); syncDeviceInformation = null; syncDeviceSelector = null; var taskCompleteStatus = (String)ApplicationData.Current.LocalSettings.Values[LocalSettingKeys.SyncBackgroundTaskStatus]; if (taskCompleteStatus == SyncBackgroundTaskInformation.TaskCompleted) { UInt32 totalBytesWritten = (UInt32)ApplicationData.Current.LocalSettings.Values[LocalSettingKeys.SyncBackgroundTaskResult]; rootPage.NotifyUser("Sync: Wrote " + totalBytesWritten.ToString() + " bytes to the device", NotifyType.StatusMessage); } else if (taskCompleteStatus == SyncBackgroundTaskInformation.TaskCanceled) { rootPage.NotifyUser("Syncing was canceled", NotifyType.StatusMessage); } // Remove all local setting values ApplicationData.Current.LocalSettings.Values.Clear(); isSyncing = false; UpdateButtonStates(); })); // Unregister the background task and let the remaining task finish until completion if (backgroundSyncTaskRegistration != null) { backgroundSyncTaskRegistration.Unregister(false); } }
private void OnBackgroundTaskProgress(BackgroundTaskRegistration sender, BackgroundTaskProgressEventArgs args) { Debug.WriteLine("Sender si {0}", sender); Debug.WriteLine("Progress is {0}", args.Progress); }
/// <summary> /// Handle background task completion. /// </summary> /// <param name="task">The task that is reporting completion.</param> /// <param name="e">Arguments of the completion report.</param> private async void OnBackgroundTaskCompleted(BackgroundTaskRegistration task, BackgroundTaskCompletedEventArgs eventArgs) { // We get the status changed processed by the background task if (ApplicationData.Current.LocalSettings.Values.Keys.Contains(taskName)) { string backgroundMessage = (string) ApplicationData.Current.LocalSettings.Values[taskName]; // Serialize UI update to the main UI thread await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { // Display the status change PublisherStatusBlock.Text = backgroundMessage; }); } }
/// <summary> /// Called when background task defferal is completed. This can happen for a number of reasons (both expected and unexpected). /// IF this is expected, we'll notify the user. If it's not, we'll show that this is an error. Finally, clean up the connection by calling Disconnect(). /// </summary> /// <param name="sender"></param> /// <param name="args"></param> private async void OnCompleted(BackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs args) { var settings = ApplicationData.Current.LocalSettings; if (settings.Values.ContainsKey("TaskCancelationReason")) { await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { statusTextBlock.Text = "ERROR: Task cancelled unexpectedly - reason: " + settings.Values["TaskCancelationReason"].ToString(); }); } else { await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { statusTextBlock.Text = "STATUS: Background task completed"; }); } try { args.CheckResult(); } catch (Exception ex) { throw; //rootPage.NotifyUser(ex.Message, NotifyType.ErrorMessage); } Disconnect(); }
/// <summary> /// Indicate that the background task is completed. /// </summary> void TaskCompleted(BackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs args) { Debug.WriteLine("MyBackgroundAudioTask " + sender.TaskId + " Completed..."); deferral.Complete(); }
void liveTileUpdater_BackgroundTaskCompleted(BackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs args) { DispatchUpdateUI(); }