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();
}
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);
}
}
public async Task InitializeBackgroundGeolocation()
{
// Loop through all background tasks to see if SampleGeofenceBackgroundTask is already registered
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (task.Value.Name == Constants.ApplicationTriggerBackgroundTaskName)
{
_applicationTriggerBackgroundTask = task.Value;
}
}
if (_applicationTriggerBackgroundTask == null)
{
// Create a new trigger
//applicationtrigger = new ApplicationTrigger();
SystemCondition condition = new SystemCondition(SystemConditionType.UserNotPresent | SystemConditionType.InternetAvailable);
_applicationTriggerBackgroundTask = await BackgroundTaskHelper.RegisterBackgroundTask(
Constants.ApplicationTriggerBackgroundTaskEntryPoint,
Constants.ApplicationTriggerBackgroundTaskName,
applicationtrigger,
null);
var result = await applicationtrigger.RequestAsync();
if (result.Equals(ApplicationTriggerResult.Allowed))
{
Toast.ShowToast("Location Monitoring Started");
}
}
await LoadExitingLocations();
}
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 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 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 async void RunBackgroudTask(object sender, RoutedEventArgs e)
{
var valueSet = new ValueSet {
{ "CT", 1 }
};
ApplicationTriggerResult applicationTriggerResult = await _applicationTrigger.RequestAsync(valueSet);
switch (applicationTriggerResult)
{
case ApplicationTriggerResult.Allowed:
break;
case ApplicationTriggerResult.CurrentlyRunning:
break;
case ApplicationTriggerResult.DisabledByPolicy:
break;
case ApplicationTriggerResult.UnknownError:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
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;
}
}
public override async void Trigger() //AJS
{
_cancelRequested = false;
await trigger.RequestAsync();
// https://stackoverflow.com/questions/51914667/uwp-start-background-task-at-startup
}
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; }
}
/// <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);
}
}
}
public async Task Start(IEnumerable <SyncPair> syncs, Api api, bool isTestRun = false, SyncMode?mode = null)
{
bool addedHandler = false;
foreach (SyncPair pair in syncs)
{
SyncPairHandler handler;
if (handlers.TryGetValue(pair.Token, out handler) && !handler.IsEnded)
{
continue;
}
handler = SyncPairHandler.FromSyncPair(pair, api, isTestRun, mode);
Queue.Enqueue(handler);
handlers[handler.Token] = handler;
AddedHandler?.Invoke(this, handler);
addedHandler = true;
}
if (!addedHandler || IsRunning)
{
return;
}
if (appTrigger == null)
{
RegisterAppBackgroundTask();
}
await appTrigger.RequestAsync();
}
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();
}
}
}
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();
}
}
/// <summary>
/// Runs after the service is completed.
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
protected void TaskCompleted(BackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs args)
{
Task.Run(async() =>
{
foreach (var item in BackgroundJobs)
{
var result = await item.RunAsync();
//Update database, because job is finished.
if (!result)
{
item.Dispose();
BackgroundJobs.Remove(item);
return;
}
}
if (BackgroundJobs.Count == 0)
{
return;
}
//Repeat it.
await _trigger.RequestAsync();
}).Wait();
}
/// <summary>
/// Signal a ApplicationTriggerTask.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void SignalBackgroundTask(object sender, RoutedEventArgs e)
{
// Reset the completion status
var settings = ApplicationData.Current.LocalSettings;
//Signal the ApplicationTrigger
var result = await trigger.RequestAsync();
}
public async Task Start()
{
if (appTrigger == null)
{
RegisterAppBackgroundTask();
}
await appTrigger.RequestAsync();
}
private async void StartBackgroundTask()
{
// Reset the completion status
var settings = ApplicationData.Current.LocalSettings;
settings.Values.Remove(LocalDataStore.BackgroundTriggerName);
//Signal the ApplicationTrigger
var result = await taskTrigger.RequestAsync();
}
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);
}
/// <summary>
/// Signal a ApplicationTriggerTask.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void SignalBackgroundTask(object sender, RoutedEventArgs e)
{
// Reset the completion status
BackgroundTaskSample.TaskStatuses.Remove(BackgroundTaskSample.ApplicationTriggerTaskName);
//Signal the ApplicationTrigger
var result = await trigger.RequestAsync();
BackgroundTaskSample.ApplicationTriggerTaskResult = "Signal result: " + result.ToString();
UpdateUI();
}
protected async override void OnNavigatedTo(NavigationEventArgs e)
{
try
{
await RegisterBackgroundTask();
await _appTrigger.RequestAsync();
}
catch (Exception ex)
{
}
}
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();
});
}
/// <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();
}
private async Task <ApplicationTriggerResult> StarTaskAsync()
{
const string TaskName = "TweLiteMonitor-uwp";
foreach (var t in BackgroundTaskRegistration.AllTasks)
{
if (t.Value.Name == TaskName)
{
t.Value.Unregister(true);
//return ApplicationTriggerResult.CurrentlyRunning;
}
}
var builder = new BackgroundTaskBuilder
{
Name = TaskName,
TaskEntryPoint = typeof(MonitorTask).FullName
};
var trigger = new ApplicationTrigger();
builder.SetTrigger(trigger);
await BackgroundExecutionManager.RequestAccessAsync();
taskRegistration = builder.Register();
taskRegistration.Completed += async(sender, args) =>
{
AppendLog("BackgroundTask Completed");
if (!InPage)
{
return;
}
// restart when ExecutionTimeExceeded
var restarted = await trigger.RequestAsync();
AppendLog(string.Format("Restart BackgroundTask: {0}", restarted));
};
var result = await trigger.RequestAsync();
AppendLog(string.Format("Start BackgroundTask: {0}", result));
return(result);
}
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 SignalBackgroundTask(object sender, RoutedEventArgs e)
{
// Reset the completion status
var settings = ApplicationData.Current.LocalSettings;
settings.Values.Remove(LocalDataStore.BackgroundTriggerName);
//Signal the ApplicationTrigger
var result = await trigger.RequestAsync();
//BackgroundTaskSample.ApplicationTriggerTaskResult = "Signal result: " + result.ToString();
//UpdateUI();
}
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 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 static async Task <bool> RegisterAllBackgroundTasksAsyncHelper(bool runAppTrigger)
{
// Check for background registration permissions.
var status = await BackgroundExecutionManager.RequestAccessAsync();
Debug.WriteLine("BackgroundExecutionManager.RequestAccessAsync returned status " + status);
if (status == BackgroundAccessStatus.DeniedBySystemPolicy ||
status == BackgroundAccessStatus.DeniedByUser)
{
Debug.WriteLine("Cannot register background tasks. TODO: Notify user?");
return(false);
}
// TODO: Remove this after development
//UnregisterAllBackgroundTasks();
// Background task parameters.
ApplicationTrigger appTrigger = new ApplicationTrigger();
SystemTrigger sessionConnectedTrigger = new SystemTrigger(SystemTriggerType.SessionConnected, false);
SystemCondition userPresentCondition = new SystemCondition(SystemConditionType.UserPresent);
SystemCondition internetCondition = new SystemCondition(SystemConditionType.InternetAvailable);
/**
* App store update task registration
*/
// Trigger the task to run when the app launches.
_ = RegisterBackgroundTask(
CheckStoreUpdatesApp, CheckStoreUpdatesEntry,
appTrigger,
new[] { internetCondition }
);
// Trigger the task to run when the user logs in, i.e. startup, logon.
_ = RegisterBackgroundTask(
CheckStoreUpdatesSession, CheckStoreUpdatesEntry,
sessionConnectedTrigger,
new[] { userPresentCondition, internetCondition }
);
// Run background tasks that should start when the app is launched.
if (runAppTrigger)
{
ApplicationTriggerResult result = await appTrigger.RequestAsync();
Debug.WriteLine("ApplicationTrigger result is" + result);
}
return(true);
}
private async void TryStartTask()
{
if (task != null)
{
IBackgroundTaskRegistration2 task2 = task as IBackgroundTaskRegistration2;
if (task2 != null)
{
ApplicationTrigger trigger = task2.Trigger as ApplicationTrigger;
if (trigger != null)
{
await trigger.RequestAsync();
}
}
}
}
private async void Start_Click()
{
string text = dictationTextBox.Text;
int length = dictationTextBox.Text.Length;
int position = 0;
if (length >= 2000)
{
while (position <= length)
{
string partStr;
int delta = length - position;
if (delta < 2000)
{
partStr = text.Substring(position, delta);
}
else
{
partStr = text.Substring(position, 2000);
}
ApplicationData.Current.RoamingSettings.Values["dictationText" + position.ToString()] = partStr;
position += 2000;
}
}
else
{
ApplicationData.Current.RoamingSettings.Values["dictationText"] = text;
}
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(BackgroundTask.AutoSaveFile).ToString();
ApplicationTrigger appTrigger = new ApplicationTrigger();
taskBuilder.SetTrigger(appTrigger);
task = taskBuilder.Register();
//task.Progress += Task_Progress;
task.Completed += Task_Completed;
await appTrigger.RequestAsync();
}
}
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; }
}
