private async void RegisterBackgroundTask()
{
var backgroundAccessStatus = await BackgroundExecutionManager.RequestAccessAsync();
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (task.Value.Name == taskName)
{
task.Value.Unregister(true);
}
}
BackgroundTaskBuilder taskBuilder = new BackgroundTaskBuilder();
taskBuilder.Name = taskName;
taskBuilder.TaskEntryPoint = taskEntryPoint;
taskBuilder.SetTrigger(new TimeTrigger(15, false));
var registration = taskBuilder.Register();
}
/// <summary>
/// 在此页将要在 Frame 中显示时进行调用。
/// </summary>
/// <param name="e">描述如何访问此页的事件数据。
/// 此参数通常用于配置页。</param>
protected async override void OnNavigatedTo(NavigationEventArgs e)
{
bool taskRegistered = BackgroundTaskRegistration.AllTasks.Any(x => x.Value.Name == "TaskDemo");
if (!taskRegistered)
{
BackgroundAccessStatus status = await BackgroundExecutionManager.RequestAccessAsync();
if (status != BackgroundAccessStatus.Denied)
{
var builder = new BackgroundTaskBuilder();
builder.Name = "TaskDemo";
builder.TaskEntryPoint = "MyTask.TaskDemo";
builder.SetTrigger(new SystemTrigger(SystemTriggerType.BackgroundWorkCostChange, false));
builder.AddCondition(new SystemCondition(SystemConditionType.UserPresent));
BackgroundTaskRegistration task = builder.Register();
}
}
}
private async void OnLoad(object sender, RoutedEventArgs e)
{
var status = await BackgroundExecutionManager.RequestAccessAsync();
Debug.WriteLine($"background execution status = {status}");
// Register background task...
var taskRegistered = false;
var exampleTaskName = "MyEmailBackgroundTask";
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (task.Value.Name == exampleTaskName)
{
taskRegistered = true;
break;
}
}
if (taskRegistered == false)
{
var builder = new BackgroundTaskBuilder();
builder.Name = nameof(EmailBackgroundTask);
builder.TaskEntryPoint = typeof(EmailBackgroundTask).ToString();
builder.SetTrigger(new EmailStoreNotificationTrigger());
builder.Register().Completed += EmailTriggered;
}
UserDataAccountStore store =
await UserDataAccountManager.RequestStoreAsync(UserDataAccountStoreAccessType.AllAccountsReadOnly);
var accts = await store.FindAccountsAsync();
foreach (var acct in accts)
{
foreach (EmailMailbox mailbox in await acct.FindEmailMailboxesAsync())
{
//mailbox.MailboxChanged += Mailbox_MailboxChanged;
Debug.WriteLine($"mailbox id {mailbox.DisplayName}");
}
}
}
/// <summary>
/// Invoked as an event handler when the Run button is pressed.
/// </summary>
/// <param name="sender">Instance that triggered the event.</param>
/// <param name="e">Event data describing the conditions that led to the event.</param>
private async void RunButton_Click(object sender, RoutedEventArgs e)
{
// Registering a background trigger if it is not already registered. It will start background advertising.
// First get the existing tasks to see if we already registered for it
if (taskRegistration != null)
{
rootPage.NotifyUser("Background publisher already registered.", NotifyType.StatusMessage);
return;
}
else
{
// Applications registering for background trigger must request for permission.
BackgroundAccessStatus backgroundAccessStatus = await BackgroundExecutionManager.RequestAccessAsync();
// Here, we do not fail the registration even if the access is not granted. Instead, we allow
// the trigger to be registered and when the access is granted for the Application at a later time,
// the trigger will automatically start working again.
// At this point we assume we haven't found any existing tasks matching the one we want to register
// First, configure the task entry point, trigger and name
var builder = new BackgroundTaskBuilder();
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
builder.Name = taskName;
// Now perform the registration.
taskRegistration = builder.Register();
// For this scenario, attach an event handler to display the result processed from the background task
taskRegistration.Completed += OnBackgroundTaskCompleted;
// Even though the trigger is registered successfully, it might be blocked. Notify the user if that is the case.
if ((backgroundAccessStatus == BackgroundAccessStatus.AlwaysAllowed) || (backgroundAccessStatus == BackgroundAccessStatus.AllowedSubjectToSystemPolicy))
{
rootPage.NotifyUser("Background publisher registered.", NotifyType.StatusMessage);
}
else
{
rootPage.NotifyUser("Background tasks may be disabled for this app", NotifyType.ErrorMessage);
}
}
}
/// <summary>
/// Register notification Background task
/// </summary>
public static async Task UpdateNotificationBGTask()
{
//Unregister task
string taskName = "MainClass";
string name = "DiscordBackgroundTask1";
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (task.Value.Name == taskName)
{
task.Value.Unregister(true);
}
}
//Re-register task
if (Storage.Settings.BackgroundTaskTime != 0)
{
var trigger = new TimeTrigger(Convert.ToUInt32(Storage.Settings.BackgroundTaskTime * 5), false);
BackgroundAccessStatus access = BackgroundAccessStatus.Unspecified;
try
{
await BackgroundExecutionManager.RequestAccessAsync();
}
catch (Exception ex)
{
if (ex.Message != "More data is available.")
{
return;
}
}
if (access == BackgroundAccessStatus.DeniedBySystemPolicy || access == BackgroundAccessStatus.DeniedByUser)
{
return;
}
var builder = new BackgroundTaskBuilder();
builder.Name = taskName;
builder.TaskEntryPoint = name + "." + taskName;
builder.AddCondition(new SystemCondition(SystemConditionType.InternetAvailable));
builder.SetTrigger(trigger);
builder.Register();
}
}
/// <summary>
/// Invoked when the application is launched normally by the end user. Other entry points
/// will be used such as when the application is launched to open a specific file.
/// </summary>
/// <param name="e">Details about the launch request and process.</param>
protected override void OnLaunched(LaunchActivatedEventArgs e)
{
#if DEBUG
if (System.Diagnostics.Debugger.IsAttached)
{
DebugSettings.EnableFrameRateCounter = true;
}
#endif
BackgroundExecutionManager.RemoveAccess();
BackgroundExecutionManager.RequestAccessAsync().AsTask().Wait();
BGTask.RegisterBackgroundTask("", "task", new SystemTrigger(SystemTriggerType.InternetAvailable, false), new SystemCondition(SystemConditionType.InternetAvailable));
Frame rootFrame = Window.Current.Content as Frame;
// Do not repeat app initialization when the Window already has content,
// just ensure that the window is active
if (rootFrame == null)
{
// Create a Frame to act as the navigation context and navigate to the first page
rootFrame = new Frame();
rootFrame.NavigationFailed += OnNavigationFailed;
if (e.PreviousExecutionState == ApplicationExecutionState.Terminated)
{
//TODO: Load state from previously suspended application
}
// Place the frame in the current Window
Window.Current.Content = rootFrame;
}
if (rootFrame.Content == null)
{
// When the navigation stack isn't restored navigate to the first page,
// configuring the new page by passing required information as a navigation
// parameter
rootFrame.Navigate(typeof(MainPage), e.Arguments);
}
// Ensure the current window is active
Window.Current.Activate();
}
public async static Task <BackgroundTaskRegistration> Register <T>(IBackgroundTrigger trigger, IEnumerable <IBackgroundCondition> conditions = null) where T : class
{
await BackgroundExecutionManager.RequestAccessAsync();
var allowed = BackgroundExecutionManager.GetAccessStatus();
switch (allowed)
{
case BackgroundAccessStatus.AllowedWithAlwaysOnRealTimeConnectivity:
case BackgroundAccessStatus.AllowedMayUseActiveRealTimeConnectivity:
break;
case BackgroundAccessStatus.Unspecified:
case BackgroundAccessStatus.Denied:
return(null);
}
var existing = FindRegistration <T>();
if (existing != null)
{
existing.Unregister(false);
}
var task = new BackgroundTaskBuilder
{
Name = nameof(T),
CancelOnConditionLoss = false,
TaskEntryPoint = typeof(T).ToString(),
};
task.SetTrigger(trigger);
if (conditions != null)
{
foreach (var condition in conditions)
{
task.AddCondition(condition);
}
}
return(task.Register());
}
/// <summary>
/// Registers all background tasks related to this application.
/// </summary>
/// <returns>Awaitable task is returned.</returns>
public async Task RegisterAllAsync()
{
try
{
// Keep track of the previous version of the app. If the app has been updated, we must first remove the previous task registrations and then re-add them.
var previousVersion = Platform.Current.Storage.LoadSetting <string>("PreviousAppVersion");
if (previousVersion != Platform.Current.AppInfo.VersionNumber.ToString())
{
this.RemoveAll();
Platform.Current.Storage.SaveSetting("PreviousAppVersion", Platform.Current.AppInfo.VersionNumber.ToString());
}
// Propmts users to give access to run background tasks.
var backgroundAccessStatus = await BackgroundExecutionManager.RequestAccessAsync();
if (backgroundAccessStatus == BackgroundAccessStatus.AllowedMayUseActiveRealTimeConnectivity || backgroundAccessStatus == BackgroundAccessStatus.AllowedWithAlwaysOnRealTimeConnectivity)
{
try
{
// Register each of your background tasks here:
RegisterBackgroundTaskAsync("MediaAppSample.BackgroundTasks.TimedWorkerTask", "MediaAppSampleTimeTriggerTask", new TimeTrigger(15, false), null);
// Flag that registration was completed
this.AreTasksRegistered = true;
}
catch (Exception ex)
{
Platform.Current.Logger.LogError(ex, "Failed to register background tasks.");
}
}
else
{
// User did not give the app access to run background tasks
Platform.Current.Logger.Log(LogLevels.Information, "Could not register tasks because background access status is '{0}'.", backgroundAccessStatus);
this.AreTasksRegistered = false;
}
}
catch (Exception ex)
{
Platform.Current.Logger.LogError(ex, "Error during BackgroundTaskManager.RegisterAllAsync()");
}
}
/// <summary>
/// Invoked when the application is launched normally by the end user. Other entry points
/// will be used when the application is launched to open a specific file, to display
/// search results, and so forth.
/// </summary>
/// <param name="args">Details about the launch request and process.</param>
protected override async void OnLaunched(LaunchActivatedEventArgs args)
{
// LoadSettings settings
await Logic.LoadSettings();
await Logic.Update();
Frame rootFrame = Window.Current.Content as Frame;
// Do not repeat app initialization when the Window already has content,
// just ensure that the window is active
if (rootFrame == null)
{
// Create a Frame to act as the navigation context and navigate to the first page
rootFrame = new Frame();
if (args.PreviousExecutionState == ApplicationExecutionState.Terminated)
{
//TODO: LoadSettings state from previously suspended application
}
// Place the frame in the current Window
Window.Current.Content = rootFrame;
}
if (rootFrame.Content == null)
{
// When the navigation stack isn't restored navigate to the first page,
// configuring the new page by passing required information as a navigation
// parameter
if (!rootFrame.Navigate(typeof(MainPage), args.Arguments))
{
throw new Exception("Failed to create initial page");
}
}
// Ensure the current window is active
Window.Current.Activate();
// Add to lockscreen
BackgroundExecutionManager.RequestAccessAsync();
}
public async void RegisterLongTermReminder()
{
// --------- Long Term Reminder background task -----------------------------------
string myTaskName = "TDNLongReminder";
bool skip = false;
BackgroundTaskBuilder taskBuilder;
ApplicationTrigger trigger = new ApplicationTrigger();
if (BackgroundTaskRegistration.AllTasks.Any(i => i.Value.Name.Equals(myTaskName)))
{
skip = true;
}
foreach (var cur in BackgroundTaskRegistration.AllTasks)
{
if (cur.Value.Name == myTaskName)
{
skip = true;
}
}
if (!skip)
{
BackgroundExecutionManager.RemoveAccess();
// Windows Phone app must call this to use trigger types (see MSDN)
var res = await BackgroundExecutionManager.RequestAccessAsync();
// register a new task
taskBuilder = new BackgroundTaskBuilder {
Name = myTaskName, TaskEntryPoint = "LongTermReminder.LongTermReminder"
};
taskBuilder.SetTrigger(new SystemTrigger(SystemTriggerType.SessionConnected, false));
taskBuilder.SetTrigger(new SystemTrigger(SystemTriggerType.UserPresent, false));
taskBuilder.SetTrigger(new TimeTrigger(15, false));
taskBuilder.SetTrigger(trigger);
BackgroundTaskRegistration Reminder = taskBuilder.Register();
await trigger.RequestAsync();
}
}
private async Task Register()
{
BackgroundExecutionManager.RemoveAccess();
var promise = await BackgroundExecutionManager.RequestAccessAsync();
if (promise == BackgroundAccessStatus.DeniedByUser || promise == BackgroundAccessStatus.DeniedBySystemPolicy)
{
return;
}
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (task.Value.Name == TaskName)
{
task.Value.Unregister(true);
}
}
var builder = new BackgroundTaskBuilder();
builder.Name = TaskName;
builder.TaskEntryPoint = EntryPoint;
var library = await StorageLibrary.GetLibraryAsync(KnownLibraryId.Pictures);
var contentChangedTrigger = StorageLibraryContentChangedTrigger.Create(library);
builder.SetTrigger(contentChangedTrigger);
builder.IsNetworkRequested = true;
builder.CancelOnConditionLoss = true;
try
{
BackgroundTaskRegistration registration = builder.Register();
Debug.WriteLine(registration.Name);
Debug.WriteLine(registration.TaskId);
Debug.WriteLine(registration.Trigger);
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
throw;
}
}
public ShellViewModel()
{
string backgroundTask = "CheckTodos";
return;
//Background-Task registrieren
foreach (var item in BackgroundTaskRegistration.AllTasks)
{
if (item.Value.Name == "CheckTodos")
{
item.Value.Unregister(true);
}
}
var builder = new BackgroundTaskBuilder();
builder.Name = backgroundTask;
builder.TaskEntryPoint = "TodoBackground.CheckTodos";
builder.SetTrigger(new TimeTrigger(15, true));
var state = BackgroundExecutionManager.RequestAccessAsync().AsTask().Result;
switch (state)
{
case BackgroundAccessStatus.AlwaysAllowed:
break;
case BackgroundAccessStatus.AllowedSubjectToSystemPolicy:
break;
case BackgroundAccessStatus.DeniedBySystemPolicy:
case BackgroundAccessStatus.DeniedByUser:
return;
}
BackgroundTaskRegistration registeredTask = builder.Register();
registeredTask.Completed += RegisteredTask_Completed;
registeredTask.Progress += RegisteredTask_Progress;
new MessageDialog("Hallo").ShowAsync().AsTask();
}
private async void OnRegisterTask(object sender, RoutedEventArgs e)
{
if (BackgroundTaskRegistration.AllTasks.All(x => x.Value.Name != "SyncTask"))
{
BackgroundTaskBuilder builder = new BackgroundTaskBuilder
{
Name = "SyncTask",
TaskEntryPoint = "OneDriveSample.SyncTask.UploadTask"
};
builder.SetTrigger(new TimeTrigger(60, false));
builder.AddCondition(new SystemCondition(SystemConditionType.InternetAvailable));
BackgroundAccessStatus status = await BackgroundExecutionManager.RequestAccessAsync();
if (status != BackgroundAccessStatus.Denied)
{
builder.Register();
}
}
}
public static async void RegisterTask()
{
var result = await BackgroundExecutionManager.RequestAccessAsync();
RegisterTask("Timezone Background Task",
typeof(TimerTriggerPingPongTask).FullName,
new SystemTrigger(SystemTriggerType.TimeZoneChange, false));
RegisterTask("InternetAvailable Background Task",
typeof(TimerTriggerPingPongTask).FullName,
new SystemTrigger(SystemTriggerType.InternetAvailable, false));
RegisterTask("SessionConnected Background Task",
typeof(TimerTriggerPingPongTask).FullName,
new SystemTrigger(SystemTriggerType.SessionConnected, false));
RegisterTask("UserPresent Background Task",
typeof(TimerTriggerPingPongTask).FullName,
new SystemTrigger(SystemTriggerType.UserPresent, false));
}
//If BG is not registered, application should register PhoneCallOriginDataRequestTrigger BG
//when it's selected as active call origin app
async Task RegisterTask()
{
BackgroundExecutionManager.RemoveAccess();
var access = await BackgroundExecutionManager.RequestAccessAsync();
if (access == BackgroundAccessStatus.AllowedMayUseActiveRealTimeConnectivity)
{
BackgroundTaskBuilder taskBuilder = new BackgroundTaskBuilder();
taskBuilder.Name = "CallOriginLookupBackgroundTask";
PhoneTrigger trigger =
new PhoneTrigger(PhoneTriggerType.CallOriginDataRequest);
taskBuilder.SetTrigger(trigger);
taskBuilder.TaskEntryPoint = typeof(CallExtraInfoLookupBackgroundTask).FullName;
taskBuilder.Register();
}
else
{
showRegistryFailMessage();
}
}
private async void RegisterClockTask()
{
var result = await BackgroundExecutionManager.RequestAccessAsync();
if (result == BackgroundAccessStatus.AlwaysAllowed || result == BackgroundAccessStatus.AllowedSubjectToSystemPolicy)
{
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (task.Value.Name == TASKNAME)
{
return;
}
}
BackgroundTaskBuilder builder = new BackgroundTaskBuilder();
builder.Name = TASKNAME;
builder.TaskEntryPoint = TASKENTRYPOINT;
builder.SetTrigger(new TimeTrigger(240, false));
builder.Register();
}
}
/// <summary>
/// Request background access so that we can register toasts.
/// Do this once to begin with so that we don't have to do this everywhere.
/// </summary>
/// <returns></returns>
public static async Task RequestBackgroundAccessAsync()
{
if (BackgroundAccessRequested)
{
return;
}
// Request access to run toast in background
var result = await BackgroundExecutionManager.RequestAccessAsync();
// Check if got access
if (result == BackgroundAccessStatus.Denied)
{
BackgroundAccessRequested = false;
}
else
{
BackgroundAccessRequested = true;
}
}
public static async void UnRegisterBackgroundTask(Type taskEntryPoint,
string taskName,
IBackgroundTrigger trigger,
IBackgroundCondition condition)
{
var status = await BackgroundExecutionManager.RequestAccessAsync();
if (status == BackgroundAccessStatus.Unspecified || status == BackgroundAccessStatus.Denied)
{
return;
}
foreach (var cur in BackgroundTaskRegistration.AllTasks)
{
if (cur.Value.Name == taskName)
{
cur.Value.Unregister(true);
}
}
}
public static async void RegisterBackgroundTask()
{
var taskRegistered = BackgroundTaskRegistration.AllTasks.Values
.Any(a => a.Name.Equals(nameof(NotificationBackgroundTask)));
if (await BackgroundExecutionManager.RequestAccessAsync() == BackgroundAccessStatus.DeniedBySystemPolicy)
{
return;
}
if (!taskRegistered)
{
var builder = new BackgroundTaskBuilder()
{
Name = $"{nameof(NotificationBackgroundTask)}",
TaskEntryPoint = $"{nameof(NotificationHelper)}.{nameof(BackgroundTasks)}.{nameof(NotificationBackgroundTask)}"
};
builder.SetTrigger(new TimeTrigger(15, false));
builder.Register();
}
}
public async static Task <BackgroundTaskRegistration> RegisterBackgroundTask(string taskEntryPoint, string name, IBackgroundTrigger trigger, IBackgroundCondition condition)
{
var builder = new BackgroundTaskBuilder {
Name = name, TaskEntryPoint = taskEntryPoint
};
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
}
BackgroundAccessStatus status = await BackgroundExecutionManager.RequestAccessAsync();
BackgroundTaskRegistration task = builder.Register();
return(task);
}
public static async Task Register()
{
BackgroundExecutionManager.RemoveAccess();
var result = await BackgroundExecutionManager.RequestAccessAsync();
if (result == BackgroundAccessStatus.DeniedBySystemPolicy ||
result == BackgroundAccessStatus.DeniedByUser)
{
return;
}
foreach (var task in backgroundTasks)
{
task.Value.Register(
new BackgroundTaskBuilder()
{
Name = task.Value.Name
});
}
}
private async Task InitializeBackgroundTaskAsync()
{
switch (BackgroundExecutionManager.GetAccessStatus())
{
case BackgroundAccessStatus.AllowedSubjectToSystemPolicy:
case BackgroundAccessStatus.AlwaysAllowed:
break;
default:
BackgroundExecutionManager.RemoveAccess();
await BackgroundExecutionManager.RequestAccessAsync();
break;
}
D("Background execution access checked");
BackgroundTaskManager.UnregisterTasks();
BackgroundTaskManager.RegisterTasks();
D("Background task reregistered");
}
public static async Task UnregisterAsync()
{
var status = await BackgroundExecutionManager.RequestAccessAsync();
if (status != BackgroundAccessStatus.AlwaysAllowed &&
status != BackgroundAccessStatus.AllowedSubjectToSystemPolicy)
{
return;
}
foreach (var cur in BackgroundTaskRegistration.AllTasks)
{
if (cur.Value.Name == NAME)
{
cur.Value.Unregister(true);
}
}
Debug.WriteLine($"===================unregistered===================");
}
private async void RegisterBackgroundTask()
{
await BackgroundExecutionManager.RequestAccessAsync();
var builder = new BackgroundTaskBuilder
{
Name = SyncTaskName,
TaskEntryPoint = "BackgroundTask.SyncBackgroundTask"
};
var applicationTrigger = new ApplicationTrigger();
builder.SetTrigger(applicationTrigger);
var registration = builder.Register();
registration.Completed += OnCompleted;
registration.Progress += OnProgress;
await applicationTrigger.RequestAsync();
}
private async Task <BackgroundTaskRegistration> RegisterBackgroundTask(string name,
TimeTrigger trigger,
IBackgroundCondition condition)
{
var access = await BackgroundExecutionManager.RequestAccessAsync();
//Check for existing registrations
foreach (var _task in BackgroundTaskRegistration.AllTasks)
{
if (_task.Value.Name == name)
{
//The task is already registered
//_task.Value.Unregister(true);
return((BackgroundTaskRegistration)(_task.Value));
}
}
//Register the task
var builder = new BackgroundTaskBuilder();
await BackgroundExecutionManager.RequestAccessAsync();
builder.Name = name;
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
}
try
{
BackgroundTaskRegistration task = builder.Register();
return(task);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
return(null);
}
async void ClientInit()
{
commModule = new CommModule();
// In the client role, we require the application to be on lock screen.
// Lock screen is required to let in-process RealTimeCommunication related
// background code to execute.
if (lockScreenAdded == false)
{
BackgroundAccessStatus status = await BackgroundExecutionManager.RequestAccessAsync();
Diag.DebugPrint("Lock screen status" + status);
switch (status)
{
case BackgroundAccessStatus.AllowedWithAlwaysOnRealTimeConnectivity:
// App is allowed to use RealTimeConnection broker
// functionality even in low power mode.
lockScreenAdded = true;
break;
case BackgroundAccessStatus.AllowedMayUseActiveRealTimeConnectivity:
// App is allowed to use RealTimeConnection broker
// functionality but not in low power mode.
lockScreenAdded = true;
break;
case BackgroundAccessStatus.Denied:
// App should switch to polling mode (example: poll for email based on time triggers)
Diag.DebugPrint("As Lockscreen status was Denied, App should switch to polling mode such as email based on time triggers.");
break;
}
}
ClientSettings.Visibility = Visibility.Visible;
ConnectButton.Visibility = Visibility.Visible;
return;
}
private async void NetworkStateChangeLoginSetter(object original_sender, RoutedEventArgs e)
{
var sender = original_sender as ToggleSwitch;
MyNetworkStateChangeLoginSetting.ApplySetting(sender.IsOn);
if (sender.IsOn)
{
if (!BackgroundTaskHelper.IsBackgroundTaskRegistered(NameManager.LIVETILETASK_NetWorkChanged))
{
await BackgroundExecutionManager.RequestAccessAsync();
BackgroundTaskHelper.Register(
NameManager.LIVETILETASK_NetWorkChanged,
typeof(TileRefresh.TileRefreshUtils).FullName,
new SystemTrigger(SystemTriggerType.NetworkStateChange, false));
}
//RefreshLoginSetting_UI.IsEnabled = true;
//await App.RegisterLiveTileTask(
// NameManager.LIVETILETASK_UserPresent,
// typeof(TileRefresh.TileRefreshUtils).FullName,
// new SystemTrigger(SystemTriggerType.UserPresent, false),
// null
//);
}
else
{
//RefreshLoginSetting_UI.IsOn = false;
//MyRefreshLoginSetting.ApplySetting(false);
//RefreshLoginSetting_UI.IsEnabled = false;
//if (BackgroundTaskHelper.IsBackgroundTaskRegistered(NameManager.LIVETILETASK_NetWorkChanged))
//{
// BackgroundTaskHelper.Unregister(NameManager.LIVETILETASK_NetWorkChanged);
//}
//await App.RegisterLiveTileTask(
// NameManager.LIVETILETASK_UserPresent,
// typeof(TileRefresh.TileRefreshUtils).FullName,
// null,
// null
//);
}
}
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();
}
async void RegisterBackgroundTask()
{
// 判断一下是否允许访问后台任务
var res = await BackgroundExecutionManager.RequestAccessAsync();
if (res == BackgroundAccessStatus.Denied || res == BackgroundAccessStatus.Unspecified)
{
return;
}
Type taskType = typeof(BackgroundTask.UpdateToastTask);
var task = BackgroundTaskRegistration.AllTasks.Values.FirstOrDefault(t => t.Name == taskType.Name);
if (task == null)
{
// 注册后台任务
BackgroundTaskBuilder bd = new BackgroundTaskBuilder();
bd.Name = taskType.Name;
bd.TaskEntryPoint = taskType.FullName;
// 声明触发器
TimeTrigger trigger = new TimeTrigger(15, false);
bd.SetTrigger(trigger);
bd.Register();
}
Type taskType2 = typeof(BackgroundTask.HandleToastActionTask);
var task2 = BackgroundTaskRegistration.AllTasks.Values.FirstOrDefault(t => t.Name == taskType2.Name);
if (task2 == null)
{
// 注册后台任务
BackgroundTaskBuilder bd = new BackgroundTaskBuilder();
bd.Name = taskType2.Name;
bd.TaskEntryPoint = taskType2.FullName;
// 声明触发器
bd.SetTrigger(new ToastNotificationActionTrigger());
bd.Register();
}
}
private async Task <bool> registerBackgroundTaskForPushNotification()
{
ResourceLoader rl = new ResourceLoader();
string app_id = rl.GetString("ApplicationID");
var taskRegistered = false;
var exampleTaskName = app_id + "_NotificationBackgroundTask";
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (task.Value.Name == exampleTaskName)
{
taskRegistered = true;
break;
}
}
if (taskRegistered)
{
//OutputText.Text = "Task already registered.";
return(true);
}
// Register background task
BackgroundAccessStatus backgroundStatus = await BackgroundExecutionManager.RequestAccessAsync();
if (backgroundStatus != BackgroundAccessStatus.Denied && backgroundStatus != BackgroundAccessStatus.Unspecified)
{
var builder = new BackgroundTaskBuilder();
builder.Name = exampleTaskName;
builder.TaskEntryPoint = "HindiJokes_BackgroundTasks.NotificationBackgroundTask";
builder.SetTrigger(new PushNotificationTrigger());
BackgroundTaskRegistration task = builder.Register();
return(true);
}
else
{
return(false);
}
}
