public void TestCleanUp()
{
if (BackgroundTaskHelper.IsBackgroundTaskRegistered("TaskName"))
{
BackgroundTaskHelper.Unregister("TaskName");
}
}
/// <summary>
/// 注销后台任务
/// </summary>
/// <param name="type">类型</param>
public void UnRegisterBackgroundTask(string type)
{
string backgroundTaskName = $"{type}NotificationTask";
if (BackgroundTaskHelper.IsBackgroundTaskRegistered(backgroundTaskName))
{
BackgroundTaskHelper.Unregister(backgroundTaskName);
}
}
/// <summary>
/// Registers a particular bg tasks specified by <paramref name="backgroundTask"/>
/// </summary>
/// <param name="backgroundTask">The background task to register</param>
/// <param name="restart">Indicates if the registration of the bg task is mandatory(True by default)</param>
public static void RegisterBackgroundTask(BackgroundTaskType backgroundTask, int bgTaskInterval = 0, bool restart = true)
{
string bgTaskName;
Type bgTaskType;
IBackgroundTrigger trigger;
var conditions = new List <IBackgroundCondition>();
switch (backgroundTask)
{
case BackgroundTaskType.ANY:
throw new ArgumentException("Is not allowed to register all bg tasks at the same time");
case BackgroundTaskType.SYNC:
bgTaskName = nameof(SyncBackgroundTask);
bgTaskType = typeof(SyncBackgroundTask);
trigger = new TimeTrigger((uint)bgTaskInterval, false);
conditions.Add(new SystemCondition(SystemConditionType.FreeNetworkAvailable));
conditions.Add(new SystemCondition(SystemConditionType.InternetAvailable));
break;
case BackgroundTaskType.MARK_AS_COMPLETED:
bgTaskName = nameof(MarkAsCompletedBackgroundTask);
bgTaskType = typeof(MarkAsCompletedBackgroundTask);
trigger = new ToastNotificationActionTrigger();
break;
default:
throw new ArgumentOutOfRangeException($"Provided bg task {backgroundTask} does not exists");
}
bool isBgTaskAlreadyRegistered = BackgroundTaskHelper.IsBackgroundTaskRegistered(bgTaskType);
if (isBgTaskAlreadyRegistered && !restart)
{
return;
}
if (isBgTaskAlreadyRegistered)
{
UnregisterBackgroundTask(backgroundTask);
}
if (bgTaskInterval <= 0 && backgroundTask != BackgroundTaskType.MARK_AS_COMPLETED)
{
return;
}
BackgroundTaskHelper.Register(
bgTaskName,
trigger,
false,
true,
conditions.ToArray());
}
private bool IsBackgroundTaskRegistered(string taskName)
{
if (BackgroundTaskHelper.IsBackgroundTaskRegistered(taskName))
{
// Background task already registered.
StatusMessage.Text = "Background Task already registered";
return(true);
}
return(false);
}
public void Test_BackgroundTaskHelper_IsBackgroundTaskRegistered_WithValidTask()
{
BackgroundTaskRegistration registeredTask = BackgroundTaskHelper.Register("TaskName", new TimeTrigger(15, true));
if (registeredTask == null)
{
Assert.Inconclusive("Task failed to register");
}
Assert.IsTrue(BackgroundTaskHelper.IsBackgroundTaskRegistered("TaskName"));
}
//--------------------------------------------------------Misc Methods:---------------------------------------------------------------\\
#region --Misc Methods (Public)--
#endregion
#region --Misc Methods (Private)--
/// <summary>
/// Registers the socket background task if necessary.
/// </summary>
public async static Task registerBackgroundTask()
{
if (BackgroundTaskHelper.IsBackgroundTaskRegistered(BACKGROUND_TASK_NAME))
{
removeBackgroundTask();
}
await BackgroundExecutionManager.RequestAccessAsync();
socketTask = BackgroundTaskHelper.Register(BACKGROUND_TASK_NAME, BACKGROUND_TASK_ENTRY_POINT, new SocketActivityTrigger(), false, true);
Logger.Info("Registered the " + BACKGROUND_TASK_NAME + " background task.");
}
public void Test_BackgroundTaskHelper_Unregister()
{
BackgroundTaskHelper.Register("TaskName", new TimeTrigger(15, true));
if (!BackgroundTaskHelper.IsBackgroundTaskRegistered("TaskName"))
{
Assert.Inconclusive("Task failed to register!");
}
BackgroundTaskHelper.Unregister("TaskName");
Assert.IsFalse(BackgroundTaskHelper.IsBackgroundTaskRegistered("TaskName"));
}
public void UpdateWorkRegister()
{
var Timer_Condition = new IBackgroundCondition[] {
new SystemCondition(SystemConditionType.FreeNetworkAvailable)
};
bool HasRegistered = BackgroundTaskHelper.IsBackgroundTaskRegistered(typeof(TileRefreshUtils));
if (Enabled)
{
BackgroundTaskHelper.Register(typeof(TileRefreshUtils), new TimeTrigger(TimerSpan, false), false, true, Timer_Condition);
}
else if (HasRegistered)
{
BackgroundTaskHelper.Unregister(typeof(TileRefreshUtils));
}
}
private async void RegisterButton_Click(object sender, RoutedEventArgs e)
{
if (BackgroundTaskHelper.IsBackgroundTaskRegistered("TestBackgroundTaskName"))
{
// Background task already registered.
StatusMessage.Text = "Background Task already registered";
return;
}
// Check for background access.
await BackgroundExecutionManager.RequestAccessAsync();
BackgroundTaskHelper.Register("TestBackgroundTaskName", new TimeTrigger(15, false));
// If registering Multi-Process Background task
// BackgroundTaskHelper.Register("TestName", "TestEntryPoint", new TimeTrigger(15, false), false, true, new SystemCondition(SystemConditionType.InternetAvailable));
StatusMessage.Text = "Background Task registered";
}
private void RegisterBackgroundTasks()
{
// Remove old Background Tasks
if (BackgroundTaskHelper.IsBackgroundTaskRegistered("NewEpisodesBackgroundTask"))
{
BackgroundTaskHelper.Unregister("NewEpisodesBackgroundTask");
}
// Check if Background Task is already registered and register new ones
if (!BackgroundTaskHelper.IsBackgroundTaskRegistered(typeof(NewEpisodesV2BackgroundTask)))
{
BackgroundTaskHelper.Register(
nameof(NewEpisodesV2BackgroundTask),
new TimeTrigger(15, false),
conditions: new SystemCondition(SystemConditionType.InternetAvailable)
);
}
}
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
//);
}
}
/// <summary>
/// 注册后台任务
/// </summary>
/// <param name="type">注册类型</param>
/// <returns></returns>
public async Task <bool> RegisterBackgroundTask(string type)
{
string backgroundTaskName = $"{type}NotificationTask";
if (BackgroundTaskHelper.IsBackgroundTaskRegistered(backgroundTaskName))
{
return(true);
}
var status = await BackgroundExecutionManager.RequestAccessAsync();
if (status.ToString().Contains("Allowed"))
{
BackgroundTaskHelper.Register(backgroundTaskName, $"BiliBili_Notification.{type}Notification", new TimeTrigger(15, false), false, true, new SystemCondition(SystemConditionType.InternetAvailable));
return(true);
}
else
{
new TipPopup("需要开启后台通知").ShowError();
return(false);
}
}
/// <summary>
/// Performs a registration of a background task.
/// </summary>
private async void RegisterBackgroundTask()
{
const string taskName = "ArcadeBackgroundTask";
const string taskEntryPoint = "BackgroundTasks.ArcadeBackgroundTask";
var accessStatus = await BackgroundExecutionManager.RequestAccessAsync();
var isRegistered = BackgroundTaskHelper.IsBackgroundTaskRegistered(taskName);
if (accessStatus == BackgroundAccessStatus.DeniedByUser ||
accessStatus == BackgroundAccessStatus.DeniedBySystemPolicy ||
isRegistered)
{
return;
}
var trigger = new TimeTrigger(120, false);
BackgroundTaskHelper.Register(taskName,
taskEntryPoint,
trigger,
conditions: new SystemCondition(SystemConditionType.InternetAvailable));
}
private async void RegisterWorks()
{
foreach (var t in BackgroundTaskRegistration.AllTasks)
{
t.Value.Unregister(true);
}
if (!BackgroundTaskHelper.IsBackgroundTaskRegistered(NameManager.LIVETILETASK_Timer))
{
await BackgroundExecutionManager.RequestAccessAsync();
BackgroundTaskHelper.Register(
NameManager.LIVETILETASK_Timer,
typeof(TileRefreshUtils).FullName,
new TimeTrigger(15, false));
}
if (!BackgroundTaskHelper.IsBackgroundTaskRegistered(NameManager.LIVETILETASK_NetWorkChanged))
{
await BackgroundExecutionManager.RequestAccessAsync();
BackgroundTaskHelper.Register(
NameManager.LIVETILETASK_NetWorkChanged,
typeof(TileRefreshUtils).FullName,
new SystemTrigger(SystemTriggerType.NetworkStateChange, false));
}
if (!BackgroundTaskHelper.IsBackgroundTaskRegistered(NameManager.LIVETILETASK_UserPresent))
{
await BackgroundExecutionManager.RequestAccessAsync();
BackgroundTaskHelper.Register(
NameManager.LIVETILETASK_UserPresent,
typeof(TileRefreshUtils).FullName,
new SystemTrigger(SystemTriggerType.SessionConnected, false)
);
}
}
/// <summary>
/// 在应用程序由最终用户正常启动时进行调用。
/// 将在启动应用程序以打开特定文件等情况下使用。
/// </summary>
/// <param name="e">有关启动请求和过程的详细信息。</param>
protected override async void OnLaunched(LaunchActivatedEventArgs e)
{
if (e.Kind == ActivationKind.Protocol)
{
return;
}
var t = Task.Run(async() =>
{
if (BackgroundTaskHelper.IsBackgroundTaskRegistered(Consts.PodcastTaskName))
{
// Background task already registered.
//Unregister
BackgroundTaskHelper.Unregister(Consts.PodcastTaskName);
}
// Check for background access (optional)
await BackgroundExecutionManager.RequestAccessAsync();
// Register (Multi Process) w/ Conditions.
BackgroundTaskHelper.Register(Consts.PodcastTaskName, typeof(PodcastsFetcher).FullName, new TimeTrigger(Settings.Current.FetchInterval, false), true, true, new SystemCondition(SystemConditionType.InternetAvailable));
});
if (e.PrelaunchActivated == false)
{
TryDisablePrelaunch();
if (Window.Current.Content == null)
{
CreateRootFrame(e.PreviousExecutionState);
}
if (e.Arguments.StartsWith("as-music:", StringComparison.InvariantCultureIgnoreCase) && Uri.TryCreate(e.Arguments, UriKind.Absolute, out var u))
{
await NavigateByProtocol(u);
return;
}
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 (Settings.Current.WelcomeFinished)
{
rootFrame.Navigate(typeof(MainPage), e.Arguments);
}
else
{
rootFrame.Navigate(typeof(WelcomePage), e.Arguments);
}
}
// 确保当前窗口处于活动状态
Window.Current.Activate();
}
else
{
CreateRootFrame(e.PreviousExecutionState);
if (e.Arguments.StartsWith("as-music:", StringComparison.InvariantCultureIgnoreCase) && Uri.TryCreate(e.Arguments, UriKind.Absolute, out var u))
{
await NavigateByProtocol(u);
return;
}
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 (Settings.Current.WelcomeFinished)
{
rootFrame.Navigate(typeof(MainPage), e.Arguments);
}
else
{
rootFrame.Navigate(typeof(WelcomePage), e.Arguments);
}
}
}
}
public void Test_BackgroundTaskHelper_IsBackgroundTaskRegistered_NoTask()
{
Assert.IsFalse(BackgroundTaskHelper.IsBackgroundTaskRegistered("TaskName"));
}
private async Task PerformAsyncWork(string path)
{
App.IsLoading = true;
// Set the app language
ApplicationLanguages.PrimaryLanguageOverride =
string.IsNullOrEmpty(SettingsService.Instance.CurrentAppLanguage)
? ApplicationLanguages.Languages[0]
: SettingsService.Instance.CurrentAppLanguage;
// Set the on back requested event
SystemNavigationManager.GetForCurrentView().BackRequested += OnBackRequested;
// Navigate to the first page
await HandleProtocolAsync(path);
// Handle donation logic
await MonitizeService.Instance.InitProductInfoAsync();
// Test Version and tell user app upgraded
HandleNewAppVersion();
// Clear the unread badge
BadgeUpdateManager.CreateBadgeUpdaterForApplication().Clear();
// The methods below are sorted into try catch groups. many of them can fail, but they are not important
try
{
// Get the store and check for app updates
var updates = await StoreContext.GetDefault().GetAppAndOptionalStorePackageUpdatesAsync();
// If we have updates navigate to the update page where we
// ask the user if they would like to update or not (depending
// if the update is mandatory or not).
if (updates.Count > 0)
{
await new PendingUpdateDialog().ShowAsync();
}
}
catch
{
// Ignore
}
try
{
var engagementManager = StoreServicesEngagementManager.GetDefault();
await engagementManager.RegisterNotificationChannelAsync();
}
catch
{
// Ignore
}
try
{
// Install Cortana Voice Commands
var vcdStorageFile = await Package.Current.InstalledLocation.GetFileAsync(@"SoundByteCommands.xml");
await VoiceCommandDefinitionManager.InstallCommandDefinitionsFromStorageFileAsync(vcdStorageFile);
}
catch
{
// Ignore
}
try
{
// Register the background task
if (!BackgroundTaskHelper.IsBackgroundTaskRegistered("NotificationTask"))
{
BackgroundTaskHelper.Register("NotificationTask", "SoundByte.Notifications.NotificationTask",
new TimeTrigger(15, false));
}
}
catch
{
// Ignore
}
}
