// Handle background task completion event.
private async void OnCompleted(IBackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs e)
{
// Update the UI with the complrtion status reported by the background task.
// Dispatch an anonymous task to the UI thread to do the update.
await sampleDispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
try
{
if ((sender != null) && (e != null))
{
// this method throws if the event is reporting an error
e.CheckResult();
// Update the UI with the background task's completion status.
// The task stores status in the application data settings indexed by the task ID.
var key = sender.TaskId.ToString();
var settings = ApplicationData.Current.LocalSettings;
BackgroundTaskStatus.Text = settings.Values[key].ToString();
}
}
catch (Exception ex)
{
rootPage.NotifyUser(ex.ToString(), NotifyType.ErrorMessage);
}
});
}
/// <summary>
/// Background task completion handler. When authenticating through the foreground app, this triggers the authentication flow if the app is currently running.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public async void OnBackgroundTaskCompleted(IBackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs e)
{
// Update the UI with progress reported by the background task.
await coreDispatcher.RunAsync(CoreDispatcherPriority.Normal,
new DispatchedHandler(() =>
{
try
{
if ((sender != null) && (e != null))
{
// If the background task threw an exception, display the exception in the error text box.
e.CheckResult();
// Update the UI with the completion status of the background task
// The Run method of the background task sets this status.
if (sender.Name == BackgroundTaskName)
{
rootPage.NotifyUser("Background task completed", NotifyType.StatusMessage);
// Signal callback for foreground authentication
if (!ConfigStore.AuthenticateThroughBackgroundTask && ForegroundAuthenticationCallback != null)
{
ForegroundAuthenticationCallback(this, null);
}
}
}
}
catch (Exception ex)
{
rootPage.NotifyUser(ex.ToString(), NotifyType.ErrorMessage);
}
}));
}
/// <summary>
/// This is the callback when background event has been handled
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
async private void OnCompleted(IBackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs e)
{
if (sender != null)
{
// Update the UI with progress reported by the background task
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
try
{
// If the background task threw an exception, display the exception in
// the error text box.
e.CheckResult();
// Update the UI with the completion status of the background task
// The Run method of the background task sets the LocalSettings.
var settings = ApplicationData.Current.LocalSettings;
// get status
if (settings.Values.ContainsKey("Status"))
{
rootPage.NotifyUser(settings.Values["Status"].ToString(), NotifyType.StatusMessage);
}
FillEventListBoxWithExistingEvents();
}
catch (Exception ex)
{
// The background task had an error
rootPage.NotifyUser(ex.ToString(), NotifyType.ErrorMessage);
}
});
}
}
//处理通知
private async void Task_Completed(BackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs args)
{
if (sender != null)
{
// Update the UI with progress reported by the background task.
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
try
{
// If the background task threw an exception, display the exception in
// the error text box.
args.CheckResult();
// Update the UI with the completion status of the background task.
// The Run method of the background task sets the LocalSettings.
// var settings = ApplicationData.Current.LocalSettings;
// Get the status.
// Do your app work here.
showMessage("围栏过期");
}
catch (Exception ex)
{
// The background task had an error.
// rootPage.NotifyUser(ex.ToString(), NotifyType.ErrorMessage);
Debug.Write(ex.Message);
}
});
}
}
private void WeatherUpdateTaskOnCompleted(BackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs args)
{
try
{
args.CheckResult();
WeatherCondition condition;
Enum.TryParse(GetSetting("weather.condition"), out condition);
double celsius;
double.TryParse(GetSetting("weather.celsius"), out celsius);
double fahrenheit;
double.TryParse(GetSetting("weather.fahrenheit"), out fahrenheit);
CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Weather = new WeatherForecast()
{
Condition = condition,
TemperatureCelsius = celsius,
TemperatureFahrenheit = fahrenheit
};
});
}
catch (Exception exc)
{
new MessageDialog(exc.Message).ShowAsync();
}
}
/// <summary>
/// Event handle to be raised when the background task is completed
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void OnCompleted(IBackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs e)
{
if (sender != null)
{
// Update the UI with progress reported by the background task
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
try
{
// If the background task threw an exception, display the exception in
// the error text box.
e.CheckResult();
// Update the UI with the completion status of the background task
// The Run method of the background task sets this status.
var settings = ApplicationData.Current.LocalSettings;
if (settings.Values["Status"] != null)
{
_rootPage.NotifyUser(settings.Values["Status"].ToString(), NotifyType.StatusMessage);
}
// Extract and display location data set by the background task if not null
ScenarioOutput_Latitude.Text = (settings.Values["Latitude"] == null) ? "No data" : settings.Values["Latitude"].ToString();
ScenarioOutput_Longitude.Text = (settings.Values["Longitude"] == null) ? "No data" : settings.Values["Longitude"].ToString();
ScenarioOutput_Accuracy.Text = (settings.Values["Accuracy"] == null) ? "No data" : settings.Values["Accuracy"].ToString();
}
catch (Exception ex)
{
// The background task had an error
_rootPage.NotifyUser(ex.ToString(), NotifyType.ErrorMessage);
}
});
}
}
private async void OnBackgroundTaskCompleted(BackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs args)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
try
{
args.CheckResult();
if (ApplicationData.Current.LocalSettings.Values.ContainsKey("TaskCancelationReason"))
{
string cancelationReason = (string)ApplicationData.Current.LocalSettings.Values["TaskCancelationReason"];
Error = cancelationReason;
}
}
catch (Exception ex)
{
Error = "Exception" + ex.Message;
}
#warning unregisters the background task
if (null != saferAccelerometerRegistrationManual)
{
saferAccelerometerRegistrationManual.Unregister(false);
saferAccelerometerRegistrationManual = null;
}
});
}
private async void GeofenceTask_Completed(BackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs args)
{
if (sender != null)
{
// Update the UI with progress reported by the background task
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
try
{
// If the background task threw an exception, display the exception
args.CheckResult();
var settings = ApplicationData.Current.LocalSettings;
// get status
if (settings.Values.ContainsKey("Status"))
{
Status.Text = settings.Values["Status"].ToString();
}
}
catch (Exception ex)
{
ShowMessage(ex.Message);
}
});
}
}
/// <summary>
/// Event handler called when the background task is completed
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void OnCompleted(IBackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs e)
{
// Update the UI with progress reported by the background task
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
try
{
// Rethrow any exception that occurred in the background task.
e.CheckResult();
// Update the UI with the completion status of the background task
// The Run method of the background task sets this status.
MainPage.ReportSavedStatus();
// Extract and display location data set by the background task if not null
ScenarioOutput_Latitude.Text = MainPage.LookupSavedString("Latitude", "No data");
ScenarioOutput_Longitude.Text = MainPage.LookupSavedString("Longitude", "No data");
ScenarioOutput_Accuracy.Text = MainPage.LookupSavedString("Accuracy", "No data");
}
catch (Exception ex)
{
// The background task had an error
_rootPage.NotifyUser(ex.ToString(), NotifyType.ErrorMessage);
}
});
}
/// <summary>
/// This is the background task completion handler.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void OnBackgroundTaskCompleted(BackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs e)
{
// Dispatch to the UI thread to display the output.
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
// An exception may be thrown if an error occurs in the background task.
try
{
e.CheckResult();
if (ApplicationData.Current.LocalSettings.Values.ContainsKey("TaskCancelationReason"))
{
string cancelationReason = (string)ApplicationData.Current.LocalSettings.Values["TaskCancelationReason"];
rootPage.NotifyUser("Background task was stopped, reason: " + cancelationReason, NotifyType.StatusMessage);
}
}
catch (Exception ex)
{
rootPage.NotifyUser("Exception in background task: " + ex.Message, NotifyType.ErrorMessage);
}
_refreshTimer.Stop();
});
// Unregister the background task and let the remaining task finish until completion.
if (null != _deviceUseBackgroundTaskRegistration)
{
_deviceUseBackgroundTaskRegistration.Unregister(false);
_deviceUseBackgroundTaskRegistration = null;
}
}
/// <summary>
/// This is the callback when background event has been handled
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnCompleted(IBackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs e)
{
if (sender != null)
{
try
{
// If the background task threw an exception, display the exception in
// the error text box.
e.CheckResult();
// Update the UI with the completion status of the background task
// The Run method of the background task sets the LocalSettings.
var settings = ApplicationData.Current.LocalSettings;
// get status
if (settings.Values.ContainsKey("Status"))
{
//_rootPage.NotifyUser(settings.Values["Status"].ToString(), NotifyType.StatusMessage);
}
//FillEventListBoxWithExistingEvents();
}
catch { }
}
}
/// <summary>
/// This is the callback when background event has been handled
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void OnCompleted(IBackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs e)
{
try
{
// Update the UI with progress reported by the background task
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
try
{
// If the background task threw an exception, display the exception in
// the status text box.
e.CheckResult();
}
catch (Exception ex)
{
// The background task had an error
ShowStatus(ex.ToString());
}
});
await RestoreStateAsync();
await AttemptDeferredCheckinsAsync();
await LogBackgroundEventsAsync();
}
catch (Exception exception)
{
Logger.Trace(TraceLevel.Error, "Background Task: OnCompleted exception " + Logger.FormatException(exception));
}
}
/// <summary>
/// Called when background task defferal is completed. This can happen for a number of reasons (both expected and unexpected).
/// IF this is expected, we'll notify the user. If it's not, we'll show that this is an error. Finally, clean up the connection by calling Disconnect().
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private async void OnCompleted(BackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs args)
{
var settings = ApplicationData.Current.LocalSettings;
if (settings.Values.ContainsKey("TaskCancelationReason"))
{
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
rootPage.NotifyUser("Task cancelled unexpectedly - reason: " + settings.Values["TaskCancelationReason"].ToString(), NotifyType.ErrorMessage);
});
}
else
{
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
rootPage.NotifyUser("Background task completed", NotifyType.StatusMessage);
});
}
try
{
args.CheckResult();
}
catch (Exception ex)
{
rootPage.NotifyUser(ex.Message, NotifyType.ErrorMessage);
}
Disconnect();
}
/// <summary>
/// background task completion handler
///
/// </summary>
private async void OnCompleted(IBackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs e)
{
// Update the UI with the completion status reported by the background task.
// Dispatch an anonymous task to the UI thread to do the update.
await sampleDispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
try
{
e.CheckResult();
// get the completion status
var key = sender.TaskId.ToString() + "_type";
var settings = ApplicationData.Current.LocalSettings;
var status = settings.Values[key].ToString();
if ((status == NetworkOperatorEventMessageType.TetheringOperationalStateChanged.ToString()) ||
(status == NetworkOperatorEventMessageType.TetheringNumberOfClientsChanged.ToString()))
{
UpdateUIWithTetheringState();
}
}
catch (Exception ex)
{
rootPage.NotifyUser("Unexpected exception occured: " + ex.ToString(), NotifyType.ErrorMessage);
}
});
}
/// <summary>
/// Reopen the device after the background task is done syncing. Notify the UI of how many bytes we wrote to the device.
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private async void OnSyncWithDeviceCompleted(BackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs args)
{
isSyncing = false;
// Exception may be thrown if an error occurs during running the background task
args.CheckResult();
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
new DispatchedHandler(async() =>
{
// Reopen the device once the background task is completed
// Don't attempt to reconnect if the device failed to connect
var isDeviceSuccessfullyConnected = await EventHandlerForDevice.Current.OpenDeviceAsync(syncDeviceInformation, syncDeviceSelector);
if (!isDeviceSuccessfullyConnected)
{
EventHandlerForDevice.Current.IsEnabledAutoReconnect = false;
}
syncDeviceInformation = null;
syncDeviceSelector = null;
// Since we are navigating away, don't touch the UI; we don't care what the output/result of the background task is
if (!navigatedAway)
{
var taskCompleteStatus = (String)ApplicationData.Current.LocalSettings.Values[LocalSettingKeys.SyncBackgroundTaskStatus];
if (taskCompleteStatus == SyncBackgroundTaskInformation.TaskCompleted)
{
UInt32 totalBytesWritten = (UInt32)ApplicationData.Current.LocalSettings.Values[LocalSettingKeys.SyncBackgroundTaskResult];
// Set the progress bar to be completely filled in case the progress was not updated (this can happen if the app is suspended)
SyncProgressBar.Value = 100;
rootPage.NotifyUser("Sync: Wrote " + totalBytesWritten.ToString() + " bytes to the device", NotifyType.StatusMessage);
}
else if (taskCompleteStatus == SyncBackgroundTaskInformation.TaskCanceled)
{
// Reset the progress bar in case the progress was not updated (this can happen if the app is suspended)
SyncProgressBar.Value = 0;
rootPage.NotifyUser("Syncing was canceled", NotifyType.StatusMessage);
}
UpdateButtonStates();
}
// Remove all local setting values
ApplicationData.Current.LocalSettings.Values.Clear();
}));
// Unregister the background task and let the remaining task finish until completion
if (backgroundSyncTaskRegistration != null)
{
backgroundSyncTaskRegistration.Unregister(false);
}
}
private void OnCompleted(IBackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs e)
{
try
{
e.CheckResult();
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
}
/// <summary>
/// This is the event handler for background task completion.
/// </summary>
/// <param name="task">The task that is reporting completion.</param>
/// <param name="args">The completion report arguments.</param>
private void OnCompleted(IBackgroundTaskRegistration task, BackgroundTaskCompletedEventArgs args)
{
string status = "Completed";
try
{
args.CheckResult();
}
catch (Exception e)
{
status = e.Message;
}
UpdateUIAsync(status);
}
private void OnCompleted(IBackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs e)
{
if (sender != null)
{
// If the background task threw an exception, display the exception in
// the error text box.
e.CheckResult();
LocationChanged();
// if( settings.Values[ "Longitude" ] != null )
// if( settings.Values[ "Accuracy" ] != null )
}
}
private void RegisteredOnCompleted(BackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs args)
{
var messageDict = new Dictionary <string, string>();
try
{
args.CheckResult();
messageDict.Add("Successful", "true");
} catch (Exception ex)
{
messageDict.Add("Successful", "false");
messageDict.Add("Exception", ex.ToString());
}
Analytics.TrackEvent("Sync Backup Task finished", messageDict);
}
public void OnTaskCompleted(BackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs args)
{
Debug.WriteLine("BackgroundAudioRun.TaskOnCompleted() " + _id);
try
{
args.CheckResult();
}
catch (Exception ex)
{
Debug.WriteLine("BackgroundAudioRun.TaskOnCompleted() " + _id + " failed: " + ex.Message);
}
_completionSource.TrySetResult(null);
}
private void OnBackgroundTaskCompleted(BackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs args)
{
args.CheckResult(); // TODO: What kind of errors does this report?
Debug.WriteLine(sender); // BackgroundTaskRegistration
string instanceIdString = args.InstanceId.ToString();
if (!ApplicationData.Current.LocalSettings.Values.ContainsKey(instanceIdString))
{
// This task didn't schedule a download.
return;
}
Guid transferGuid = (Guid)ApplicationData.Current.LocalSettings.Values[instanceIdString];
Debug.WriteLine("Background task completed! Last download was {0}", transferGuid);
}
private void OnCompleted(IBackgroundTaskRegistration task, BackgroundTaskCompletedEventArgs args)
{
// 后台任务已经执行完成
_taskProgress = "完成";
// 如果此次后台任务的执行出现了错误，则调用 CheckResult() 后会抛出异常
try
{
args.CheckResult();
}
catch (Exception ex)
{
_taskProgress = ex.ToString();
}
UpdateUI();
}
/// <summary>
/// Optional: Callback for geofence background task completion.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnGeofenceBackgroundTaskCompleted(IBackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs e)
{
Debug.WriteLine("Background task completed.");
if (sender != null)
{
// Update the UI with progress reported by the background task
try
{
e.CheckResult();
}
catch (Exception ex)
{
// The background task had an error
Debug.WriteLine(ex.ToString());
}
}
}
private async void OnCompleted(IBackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs e)
{
if (sender != null)
{
// Update the UI with progress reported by the background task
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
try
{
// If the background task threw an exception, display the exception in
// the error text box.
e.CheckResult();
}
catch (Exception ex)
{
}
});
}
}
/// <summary>
/// Reopen the device after the background task is done syncing. Notify the UI of how many bytes we wrote to the device.
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private async void OnSyncWithDeviceCompleted(BackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs args)
{
// Exception may be thrown if an error occurs during running the background task
args.CheckResult();
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
new DispatchedHandler(async() =>
{
// Reopen the device once the background task is completed
await EventHandlerForDevice.Current.OpenDeviceAsync(syncDeviceInformation, syncDeviceSelector);
syncDeviceInformation = null;
syncDeviceSelector = null;
var taskCompleteStatus = (String)ApplicationData.Current.LocalSettings.Values[LocalSettingKeys.SyncBackgroundTaskStatus];
if (taskCompleteStatus == SyncBackgroundTaskInformation.TaskCompleted)
{
UInt32 totalBytesWritten = (UInt32)ApplicationData.Current.LocalSettings.Values[LocalSettingKeys.SyncBackgroundTaskResult];
rootPage.NotifyUser("Sync: Wrote " + totalBytesWritten.ToString() + " bytes to the device", NotifyType.StatusMessage);
}
else if (taskCompleteStatus == SyncBackgroundTaskInformation.TaskCanceled)
{
rootPage.NotifyUser("Syncing was canceled", NotifyType.StatusMessage);
}
// Remove all local setting values
ApplicationData.Current.LocalSettings.Values.Clear();
isSyncing = false;
UpdateButtonStates();
}));
// Unregister the background task and let the remaining task finish until completion
if (backgroundSyncTaskRegistration != null)
{
backgroundSyncTaskRegistration.Unregister(false);
}
}
/// <summary>
/// This is the callback when background event has been handled
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
async private void OnCompleted(IBackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs e)
{
// Update the UI with progress reported by the background task
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
try
{
// If the background task threw an exception, display the exception in
// the error text box.
e.CheckResult();
// Update the UI with the completion status of the background task
FillEventListBoxWithExistingEvents();
}
catch (Exception ex)
{
// The background task had an error
_rootPage.NotifyUser(ex.ToString(), NotifyType.ErrorMessage);
}
});
}
/// <summary>
/// This is the callback when background event has been handled
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
async private void OnCompleted(IBackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs e)
{
// Update the UI with progress reported by the background task
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
try
{
// Rethrow any exception that occurred in the background task.
e.CheckResult();
// Update the UI with the completion status of the background task
MainPage.ReportSavedStatus();
FillEventListBoxWithExistingEvents();
}
catch (Exception ex)
{
// The background task had an error
_rootPage.NotifyUser(ex.ToString(), NotifyType.ErrorMessage);
}
});
}
/// <summary>
/// Task registration complete handler.
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private async void OnTaskRegistrationCompleted(BackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs args)
{
bool unregister = false;
// check for exceptions in registration
try
{
args.CheckResult();
}
catch (Exception e)
{
// note: this code-path never actually got hit in testing.
Utilities.OnException(e);
unregister = true;
}
if (unregister)
{
await TaskUnregisterForToastAsync();
}
}
/// <summary>
/// Background task completion handler. When authenticating through the foreground app, this triggers the authentication flow if the app is currently running.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public void OnBackgroundTaskCompleted(IBackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs e)
{
if (sender.Name == BackgroundTaskName)
{
Exception exception = null;
try
{
// If the background task threw an exception, re-raise it here so we can pass it to the event handler.
e.CheckResult();
}
catch (Exception ex)
{
exception = ex;
}
if (!ConfigStore.AuthenticateThroughBackgroundTask)
{
BackgroundAuthenticationCompleted?.Invoke(this, new BackgroundAuthenticationCompletedEventArgs(null));
}
}
}
/// <summary>
/// Print the version number
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private async void OnFirmwareUpdateCompleted(BackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs args)
{
// Exception may be thrown if an error occurs during running the background task
args.CheckResult();
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
new DispatchedHandler(() =>
{
var taskCompleteStatus = (String)ApplicationData.Current.LocalSettings.Values[LocalSettingKeys.FirmwareUpdateBackgroundTask.TaskStatus];
if (taskCompleteStatus == FirmwareUpdateTaskInformation.TaskCompleted)
{
// Display firmware version after the firmware update
var newFirmwareVersion = (UInt32)ApplicationData.Current.LocalSettings.Values[LocalSettingKeys.FirmwareUpdateBackgroundTask.NewFirmwareVersion];
var newFirmwareVersionHex = "0x" + newFirmwareVersion.ToString("X4", NumberFormatInfo.InvariantInfo);
UpdateNewFirmwareVersionInUI(newFirmwareVersionHex);
rootPage.NotifyUser("Firmware update completed", NotifyType.StatusMessage);
}
else if (taskCompleteStatus == FirmwareUpdateTaskInformation.TaskCanceled)
{
rootPage.NotifyUser("Firmware update was canceled", NotifyType.StatusMessage);
}
// Remove all local setting values
ApplicationData.Current.LocalSettings.Values.Clear();
isUpdatingFirmware = false;
UpdateButtonStates();
}));
if (firmwareUpdateBackgroundTaskRegistration != null)
{
// Unregister the background task and let the remaining task finish until completion
firmwareUpdateBackgroundTaskRegistration.Unregister(false);
}
}
