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);
}
}
}
}
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 async void RegisterAndRunAsync()
{
var taskName = typeof(CheckHeartRateInBackgroundTask).Name;
IBackgroundTaskRegistration checkHeartRateInBackground = BackgroundTaskRegistration.AllTasks.Values.FirstOrDefault(t => t.Name == taskName);
if (band.IsConnected() && band.Identity.IsAuthenticated())
{
if (checkHeartRateInBackground != null)
{
checkHeartRateInBackground.Unregister(true);
}
var deviceTrigger = new DeviceUseTrigger();
var deviceInfo = await band.Identity.GetPairedBand();
var taskBuilder = new BackgroundTaskBuilder
{
Name = taskName,
TaskEntryPoint = typeof(CheckHeartRateInBackgroundTask).ToString(),
IsNetworkRequested = false
};
taskBuilder.SetTrigger(deviceTrigger);
BackgroundTaskRegistration task = taskBuilder.Register();
await deviceTrigger.RequestAsync(deviceInfo.Id);
}
}
private static async Task BuildBandDataTask(string taskName, string deviceId)
{
var taskBuilder = new BackgroundTaskBuilder {
Name = BandDataTaskId, TaskEntryPoint = taskName
};
DeviceUseTrigger = new DeviceUseTrigger();
taskBuilder.SetTrigger(DeviceUseTrigger);
taskBuilder.Register();
var triggerResult = await DeviceUseTrigger.RequestAsync(deviceId);
switch (triggerResult)
{
case DeviceTriggerResult.Allowed:
return;
case DeviceTriggerResult.DeniedByUser:
throw new InvalidOperationException("Cannot start the background task. Access denied by user.");
case DeviceTriggerResult.DeniedBySystem:
throw new InvalidOperationException("Cannot start the background task. Access denied by system.");
case DeviceTriggerResult.LowBattery:
throw new InvalidOperationException("Cannot start the background task. Low battery.");
}
}
public static async void RegisterAndRunAsync(DeviceInformation devInfo)
{
var taskName = typeof(CheckHeartRateInBackgroundTask).ToString();
IBackgroundTaskRegistration checkHeartRateInBackground = BackgroundTaskRegistration.AllTasks.Values.FirstOrDefault(t => t.Name == taskName);
if (band.IsConnected() && band.Identity.IsAuthenticated())
{
if (checkHeartRateInBackground != null)
{
// if the task is already executing, unregister it
checkHeartRateInBackground.Unregister(true);
}
var devTrigger = new DeviceUseTrigger();
var taskBuilder = new BackgroundTaskBuilder {
Name = taskName,
TaskEntryPoint = typeof(CheckHeartRateInBackgroundTask).ToString(),
IsNetworkRequested = false
};
taskBuilder.SetTrigger(devTrigger);
BackgroundTaskRegistration task = taskBuilder.Register();
task.Completed += Task_Completed;
task.Progress += Task_Progress;
await devTrigger.RequestAsync(devInfo.Id);
}
}
/// <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_DeviceUse_TaskName,
TaskEntryPoint = SampleConstants.Scenario1_DeviceUse_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>
/// Starts the background task that syncs with the device
///
/// The trigger.RequestAsync() must be started on the UI thread because of the prompt that appears. The caller of StartSyncBackgroundTaskAsync()
/// is responsible for running this method in the UI thread.
/// </summary>
/// <returns></returns>
private Task <DeviceTriggerResult> StartSyncBackgroundTaskAsync()
{
// Save the current device information so that we can reopen it after syncing
syncDeviceInformation = EventHandlerForDevice.Current.DeviceInformation;
syncDeviceSelector = EventHandlerForDevice.Current.DeviceSelector;
// Allow the background task to open the device and sync with it.
// We must close the device because Background tasks need to create new handle to the device and cannot reuse the one from this app.
// Since the device is opened exclusively, the app must close the device before the background task can use the device.
EventHandlerForDevice.Current.CloseDevice();
return(syncBackgroundTaskTrigger.RequestAsync(syncDeviceInformation.Id).AsTask());
}
private async Task ActivateBackground()
{
_deviceUseTrigger = new DeviceUseTrigger();
accessStatus = await BackgroundExecutionManager.RequestAccessAsync();
if ((BackgroundAccessStatus.AllowedWithAlwaysOnRealTimeConnectivity == accessStatus) ||
(BackgroundAccessStatus.AllowedMayUseActiveRealTimeConnectivity == accessStatus))
{
var backgroundTaskBuilder = new BackgroundTaskBuilder()
{
Name = "BandTaskInBackground",
TaskEntryPoint = "BandBackgroundTask.BandTaskInBackground"
};
backgroundTaskBuilder.SetTrigger(_deviceUseTrigger);
_deviceUseBackgroundTaskRegistration = backgroundTaskBuilder.Register();
_deviceUseBackgroundTaskRegistration.Progress += _deviceUseBackgroundTaskRegistration_Progress;
var triggerResult = await _deviceUseTrigger.RequestAsync(device.Id);
}
}
private async Task <bool> StartAccelerometerBackGroundTask(String deviceId)
{
bool started = false;
try
{
// Request a DeviceUse task to use the accelerometer.
DeviceTriggerResult accelerometerTriggerResult = await manualTrigger.RequestAsync(deviceId);
#warning background task seems to be run from here
switch (accelerometerTriggerResult)
{
case DeviceTriggerResult.Allowed:
Status = "Background task started";
started = true;
break;
case DeviceTriggerResult.LowBattery:
Error = "Insufficient battery to run the background task";
break;
case DeviceTriggerResult.DeniedBySystem:
// The system can deny a task request if the system-wide DeviceUse task limit is reached.
Error = "The system has denied the background task request";
break;
default:
Error = "Could not start the background task: " + accelerometerTriggerResult;
break;
}
}
catch (InvalidOperationException)
{
// If toggling quickly between 'Disable' and 'Enable', the previous task
// could still be in the process of cleaning up.
Status = "A previous background task is still running, please wait for it to exit";
FindAndCancelExistingBackgroundTask();
}
return(started);
}
public async Task StartBackgroundTask(Initiator InitiatedBy)
{
/* PebbleConnector _pc = PebbleConnector.GetInstance();
* int Handler = await _pc.Connect(-1);
*
* return;*/
var result = await BackgroundExecutionManager.RequestAccessAsync();
if (result == BackgroundAccessStatus.Denied)
{
return;
}
PebbleConnector.SetBackgroundTaskRunningStatus(InitiatedBy);
if (!await IsBackgroundTaskRunning())
{
backgroundSyncTaskRegistration = FindSyncTask();
while (backgroundSyncTaskRegistration != null)
{
backgroundSyncTaskRegistration.Unregister(true);
backgroundSyncTaskRegistration = FindSyncTask();
}
//if (backgroundSyncTaskRegistration == null)
// {
syncBackgroundTaskTrigger = new DeviceUseTrigger();
// Create background task to write
var backgroundTaskBuilder = new BackgroundTaskBuilder();
backgroundTaskBuilder.Name = Constants.BackgroundCommunicationTaskName;
backgroundTaskBuilder.TaskEntryPoint = Constants.BackgroundCommunicationTaskEntry;
backgroundTaskBuilder.SetTrigger(syncBackgroundTaskTrigger);
backgroundSyncTaskRegistration = backgroundTaskBuilder.Register();
// }
try
{
PebbleDevice _AssociatedDevice = PebbleDevice.LoadAssociatedDevice();
if (_AssociatedDevice != null)
{
var _device = await BluetoothDevice.FromIdAsync(_AssociatedDevice.ServiceId);
//var device = (await DeviceInformation.FindAllAsync(RfcommDeviceService.GetDeviceSelector(RfcommServiceId.FromUuid(new Guid(Constants.PebbleGuid))))).FirstOrDefault(y => y.Name.ToLower().Contains("pebble"));
if (_device == null)
{
throw new OperationCanceledException("Is bluetooth enabled and the Pebble Time paired?");
}
//DeviceTriggerResult x = await syncBackgroundTaskTrigger.RequestAsync(device.Id);
var abc = syncBackgroundTaskTrigger.RequestAsync(_device.DeviceId).AsTask();
var x = await abc;
System.Diagnostics.Debug.WriteLine("DeviceTriggerResult: " + x.ToString());
if (x != DeviceTriggerResult.Allowed)
{
throw new Exception(x.ToString());
}
}
}
catch (Exception exc)
{
if (exc.GetType() == typeof(System.OperationCanceledException))
{
throw exc;
}
if (exc.GetType() != typeof(System.InvalidOperationException))
{
throw new Exception("Background communication task can't be started: " + exc.Message);
}
throw new Exception("Unexpected error: " + exc.Message);
}
}
}
private static async Task<bool> RequestDeviceUseTriggerAsync(string deviceId, DeviceUseTrigger deviceUseTrigger, string taskName, string arguments)
{
try
{
DeviceTriggerResult deviceTriggerResult = await deviceUseTrigger.RequestAsync(deviceId, arguments);
switch (deviceTriggerResult)
{
case DeviceTriggerResult.Allowed:
//ShowNotifyMessage("Background Task wurde gestartet.", NotifyLevel.Info);
return true;
case DeviceTriggerResult.DeniedBySystem:
//ShowNotifyMessage("Background Task wurde vom System verweigert.", NotifyLevel.Warn);
break;
case DeviceTriggerResult.DeniedByUser:
//ShowNotifyMessage("Background Task wurde vom Nutzer verweigert.", NotifyLevel.Warn);
break;
case DeviceTriggerResult.LowBattery:
//ShowNotifyMessage("Background Task wurde wegen geringer Batterie verweigert.", NotifyLevel.Warn);
break;
}
}
catch (InvalidOperationException)
{
DeregisterBackgroundTask(taskName);
}
return false;
}
private static async Task BuildBandDataTask(string taskName, string deviceId)
{
var taskBuilder = new BackgroundTaskBuilder { Name = BandDataTaskId, TaskEntryPoint = taskName };
DeviceUseTrigger = new DeviceUseTrigger();
taskBuilder.SetTrigger(DeviceUseTrigger);
taskBuilder.Register();
var triggerResult = await DeviceUseTrigger.RequestAsync(deviceId);
switch (triggerResult)
{
case DeviceTriggerResult.Allowed:
return;
case DeviceTriggerResult.DeniedByUser:
throw new InvalidOperationException("Cannot start the background task. Access denied by user.");
case DeviceTriggerResult.DeniedBySystem:
throw new InvalidOperationException("Cannot start the background task. Access denied by system.");
case DeviceTriggerResult.LowBattery:
throw new InvalidOperationException("Cannot start the background task. Low battery.");
}
}