public async Task InitializeBackgroundGeolocation()
{
// Loop through all background tasks to see if SampleGeofenceBackgroundTask is already registered
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (task.Value.Name == Constants.ApplicationTriggerBackgroundTaskName)
{
_applicationTriggerBackgroundTask = task.Value;
}
}
if (_applicationTriggerBackgroundTask == null)
{
// Create a new trigger
//applicationtrigger = new ApplicationTrigger();
SystemCondition condition = new SystemCondition(SystemConditionType.UserNotPresent | SystemConditionType.InternetAvailable);
_applicationTriggerBackgroundTask = await BackgroundTaskHelper.RegisterBackgroundTask(
Constants.ApplicationTriggerBackgroundTaskEntryPoint,
Constants.ApplicationTriggerBackgroundTaskName,
applicationtrigger,
null);
var result = await applicationtrigger.RequestAsync();
if (result.Equals(ApplicationTriggerResult.Allowed))
{
Toast.ShowToast("Location Monitoring Started");
}
}
await LoadExitingLocations();
}
private async void RegisterBackgroundTasks()
{
var access = await BackgroundExecutionManager.RequestAccessAsync();
if (access == BackgroundAccessStatus.AllowedMayUseActiveRealTimeConnectivity || access == BackgroundAccessStatus.AllowedWithAlwaysOnRealTimeConnectivity)
{
TimeTrigger taskTrigger = new TimeTrigger(15, false);
foreach (var _task in BackgroundTaskRegistration.AllTasks)
{
if (_task.Value.Name == "WPGetListUpdateTimer" || _task.Value.Name == "WPGetListUpdateInternet")
{
_task.Value.Unregister(true);
}
}
SystemTrigger striger = new SystemTrigger(SystemTriggerType.InternetAvailable, false);
var bgTaskBuilder = new BackgroundTaskBuilder();
bgTaskBuilder.Name = "WPGetListUpdateTimer";
bgTaskBuilder.TaskEntryPoint = "BackgroundTaskWinMD.WPGetListUpdateBackgroundTask";
bgTaskBuilder.SetTrigger(taskTrigger);
// условие, согласно которому триггер будет выполнен только если интернет доступен
SystemCondition internetCondition = new SystemCondition(SystemConditionType.InternetAvailable);
bgTaskBuilder.AddCondition(internetCondition);
BackgroundTaskRegistration task = bgTaskBuilder.Register();
bgTaskBuilder = new BackgroundTaskBuilder();
bgTaskBuilder.Name = "WPGetListUpdateInternet";
bgTaskBuilder.TaskEntryPoint = "BackgroundTaskWinMD.WPGetListUpdateBackgroundTask";
bgTaskBuilder.SetTrigger(striger);
bgTaskBuilder.AddCondition(internetCondition);
BackgroundTaskRegistration task2 = bgTaskBuilder.Register();
}
}
public async void RegisterBackgroundTask()
{
if (BackgroundTaskRegistration.AllTasks.Any(x => x.Value.Name == taskName))
{
return;
}
var backgroundAccessStatus = await BackgroundExecutionManager.RequestAccessAsync();
if (backgroundAccessStatus == BackgroundAccessStatus.AlwaysAllowed ||
backgroundAccessStatus == BackgroundAccessStatus.AllowedSubjectToSystemPolicy)
{
var taskBuilder = new BackgroundTaskBuilder
{
Name = taskName,
TaskEntryPoint = taskEntryPoint
};
taskBuilder.SetTrigger(new TimeTrigger(120, false));
taskBuilder.IsNetworkRequested = true;
var internetCondition = new SystemCondition(SystemConditionType.InternetAvailable);
taskBuilder.AddCondition(internetCondition);
var registration = taskBuilder.Register();
}
}
public async static void Register()
{
await Task.Delay(1000);
await BackgroundExecutionManager.RequestAccessAsync();
var existing = BackgroundTaskRegistration.AllTasks.Where(x => x.Value.Name.Equals(Name)).Select(x => x.Value).FirstOrDefault();
if (existing != null)
{
existing.Unregister(true);
}
var builder = new BackgroundTaskBuilder
{
Name = Name,
CancelOnConditionLoss = false,
TaskEntryPoint = typeof(Task1).ToString()
};
var trigger = new TimeTrigger(120, false);
builder.SetTrigger(trigger);
var cond1 = new SystemCondition(SystemConditionType.InternetAvailable);
builder.AddCondition(cond1);
builder.Register();
}
public static async void RegisterBackgroundTask(string taskName, string entryPoint)
{
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (task.Value.Name == taskName)
{
return;
}
}
BackgroundExecutionManager.RemoveAccess();
BackgroundAccessStatus status = await BackgroundExecutionManager.RequestAccessAsync();
if (status == BackgroundAccessStatus.Denied)
{
return;
}
SystemCondition internetCondition = new SystemCondition(SystemConditionType.InternetAvailable);
var builder = new BackgroundTaskBuilder();
builder.Name = taskName;
builder.TaskEntryPoint = entryPoint;
var timeTrigger = new TimeTrigger(16, false);
builder.SetTrigger(timeTrigger);
//builder.SetTrigger(new SystemTrigger(SystemTriggerType.PowerStateChange, false));
builder.AddCondition(internetCondition);
BackgroundTaskRegistration taskRegistered = builder.Register();
}
private async void RegisterBackgroundTasks()
{
var builder = new BackgroundTaskBuilder
{
Name = "BackgroundUpdateReadingList",
TaskEntryPoint = "EasyReader.BackgroundTasks.UpdateReadingList"
};
try
{
await BackgroundExecutionManager.RequestAccessAsync();
}
catch (Exception)
{
}
IBackgroundTrigger trigger = new TimeTrigger(15, true);
builder.SetTrigger(trigger);
IBackgroundCondition condition = new SystemCondition(SystemConditionType.InternetAvailable);
builder.AddCondition(condition);
IBackgroundTaskRegistration task = builder.Register();
task.Progress += task_Progress;
task.Completed += task_Completed;
}
public async Task RegisterBackgroundTasks()
{
isSystemTaskRegistered = GetTaskStatus(SYSTEM_TRIGGERED_TASK_NAME);
isTimeTaskRegistered = GetTaskStatus(TIME_TRIGGERED_TASK_NAME);
if (!isSystemTaskRegistered)
{
var trigger = new SystemTrigger(SystemTriggerType.UserPresent | SystemTriggerType.SessionConnected, false);
SytemTriggeredBackgroundTask = await BackgroundTasksHelper.RegisterBackgroundTask(ENTRY_POINT,
SYSTEM_TRIGGERED_TASK_NAME,
trigger,
null,
true);
isSystemTaskRegistered = true;
}
if (!isTimeTaskRegistered)
{
SystemCondition userPresentCondition = new SystemCondition(SystemConditionType.UserPresent);
TimeTriggeredBackgroundTask = await BackgroundTasksHelper.RegisterBackgroundTask(ENTRY_POINT,
TIME_TRIGGERED_TASK_NAME,
new TimeTrigger(BACKGROUND_RATE, false),
userPresentCondition,
true);
isTimeTaskRegistered = true;
}
}
public static async void RegisterBackgroundTask()
{
try
{
if (!BackgroundTaskRegistration.AllTasks.Any(x => x.Value.Name == "Background-Worker"))
{
TimeTrigger trigger = new TimeTrigger(120, false);
SystemCondition condition = new SystemCondition(SystemConditionType.InternetAvailable | SystemConditionType.UserPresent);
var requestStatus = await BackgroundExecutionManager.RequestAccessAsync();
if (requestStatus == BackgroundAccessStatus.DeniedBySystemPolicy || requestStatus == BackgroundAccessStatus.DeniedByUser)
{
return;
}
BackgroundTaskBuilder builder = new BackgroundTaskBuilder();
builder.Name = "Background-Worker";
builder.TaskEntryPoint = "Xbox.Ambassadors.BackgroundTasks.BackgroundUpdateTask";
builder.AddCondition(condition);
builder.SetTrigger(trigger);
BackgroundTaskRegistration task = builder.Register();
}
}
catch
{
}
}
internal static void RegisterBackgroundTasks()
{
IBackgroundCondition internetAvailableCondition = new SystemCondition(SystemConditionType.InternetAvailable),
userPresentCondition = new SystemCondition(SystemConditionType.UserPresent),
sessionConnectedCondition = new SystemCondition(SystemConditionType.SessionConnected),
backgroundCostNotHighCondition = new SystemCondition(SystemConditionType.BackgroundWorkCostNotHigh);
var conditions = new[] {
internetAvailableCondition,
// userPresentCondition,
//sessionConnectedCondition
};
var bgBuilderModel = new BackgroundTaskBuilderModel(
"ToastNotificationAction",
new ToastNotificationActionTrigger(),
conditions
);
var toastActionTask = BuildTask(bgBuilderModel, true, true, null);
toastActionTask.Register(true, false, true);
bgBuilderModel = new BackgroundTaskBuilderModel(
"SyncNotifications",
new TimeTrigger(15, false),
conditions
);
var syncTask = BuildTask(bgBuilderModel, true, true, null);
syncTask.Register(true, false, true);
}
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;
}));
}
/// <summary>
/// Registers a background task to update the live tile
/// </summary>
private static void RegisterBackgroundTask()
{
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (task.Value.Name == "BackgroundLiveTiles")
{
task.Value.Unregister(true);
}
}
//var result = await BackgroundExecutionManager.RequestAccessAsync();
BackgroundTaskBuilder builder = new BackgroundTaskBuilder();
// Friendly string name identifying the background task
builder.Name = "BackgroundLiveTiles";
// Class name
builder.TaskEntryPoint = "TileBackground.LiveTileUpdater";
IBackgroundTrigger trigger = new TimeTrigger(15, false);
builder.SetTrigger(trigger);
IBackgroundCondition condition = new SystemCondition(SystemConditionType.InternetAvailable);
builder.AddCondition(condition);
IBackgroundTaskRegistration taskRegistration = builder.Register();
// clean up
condition = null;
trigger = null;
builder = null;
}
private void RegisterTaskButton_Click(Object sender, RoutedEventArgs e)
{
if (GetRegisteredTask() == null)
{
BackgroundTaskBuilder taskBuilder = new BackgroundTaskBuilder();
MaintenanceTrigger trigger = new MaintenanceTrigger(MAINTENANCE_INTERVAL, false);
taskBuilder.SetTrigger(trigger);
taskBuilder.TaskEntryPoint = PUSH_NOTIFICATIONS_TASK_ENTRY_POINT;
taskBuilder.Name = PUSH_NOTIFICATIONS_TASK_NAME;
SystemCondition internetCondition = new SystemCondition(SystemConditionType.InternetAvailable);
taskBuilder.AddCondition(internetCondition);
try
{
taskBuilder.Register();
rootPage.NotifyUser("Task registered", NotifyType.StatusMessage);
}
catch (Exception ex)
{
rootPage.NotifyUser("Error registering task: " + ex.Message, NotifyType.ErrorMessage);
}
}
else
{
rootPage.NotifyUser("Task already registered", NotifyType.ErrorMessage);
}
}
/// <summary>
/// Subscribe background task to inform no internet connection.
/// </summary>
/// <returns></returns>
public static async Task RegisterTaskAsync()
{
string taskName = "NoInternet";
SystemTrigger internet = new SystemTrigger(SystemTriggerType.NetworkStateChange, false);
SystemCondition conditionNOInternet = new SystemCondition(SystemConditionType.InternetNotAvailable);
string taskEntryPoint = typeof(BackgroundTaskApp.MyBackgroundTask).ToString();
await BackgroundTaskHelper.RegisterBackgroundTaskAsync(taskEntryPoint, taskName, internet, conditionNOInternet);
}
public void Handle(RegisterTilesBackgroundTaskMessage message)
{
var trigger = new SystemTrigger(SystemTriggerType.InternetAvailable, false);
var condition = new SystemCondition(SystemConditionType.UserPresent);
_backGrdTaskRegistrator.RegisterBackgroundTask(WordFinder.Common.BackgroundTasks.TilesBackgroundTaskEntryPoint,
WordFinder.Common.BackgroundTasks.TilesBackgroundTaskName,
trigger,
condition);
}
private async void Grid_Loaded(object sender, RoutedEventArgs e)
{
TimeTrigger trigger = new TimeTrigger(15, false);
SystemCondition condition = new SystemCondition(SystemConditionType.InternetAvailable);
await BackgroundExecutionManager.RequestAccessAsync();
string entryPoint = typeof(BackgroundTask).FullName;
string taskName = "UZTracer Updates";
BackgroundTaskRegistration task = RegisterBackGroundTask(entryPoint, taskName, trigger, null);
}
/// <summary>
/// Registers all the required background tasks
/// This should be done once
/// <summary>
private void RegisterPushBackgroundTask()
{
const string PushBackgroundTaskName = "DeskhelpBackgroundNotification";
const string timerRegisterTask = "DeskHelpBackgroundDailyValidation";
const string startupTask = "DeskHelpBackgroundStartupValidation";
try
{
//If deactivation of all tasks is required, uncomment this code
//todo: leave commented for release
//foreach (var task in BackgroundTaskRegistration.AllTasks)
// task.Value.Unregister(true);
if (!BackgroundTaskRegistration.AllTasks.Any(i => i.Value.Name == PushBackgroundTaskName))
{
var builder = new BackgroundTaskBuilder();
builder.Name = PushBackgroundTaskName;
builder.SetTrigger(new PushNotificationTrigger());
builder.Register();
}
if (!BackgroundTaskRegistration.AllTasks.Any(i => i.Value.Name == timerRegisterTask))
{
var builder = new BackgroundTaskBuilder();
builder.Name = timerRegisterTask;
SystemCondition internetCondition = new SystemCondition(SystemConditionType.InternetAvailable);
builder.AddCondition(internetCondition);
builder.SetTrigger(new TimeTrigger(24 * 60, false));
builder.Register();
}
if (!BackgroundTaskRegistration.AllTasks.Any(i => i.Value.Name == startupTask))
{
var builder = new BackgroundTaskBuilder();
builder.Name = startupTask;
SystemCondition userPresent = new SystemCondition(SystemConditionType.UserPresent);
builder.AddCondition(userPresent);
builder.SetTrigger(new TimeTrigger(24 * 60, true));
builder.Register();
}
}
catch (Exception ex)
{
var dontWait = new MessageDialog(ex.ToString()).ShowAsync();
LogException(ex);
}
}
private static void RegisterMaintenanceBackgroundTask()
{
var builder = new BackgroundTaskBuilder {
Name = TaskName, TaskEntryPoint = TaskEntry
};
IBackgroundTrigger trigger = new TimeTrigger(15, false);
builder.SetTrigger(trigger);
IBackgroundCondition condition =
new SystemCondition(SystemConditionType.InternetAvailable);
builder.AddCondition(condition);
IBackgroundTaskRegistration task = builder.Register();
}
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);
}
private static async Task ScheduleTimeTriggerTaskHelperAsync(uint minutesFromNow)
{
await BackgroundExecutionManager.RequestAccessAsync();
// Remove any existing scheduled time trigger
var existing = BackgroundTaskRegistration.AllTasks.FirstOrDefault(i => i.Value.Name == "TimeTriggerNotification").Value;
if (existing != null)
{
existing.Unregister(cancelTask: false);
}
TimeTrigger timeTrigger = new TimeTrigger(minutesFromNow, oneShot: true);
var condition = new SystemCondition(SystemConditionType.UserPresent);
BackgroundTasksHelper.RegisterBackgroundTask("XboxToastBackgroundProject.TimeTriggerTask", "TimeTriggerNotification", timeTrigger, condition);
}
public static async Task RegisterTestTask()
{
var task = new BackgroundTaskBuilder
{
Name = "My Task",
TaskEntryPoint = typeof(TestTask).ToString()
};
var trigger = new ApplicationTrigger();
task.SetTrigger(trigger);
var condition = new SystemCondition(SystemConditionType.InternetNotAvailable);
task.Register();
await trigger.RequestAsync();
}
public static async Task RegisterBackgroundTasksAsync()
{
//BGUpdater
string name = "KomunikatyRSOUWPBackgroundSettingsUpdater";
string entryPoint = "BGUpdater.BackgroundSettingsUpdater";
TimeTrigger timeTrigger = new TimeTrigger(3 * 60, false);
SystemTrigger st = new SystemTrigger(SystemTriggerType.InternetAvailable, false);
SystemCondition internetCondition = new SystemCondition(SystemConditionType.InternetAvailable);
try
{
await RegisterBackgroundTaskAsync(entryPoint, name, timeTrigger, internetCondition);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("Background task registration error: {0}", ex);
}
}
private async Task RegisterBackgroundTasksAsync()
{
await BackgroundExecutionManager.RequestAccessAsync();
var entryPoint = "BackgroundTask.TestBackgroundTask";
var condition = new SystemCondition(SystemConditionType.InternetAvailable);
// check with SYSTEM trigger (when internet available)
var internetAvailableTrigger = new SystemTrigger(SystemTriggerType.InternetAvailable, false);
RegisterBackgroundTask(entryPoint, "TestBackgroundTask", internetAvailableTrigger, null);
// check with Maintenance trigger (when internet available)
var maintenanceTriggerPeriod = TimeSpan.FromDays(1);
var timeTrigger = new MaintenanceTrigger((uint)maintenanceTriggerPeriod.TotalMinutes, false);
RegisterBackgroundTask(entryPoint, "TestBackgroundTask", timeTrigger, condition);
}
private const int MAINTENANCE_INTERVAL = 10 * 24 * 60; // Check for channels that need to be updated every 10 days
public App()
{
InitializeComponent();
this.Suspending += new SuspendingEventHandler(OnSuspending);
if (!IsTaskRegistered())
{
BackgroundTaskBuilder taskBuilder = new BackgroundTaskBuilder();
MaintenanceTrigger trigger = new MaintenanceTrigger(MAINTENANCE_INTERVAL, false);
taskBuilder.SetTrigger(trigger);
taskBuilder.TaskEntryPoint = PUSH_NOTIFICATIONS_TASK_ENTRY_POINT;
taskBuilder.Name = PUSH_NOTIFICATIONS_TASK_NAME;
SystemCondition internetCondition = new SystemCondition(SystemConditionType.InternetAvailable);
taskBuilder.AddCondition(internetCondition);
taskBuilder.Register();
}
}
void ConfigureToastActions()
{
try
{
var trigger = new ToastNotificationActionTrigger();
var condition = new SystemCondition(SystemConditionType.InternetAvailable);
var builder = new BackgroundTaskBuilder();
builder.Name = "ToastTask";
builder.SetTrigger(trigger);
builder.AddCondition(condition);
var task = builder.Register();
}
catch (Exception ex)
{
Diag.DebugPrint("Exception caught while setting up toast actions " + ex.Message);
}
}
private void RegisterBackgroundTasks()
{
BackgroundTaskBuilder builder = new BackgroundTaskBuilder();
// Friendly string name identifying the background task
builder.Name = "BackgroundLiveTiles";
// Class name
builder.TaskEntryPoint = "TileBackground.Class1";
IBackgroundTrigger trigger = new TimeTrigger(15, true);
builder.SetTrigger(trigger);
IBackgroundCondition condition = new SystemCondition(SystemConditionType.InternetAvailable);
builder.AddCondition(condition);
IBackgroundTaskRegistration task = builder.Register();
//YOu have the option of implementing these events to do something upon completion
//task.Progress += task_Progress;
//task.Completed += task_Completed;
}
private async void Register_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 = TaskNames,
TaskEntryPoint = typeof(RuntimeComponent2.NotifyUser).ToString()
};
var trigger = new ApplicationTrigger();
task.SetTrigger(trigger);
var condition = new SystemCondition(SystemConditionType.InternetAvailable);
task.Register();
Register.IsEnabled = false;
Unregister.IsEnabled = true;
await Initiate.InitializeAsync();
NotifyUser("Server Says: " + Initiate.ServerMessage, NotifyType.StatusMessage);
await trigger.RequestAsync();
}
//
// 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);
}
/// <summary>
/// Cannot avoid this method being blocking on the UI thread, because creating the background task requires it
/// (otherwise creating the LocationTrigger gives a COM exception)
/// </summary>
public async Task On(string backgroundTaskEntryPoint)
{
if (string.IsNullOrWhiteSpace(backgroundTaskEntryPoint))
{
throw new ArgumentNullException(nameof(backgroundTaskEntryPoint));
}
await _permissionRepository.RequestRequired();
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
var trigger = new LocationTrigger(LocationTriggerType.Geofence);
var condition = new SystemCondition(SystemConditionType.InternetAvailable);
_backgroundTaskRegistrar.Register(backgroundTaskEntryPoint,
BackgroundTaskName, trigger, condition);
});
_applicationRepository.UpdateIsEnabled(isEnabled: true);
}
public static IAsyncOperation <PushNotificationChannel> Run()
{
const string PushNotificationTaskName = "ToastNotifications";
var ns = new NotificationStore();
var channelTask = ns.Register();
if (GetRegisteredTask(PushNotificationTaskName) != null)
{
return(channelTask.AsAsyncOperation());
}
ObtainLockScreenAccess();
var taskBuilder = new BackgroundTaskBuilder
{
Name = PushNotificationTaskName,
TaskEntryPoint = typeof(PushBackgroundTask).FullName
};
var trigger = new PushNotificationTrigger();
taskBuilder.SetTrigger(trigger);
var internetCondition = new SystemCondition(SystemConditionType.InternetAvailable);
taskBuilder.AddCondition(internetCondition);
try
{
taskBuilder.Register();
}
catch (Exception exception)
{
}
return(channelTask.AsAsyncOperation());
}
