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(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);
}
}
}//Constructor End
/// <summary>
/// Function to Request Background Access, Sets BackgroundRequestGranted to 'true' if granted
/// Also checks if the accelerometer exists
/// </summary>
async void RequestBackgroundAccessAsync()
{
if (_acclerometer != null)
{
manualTrigger = new DeviceUseTrigger();
BackgroundAccessStatus accessStatus = await BackgroundExecutionManager.RequestAccessAsync();
if ((BackgroundAccessStatus.AllowedWithAlwaysOnRealTimeConnectivity == accessStatus) ||
(BackgroundAccessStatus.AllowedMayUseActiveRealTimeConnectivity == accessStatus))
{
BackgroundRequestGranted = true;
return;
}
else
{
#warning shift to UI
Error = "Background tasks may be disabled for this app";
return;
}
}
else
{
#warning shift to UI
Error = "Accelerometer unavailable";
return;
}
}//RequestBackgroundAccess end
/// <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)
{
BackgroundTaskRegistration task = null;
try
{
var builder = new BackgroundTaskBuilder();
builder.Name = name;
builder.TaskEntryPoint = taskEntryPoint;
DeviceUseTrigger de = new DeviceUseTrigger();
// de.RequestAsync();
// builder.SetTrigger(new TimeTrigger(15, true));
task = builder.Register();
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine("Exception while registering background task: " + e.Message);
}
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)
{
BackgroundTaskRegistration task = null;
try
{
var builder = new BackgroundTaskBuilder();
builder.Name = name;
builder.TaskEntryPoint = taskEntryPoint;
DeviceUseTrigger de = new DeviceUseTrigger();
// de.RequestAsync();
// builder.SetTrigger(new TimeTrigger(15, true));
task = builder.Register();
}
catch(Exception e)
{
System.Diagnostics.Debug.WriteLine("Exception while registering background task: " + e.Message);
}
UpdateBackgroundTaskStatus(name, true);
//
// Remove previous completion status from local settings.
//
var settings = ApplicationData.Current.LocalSettings;
settings.Values.Remove(name);
return task;
}
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.");
}
}
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);
}
}
}
}
private void Open_Button_Click(object sender, RoutedEventArgs e)
{
alti = Altimeter.GetDefault();
if (null != alti)
{
_deviceUseTrigger = new DeviceUseTrigger();
}
openBackgroup();
}
public SyncDevice()
{
isSyncing = false;
// Save trigger so that we may start the background task later
// Only one instance of the trigger can exist at a time. Since the trigger does not implement
// IDisposable, it may still be in memory when a new trigger is created.
syncBackgroundTaskTrigger = new DeviceUseTrigger();
this.InitializeComponent();
}
public SyncDevice()
{
isSyncing = false;
// Save trigger so that we may start the background task later
// Only one instance of the trigger can exist at a time. Since the trigger does not implement
// IDisposable, it may still be in memory when a new trigger is created.
syncBackgroundTaskTrigger = new DeviceUseTrigger();
this.InitializeComponent();
}
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);
}
}
public Home()
{
uriSelection = App.uriItemsAvailable;
this.InitializeComponent();
Accelerometer = Accelerometer.GetDefault();
if (null != Accelerometer)
{
// Save trigger so that we may start the background task later.
// Only one instance of the trigger can exist at a time. Since the trigger does not implement
// IDisposable, it may still be in memory when a new trigger is created.
_deviceUseTrigger = new DeviceUseTrigger();
}
else
{
this.NotifyUser("No accelerometer found", NotifyType.StatusMessage);
}
this.Loaded += Home_Loaded;
}
public Scenario1()
{
this.InitializeComponent();
_accelerometer = Accelerometer.GetDefault();
if (null != _accelerometer)
{
// Save trigger so that we may start the background task later.
// Only one instance of the trigger can exist at a time. Since the trigger does not implement
// IDisposable, it may still be in memory when a new trigger is created.
_deviceUseTrigger = new DeviceUseTrigger();
// Setup a timer to periodically refresh results when the app is visible.
_refreshTimer = new DispatcherTimer()
{
Interval = new TimeSpan(0, 0, 1) // Refresh once every second
};
_refreshTimer.Tick += RefreshTimer_Tick;
}
else
{
rootPage.NotifyUser("No accelerometer found", NotifyType.StatusMessage);
}
}
public Scenario1_DeviceUse()
{
this.InitializeComponent();
Accelerometer = Accelerometer.GetDefault();
if (null != Accelerometer)
{
// Save trigger so that we may start the background task later.
// Only one instance of the trigger can exist at a time. Since the trigger does not implement
// IDisposable, it may still be in memory when a new trigger is created.
_deviceUseTrigger = new DeviceUseTrigger();
// Setup a timer to periodically refresh results when the app is visible.
_refreshTimer = new DispatcherTimer()
{
Interval = new TimeSpan(0, 0, 1) // Refresh once every second
};
_refreshTimer.Tick += RefreshTimer_Tick;
}
else
{
rootPage.NotifyUser("No accelerometer found", NotifyType.StatusMessage);
}
}
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.");
}
}
private static async Task<bool> RegisterAccelerometerTaskAsync(string deviceId, string taskName, string arguments)
{
String taskEntryPoint = "BackgroundTask.TaskAction";
DeviceUseTrigger trigger = new DeviceUseTrigger();
if (!isBackgroundTaskRegistered(taskName))
{
var builder = new BackgroundTaskBuilder();
builder.Name = taskName;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
BackgroundTaskRegistration backgroundTaskregistration = builder.Register();
if (!await RequestDeviceUseTriggerAsync(deviceId, trigger, taskName, arguments))
{
DeregisterBackgroundTask(taskName);
return false;
}
}
return true;
}
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;
}
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);
}
}
}
