public static async Task <BackgroundTaskRegistration> RegisterBackgroundTask(IBackgroundTrigger trigger)
{
var task = new BackgroundTaskBuilder
{
Name = "DynamicWall Process",
TaskEntryPoint = typeof(BackgroundComponent.Class1).ToString()
};
task.SetTrigger(trigger);
var Trigger = new ApplicationTrigger();
TimeTrigger hourlyTrigger = new TimeTrigger(60, false);
task.SetTrigger(hourlyTrigger);
var requestStatus = await Windows.ApplicationModel.Background.BackgroundExecutionManager.RequestAccessAsync();
if (requestStatus != BackgroundAccessStatus.AlwaysAllowed)
{
// Depending on the value of requestStatus, provide an appropriate response
// such as notifying the user which functionality won't work as expected
}
BackgroundTaskRegistration backtask = task.Register();
return(backtask);
}
private void RegisterAppBackgroundTask()
{
IBackgroundTaskRegistration taskRegistration;
Guid taskRegistrationId = Settings.Current.ApplicationBackgroundTaskRegistrationId;
if (BackgroundTaskRegistration.AllTasks.TryGetValue(taskRegistrationId, out taskRegistration))
{
if (taskRegistration is BackgroundTaskRegistration lastTraskRegistration &&
lastTraskRegistration.Trigger is ApplicationTrigger)
{
appTrigger = (ApplicationTrigger)lastTraskRegistration.Trigger;
return;
}
taskRegistration.Unregister(false);
}
appTrigger = new ApplicationTrigger();
BackgroundTaskBuilder builder = new BackgroundTaskBuilder
{
Name = applicationBackgroundTaskBuilderName,
IsNetworkRequested = true,
};
builder.SetTrigger(appTrigger);
builder.AddCondition(new SystemCondition(SystemConditionType.FreeNetworkAvailable));
taskRegistration = builder.Register();
Settings.Current.ApplicationBackgroundTaskRegistrationId = taskRegistration.TaskId;
}
private void CreatePoller()
{
foreach (var bgTask in BackgroundTaskRegistration.AllTasks)
{
if (bgTask.Value.Name == taskName)
{
bgTask.Value.Unregister(true);
}
}
trigger = new ApplicationTrigger();
BackgroundTaskBuilder taskBuilderActive = new BackgroundTaskBuilder();
taskBuilderActive.Name = taskName;
taskBuilderActive.TaskEntryPoint = taskEntryPoint;
taskBuilderActive.SetTrigger(trigger);
var registration = taskBuilderActive.Register();
var task = Task.Run(async() => {
for (; ;)
{
await Task.Delay(5000);
Debug.WriteLine("Hello World after 10 seconds");
await trigger.RequestAsync();
}
});
}
private async void Start_Click(object sender, RoutedEventArgs e)
{
ApplicationData.Current.LocalSettings.Values["number"] = 6; // число для подсчета факториала
var taskList = BackgroundTaskRegistration.AllTasks.Values;
var task = taskList.FirstOrDefault(i => i.Name == taskName);
if (task == null)
{
var taskBuilder = new BackgroundTaskBuilder();
taskBuilder.Name = taskName;
taskBuilder.TaskEntryPoint = typeof(MyRuntimeComponent.MyBackgroundTask).ToString();
ApplicationTrigger appTrigger = new ApplicationTrigger();
taskBuilder.SetTrigger(appTrigger);
task = taskBuilder.Register();
task.Progress += Task_Progress;
task.Completed += Task_Completed;
var taskParameters = new ValueSet();
taskParameters.Add("Message", "Заработало из фонового потока!");
await appTrigger.RequestAsync(taskParameters);
startButton.IsEnabled = false;
stopButton.IsEnabled = true;
}
}
private async void button_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 = "Test Task",
TaskEntryPoint = typeof(BackgroundStuff.MyBackgroundTask).ToString()
};
var trigger = new ApplicationTrigger();
task.SetTrigger(trigger);
await trigger.RequestAsync();
}
/// <summary>
/// Register the background task of the app.
/// </summary>
/// <returns></returns>
public async Task RegisterAsync()
{
//Update the access to the execution manager.
BackgroundExecutionManager.RemoveAccess();
var requestAccessStatus = await BackgroundExecutionManager.RequestAccessAsync();
//Create new background task.
var builder = new BackgroundTaskBuilder
{
Name = "ChiotaBackgroundService",
TaskEntryPoint = "RuntimeComponent.UWP.BackgroundTask"
};
if (requestAccessStatus == BackgroundAccessStatus.AlwaysAllowed || requestAccessStatus == BackgroundAccessStatus.AllowedSubjectToSystemPolicy)
{
_trigger = new ApplicationTrigger();
//Set the triggers.
builder.SetTrigger(_trigger);
builder.AddCondition(new SystemCondition(SystemConditionType.InternetAvailable));
//Register the new task.
var task = builder.Register();
task.Completed += TaskCompleted;
await _trigger.RequestAsync();
}
}
private void RegisterAppBackgroundTask()
{
IBackgroundTaskRegistration taskRegistration;
Guid taskRegistrationId = Settings.Current.ApplicationBackgroundTaskRegistrationId;
if (BackgroundTaskRegistration.AllTasks.TryGetValue(taskRegistrationId, out taskRegistration))
{
if (taskRegistration is BackgroundTaskRegistration lastTraskRegistration &&
lastTraskRegistration.Trigger is ApplicationTrigger)
{
appTrigger = (ApplicationTrigger)lastTraskRegistration.Trigger;
return;
}
taskRegistration.Unregister(false);
}
appTrigger = new ApplicationTrigger();
BackgroundTaskBuilder builder = new BackgroundTaskBuilder
{
Name = applicationBackgroundTaskBuilderName,
};
builder.SetTrigger(appTrigger);
taskRegistration = builder.Register();
Settings.Current.ApplicationBackgroundTaskRegistrationId = taskRegistration.TaskId;
}
private async void ExecuteUpdateTileCommand(string value)
{
try
{
Busy = true;
var number = default(int);
if (!int.TryParse(value, out number))
{
return;
}
await Task.Delay(2000);
var trigger = new ApplicationTrigger();
var task = await BackgroundHelper.Register <MyUpdateBadgeTask>(trigger);
task.Completed += (s, e) => { Busy = false; };
var allowed = await trigger.RequestAsync();
if (allowed != ApplicationTriggerResult.Allowed)
{
// it was not allowed to run
Busy = false;
}
}
catch { Busy = false; }
}
public async Task isRegisteredAsync()
{
var taskRegistered = false;
var taskName = "Run";
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (task.Value.Name == taskName)
{
taskRegistered = true;
break;
}
else
{
//If backroundtask is not registered then register it
var builder = new BackgroundTaskBuilder();
var appTrigger = new ApplicationTrigger();
builder.Name = taskName;
builder.TaskEntryPoint = "LocationBackgroundTask";
builder.SetTrigger(appTrigger);
var result = await appTrigger.RequestAsync();
task = builder.Register();
}
}
}
/// <summary>
/// Passes package file path and of file paths dependencies into the backgroundTask
/// using a ValueSet.
/// </summary>
private async void showProgressInNotification()
{
permissionTextBlock.Text = "Check Your Notifications/Action Center 😉";
var thingsToPassOver = new ValueSet();
thingsToPassOver.Add("packagePath", packageInContext.Path);
if (dependenciesAsString != null & dependenciesAsString.Count > 0)
{
int count = dependenciesAsString.Count();
for (int i = 0; i < count; i++)
{
thingsToPassOver.Add($"dependencies{i}", dependenciesAsString[i]);
}
thingsToPassOver.Add("installType", 1);
}
else
{
thingsToPassOver.Add("installType", 0);
}
PackageManager pkgManager = new PackageManager();
ApplicationTrigger appTrigger = new ApplicationTrigger();
var backgroundTask = RegisterBackgroundTask("installTask.install", "installTask", appTrigger);
//backgroundTask.Completed += new BackgroundTaskCompletedEventHandler(OnCompleted);
//backgroundTask.Progress += new BackgroundTaskProgressEventHandler(OnProgress);
var result = await appTrigger.RequestAsync(thingsToPassOver);
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (task.Value.Name == "installTask")
{
AttachCompletedHandler(task.Value);
}
}
}
private async void RegisterTask()
{
var taskRegistered = false;
ApplicationTrigger trigger = null;
var taskName = "SendGrats";
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (task.Value.Name == taskName)
{
taskRegistered = true;
break;
}
}
if (!taskRegistered)
{
var builder = new BackgroundTaskBuilder()
{
Name = taskName,
};
builder.AddCondition(new SystemCondition(SystemConditionType.InternetAvailable));
trigger = new ApplicationTrigger();
var x = await BackgroundExecutionManager.RequestAccessAsync();
builder.SetTrigger(trigger);
builder.IsNetworkRequested = true;
BackgroundTaskRegistration task = builder.Register();
task.Completed += new BackgroundTaskCompletedEventHandler(Task_Completed);
await trigger.RequestAsync();
}
}
public static async Task RegisterApplicationTrigger(Type backgroundTaskType)
{
var backgroundAccessStatus = await BackgroundExecutionManager.RequestAccessAsync();
if (backgroundAccessStatus == BackgroundAccessStatus.AllowedMayUseActiveRealTimeConnectivity ||
backgroundAccessStatus == BackgroundAccessStatus.AllowedWithAlwaysOnRealTimeConnectivity)
{
var appTrigger = new ApplicationTrigger();
string taskEntryPoint = backgroundTaskType.ToString();
var backgroundTaskBuilder = new BackgroundTaskBuilder
{
Name = backgroundTaskType.Name,
TaskEntryPoint = taskEntryPoint
};
backgroundTaskBuilder.SetTrigger(appTrigger);
var task = BackgroundTaskRegistration.AllTasks.Values.FirstOrDefault(i => i.Name.Equals(backgroundTaskType.Name));
task?.Unregister(true);
backgroundTaskBuilder.Register();
ValueSet message = new ValueSet { { "Command", "Init" } };
var result = await appTrigger.RequestAsync(message);
if (result == ApplicationTriggerResult.Allowed)
{
Debug.WriteLine(string.Format("{0} called!", backgroundTaskType.Name));
}
}
}
private void RegisterListenerTask()
{
// 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)
{
ApplicationData.Current.LocalSettings.Values[CURRENTINRANGE_TAG] = "";
ApplicationData.Current.LocalSettings.Values[BTWatcherManager.taskName] = "";
// 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
ApplicationTrigger trigger = new ApplicationTrigger();
//SystemTrigger trigger = new SystemTrigger(SystemTriggerType.InternetAvailable, false);
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 += OnMessageListenerTaskCompleted;
taskRegistration.Progress += OnMessageListenerTaskProgress;
var ignored = trigger.RequestAsync();
MainPage.Current.UpdateDebugMessage(this, "RegisterListenerTask: " + taskRegistration.Name + " / " + taskRegistration.TaskId);
}
}
/// <summary>
/// We proceed to register the task if it hasn't been registered yet. Otherwise, we fetch the registration
/// and retrieve the ApplicationTrigger from there.
/// </summary>
private async void RegisterBackgroundTask()
{
try
{
if (!BackgroundTaskRegistration.AllTasks.Any(reg => reg.Value.Name == TileRegistrationName))
{
// Configure task parameters
BackgroundTaskBuilder builder = new BackgroundTaskBuilder();
builder.TaskEntryPoint = typeof(TileUpdateTask).FullName;
builder.Name = TileRegistrationName;
// Remember to set an ApplicationTrigger so we can run it on demand later
this.backgroundTrigger = new ApplicationTrigger();
builder.SetTrigger(backgroundTrigger);
builder.Register();
MessageDialog infoDialog = new MessageDialog("Background task successfully registered.", "Info");
await infoDialog.ShowAsync();
}
else
{
// Fetch registration details and trigger if already existing
var registration = BackgroundTaskRegistration.AllTasks.FirstOrDefault(reg => reg.Value.Name == TileRegistrationName).Value as BackgroundTaskRegistration;
this.backgroundTrigger = registration.Trigger as ApplicationTrigger;
MessageDialog infoDialog = new MessageDialog("Background task registration data successfully retrieved.", "Info");
await infoDialog.ShowAsync();
}
}
catch (Exception ex)
{
MessageDialog errorDialog = new MessageDialog("There was an error while trying to register the background task.", "Error");
errorDialog.ShowAsync();
}
}
private async void RegisterTask(string taskName, string entryPoint)
{
bool taskRegistered = false;
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (task.Value.Name == taskName)
{
taskRegistered = true;
break;
}
}
if (!taskRegistered)
{
var builder = new BackgroundTaskBuilder();
var trigger = new ApplicationTrigger();
builder.Name = taskName;
builder.TaskEntryPoint = entryPoint;
builder.SetTrigger(trigger);
BackgroundTaskRegistration task = builder.Register();
var result = await trigger.RequestAsync();
}
}
/// <summary>
/// Register for background tasks (Time zone trigger & time trigger)
/// </summary>
static async void ThreadProc()
{
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("******************************************");
Console.WriteLine("**** Time zone trigger backgrond task ****");
Console.WriteLine("******************************************");
await BackgroundExecutionManager.RequestAccessAsync();
// Register a TimeZoneTrigger background task with name and trigger
RegisterBackgroundTask("TimeZoneTriggerTest", new SystemTrigger(SystemTriggerType.TimeZoneChange, false));
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Registration completed for Time Zone change system event. Change the time zone to trigger the backgrond task");
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("*************************************");
Console.WriteLine("**** Time trigger backgrond task ****");
Console.WriteLine("*************************************");
// Register a background TimeTrigger task with name and trigger
RegisterBackgroundTask("TimerTriggerTest", new TimeTrigger(15, false));
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Registration completed for Time trigger event. The backgrond task runs every 15 mins");
Console.WriteLine("Pin the app to start and see how the tile is updated every time the task is triggered");
// just a test
ApplicationTrigger trigger = new ApplicationTrigger();
if (trigger is ApplicationTrigger)
{
var result = await(trigger as ApplicationTrigger).RequestAsync(); // returns UnknownError
}
}
/// <summary>
/// Initializes the singleton application object. This is the first line of authored code
/// executed, and as such is the logical equivalent of main() or WinMain().
/// </summary>
public App()
{
BackgroundNotificationTrigger = new ApplicationTrigger();
RegisterBackgroundTasks();
this.InitializeComponent();
this.Suspending += OnSuspending;
}
/// <summary>
/// We proceed to register the task if it hasn't been registered yet. Otherwise, we fetch the registration
/// and retrieve the ApplicationTrigger from there.
/// </summary>
private async void RegisterBackgroundTask()
{
try
{
if (!BackgroundTaskRegistration.AllTasks.Any(reg => reg.Value.Name == TileRegistrationName))
{
// Configure task parameters
BackgroundTaskBuilder builder = new BackgroundTaskBuilder();
builder.TaskEntryPoint = typeof(TileUpdateTask).FullName;
builder.Name = TileRegistrationName;
// Remember to set an ApplicationTrigger so we can run it on demand later
this.backgroundTrigger = new ApplicationTrigger();
builder.SetTrigger(backgroundTrigger);
builder.Register();
MessageDialog infoDialog = new MessageDialog("Background task successfully registered.", "Info");
await infoDialog.ShowAsync();
}
else
{
// Fetch registration details and trigger if already existing
var registration = BackgroundTaskRegistration.AllTasks.FirstOrDefault(reg => reg.Value.Name == TileRegistrationName).Value as BackgroundTaskRegistration;
this.backgroundTrigger = registration.Trigger as ApplicationTrigger;
MessageDialog infoDialog = new MessageDialog("Background task registration data successfully retrieved.", "Info");
await infoDialog.ShowAsync();
}
}
catch (Exception ex)
{
MessageDialog errorDialog = new MessageDialog("There was an error while trying to register the background task.", "Error");
errorDialog.ShowAsync();
}
}
public static ref ApplicationTrigger GetAppTrigger()
{
if (AppTrigger == null)
{
AppTrigger = new ApplicationTrigger();
}
return(ref AppTrigger);
}
private async Task RegisterCommandExecute()
{
_trigger = new ApplicationTrigger();
var task = await BackgroundTaskHelper.RegisterApplicationTrigger(typeof(BackgroundTask), _trigger);
AttachProgressAndCompletedHandlers(task);
Info += "Registered" + Environment.NewLine;
}
private async void btnApplicationTrigger_Tapped(object sender, TappedRoutedEventArgs e)
{
var trigger = new ApplicationTrigger();
var reg = await RegisterBackgroundTask(typeof(TheBackgroundTask.TheTask).FullName,
trigger.GetType().Name, trigger, null);
var md = new ValueSet();
md.Add("command", txtForApplicationTrigger.Text);
var res = await trigger.RequestAsync(md);
}
public MainPage()
{
this.InitializeComponent();
//ReadConfiguration().GetAwaiter();
//DispatcherTimerSetup();
//RegisterBackgroundTask();
trigger = new ApplicationTrigger();
//uwpScheduler uwp = new uwpScheduler();
initializeSettings();
LocalDataStore.CreateLocalConfigurationSettings();
}
private void RegisterBackgroundTask(object sender, RoutedEventArgs e)
{
trigger = new ApplicationTrigger();
var task = SchedulerConfigurations.RegisterBackgroundTask(LocalDataStore.BackgroundTaskEntryPoint,
LocalDataStore.BackgroundTriggerName,
trigger,
null);
// AttachProgressAndCompletedHandlers(task);
//SignalBackgroundTask(null, null);
// UpdateUI();
}
public static void Init(WindowsPage page)
{
MessagingCenter.Subscribe <StartLongRunningTask>(page, nameof(StartLongRunningTask),
async(message) =>
{
var access = await BackgroundExecutionManager.RequestAccessAsync();
switch (access)
{
case Unspecified:
return;
case AllowedMayUseActiveRealTimeConnectivity:
return;
case AllowedWithAlwaysOnRealTimeConnectivity:
return;
case Denied:
return;
}
var task = new BackgroundTaskBuilder
{
Name = BackServiceName,
//TaskEntryPoint = "Matcha.BackgroundService.UWP.MatchaBackgrounService"
};
var trigger = new ApplicationTrigger();
task.SetTrigger(trigger);
//var condition = new SystemCondition(SystemConditionType.InternetAvailable);
task.Register();
await trigger.RequestAsync();
});
MessagingCenter.Subscribe <StopLongRunningTask>(page, nameof(StopLongRunningTask),
message =>
{
var tasks = BackgroundTaskRegistration.AllTasks;
foreach (var task in tasks)
{
// You can check here for the name
string name = task.Value.Name;
if (name == BackServiceName)
{
task.Value.Unregister(true);
}
}
//BackgroundAggregatorService.Instance.Stop();
});
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (task.Value.Name == WallpaperTaskConfig.WallpaperTaskName)
{
WallpaperTaskConfig.UpdateBackgroundTaskRegistrationStatus(WallpaperTaskConfig.WallpaperTaskName, true);
break;
}
}
trigger = new ApplicationTrigger();
}
/// <summary>
/// Register a ApplicationTriggerTask.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void RegisterBackgroundTask(object sender, RoutedEventArgs e)
{
trigger = new ApplicationTrigger();
var task = BackgroundTaskSample.RegisterBackgroundTask(BackgroundTaskSample.SampleBackgroundTaskEntryPoint,
BackgroundTaskSample.ApplicationTriggerTaskName,
trigger,
null);
await task;
AttachProgressAndCompletedHandlers(task.Result);
UpdateUI();
}
private async Task RegisterTasks()
{
var status = await BackgroundExecutionManager.RequestAccessAsync();
if (status != BackgroundAccessStatus.Denied)
{
RegisterTask("timerTask", new TimeTrigger(240, false));
}
RegisterTask("toastNotificationActionTask", new ToastNotificationActionTrigger());
RegisterTask("appTriggerTask", _bgTaskTrigger = new ApplicationTrigger());
}
/// <summary>
/// Registration of background tasks
/// </summary>
public static async void RegistrBackgroundTaskAsync()
{
string myTaskName = "TDNReminder";
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)
{
return;
}
}
if (!skip)
{
// Windows Phone app must call this to use trigger types (see MSDN)
await BackgroundExecutionManager.RequestAccessAsync();
// register a new task
taskBuilder = new BackgroundTaskBuilder {
Name = "TDNReminder", TaskEntryPoint = "Reminder.Reminder"
};
taskBuilder.SetTrigger(new SystemTrigger(SystemTriggerType.SessionConnected, false));
taskBuilder.SetTrigger(new SystemTrigger(SystemTriggerType.UserPresent, false));
taskBuilder.SetTrigger(new TimeTrigger(15, false));
taskBuilder.SetTrigger(trigger);
taskBuilder.AddCondition(new SystemCondition(SystemConditionType.SessionConnected));
BackgroundTaskRegistration Reminder = taskBuilder.Register();
await trigger.RequestAsync();
}
// --------------------------------------------------------------------------------
//myTaskName = "TDNCompleter";
//if (BackgroundTaskRegistration.AllTasks.Any(i => i.Value.Name.Equals(myTaskName)))
// return;
//// register a new task
//taskBuilder = new BackgroundTaskBuilder { Name = myTaskName };
//taskBuilder.SetTrigger(new ToastNotificationActionTrigger());
//BackgroundTaskRegistration Completer = taskBuilder.Register();
}
/// <summary>
/// Register a ApplicationTriggerTask.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void RegisterBackgroundTask(object sender, RoutedEventArgs e)
{
trigger = new ApplicationTrigger();
var task = BackgroundTaskSample.RegisterBackgroundTask(BackgroundTaskSample.SampleBackgroundTaskEntryPoint,
BackgroundTaskSample.ApplicationTriggerTaskName,
trigger,
null);
await task;
AttachProgressAndCompletedHandlers(task.Result);
UpdateUI();
}
public void RegisterTask()
{
runCount++;
Debug.WriteLine("............................................................................................Datetime : " + DateTime.Now + " in RegisterTask ...............Run Count : " + runCount);
taskTrigger = new ApplicationTrigger();
var task = SchedulerConfigurations.RegisterBackgroundTask(LocalDataStore.BackgroundTaskEntryPoint,
LocalDataStore.BackgroundTriggerName,
taskTrigger,
null);
// taskRunning = true;
StartBackgroundTask();
}
public SettingsViewModel(IBackgroundService _backgroundService)
{
backgroundService = _backgroundService;
// Create a new trigger
applicationtrigger = new ApplicationTrigger();
localFolder = ApplicationData.Current.LocalFolder;
_fences = new ObservableCollection <Fence>();
_locations = new ObservableCollection <Location>();
formatterLongTime = new DateTimeFormatter("{hour.integer}:{minute.integer(2)}:{second.integer(2)}", new[] { "en-US" }, "US", Windows.Globalization.CalendarIdentifiers.Gregorian, Windows.Globalization.ClockIdentifiers.TwentyFourHour);
calendar = new Calendar();
}
public async Task <int> backTaskUpdateTiles()
{
if (isUpdateCompleted == true)
{
isUpdateCompleted = false;
ApplicationTrigger trigger = new ApplicationTrigger();
var btr = await BackTaskReg.RegisterBackgroundTask("BackTaskUpdateTiles", "Taq.BackTask.BackTaskUpdateTiles", trigger);
btr.Completed += Btr_Completed;
var result = await trigger.RequestAsync();
}
return(0);
}
private async void RegisterTask(string taskName)
{
BackgroundTaskBuilder taskBuilder = new BackgroundTaskBuilder
{
Name = taskName,
};
var trigger = new ApplicationTrigger();
taskBuilder.SetTrigger(trigger);
var registration = taskBuilder.Register();
await trigger.RequestAsync();
}
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);
}
/// <summary>
/// Invoked when this page is about to be displayed in a Frame.
/// </summary>
/// <param name="e">Event data that describes how this page was reached. The Parameter
/// property is typically used to configure the page.</param>
protected override void OnNavigatedTo(NavigationEventArgs e)
{
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (task.Value.Name == BackgroundTaskSample.ApplicationTriggerTaskName)
{
AttachProgressAndCompletedHandlers(task.Value);
BackgroundTaskSample.UpdateBackgroundTaskRegistrationStatus(BackgroundTaskSample.ApplicationTriggerTaskName, true);
break;
}
}
trigger = new ApplicationTrigger();
UpdateUI();
}
public static async Task<BackgroundTaskRegistration> RegisterApplicationTrigger(Type backgroundTaskType,
ApplicationTrigger trigger)
{
try
{
var backgroundAccessStatus = await BackgroundExecutionManager.RequestAccessAsync();
if (backgroundAccessStatus == BackgroundAccessStatus.AllowedMayUseActiveRealTimeConnectivity ||
backgroundAccessStatus == BackgroundAccessStatus.AllowedWithAlwaysOnRealTimeConnectivity)
{
string taskEntryPoint = backgroundTaskType.ToString();
var backgroundTaskBuilder = new BackgroundTaskBuilder
{
Name = backgroundTaskType.Name,
TaskEntryPoint = taskEntryPoint
};
backgroundTaskBuilder.SetTrigger(trigger);
var task =
BackgroundTaskRegistration.AllTasks.Values.FirstOrDefault(
i => i.Name.Equals(backgroundTaskType.Name));
task?.Unregister(true);
var appTriggerTask = backgroundTaskBuilder.Register();
return appTriggerTask;
}
return null;
}
catch(Exception ex)
{
Debug.WriteLine(ex.Message);
return null;
}
}
public MainPage()
{
this.InitializeComponent();
_trigger = new ApplicationTrigger();
}
private async Task<Tuple<bool, string>> TryRegisterUploadToOneDriveBackgroundTaskAsync()
{
bool isOk = false;
string msg = string.Empty;
string errorMsg = string.Empty;
BackgroundAccessStatus backgroundAccessStatus = BackgroundAccessStatus.Unspecified;
_uploadToOneDriveBkgTaskReg = null;
UnregisterTaskIfAlreadyRegistered(); // I need to unregister and register anew coz I need to obtain the trigger
try
{
// Get permission for a background task from the user. If the user has already answered once,
// this does nothing and the user must manually update their preference via PC Settings.
Task<BackgroundAccessStatus> requestAccess = null;
await RunInUiThreadIdleAsync(() => requestAccess = BackgroundExecutionManager.RequestAccessAsync().AsTask()).ConfigureAwait(false);
backgroundAccessStatus = await requestAccess.ConfigureAwait(false);
// Regardless of the answer, register the background task. If the user later adds this application
// to the lock screen, the background task will be ready to run.
// Create a new background task builder
BackgroundTaskBuilder bkgTaskBuilder = new BackgroundTaskBuilder
{
Name = ConstantData.ODU_BACKGROUND_TASK_NAME,
TaskEntryPoint = ConstantData.ODU_BACKGROUND_TASK_ENTRY_POINT
};
_uploadToOneDriveTrigger = new ApplicationTrigger();
bkgTaskBuilder.SetTrigger(_uploadToOneDriveTrigger);
// bkgTaskBuilder.AddCondition(new SystemCondition(SystemConditionType.SessionDisconnected)); // NO!
// Register the background task
_uploadToOneDriveBkgTaskReg = bkgTaskBuilder.Register();
}
catch (Exception ex)
{
errorMsg = ex.ToString();
backgroundAccessStatus = BackgroundAccessStatus.Denied;
Logger.Add_TPL(ex.ToString(), Logger.ForegroundLogFilename);
}
switch (backgroundAccessStatus)
{
case BackgroundAccessStatus.Unspecified:
msg = "Cannot run in background, enable it in the \"Battery Saver\" app";
break;
case BackgroundAccessStatus.Denied:
msg = string.IsNullOrWhiteSpace(errorMsg) ? "Cannot run in background, enable it in Settings - Privacy - Background apps" : errorMsg;
break;
default:
msg = "Background task on";
isOk = true;
break;
}
return Tuple.Create(isOk, msg);
}
private async Task RegisterTasks()
{
var status = await BackgroundExecutionManager.RequestAccessAsync();
if (status != BackgroundAccessStatus.Denied)
{
RegisterTask("timerTask", new TimeTrigger(240, false));
}
RegisterTask("toastNotificationActionTask", new ToastNotificationActionTrigger());
RegisterTask("appTriggerTask", _bgTaskTrigger = new ApplicationTrigger());
}
private async void ExecuteUpdateTileCommand(string value)
{
try
{
Busy = true;
var number = default(int);
if (!int.TryParse(value, out number))
return;
await Task.Delay(2000);
var trigger = new ApplicationTrigger();
var task = await BackgroundHelper.Register<MyUpdateBadgeTask>(trigger);
task.Completed += (s,e)=> { Busy = false; };
var allowed = await trigger.RequestAsync();
if (allowed != ApplicationTriggerResult.Allowed)
{
// it was not allowed to run
Busy = false;
}
}
catch { Busy = false; }
}
private async Task Register()
{
if (ExistingRegistration.Any())
return;
// request access
var access = BackgroundExecutionManager.GetAccessStatus();
switch (access)
{
case BackgroundAccessStatus.Unspecified:
case BackgroundAccessStatus.Denied:
{
await new ContentDialog { Title = "Cannot register", Content = "Get Access: " + access.ToString(), PrimaryButtonText = "Close" }.ShowAsync();
return;
}
}
// build task
var task = new BackgroundTaskBuilder
{
Name = nameof(MyBackgroundTask),
CancelOnConditionLoss = true,
TaskEntryPoint = typeof(MyBackgroundTask).ToString(),
};
task.SetTrigger(this._applicationTrigger = new ApplicationTrigger());
// register
BackgroundTaskRegistration registration = null;
try { registration = task.Register(); }
catch (Exception ex)
{
this.ProgressText.Text = "Registration failed: " + ex.Message;
return;
}
// report
var dispatcher = this.Dispatcher;
registration.Progress += async (s, e) =>
{
await dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () =>
{
this.ProgressText.Text = string.Format("Task progress: {0}", e.Progress);
});
};
// handle complete
registration.Completed += async (s, e) =>
{
await dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () =>
{
try
{
e.CheckResult();
this.ProgressText.Text = "Task completed.";
}
catch (Exception ex)
{
this.ProgressText.Text = string.Format("Task error {0}", ex.Message);
}
finally { UpdateButtons(); }
});
};
}
