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;
}
}
// Registers a background task with an network change system trigger.
private void RegisterNetworkChangeTask()
{
try
{
if (NetworkTaskRegistrationGuid != Guid.Empty)
{
IReadOnlyDictionary <Guid, IBackgroundTaskRegistration> allTasks = BackgroundTaskRegistration.AllTasks;
if (allTasks.ContainsKey(NetworkTaskRegistrationGuid))
{
Diag.DebugPrint("Network task is already registered.");
return;
}
}
BackgroundTaskBuilder myTaskBuilder = new BackgroundTaskBuilder();
SystemTrigger myTrigger = new SystemTrigger(SystemTriggerType.NetworkStateChange, false);
myTaskBuilder.SetTrigger(myTrigger);
myTaskBuilder.TaskEntryPoint = "Background.NetworkChangeTask";
myTaskBuilder.Name = "Network change task";
BackgroundTaskRegistration myTask = myTaskBuilder.Register();
NetworkTaskRegistrationGuid = myTask.TaskId;
}
catch (Exception exp)
{
Diag.DebugPrint("Exception caught while setting up system event" + exp.ToString());
}
}
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();
}
}
// Registers a background task with a network change system trigger.
private void RegisterNetworkChangeTask()
{
try
{
// Delete previously registered network status change tasks as
// the background triggers are persistent by nature across process
// lifetimes.
foreach (var cur in BackgroundTaskRegistration.AllTasks)
{
Diag.DebugPrint("Deleting Background Taks " + cur.Value.Name);
cur.Value.Unregister(true);
}
var myTaskBuilder = new BackgroundTaskBuilder();
var myTrigger = new SystemTrigger(SystemTriggerType.NetworkStateChange, false);
myTaskBuilder.SetTrigger(myTrigger);
myTaskBuilder.TaskEntryPoint = "Background.NetworkChangeTask";
myTaskBuilder.Name = "Network change task";
var myTask = myTaskBuilder.Register();
}
catch (Exception exp)
{
Diag.DebugPrint("Exception caught while setting up system event" + exp.ToString());
}
}
private void RegisterDebugSessionConnectedTask()
{
// This task runs every time the user logs in, which then invokes the same code as the preinstall task would. Used only for testing purposes.
var trigger = new SystemTrigger(SystemTriggerType.SessionConnected, oneShot: false);
BackgroundTasksHelper.RegisterBackgroundTask("EdgeToastBackgroundProject.PreinstallTask", "SessionConnectedTask", trigger, null);
}
/// <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);
}
// Handle request to register the background task
private async void RegisterBackgroundTask_Click(object sender, RoutedEventArgs e)
{
// SMS is a sensitive capability and the user may be prompted for consent. If the app
// does not obtain permission for the package to have access to SMS before the background
// work item is run (perhaps after the app is suspended or terminated), the background
// work item will not have access to SMS and will have no way to prompt the user for consent
// without an active window. Here, any available SMS device is activated in order to ensure
// consent. Your app will likely do something with the SMS device as part of its features.
if (!hasDeviceAccess)
{
try
{
SmsDevice smsDevice = (SmsDevice)await SmsDevice.GetDefaultAsync();
rootPage.NotifyUser("Successfully connnected to SMS device with account number: " + smsDevice.AccountPhoneNumber, NotifyType.StatusMessage);
hasDeviceAccess = true;
}
catch (Exception ex)
{
rootPage.NotifyUser("Failed to find SMS device\n" + ex.Message, NotifyType.ErrorMessage);
return;
}
}
try
{
// Create a new background task builder.
BackgroundTaskBuilder taskBuilder = new BackgroundTaskBuilder();
// Create a new SmsReceived trigger.
SystemTrigger trigger = new SystemTrigger(SystemTriggerType.SmsReceived, false);
// Associate the SmsReceived trigger with the background task builder.
taskBuilder.SetTrigger(trigger);
// Specify the background task to run when the trigger fires.
taskBuilder.TaskEntryPoint = BackgroundTaskEntryPoint;
// Name the background task.
taskBuilder.Name = BackgroundTaskName;
// Register the background task.
BackgroundTaskRegistration taskRegistration = taskBuilder.Register();
// Associate completed event handler with the new background task.
taskRegistration.Completed += new BackgroundTaskCompletedEventHandler(OnCompleted);
UpdateBackgroundTaskUIState(true);
rootPage.NotifyUser("Registered SMS background task", NotifyType.StatusMessage);
}
catch (Exception ex)
{
rootPage.NotifyUser(ex.ToString(), NotifyType.ErrorMessage);
}
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
BackgroundTaskBuilder builder = new BackgroundTaskBuilder();
builder.Name = "My Wifi Checker";
builder.TaskEntryPoint = "MyBackgroundTask.Class1";
SystemTrigger trigger = new SystemTrigger(SystemTriggerType.NetworkStateChange, false);
builder.SetTrigger(trigger);
var task = builder.Register();
}
private void btnRegisterStart_Click(object sender, RoutedEventArgs e)
{
AddTile();
BackgroundTaskBuilder builder = new BackgroundTaskBuilder();
builder.Name = "Wifi Checking";
builder.TaskEntryPoint = "BackgroundTaskInternet.BGTaskInterface";
SystemTrigger trigger = new SystemTrigger(SystemTriggerType.NetworkStateChange, false);
builder.SetTrigger(trigger);
BackgroundTaskRegistration task = builder.Register();
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
BackgroundTaskBuilder builder = new BackgroundTaskBuilder();
builder.Name = "Wifi Checking";
builder.TaskEntryPoint = "BGInterface.NetInterface";
SystemTrigger trigger = new SystemTrigger(SystemTriggerType.NetworkStateChange, false);
builder.SetTrigger(trigger);
var task = builder.Register();
}
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);
}
public async Task registerBackgroundTask()
{
await BackgroundExecutionManager.RequestAccessAsync();
BackgroundTaskBuilder builder = new BackgroundTaskBuilder();
builder.Name = "BackGroundTask";
SystemTrigger trig = new SystemTrigger(SystemTriggerType.InternetAvailable, false);
builder.SetTrigger(trig);
builder.AddCondition(new SystemCondition(SystemConditionType.FreeNetworkAvailable));
builder.TaskEntryPoint = typeof(BackGroundTask.Backgroud).FullName;
BackgroundTaskRegistration register = builder.Register();
}
/// <summary>
/// Registers the background network task.
/// </summary>
/// <returns>Regisred background task</returns>
public async Task <BackgroundTaskRegistration> RegisterBackgroundTask()
{
BackgroundTaskRegistration taskRegistration = null;
if (await hasAccessAsync())
{
var builder = new BackgroundTaskBuilder {
Name = TaskName, TaskEntryPoint = typeof(NetworkBackgroundTask).FullName
};
var trigger = new SystemTrigger(SystemTriggerType.NetworkStateChange, false);
builder.SetTrigger(trigger);
taskRegistration = builder.Register();
}
return(taskRegistration);
}
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);
}
}
async Task RegisterTask()
{
// Rumour of a bug which means you have to call this before calling Request...
BackgroundExecutionManager.RemoveAccess();
await BackgroundExecutionManager.RequestAccessAsync();
BackgroundTaskBuilder taskBuilder = new BackgroundTaskBuilder();
taskBuilder.Name = "MyBackgroundTask";
SystemTrigger trigger = new SystemTrigger(SystemTriggerType.TimeZoneChange, false);
taskBuilder.SetTrigger(trigger);
taskBuilder.TaskEntryPoint = typeof(MyBackgroundTask.TheTask).FullName;
taskBuilder.Register();
this.GetTask();
}
void RegisterNetworkChangeTask()
{
try
{
UnregisterBackgroundTasks();
var builder = new BackgroundTaskBuilder();
var trigger = new SystemTrigger(SystemTriggerType.NetworkStateChange, false);
builder.SetTrigger(trigger);
builder.TaskEntryPoint = "NotificationManager.Tasks.NetworkChangeTask";
builder.Name = "NetworkChangeTask";
var task = builder.Register();
}
catch (Exception ex)
{
Diag.DebugPrint("Exception caught while setting up system event " + ex.ToString());
}
}
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);
}
/// <summary>
/// 屏幕点亮时执行该任务
/// </summary>
private void RegisterUpdateTopStoriesBackgroundTask()
{
string Task_NAME = "Update Task";
var taskReg = BackgroundTaskRegistration.AllTasks.Values.FirstOrDefault(t => t.Name == Task_NAME) as BackgroundTaskRegistration;
if (taskReg != null)
{
return;
}
var task = new BackgroundTaskBuilder
{
Name = Task_NAME,
TaskEntryPoint = typeof(ZhiHuDaily.UWP.Background.UpdateTopStoriesBackgroundExecution).FullName
};
var trigger = new SystemTrigger(SystemTriggerType.UserPresent, false);
task.SetTrigger(trigger);
var r = task.Register();
}
/// <summary>
/// Register the background task.
/// </summary>
/// <returns>True if we were able to register the background task.</returns>
private async Task <bool> RegisterTask()
{
if (GetTaskRegistration())
{
return(true);
}
var access = await BackgroundExecutionManager.RequestAccessAsync().AsTask();
if (access != BackgroundAccessStatus.AllowedMayUseActiveRealTimeConnectivity)
{
return(false);
}
if (_timerRegistration == null)
{
var taskBuilder = new BackgroundTaskBuilder {
Name = Common.TimerTaskName
};
var trigger = new TimeTrigger(60, false);
taskBuilder.SetTrigger(trigger);
taskBuilder.TaskEntryPoint = typeof(DevicePowerTask.DevicePowerTimerBandTask).FullName;
taskBuilder.Register();
}
if (_systemRegistration == null)
{
var taskBuilder = new BackgroundTaskBuilder {
Name = Common.SystemTaskName
};
var trigger = new SystemTrigger(SystemTriggerType.PowerStateChange, false);
taskBuilder.SetTrigger(trigger);
taskBuilder.TaskEntryPoint = typeof(DevicePowerTask.DevicePowerSystemBandTask).FullName;
taskBuilder.Register();
}
return(GetTaskRegistration());
}
private void Button_Click(object sender, RoutedEventArgs e)
{
RefreshData();
const string name = "MyExampleTrigger";
if (BackgroundTaskRegistration.AllTasks.Any(task => task.Value.Name == name))
{
// One register it once
return;
}
var builder = new BackgroundTaskBuilder();
var trigger = new SystemTrigger(SystemTriggerType.TimeZoneChange, false);
builder.Name = name;
builder.TaskEntryPoint = typeof(Bg).FullName;
builder.SetTrigger(trigger);
var registration = builder.Register();
registration.Completed += registration_Completed;
}
private async void RegisterTask()
{
var result = await BackgroundExecutionManager.RequestAccessAsync();
if (result == BackgroundAccessStatus.Denied)
{
// Handle this if it is importet for your app.
}
var taskBuilder = new BackgroundTaskBuilder {
Name = "MyBackgroundTask"
};
var trigger = new SystemTrigger(SystemTriggerType.TimeZoneChange, false);
taskBuilder.SetTrigger(trigger);
taskBuilder.TaskEntryPoint = typeof(MyBackgroundTask).FullName;
//taskBuilder.Register();
var registration = taskBuilder.Register();
registration.Completed += (sender, args) => {
// Handle this if it is importet for your app.
};
GetTask();
}
private async Task RegisterBackgroundTaskAsync()
{
try
{
switch (await BackgroundExecutionManager.RequestAccessAsync())
{
case BackgroundAccessStatus.AllowedSubjectToSystemPolicy:
case BackgroundAccessStatus.AlwaysAllowed:
{
if (BackgroundTaskRegistration.AllTasks.Select((item) => item.Value).FirstOrDefault((task) => task.Name == "UpdateTask") is IBackgroundTaskRegistration Registration)
{
Registration.Unregister(true);
}
SystemTrigger Trigger = new SystemTrigger(SystemTriggerType.SessionConnected, false);
BackgroundTaskBuilder Builder = new BackgroundTaskBuilder
{
Name = "UpdateTask",
IsNetworkRequested = true,
TaskEntryPoint = "UpdateCheckBackgroundTask.UpdateCheck"
};
Builder.SetTrigger(Trigger);
Builder.AddCondition(new SystemCondition(SystemConditionType.InternetAvailable));
Builder.AddCondition(new SystemCondition(SystemConditionType.UserPresent));
Builder.AddCondition(new SystemCondition(SystemConditionType.FreeNetworkAvailable));
Builder.Register();
break;
}
default:
{
if (!ApplicationData.Current.LocalSettings.Values.ContainsKey("DisableBackgroundTaskTips"))
{
QueueContentDialog Dialog = new QueueContentDialog
{
Title = Globalization.GetString("Common_Dialog_TipTitle"),
Content = Globalization.GetString("QueueDialog_BackgroundTaskDisable_Content"),
PrimaryButtonText = Globalization.GetString("QueueDialog_BackgroundTaskDisable_PrimaryButton"),
SecondaryButtonText = Globalization.GetString("QueueDialog_BackgroundTaskDisable_SecondaryButton"),
CloseButtonText = Globalization.GetString("QueueDialog_BackgroundTaskDisable_CloseButton")
};
switch (await Dialog.ShowAsync().ConfigureAwait(true))
{
case ContentDialogResult.Primary:
{
_ = await Launcher.LaunchUriAsync(new Uri("ms-settings:privacy-backgroundapps"));
break;
}
case ContentDialogResult.Secondary:
{
break;
}
default:
{
ApplicationData.Current.LocalSettings.Values["DisableBackgroundTaskTips"] = true;
break;
}
}
}
break;
}
}
}
catch (Exception e)
{
Debug.WriteLine($"Error happened in RegisterBackgroundTaskAsync, Message: {e.Message}");
}
}
public BackgroundHelper()
{
//this.applicationTrigger = new ApplicationTrigger(); // TODO: Delete after testing
this.networkStateChangeTrigger = new SystemTrigger(SystemTriggerType.NetworkStateChange, false);
this.RegisteringBackgroundSpeedTest();
}
