/// <summary>
/// Register a background task with the specified taskEntryPoint, name, trigger,
/// and condition (optional).
/// </summary>
/// <param name="taskEntryPoint">Task entry point for the background task.</param>
/// <param name="name">A name for the background task.</param>
/// <param name="trigger">The trigger for the background task.</param>
/// <param name="condition">An optional conditional event that must be true for the task to fire.</param>
public static BackgroundTaskRegistration RegisterBackgroundTask(String taskEntryPoint, String name, IBackgroundTrigger trigger, IBackgroundCondition condition)
{
var builder = new BackgroundTaskBuilder();
builder.Name = name;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
}
BackgroundTaskRegistration task = builder.Register();
UpdateBackgroundTaskStatus(name, true);
//
// Remove previous completion status from local settings.
//
var settings = ApplicationData.Current.LocalSettings;
settings.Values.Remove(name);
return task;
}
private async void StartBackgroundTask()
{
var task = BackgroundTaskRegistration.AllTasks.Values.FirstOrDefault(x => x.Name == "testTask");
if (task != null)
{
task.Unregister(true);
}
var taskBuilder = new BackgroundTaskBuilder();
taskBuilder.Name = "testTask";
taskBuilder.TaskEntryPoint = typeof(UpdateLocalDbBackgroundTask).ToString();
ApplicationTrigger trigger = new ApplicationTrigger();
taskBuilder.SetTrigger(trigger);
taskBuilder.AddCondition(new SystemCondition(SystemConditionType.InternetAvailable));
task = taskBuilder.Register();
task.Completed += BackgroundTaskCompleted;
await trigger.RequestAsync();
}
private async void RegisterBakgroundTask()
{
var backgroundAccessStatus = await BackgroundExecutionManager.RequestAccessAsync();
if (backgroundAccessStatus == BackgroundAccessStatus.AllowedSubjectToSystemPolicy || backgroundAccessStatus == BackgroundAccessStatus.AlwaysAllowed)
{
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (task.Value.Name == taskName)
{
task.Value.Unregister(true);
}
}
var taskBuilder = new BackgroundTaskBuilder
{
Name = taskName,
TaskEntryPoint = taskEntryPoint
};
taskBuilder.SetTrigger(new TimeTrigger(15, false));
BackgroundTaskRegistration regesteration = taskBuilder.Register();
}
}
public static BackgroundTaskBuilder AddSqliteBackgroundTasksStore(this BackgroundTaskBuilder builder,
string connectionString, ConnectionScope scope = ConnectionScope.ByRequest)
{
if (scope == ConnectionScope.ByRequest)
{
builder.Services.AddHttpContextAccessor();
}
builder.Services.AddSafeLogging();
builder.Services.AddDatabaseConnection <BackgroundTaskBuilder, SqliteConnectionFactory>(connectionString,
scope);
builder.Services.Replace(ServiceDescriptor.Singleton <IBackgroundTaskStore, SqliteBackgroundTaskStore>());
SqlMapper.AddTypeHandler(DateTimeOffsetHandler.Default);
SqlMapper.AddTypeHandler(TimeSpanHandler.Default);
var serviceProvider = builder.Services.BuildServiceProvider();
var options = serviceProvider.GetRequiredService <IOptions <BackgroundTaskOptions> >();
MigrateToLatest(connectionString, options.Value);
return(builder);
}
// registers a task with the given name...
public static async Task RegisterTaskAsync <T>(string name, Action <BackgroundTaskBuilder> configureCallback)
where T : TaskBase
{
// unregister any old one...
UnregisterTask(name);
// unlock it...
await TaskBase.ResetLockFileAsync(typeof(T));
// register the new one...
var builder = new BackgroundTaskBuilder();
builder.Name = name;
// entry point is StreetFoo.Client.Tasks.<Name>Facade
builder.TaskEntryPoint = string.Format("StreetFoo.Client.Tasks.{0}Facade", typeof(T).Name);
// configure...
configureCallback(builder);
// register it...
builder.Register();
}
public static void Register()
{
if (Interlocked.Exchange(ref registered, 1) != 0)
{
return;
}
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (task.Value.Name == TASK_NAME)
{
return;
}
}
var builder = new BackgroundTaskBuilder
{
Name = TASK_NAME,
TaskEntryPoint = "ExDawnOfDayTask.Task",
IsNetworkRequested = true,
};
builder.SetTrigger(new TimeTrigger(24 * 60, false));
builder.Register();
}
private void RegisterBackgroundTask(DeviceWatcherTrigger deviceWatcherTrigger)
{
BackgroundTaskBuilder taskBuilder;
// First see if we already have this background task registered. If so, unregister
// it before we register it with the new trigger.
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (backgroundTaskName == task.Value.Name)
{
UnregisterBackgroundTask(task.Value);
}
}
taskBuilder = new BackgroundTaskBuilder();
taskBuilder.Name = backgroundTaskName;
taskBuilder.TaskEntryPoint = "BackgroundDeviceWatcherTaskCs.BackgroundDeviceWatcher";
taskBuilder.SetTrigger(deviceWatcherTrigger);
backgroundTaskRegistration = taskBuilder.Register();
backgroundTaskRegistration.Completed += new BackgroundTaskCompletedEventHandler(OnTaskCompleted);
}
private void RegisterBackgroundTask()
{
BackgroundTaskBuilder taskBuilder = new BackgroundTaskBuilder();
PushNotificationTrigger trigger = new PushNotificationTrigger();
taskBuilder.SetTrigger(trigger);
// Background tasks must live in separate DLL, and be included in the package manifest
// Also, make sure that your main application project includes a reference to this DLL
taskBuilder.TaskEntryPoint = SAMPLE_TASK_ENTRY_POINT;
taskBuilder.Name = SAMPLE_TASK_NAME;
try
{
BackgroundTaskRegistration task = taskBuilder.Register();
task.Completed += BackgroundTaskCompleted;
}
catch (Exception ex)
{
rootPage.NotifyUser("Registration error: " + ex.Message, NotifyType.ErrorMessage);
UnregisterBackgroundTask();
}
}
async Task RegisterBackgroundTask()
{
// If background task is already registered, do nothing
if (BackgroundTaskRegistration.AllTasks.Any(i => i.Value.Name.Equals(TaskName)))
{
return;
}
// Otherwise request access
BackgroundAccessStatus status = await BackgroundExecutionManager.RequestAccessAsync();
// Create the background task
BackgroundTaskBuilder builder = new BackgroundTaskBuilder()
{
Name = TaskName
};
// Assign the toast action trigger
builder.SetTrigger(new ToastNotificationActionTrigger());
// And register the task
BackgroundTaskRegistration registration = builder.Register();
}
/// <summary>
/// 后台任务注册
/// </summary>
/// <param name="isTaskReg">后台任务是否注册</param>
/// <param name="isCanReg">后台任务注册许可</param>
/// <param name="TaskName">后台任务名</param>
/// <param name="EntryPoint">后台任务入口</param>
/// <param name="trigger">后台任务触发条件</param>
public static void BackgroundTaskReg(bool isTaskReg, bool isCanReg, string TaskName, string EntryPoint, TimeTrigger trigger)
{
if (!isTaskReg && isCanReg)
{
var builder = new BackgroundTaskBuilder
{
Name = TaskName,
TaskEntryPoint = EntryPoint
};
builder.SetTrigger(trigger);
BackgroundTaskRegistration task = builder.Register();
}
else if (!isCanReg)
{
foreach (var item in BackgroundTaskRegistration.AllTasks)
{
if (item.Value.Name == TaskName)
{
item.Value.Unregister(true);
}
}
}
}
/// <summary>
/// 生成绑定了后台任务的定时出发器
/// </summary>
internal static BackgroundTaskBuilder CreateBackgroundTaskBuilder(out Guid taskId, TimeSpan interval)
{
interval = interval.Add(TimeSpan.FromSeconds(1)); //避免刚好设置成15分钟时无法触发的情况
var timeInt = (uint)interval.TotalMinutes;
if (timeInt < 15)
{
#if DEBUG
System.Diagnostics.Debugger.Break();
#else
throw new InvalidOperationException("不支持15分钟以内的录播计划，请直接保持程序打开在前台");
#endif
}
var builder = new BackgroundTaskBuilder();
builder.TaskEntryPoint = typeof(ScheduleTask).FullName;
builder.SetTrigger(new TimeTrigger(timeInt, true));
var taskReg = builder.Register();
taskId = taskReg.TaskId;
// TODO: 用builder.AddCondition(condition)增加运行条件，如果有网才继续运行
return(builder);
}
private void BackgroundAgentRegistration()
{
// Background Agent Registration.
bool isBackgroundAgentRegistered = false;
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (task.Value.Name == "ApressBackgroundAgent")
{
isBackgroundAgentRegistered = true;
break;
}
}
if (!isBackgroundAgentRegistered)
{
var builder = new BackgroundTaskBuilder();
builder.Name = "ApressBackgroundAgent";
builder.TaskEntryPoint = "BackgroundAgentDemo.ApressBackgroundAgent";
builder.SetTrigger(new SystemTrigger(SystemTriggerType.InternetAvailable, false));
BackgroundTaskRegistration backgroundAgent = builder.Register();
}
}
protected async override void OnNavigatedTo(NavigationEventArgs e)
{
var backgroundAccessStatus = await BackgroundExecutionManager.RequestAccessAsync();
var keepAliveBGName = "KeepAliveBackgroundTask";
var taskRegistered = BackgroundTaskRegistration.AllTasks.Any(task => task.Value.Name == keepAliveBGName);
if (!taskRegistered)
{
var builder = new BackgroundTaskBuilder {
Name = keepAliveBGName,
IsNetworkRequested = true,
TaskEntryPoint = typeof(KeepAliveBackgroundTask).FullName
};
var trigger = new TimeTrigger(20, false);
builder.SetTrigger(trigger);
var task = builder.Register();
}
}
public static Guid Register()
{
foreach (var current in BackgroundTaskRegistration.AllTasks)
{
if (current.Value.Name == nameof(MulticastServerBackgroundTask))
{
return(current.Value.TaskId);
}
}
BackgroundTaskBuilder socketTaskBuilder = new BackgroundTaskBuilder
{
Name = nameof(MulticastServerBackgroundTask),
TaskEntryPoint = typeof(MulticastServerBackgroundTask).FullName
};
SocketActivityTrigger trigger = new SocketActivityTrigger();
socketTaskBuilder.SetTrigger(trigger);
var task = socketTaskBuilder.Register();
return(task.TaskId);
}
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;
}
public static async void Register()
{
BackgroundAccessStatus result = await BackgroundExecutionManager.RequestAccessAsync();
if (result == BackgroundAccessStatus.Denied)
{
return;
}
KeyValuePair <Guid, IBackgroundTaskRegistration> task = BackgroundTaskRegistration.AllTasks.FirstOrDefault(x => x.Value.Name == TaskName);
task.Value?.Unregister(true);
var taskBuilder = new BackgroundTaskBuilder
{
Name = TaskName,
TaskEntryPoint = "UnofficialSteamAuthenticator.NotificationTask.BackgroundTask"
};
taskBuilder.SetTrigger(new TimeTrigger(15, false));
taskBuilder.AddCondition(new SystemCondition(SystemConditionType.InternetAvailable));
taskBuilder.Register();
}
public void RegisterBackgroundChangerTask(int interval)
{
if (interval < 1)
{
throw new ArgumentOutOfRangeException($"{nameof(interval)} should be 1 or higher");
}
const string taskName = nameof(WallpaperChangerBackgroundTask);
var registered = BackgroundTaskRegistration.AllTasks.Any(t => t.Value.Name == taskName);
if (registered)
{
return;
}
var builder = new BackgroundTaskBuilder
{
Name = taskName,
TaskEntryPoint = $"Tasks.{taskName}"
};
builder.SetTrigger(new MaintenanceTrigger((uint)interval, false));
}
private BackgroundTaskBuilder CreateTaskBuilder(string name, string entryPoint, IBackgroundTrigger trigger, IEnumerable <IBackgroundCondition> conditions, BackgroundTaskParameters parameters)
{
var builder = new BackgroundTaskBuilder
{
Name = name,
CancelOnConditionLoss = parameters.HasFlag(BackgroundTaskParameters.CancelOnConditionLoss),
IsNetworkRequested = parameters.HasFlag(BackgroundTaskParameters.IsNetworkRequested),
};
if (parameters.HasFlag(BackgroundTaskParameters.IsOutProcess))
{
builder.TaskEntryPoint = entryPoint;
}
builder.SetTrigger(trigger);
foreach (var condition in conditions)
{
builder.AddCondition(condition);
}
return(builder);
}
private static void RegisterBackgroundTask()
{
const string taskName = "ToastBackgroundTask";
// If background task is already registered, do nothing
if (BackgroundTaskRegistration.AllTasks.Any(i => i.Value.Name.Equals(taskName)))
{
return;
}
// Otherwise create the background task
var builder = new BackgroundTaskBuilder()
{
Name = taskName,
TaskEntryPoint = typeof(ToastNotificationBackgroundTask).FullName
};
// And set the toast action trigger
builder.SetTrigger(new ToastNotificationActionTrigger());
// And register the task
builder.Register();
}
/// <summary>
/// Registers a new background task instance.
/// </summary>
/// <param name="taskName">Name of the registered task. Should be unique for every unique task.</param>
/// <param name="timeInMinutes">Time in minutes after which the task will be run. Minimum is 15 minutes.</param>
/// <returns>Registration object on success, null when the task is duplicate based on its name</returns>
public static BackgroundTaskRegistration ScheduleOneTime(string taskName, uint timeInMinutes)
{
if (timeInMinutes < 15)
{
throw new ArgumentOutOfRangeException("Scheduled time must be at least 15 minutes, because UWP is bad");
}
//Checking for duplicate tasks
if (GetTask(taskName) != null)
{
Log.i(TAG, "The task " + taskName + " was already scheduled.");
return(null);
}
var builder = new BackgroundTaskBuilder();
builder.Name = taskName;
builder.TaskEntryPoint = typeof(BackgroundTask).FullName;
//Minimum is 15 minutes
builder.SetTrigger(new TimeTrigger(timeInMinutes, true));
//Registering the background task
var registered = builder.Register();
//Logging list of all scheduled tasks right after new schedule is made
var tasks = BackgroundTaskRegistration.AllTasks;
int i = 0;
Log.i(TAG, "There are now " + tasks.Count.ToString() + " tasks scheduled:");
foreach (var task in tasks)
{
Log.i(TAG, (i++ + 1).ToString() + " (ID " + task.Value.TaskId + ") = " + task.Value.Name);
}
return(registered);
}
/// <summary>
/// Register a background task with the specified taskEntryPoint, name, trigger,
/// and condition (optional).
/// </summary>
/// <param name="taskEntryPoint">Task entry point for the background task.</param>
/// <param name="name">A name for the background task.</param>
/// <param name="trigger">The trigger for the background task.</param>
/// <param name="condition">An optional conditional event that must be true for the task to fire.</param>
public static BackgroundTaskRegistration RegisterBackgroundTask(String taskEntryPoint, String name, IBackgroundTrigger trigger, IBackgroundCondition condition)
{
if (TaskRequiresBackgroundAccess(name))
{
// If the user denies access, the task will not run.
var requestTask = BackgroundExecutionManager.RequestAccessAsync();
}
var builder = new BackgroundTaskBuilder();
builder.Name = name;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
if (condition != null)
{
builder.AddCondition(condition);
//
// If the condition changes while the background task is executing then it will
// be canceled.
//
builder.CancelOnConditionLoss = true;
}
BackgroundTaskRegistration task = builder.Register();
UpdateBackgroundTaskRegistrationStatus(name, true);
//
// Remove previous completion status.
//
var settings = ApplicationData.Current.LocalSettings;
settings.Values.Remove(name);
return(task);
}
private static readonly string TILETASK_ENTRY_POINT = typeof(TileBackgroundTask).FullName; // "BaoZouRiBao.Background.TileBackgroundTask";
/// <summary>
/// 注册所有的后台任务
/// </summary>
public static async void RegisterAll()
{
BackgroundAccessStatus status = await BackgroundExecutionManager.RequestAccessAsync();
if (status == BackgroundAccessStatus.AllowedMayUseActiveRealTimeConnectivity ||
status == BackgroundAccessStatus.AllowedWithAlwaysOnRealTimeConnectivity)
{
//如果已经注册则先取消注册
foreach (var t in BackgroundTaskRegistration.AllTasks)
{
t.Value.Unregister(true);
}
// 注册toastTask
BackgroundTaskBuilder toastBuilder = new BackgroundTaskBuilder()
{
Name = ToastTaskName,
TaskEntryPoint = TOASTTASK_ENTRY_POINT
};
toastBuilder.SetTrigger(new ToastNotificationActionTrigger());
toastBuilder.Register();
// 注册tileTask
BackgroundTaskBuilder tileBuilder = new BackgroundTaskBuilder()
{
Name = TileTaskName,
TaskEntryPoint = TILETASK_ENTRY_POINT
};
tileBuilder.AddCondition(new SystemCondition(SystemConditionType.InternetAvailable));
tileBuilder.SetTrigger(new TimeTrigger(60, false));
tileBuilder.Register();
}
}
/// <summary>
/// Registers the background task.
/// </summary>
public async static void Register()
{
try
{
// The background task builder
IBackgroundTaskRegistration backgroundTaskRegistration = null;
try
{
// Check if we have background access
BackgroundAccessStatus backgroundAccessStatus = await BackgroundExecutionManager.RequestAccessAsync();
LogFile.Instance.LogInformation("", "", string.Format("Lock Screen Access: {0}.", backgroundAccessStatus));
}
catch
{
LogFile.Instance.LogInformation("", "", "Lock Screen Access.");
}
// If SkycapMailSyncNowPeriodically is not registered
if (!SyncMailBackgroundTask.IsRegistered(out backgroundTaskRegistration))
{
// Register SkycapMailSyncNowPeriodically
BackgroundTaskBuilder skycapMailSyncPeriodically = new BackgroundTaskBuilder();
skycapMailSyncPeriodically.Name = SkycapMailSyncTaskName;
skycapMailSyncPeriodically.TaskEntryPoint = typeof(SyncMailBackgroundTask).FullName;
skycapMailSyncPeriodically.SetTrigger(new TimeTrigger(15, false));
skycapMailSyncPeriodically.AddCondition(new SystemCondition(SystemConditionType.InternetAvailable));
skycapMailSyncPeriodically.Register();
LogFile.Instance.LogInformation("", "", "Registered Background Task.");
}
}
catch (Exception ex)
{
LogFile.Instance.LogError("", "", ex.ToString());
}
}
private async void PlayButtonClick(object sender, RoutedEventArgs e)
{
//var task = new BackgroundTaskBuilder()
//{
// Name = "MyTask",
// TaskEntryPoint = typeof(MyBackgroundTask.MyTask).ToString()
//};
//var trigger = new ApplicationTrigger();
//task.SetTrigger(trigger);
//task.Register();
//await trigger.RequestAsync();
string myTaskName = "MyBackgroundTask";
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (task.Value.Name == myTaskName)
{
await(new MessageDialog("Task already registered")).ShowAsync();
return;
}
}
await BackgroundExecutionManager.RequestAccessAsync();
BackgroundTaskBuilder taskBuilder = new BackgroundTaskBuilder()
{
Name = "SecondTask",
TaskEntryPoint = "MyBackgroundTask.MyTask"
};
taskBuilder.SetTrigger(new TimeTrigger(15, true));
BackgroundTaskRegistration mytask = taskBuilder.Register();
await(new MessageDialog("Task Registered")).ShowAsync();
}
public static async void Register()
{
try
{
var trigger = new TimeTrigger(60, false);
var result = await BackgroundExecutionManager.RequestAccessAsync();
if (result == BackgroundAccessStatus.DeniedByUser ||
result == BackgroundAccessStatus.DeniedBySystemPolicy)
{
return;
}
var query = from c in BackgroundTaskRegistration.AllTasks
where c.Value.Name == BackgroundTaskName
select c;
if (query.Any())
{
return;
}
var builder = new BackgroundTaskBuilder
{
Name = BackgroundTaskName,
IsNetworkRequested = true,
CancelOnConditionLoss = true,
TaskEntryPoint = "Light.Maintenance.MaintenanceTask"
};
builder.AddCondition(new SystemCondition(SystemConditionType.BackgroundWorkCostNotHigh));
builder.AddCondition(new SystemCondition(SystemConditionType.InternetAvailable));
builder.SetTrigger(trigger);
// builder.Register();
}
catch (Exception ex)
{
TelemetryHelper.TrackExceptionAsync(ex);
}
}
internal async static void RegisterBackgroundTask(Type taskType, string taskVersion, IBackgroundTrigger trigger)
{
string taskName = taskType.Name + "_" + taskVersion;
BackgroundAccessStatus status = await BackgroundExecutionManager.RequestAccessAsync();
if (status == BackgroundAccessStatus.DeniedBySystemPolicy || status == BackgroundAccessStatus.DeniedByUser)
{
Debug.WriteLine($"Background access denied, not registering task {taskName}");
return;
}
foreach (BackgroundTaskRegistration registration in BackgroundTaskRegistration.AllTasks.Values)
{
if (registration.Name == taskName)
{
Debug.WriteLine($"Background task {taskName} already registered");
return;
}
if (registration.Name.StartsWith(taskType.Name))
{
Debug.WriteLine($"Unregistering old background task {registration.Name}");
registration.Unregister(false);
}
}
BackgroundTaskBuilder builder = new BackgroundTaskBuilder();
builder.Name = taskName;
builder.TaskEntryPoint = taskType.FullName;
builder.SetTrigger(trigger);
Debug.WriteLine($"Registering new background task {taskName}");
builder.Register();
}
public static async Task <bool> RegisterApplicationTriggerBackgroundTask(string name, string entryPoint)
{
bool result = false;
try
{
UnregisterBackgroundTasks();
BackgroundAccessStatus accessStatus = await BackgroundExecutionManager.RequestAccessAsync();
if (accessStatus == BackgroundAccessStatus.AllowedMayUseActiveRealTimeConnectivity ||
accessStatus == BackgroundAccessStatus.AllowedWithAlwaysOnRealTimeConnectivity)
{
ApplicationTrigger trigger = new ApplicationTrigger();
if (trigger != null)
{
BackgroundTaskBuilder builder = new BackgroundTaskBuilder();
builder.Name = name;
builder.TaskEntryPoint = entryPoint;
builder.SetTrigger(trigger);
builder.Register();
ApplicationTriggerResult triggerResult = await trigger.RequestAsync();
if (triggerResult == ApplicationTriggerResult.Allowed)
{
result = true;
}
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
return(result);
}
/// <summary>
/// Registrering af diverse baggrundstråde.
/// </summary>
private static async void RegisterBackgroundTasks()
{
var backgroundAccessStatus = await BackgroundExecutionManager.RequestAccessAsync();
if (backgroundAccessStatus != BackgroundAccessStatus.AllowedMayUseActiveRealTimeConnectivity && backgroundAccessStatus != BackgroundAccessStatus.AllowedWithAlwaysOnRealTimeConnectivity)
{
return;
}
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (task.Value.Name == "OSDevGrp.OSIntranet.Gui.Runtime.FinansstyringsnyhederLoaderBackgroundTask")
{
task.Value.Unregister(true);
}
if (task.Value.Name == "OSDevGrp.OSIntranet.Gui.Runtime.FinansstyringSyncDataBackgroundTask")
{
task.Value.Unregister(true);
}
}
var backgoundTaskBuilder = new BackgroundTaskBuilder
{
Name = "OSDevGrp.OSIntranet.Gui.Runtime.FinansstyringsnyhederLoaderBackgroundTask",
TaskEntryPoint = "OSDevGrp.OSIntranet.Gui.Runtime.FinansstyringsnyhederLoaderBackgroundTask"
};
backgoundTaskBuilder.SetTrigger(new TimeTrigger(15, false));
backgoundTaskBuilder.Register();
backgoundTaskBuilder = new BackgroundTaskBuilder
{
Name = "OSDevGrp.OSIntranet.Gui.Runtime.FinansstyringSyncDataBackgroundTask",
TaskEntryPoint = "OSDevGrp.OSIntranet.Gui.Runtime.FinansstyringSyncDataBackgroundTask"
};
backgoundTaskBuilder.SetTrigger(new TimeTrigger(15, false));
backgoundTaskBuilder.Register();
}
private async void btnStartLocal_Click(object sender, RoutedEventArgs e)
{
LocalClient local = ServiceProvider.Clients.FindLocal();
if (local == null || task != null)
{
return;
}
ApplicationTrigger trigger = new ApplicationTrigger();
BackgroundTaskBuilder builder = new BackgroundTaskBuilder();
builder.Name = TaskName;
builder.TaskEntryPoint = TaskEntryPoint;
builder.SetTrigger(trigger);
task = builder.Register();
ValueSet args = new ValueSet();
args["Port"] = local.Port.ToString();
args["Delay"] = local.Delay.ToString();
args["Interval"] = local.Interval.ToString();
if (!String.IsNullOrEmpty(local.AuthenticationToken))
{
args["AuthenticationToken"] = local.AuthenticationToken;
}
ApplicationTriggerResult result = await trigger.RequestAsync(args);
if (result != ApplicationTriggerResult.Allowed)
{
task = null;
}
UpdateLocalButtons();
}
public static async void RegisterBackgroundTask(DeviceKind kind)
{
try
{
BackgroundAccessStatus status = BackgroundAccessStatus.Unspecified;
if (kind == DeviceKind.WindowsPhone)
{
status = await ApplicationManger.CheckAppVersion();
}
else if (kind == DeviceKind.Windows)
{
status = await BackgroundExecutionManager.RequestAccessAsync();
}
if (status == BackgroundAccessStatus.AllowedMayUseActiveRealTimeConnectivity ||
status == BackgroundAccessStatus.AllowedWithAlwaysOnRealTimeConnectivity)
{
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (task.Value.Name == taskName)
{
task.Value.Unregister(true);
}
}
BackgroundTaskBuilder taskBuilder = new BackgroundTaskBuilder();
taskBuilder.Name = taskName;
taskBuilder.TaskEntryPoint = (kind == DeviceKind.Windows) ? taskEntryPointWindows : taskEntryPointWindowsPhone;
taskBuilder.SetTrigger(new TimeTrigger(15, false));
var registration = taskBuilder.Register();
}
}
catch (Exception)
{
//new MessageDialog(e.Message).ShowAsync();
}
}
public async void Run(IBackgroundTaskInstance taskInstance)
{
Debug.WriteLine("Registering successfully.");
_deferral = taskInstance.GetDeferral();
var taskRegistered = false;
var TaskName = "findRandomEvents";
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (task.Value.Name == TaskName)
{
taskRegistered = true;
break;
}
}
if (!taskRegistered)
{
TimeTrigger hourlyTrigger = new TimeTrigger(15, false);
SystemCondition userCondition = new SystemCondition(SystemConditionType.UserPresent);
await BackgroundExecutionManager.RequestAccessAsync();
var builder = new BackgroundTaskBuilder();
builder.Name = TaskName;
builder.TaskEntryPoint = "ZankyoBackgroundTasks.ZBackground";
builder.SetTrigger(hourlyTrigger);
builder.Register();
}
await FindRamdon();
Debug.WriteLine("Task registered successfully.");
_deferral.Complete();
}
