public override async Task <IWorkbook> ConfigureAsync(Frame rootFrame)
{
if (rootFrame == null)
{
throw new ArgumentNullException(nameof(rootFrame));
}
bool sendAnalytics = WinSettings.Instance.GetValue <bool>(CoreSettings.SendAnalytics);
string deviceId = "n/a";
try
{
var settings = WinSettings.Instance;
if (!settings.HasValue(CoreSettings.DeviceId) || settings.GetValue <string>(CoreSettings.DeviceId) == "N/A")
{
string id = this.ComputeDeviceId();
settings.SetValue(CoreSettings.DeviceId, id);
}
deviceId = settings.GetValue <string>(CoreSettings.DeviceId);
}
catch (Exception ex)
{
TrackingManagerHelper.Exception(ex, "Error while setting device id");
}
var platformService = new PlatformService(this.version, deviceId, () => CrashHandler.GetDiagnosticsInformation());
Ioc.RegisterInstance <IPlatformService, PlatformService>(platformService);
TrackingManager trackingManager = new TrackingManager(sendAnalytics, platformService.DeviceFamily);
Ioc.RegisterInstance <ITrackingManager, TrackingManager>(trackingManager);
HttpClientHandler.Setup();
ResourcesLocator.Initialize("ms-appx://", UriKind.Absolute);
if (!WinSettings.Instance.GetValue <bool>(CoreSettings.UseDarkTheme))
{
ResourcesLocator.UpdateTheme(true);
}
var persistence = Ioc.RegisterInstance <IPersistenceLayer, WinPersistenceLayer>(new WinPersistenceLayer(automaticSave: true));
LogService.Log("Bootstraper", string.Format("Version: {0}", ApplicationVersion.GetAppVersion()));
var navigationService = new NavigationService(rootFrame, platformService);
Ioc.RegisterInstance <INavigationService, NavigationService>(navigationService);
var messageBoxService = new MessageBoxService(navigationService);
Ioc.RegisterInstance <IMessageBoxService, MessageBoxService>(messageBoxService);
Ioc.RegisterInstance <ISpeechService, SpeechService>(new SpeechService(messageBoxService));
var workbook = this.InitializeWorkbook(persistence, platformService);
// we just read the latest value of data from the DB, so even if there was a background sync
// we now have the latest version, so we remove the background sync flag here
workbook.Settings.SetValue(CoreSettings.SyncBackgroundOccured, false);
this.keyboardShortcutManager = new KeyboardShortcutManager(workbook, rootFrame, navigationService, trackingManager);
var backgroundTaskManager = new BackgroundTaskManager(workbook);
backgroundTaskManager.InitializeAsync();
Ioc.RegisterInstance <IBackgroundTaskManager, BackgroundTaskManager>(backgroundTaskManager);
var notificationService = new NotificationService();
Ioc.RegisterInstance <INotificationService, NotificationService>(notificationService);
var startupManager = Ioc.Build <StartupManager>();
Ioc.RegisterInstance <IStartupManager, StartupManager>(startupManager);
Ioc.RegisterInstance <IAlarmManager, AlarmManager>(new AlarmManager(workbook));
var tileManager = new TileManager(workbook, trackingManager, notificationService, false);
tileManager.LoadSecondaryTilesAsync();
Ioc.RegisterInstance <ITileManager, TileManager>(tileManager);
var synchronizationManager = await InitializeSyncAsync(workbook, platformService, trackingManager);
// it is important to remove old task after sync is initialized otherwise changes would not
// tracked and put in the changelog for the next sync
workbook.RemoveOldTasks();
var cortanaService = new CortanaRuntimeService(workbook);
// no need to await this call because it can runs in the background
Task.Run(() =>
{
JumpListManager.SetupJumpListAsync();
cortanaService.SetupDefinitionsAsync();
});
Ioc.RegisterInstance <ICortanaRuntimeService, CortanaRuntimeService>(cortanaService);
return(workbook);
}
public async void SafeRun(IBackgroundTaskInstance taskInstance)
{
bool hadException = false;
// Register to receive an event if Cortana dismisses the background task. This will
// occur if the task takes too long to respond, or if Cortana's UI is dismissed.
// Any pending operations should be cancelled or waited on to clean up where possible.
taskInstance.Canceled += this.OnTaskCanceled;
WinSettings.Instance.SetValue(CoreSettings.BackgroundLastStartExecution, DateTime.Now);
ReportStatus(BackgroundExecutionStatus.Started);
LogService.Initialize(new WinLogHandler());
LogService.Level = WinSettings.Instance.GetValue <LogLevel>(CoreSettings.LogLevel);
ResourcesLocator.Initialize("ms-appx://", UriKind.Absolute);
var mutex = new Mutex(false, Constants.SyncPrimitiveAppRunningForeground);
if (!mutex.WaitOne(1))
{
LogService.Log("Agent", "Skipping background agent because app is foreground");
await LogService.SaveAsync();
this.deferral.Complete();
ReportStatus(BackgroundExecutionStatus.Skipped);
return;
}
ITrackingManager trackingManager = null;
try
{
this.persistenceLayer = new WinPersistenceLayer(automaticSave: false);
var deviceFamily = DeviceFamily.Unkown;
if (AnalyticsInfo.VersionInfo.DeviceFamily.Equals("Windows.Desktop", StringComparison.OrdinalIgnoreCase))
{
deviceFamily = DeviceFamily.WindowsDesktop;
}
else if (AnalyticsInfo.VersionInfo.DeviceFamily.Equals("Windows.Mobile", StringComparison.OrdinalIgnoreCase))
{
deviceFamily = DeviceFamily.WindowsMobile;
}
trackingManager = new TrackingManager(false, deviceFamily);
var workbook = this.persistenceLayer.Open(tryUpgrade: true) as Workbook;
if (workbook != null)
{
ReportStatus(BackgroundExecutionStatus.WorkbookLoaded);
Ioc.RegisterInstance <IWorkbook, Workbook>(workbook);
workbook.Initialize();
// important: load alarm manager so that we update reminders properly is a recurring task is created
var alarmManager = new AlarmManager(workbook);
var backgroundSyncManager = new BackgroundSynchronizationManager(workbook, trackingManager, ToastHelper.ToastMessage);
await backgroundSyncManager.SetupAsync();
if (backgroundSyncManager.CanSync())
{
ReportStatus(BackgroundExecutionStatus.SyncStarted);
this.synchronizationManager = backgroundSyncManager.SynchronizationManager;
if (workbook.Settings.GetValue <bool>(CoreSettings.BackgroundToast))
{
this.synchronizationManager.OperationCompleted += (s, e) => ToastHelper.ToastMessage(e.Item);
this.synchronizationManager.OperationFailed += (s, e) => ToastHelper.ToastMessage(e.Message);
}
bool result = await backgroundSyncManager.TrySyncAsync(this.persistenceLayer);
if (result)
{
ReportStatus(BackgroundExecutionStatus.SyncCompleted);
}
else
{
ReportStatus(BackgroundExecutionStatus.SyncError);
}
}
// update tiles
ReportStatus(BackgroundExecutionStatus.TileStarted);
TileManager timeManager = new TileManager(workbook, trackingManager, null, true);
await timeManager.LoadSecondaryTilesAsync();
timeManager.UpdateTiles();
ReportStatus(BackgroundExecutionStatus.TileCompleted);
// save log
await LogService.SaveAsync();
}
else
{
ReportStatus(BackgroundExecutionStatus.WorkbookNotLoaded);
}
}
catch (Exception ex)
{
hadException = true;
LogService.Level |= LogLevel.Debug;
LogService.Log("WinBackgroundTaskHelper", "Exception during background execution: " + ex.GetAllMessages());
if (trackingManager != null)
{
trackingManager.Exception(ex, "Exception Background task helper");
}
ReportStatus(BackgroundExecutionStatus.CompletedException);
}
if (!hadException)
{
ReportStatus(BackgroundExecutionStatus.CompletedSuccess);
}
await LogService.SaveAsync();
WinSettings.Instance.SetValue(CoreSettings.BackgroundLastEndExecution, DateTime.Now);
this.deferral.Complete();
}
