public void Run(IBackgroundTaskInstance taskInstance) { var details = taskInstance.TriggerDetails as ToastNotificationActionTriggerDetail; string arguments = details.Argument; var result = details.UserInput; if (arguments == "check") { int sum = int.Parse(result["message"].ToString()); string message = sum == 15 ? "Congratulations, the answer is correct!" : "Sorry, wrong answer!"; string xml = $@"<toast> <visual> <binding template=""ToastGeneric""> <image placement=""appLogoOverride"" src=""Assets/MicrosoftLogo.png"" /> <text>{message}</text> </binding> </visual> </toast>"; XmlDocument doc = new XmlDocument(); doc.LoadXml(xml); ToastNotification notification = new ToastNotification(doc); ToastNotificationManager.CreateToastNotifier().Show(notification); } }
private async void DoBufferWork(IBackgroundTaskInstance taskInstance) { string message = "Hello World!"; string unprotectedMessage = ""; string logFileName = "Bufferlog.txt"; string logFileContent = ""; StorageFolder localFolder = Windows.Storage.ApplicationData.Current.LocalFolder; StorageFile logFile = await localFolder.CreateFileAsync(logFileName, CreationCollisionOption.OpenIfExists); IBuffer inputBuffer = CryptographicBuffer.ConvertStringToBinary(message, BinaryStringEncoding.Utf8); BufferProtectUnprotectResult procBuffer = await DataProtectionManager.ProtectAsync(inputBuffer, m_EnterpriseID); logFileContent += "\r\n" + DateTime.Now + ":" + "ProtStatus:" + procBuffer.ProtectionInfo.Status + "\n"; logFileContent += "\r\n" + "Protected Buffer:" + CryptographicBuffer.EncodeToHexString(procBuffer.Buffer).Substring(0, 5); // If keys are dropped under lock, unprotectBuffer will fail so don't unprotectbuffer under lock if (!m_areKeysDropped) { BufferProtectUnprotectResult unBuffer = await DataProtectionManager.UnprotectAsync(procBuffer.Buffer); unprotectedMessage = CryptographicBuffer.ConvertBinaryToString(BinaryStringEncoding.Utf8, procBuffer.Buffer); logFileContent += "\n Unprotected string:" + unprotectedMessage; if (message != unprotectedMessage) { throw new Exception("Original string does not match with unprotectedMessage!"); } } await FileIO.AppendTextAsync(logFile, logFileContent); }
public async void Run(IBackgroundTaskInstance taskInstance) { AddQuestionsResult result = null; BackgroundTaskDeferral deferral = taskInstance.GetDeferral(); #if DEBUG InvokeSimpleToast("Hello from " + taskInstance.Task.Name); #endif try { result = await FeedManager.QueryWebsitesAsync(); #if DEBUG InvokeSimpleToast(String.Format( "There are {0} new questions and {1} updated questions.", result.AddedQuestions, result.UpdatedQuestions)); #endif } catch (Exception ex) { Debug.WriteLine(ex); #if DEBUG InvokeSimpleToast(ex.Message); #endif } deferral.Complete(); }
public async void Run(IBackgroundTaskInstance taskInstance) { // Ensure our background task remains running taskDeferral = taskInstance.GetDeferral(); // Mutex will be used to ensure only one thread at a time is talking to the shield / isolated storage mutex = new Mutex(false, mutexId); // Initialize WeatherShield await shield.BeginAsync(); //Initialise the MCP3008 ADC Chip mcp3008.Initialize(); // Create a timer-initiated ThreadPool task to read data from I2C i2cTimer = ThreadPoolTimer.CreatePeriodicTimer(PopulateWeatherData, TimeSpan.FromSeconds(i2cReadIntervalSeconds)); //Create a timer-initiated ThreadPool task to read data from the interrupt handler counting the wind instrument activity windInterruptSample = ThreadPoolTimer.CreatePeriodicTimer(MeasureWindEventData, TimeSpan.FromSeconds(windInterruptSampleInterval)); // Task cancellation handler, release our deferral there taskInstance.Canceled += OnCanceled; //Create the interrupt handler listening to the wind speed pin (13). Triggers the GpioPin.ValueChanged event on that pin //connected to the anemometer. shield.WindSpeedPin.ValueChanged += WindSpeedPin_ValueChanged; //Create the interrupt handler listening to the rain guage pin (26). Triggers the Gpio.ValueChanged event on that pin //connected to the rain guage. shield.RainPin.ValueChanged += RainPin_ValueChanged; }
public async void Run(IBackgroundTaskInstance taskInstance) { var deferral = taskInstance.GetDeferral(); try { await Log.InfoAsync("Synchronization background task started"); var authenticatedSilently = await SecurityManager.TryAuthenticateSilently(); if (authenticatedSilently) { IBackendServiceClient storage = new MobileServiceBackendServiceClient(new SyncHandler(), new EventManager(), new LocalSettingsService()); await storage.InitializeAsync(); await storage.TrySyncAsync(); } else { await Log.WarnAsync("Authentication failed."); } await Log.InfoAsync("Synchronization background task completed"); } catch (Exception ex) { await ExceptionHandlingHelper.HandleNonFatalErrorAsync(ex, "Synchronization background task failed.", sendTelemetry: false); } finally { deferral.Complete(); } }
/// <summary> /// The entry point of a background task. /// </summary> /// <param name="taskInstance">The current background task instance.</param> public void Run(IBackgroundTaskInstance taskInstance) { Debug.WriteLine("Background " + taskInstance.Task.Name + " Starting..."); // Associate a cancellation handler with the background task. // Even though this task isn't performing much work, it can still be canceled. taskInstance.Canceled += new BackgroundTaskCanceledEventHandler(OnCanceled); // Read the sensor readings from the trigger reports SensorDataThresholdTriggerDetails triggerDetails = taskInstance.TriggerDetails as SensorDataThresholdTriggerDetails; // Ensure the type of trigger we are dealing with is of type 'ProximitySensor' if (SensorType.ProximitySensor == triggerDetails.SensorType) { var reports = ProximitySensor.GetReadingsFromTriggerDetails(triggerDetails); var settings = ApplicationData.Current.LocalSettings; var lastReading = reports[reports.Count - 1]; // cache appropriate details from this trigger in application data settings.Values["ReportCount"] = reports.Count.ToString(); settings.Values["LastTimestamp"] = lastReading.Timestamp.ToString("u"); settings.Values["Detected"] = lastReading.IsDetected.ToString(); settings.Values["TaskStatus"] = "Completed at " + DateTime.Now.ToString("u"); } // No deferral is held on taskInstance because we are returning immediately. }
public async void Run(IBackgroundTaskInstance taskInstance) { var deferral = taskInstance.GetDeferral(); var updater = new LiveTileScheduler(); await updater.CreateSchedule(); deferral.Complete(); }
public async void Run(IBackgroundTaskInstance taskInstance) { //通知 ApplicationDataContainer container = ApplicationData.Current.LocalSettings; bool Update = true; if (container.Values["UpdateCT"]!=null) { Update = (bool)container.Values["UpdateCT"]; } else { container.Values["UpdateCT"] = true; } if (Update) { var deferral = taskInstance.GetDeferral(); await GetLatestNews(); deferral.Complete(); } else { var updater = TileUpdateManager.CreateTileUpdaterForApplication(); updater.Clear(); } }
private void TaskInstance_Canceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason) { this.SendToForeground(CommunicationConstants.BackgroundTaskStopped); try { ApplicationSettings.BackgroundTaskResumeSongTime.Save(BackgroundMediaPlayer.Current.Position.TotalSeconds); /* //save state ApplicationSettingsHelper.SaveSettingsValue(Constants.CurrentTrack, Playlist.CurrentTrackName); ApplicationSettingsHelper.SaveSettingsValue(Constants.Position, BackgroundMediaPlayer.Current.Position.ToString()); ApplicationSettingsHelper.SaveSettingsValue(Constants.BackgroundTaskState, Constants.BackgroundTaskCancelled); ApplicationSettingsHelper.SaveSettingsValue(Constants.AppState, Enum.GetName(typeof(ForegroundAppStatus), foregroundAppState)); backgroundtaskrunning = false; //unsubscribe event handlers systemmediatransportcontrol.ButtonPressed -= systemmediatransportcontrol_ButtonPressed; systemmediatransportcontrol.PropertyChanged -= systemmediatransportcontrol_PropertyChanged; Playlist.TrackChanged -= playList_TrackChanged; //clear objects task cancellation can happen uninterrupted playlistManager.ClearPlaylist(); playlistManager = null; */ this.mediaControls.ButtonPressed -= mediaControls_ButtonPressed; playlistManager = null; BackgroundMediaPlayer.Shutdown(); // shutdown media pipeline } catch (Exception ex) { Debug.WriteLine(ex.ToString()); } if (_deferral != null) _deferral.Complete(); }
public async void Run(IBackgroundTaskInstance taskInstance) { // Create the deferral by requesting it from the task instance serviceDeferral = taskInstance.GetDeferral(); AppServiceTriggerDetails triggerDetails = taskInstance.TriggerDetails as AppServiceTriggerDetails; if (triggerDetails != null && triggerDetails.Name.Equals("IMCommandVoice")) { voiceServiceConnection = VoiceCommandServiceConnection.FromAppServiceTriggerDetails(triggerDetails); VoiceCommand voiceCommand = await voiceServiceConnection.GetVoiceCommandAsync(); // Perform the appropriate command depending on the operation defined in VCD switch (voiceCommand.CommandName) { case "oldback": VoiceCommandUserMessage userMessage = new VoiceCommandUserMessage(); userMessage.DisplayMessage = "The current temperature is 23 degrees"; userMessage.SpokenMessage = "The current temperature is 23 degrees"; VoiceCommandResponse response = VoiceCommandResponse.CreateResponse(userMessage, null); await voiceServiceConnection.ReportSuccessAsync(response); break; default: break; } } // Once the asynchronous method(s) are done, close the deferral serviceDeferral.Complete(); }
public void Run(IBackgroundTaskInstance taskInstance) { deferral = taskInstance.GetDeferral(); Initialize(); Start(); }
public void Run(IBackgroundTaskInstance taskInstance) { try { if (Hub.Instance.VoipTaskInstance != null) { Debug.WriteLine("VoipTask already started."); return; } _deferral = taskInstance.GetDeferral(); Hub.Instance.VoipTaskInstance = this; Debug.WriteLine($"{DateTime.Now} VoipTask started."); taskInstance.Canceled += (s, e) => CloseVoipTask(); } catch (Exception e) { if (Hub.Instance.IsAppInsightsEnabled) { Hub.Instance.RTCStatsManager.TrackException(e); } if (_deferral != null) { _deferral.Complete(); } throw e; } }
public void Run(IBackgroundTaskInstance taskInstance) { // Connect the Ultrasonic Sensor to digital port 4 IUltrasonicRangerSensor sensor = DeviceFactory.Build.UltraSonicSensor(Pin.DigitalPin4); // Loop endlessly while (true) { Task.Delay(100).Wait(); //Delay 0.1 second try { // Check the value of the Ultrasonic Sensor string sensorvalue = sensor.MeasureInCentimeters().ToString(); System.Diagnostics.Debug.WriteLine("Ultrasonic reads " + sensorvalue); } catch (Exception ex) { // NOTE: There are frequent exceptions of the following: // WinRT information: Unexpected number of bytes was transferred. Expected: '. Actual: '. // This appears to be caused by the rapid frequency of writes to the GPIO // These are being swallowed here/ // If you want to see the exceptions uncomment the following: // System.Diagnostics.Debug.WriteLine(ex.ToString()); } } }
// // The Run method is the entry point of a background task. // public void Run(IBackgroundTaskInstance taskInstance) { Windows.Storage.ApplicationDataContainer localSettings = Windows.Storage.ApplicationData.Current.LocalSettings; Debug.WriteLine("Background " + taskInstance.Task.Name + " Starting..."); // For performing asynchronous operations in the background task BackgroundTaskDeferral asyncDeferral = taskInstance.GetDeferral(); // // Query BackgroundWorkCost // Guidance: If BackgroundWorkCost is high, then perform only the minimum amount // of work in the background task and return immediately. // var cost = BackgroundWorkCost.CurrentBackgroundWorkCost; var settings = ApplicationData.Current.LocalSettings; settings.Values["BackgroundWorkCost"] = cost.ToString(); // // Associate a cancellation handler with the background task. // taskInstance.Canceled += new BackgroundTaskCanceledEventHandler(OnCanceled); // // Get the deferral object from the task instance, and take a reference to the taskInstance; // _deferral = taskInstance.GetDeferral(); _taskInstance = taskInstance; _periodicTimer = ThreadPoolTimer.CreatePeriodicTimer(new TimerElapsedHandler(PeriodicTimerCallback), TimeSpan.FromSeconds(1)); asyncDeferral.Complete(); }
// Completion groups allow us to immediately take action after a set of downloads completes. // In this sample, the server intentionally replies with an error status for some of the downloads. // Based on the trigger details, we can determine which of the downloads have failed and try them again // using a new completion group. public void Run(IBackgroundTaskInstance taskInstance) { BackgroundTransferCompletionGroupTriggerDetails details = taskInstance.TriggerDetails as BackgroundTransferCompletionGroupTriggerDetails; if (details == null) { // This task was not triggered by a completion group. return; } List<DownloadOperation> failedDownloads = new List<DownloadOperation>(); int succeeded = 0; foreach (DownloadOperation download in details.Downloads) { if (IsFailed(download)) { failedDownloads.Add(download); } else { succeeded++; } } if (failedDownloads.Count > 0) { RetryDownloads(failedDownloads); } InvokeSimpleToast(succeeded, failedDownloads.Count); }
public async void Run(IBackgroundTaskInstance taskInstance) { taskInstance.Canceled += OnCanceled; var defferal = taskInstance.GetDeferral(); TileHelper.UpdateTile(HomeSensorHelper.GetSensorData()); defferal.Complete(); }
public void Run(IBackgroundTaskInstance taskInstance) { Adapter adapter = null; deferral = taskInstance.GetDeferral(); try { adapter = new Adapter(); dsbBridge = new DsbBridge(adapter); var initResult = dsbBridge.Initialize(); if (initResult != 0) { throw new Exception("DSB Bridge initialization failed!"); } } catch (Exception ex) { if (dsbBridge != null) { dsbBridge.Shutdown(); } if (adapter != null) { adapter.Shutdown(); } throw; } }
public void Run(IBackgroundTaskInstance taskInstance) { var backgroundTaskDeferral = taskInstance.GetDeferral(); try { UpdateTile(); } catch (Exception ex) { Debug.WriteLine(ex); } finally { backgroundTaskDeferral.Complete(); } }
public void Run(IBackgroundTaskInstance taskInstance) { try { var triggerDetail = (AppServiceTriggerDetails) taskInstance.TriggerDetails; _deferral = taskInstance.GetDeferral(); Hub.Instance.ForegroundConnection = triggerDetail.AppServiceConnection; Hub.Instance.ForegroundTask = this; taskInstance.Canceled += (s, e) => Close(); triggerDetail.AppServiceConnection.ServiceClosed += (s, e) => Close(); } catch (System.Exception e) { if (Hub.Instance.IsAppInsightsEnabled) { Hub.Instance.RTCStatsManager.TrackException(e); } if (_deferral != null) { _deferral.Complete(); } throw e; } }
public async void Run(IBackgroundTaskInstance taskInstance) { BackgroundTaskDeferral deferral = taskInstance.GetDeferral(); taskInstance.Canceled += TaskInstance_Canceled; var triggerDetails = taskInstance.TriggerDetails as AppServiceTriggerDetails; if (triggerDetails?.Name != nameof(VoiceCommandService)) return; var connection = VoiceCommandServiceConnection.FromAppServiceTriggerDetails(triggerDetails); connection.VoiceCommandCompleted += ConnectionOnVoiceCommandCompleted; var command = await connection.GetVoiceCommandAsync(); //even if it's not used, you can run into issues without this line. switch (command.CommandName) { case "ReadTodaysNamedays": await HandleReadNamedaysCommandAsync(connection); break; } deferral.Complete(); }
public void Run(IBackgroundTaskInstance taskInstance) { using (device = new CanvasDevice()) { try { GenerateTileImage(TileTemplateType.TileSquare150x150Image, 150, 150); GenerateTileImage(TileTemplateType.TileWide310x150Image, 310, 150); } catch (Exception e) { if (device.IsDeviceLost(e.HResult)) { // When the device is lost we don't attempt to retry, and instead just wait for // the next time the task runs. return; } // Any other errors we bubble up throw; } } UpdateLiveTiles(); DeleteOldLiveTileImageFiles(); LiveTileUpdater.SetLatestTileImagesInSettings(tiles.Values); }
public void Run(IBackgroundTaskInstance taskInstance) { var deferal = taskInstance.GetDeferral(); if (taskInstance.TriggerDetails is RawNotification) { var details = taskInstance.TriggerDetails as RawNotification; var arguments = details.Content.Split(':'); if (arguments.Count() > 0) { switch (arguments[0]) { case "new_items": if (arguments.Count() > 1) { XmlDocument badgeXml = BadgeUpdateManager.GetTemplateContent(BadgeTemplateType.BadgeNumber); XmlElement badgeElement = (XmlElement)badgeXml.SelectSingleNode("/badge"); badgeElement.SetAttribute("value", arguments[1]); BadgeNotification badge = new BadgeNotification(badgeXml); BadgeUpdateManager.CreateBadgeUpdaterForApplication().Update(badge); } break; } } } deferal.Complete(); }
public void Run(IBackgroundTaskInstance taskInstance) { deferral = taskInstance.GetDeferral(); InitGPIO(); timer = ThreadPoolTimer.CreatePeriodicTimer(Timer_Tick, TimeSpan.FromMilliseconds(500)); }
public async void Run(IBackgroundTaskInstance taskInstance) { var deferral = taskInstance.GetDeferral(); IReadOnlyList<GeofenceStateChangeReport> reports = GeofenceMonitor.Current.ReadReports(); foreach (var report in reports) { if ((report.NewState != GeofenceState.None) && (report.NewState != GeofenceState.Removed)) { await StatusFile.AddStatusEntry( report.Geofence.Id, report.NewState == GeofenceState.Entered ? EntryType.EnteredZone : EntryType.ExitedZone); } } XmlDocument template = ToastNotificationManager.GetTemplateContent(ToastTemplateType.ToastText01); NotificationTemplateHelper.CompleteToastOrTileTemplate( template, new string[] { "One or more of our fences has been crossed" }, null); ToastNotifier notifier = ToastNotificationManager.CreateToastNotifier(); notifier.Show(new ToastNotification(template)); deferral.Complete(); }
private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason) { _cancelRequested = true; _cancelReason = reason; Debug.WriteLine($"Background '{sender.Task.Name}' Cancel Requested..."); }
public async void Run(IBackgroundTaskInstance taskInstance) { // simple example with a Toast, to enable this go to manifest file // and mark App as TastCapable - it won't work without this // The Task will start but there will be no Toast. //ToastTemplateType toastTemplate = ToastTemplateType.ToastText02; //XmlDocument toastXml = ToastNotificationManager.GetTemplateContent(toastTemplate); //XmlNodeList textElements = toastXml.GetElementsByTagName("text"); //textElements[0].AppendChild(toastXml.CreateTextNode("My first Task - Yeah")); //textElements[1].AppendChild(toastXml.CreateTextNode("I'm a message from your background task!")); //ToastNotificationManager.CreateToastNotifier().Show(new ToastNotification(toastXml)); var deferral = taskInstance.GetDeferral(); RawNotification raw = taskInstance.TriggerDetails as RawNotification; if (raw != null) { Debug.WriteLine( string.Format("XXXXXXXXXXXXXReceived from cloud:XXXXXXXXXX [{0}]", raw.Content)); } deferral.Complete(); }
/// <remarks> /// If you start any asynchronous methods here, prevent the task /// from closing prematurely by using BackgroundTaskDeferral as /// described in http://aka.ms/backgroundtaskdeferral /// </remarks> public async void Run(IBackgroundTaskInstance taskInstance) { // This deferral should have an instance reference, if it doesn't... the GC will // come some day, see that this method is not active anymore and the local variable // should be removed. Which results in the application being closed. _deferral = taskInstance.GetDeferral(); var restRouteHandler = new RestRouteHandler(); restRouteHandler.RegisterController<AsyncControllerSample>(); restRouteHandler.RegisterController<FromContentControllerSample>(); restRouteHandler.RegisterController<PerCallControllerSample>(); restRouteHandler.RegisterController<SimpleParameterControllerSample>(); restRouteHandler.RegisterController<SingletonControllerSample>(); restRouteHandler.RegisterController<ThrowExceptionControllerSample>(); restRouteHandler.RegisterController<WithResponseContentControllerSample>(); var configuration = new HttpServerConfiguration() .ListenOnPort(8800) .RegisterRoute("api", restRouteHandler) .RegisterRoute(new StaticFileRouteHandler(@"Restup.DemoStaticFiles\Web")) .EnableCors(); // allow cors requests on all origins // .EnableCors(x => x.AddAllowedOrigin("http://specificserver:<listen-port>")); var httpServer = new HttpServer(configuration); _httpServer = httpServer; await httpServer.StartServerAsync(); // Dont release deferral, otherwise app will stop }
public void Run(IBackgroundTaskInstance taskInstance) { // Check the task cost var cost = BackgroundWorkCost.CurrentBackgroundWorkCost; if (cost == BackgroundWorkCostValue.High) { return; } // Get the cancel token var cancel = new System.Threading.CancellationTokenSource(); taskInstance.Canceled += (s, e) => { cancel.Cancel(); cancel.Dispose(); }; // Get deferral var deferral = taskInstance.GetDeferral(); try { // Update Tile with the new xml XmlDocument xmldoc = new XmlDocument(); xmldoc.LoadXml(TileUpdaterTask.w10TileXml); TileNotification tileNotification = new TileNotification(xmldoc); TileUpdater tileUpdator = TileUpdateManager.CreateTileUpdaterForApplication(); tileUpdator.Update(tileNotification); } finally { deferral.Complete(); } }
public async void Run(IBackgroundTaskInstance taskInstance) { // // TODO: Insert code to perform background work // // If you start any asynchronous methods here, prevent the task // from closing prematurely by using BackgroundTaskDeferral as // described in http://aka.ms/backgroundtaskdeferral // var deferral = taskInstance.GetDeferral(); var settings = new I2cConnectionSettings(I2C_ADDRESS); settings.BusSpeed = I2cBusSpeed.FastMode; var aqs = I2cDevice.GetDeviceSelector(); /* Get a selector string that will return all I2C controllers on the system */ var dis = await DeviceInformation.FindAllAsync(aqs); /* Find the I2C bus controller devices with our selector string */ _dht11 = await I2cDevice.FromIdAsync(dis[0].Id, settings); /* Create an I2cDevice with our selected bus controller and I2C settings */ await begin(); while (true) { var temp = await readTemperature(); var hum = await readHumidity(); Debug.WriteLine($"{temp} C & {hum}% humidity"); await Task.Delay(2000); } deferral.Complete(); }
private void TaskInstance_Canceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason) { if (this.deferral != null) { this.deferral.Complete(); } }
private void TaskInstance_Canceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason) { Close(); }
public abstract void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason);
public abstract Task RunAsyncInternal(IBackgroundTaskInstance taskInstance);
public void Run(IBackgroundTaskInstance taskInstance) { backgroundTaskInstance = taskInstance; var details = taskInstance.TriggerDetails as BluetoothLEAdvertisementWatcherTriggerDetails; if (details != null) { // If the background watcher stopped unexpectedly, an error will be available here. var error = details.Error; // The Advertisements property is a list of all advertisement events received // since the last task triggered. The list of advertisements here might be valid even if // the Error status is not Success since advertisements are stored until this task is triggered IReadOnlyList <BluetoothLEAdvertisementReceivedEventArgs> advertisements = details.Advertisements; // The signal strength filter configuration of the trigger is returned such that further // processing can be performed here using these values if necessary. They are read-only here. var rssiFilter = details.SignalStrengthFilter; // In this example, the background task simply constructs a message communicated // to the App. For more interesting applications, a notification can be sent from here instead. //string eventMessage = ""; //eventMessage += string.Format("ErrorStatus: {0}, EventCount: {1}, HighDBm: {2}, LowDBm: {3}, Timeout: {4}, Sampling: {5}", // error.ToString(), // advertisements.Count.ToString(), // rssiFilter.InRangeThresholdInDBm.ToString(), // rssiFilter.OutOfRangeThresholdInDBm.ToString(), // rssiFilter.OutOfRangeTimeout.GetValueOrDefault().TotalMilliseconds.ToString(), // rssiFilter.SamplingInterval.GetValueOrDefault().TotalMilliseconds.ToString()); //// Advertisements can contain multiple events that were aggregated, each represented by //// a BluetoothLEAdvertisementReceivedEventArgs object. //foreach (var eventArgs in advertisements) //{ // // Check if there are any manufacturer-specific sections. // // If there is, print the raw data of the first manufacturer section (if there are multiple). // string manufacturerDataString = ""; // var manufacturerSections = eventArgs.Advertisement.ManufacturerData; // if (manufacturerSections.Count > 0) // { // var manufacturerData = manufacturerSections[0]; // var data = new byte[manufacturerData.Data.Length]; // using (var reader = DataReader.FromBuffer(manufacturerData.Data)) // { // reader.ReadBytes(data); // } // // Print the company ID + the raw data in hex format. // manufacturerDataString = string.Format("0x{0}: {1}", // manufacturerData.CompanyId.ToString("X"), // BitConverter.ToString(data)); // } // eventMessage += string.Format("\n[{0}] [{1}]: Rssi={2}dBm, localName={3}, manufacturerData=[{4}]", // eventArgs.Timestamp.ToString("hh\\:mm\\:ss\\.fff"), // eventArgs.AdvertisementType.ToString(), // eventArgs.RawSignalStrengthInDBm.ToString(), // eventArgs.Advertisement.LocalName, // manufacturerDataString); //} //// Store the message in a local settings indexed by this task's name so that the foreground App //// can display this message. //ApplicationData.Current.LocalSettings.Values[taskInstance.Task.Name] = eventMessage; } }
public void Run(IBackgroundTaskInstance taskInstance) { StorageFolder localFolder = ApplicationData.Current.LocalFolder; TimeSpan imageUpdateDue; TimeSpan imageUpdatePeriod; this.logging.LogEvent("Application starting"); // Log the Application build, OS version information etc. LoggingFields startupInformation = new LoggingFields(); startupInformation.AddString("Timezone", TimeZoneSettings.CurrentTimeZoneDisplayName); startupInformation.AddString("OSVersion", Environment.OSVersion.VersionString); startupInformation.AddString("MachineName", Environment.MachineName); // This is from the application manifest Package package = Package.Current; PackageId packageId = package.Id; PackageVersion version = packageId.Version; startupInformation.AddString("ApplicationVersion", string.Format($"{version.Major}.{version.Minor}.{version.Build}.{version.Revision}")); try { // see if the configuration file is present if not copy minimal sample one from application directory if (localFolder.TryGetItemAsync(ConfigurationFilename).AsTask().Result == null) { StorageFile templateConfigurationfile = Package.Current.InstalledLocation.GetFileAsync(ConfigurationFilename).AsTask().Result; templateConfigurationfile.CopyAsync(localFolder, ConfigurationFilename).AsTask(); } IConfiguration configuration = new ConfigurationBuilder().AddJsonFile(Path.Combine(localFolder.Path, ConfigurationFilename), false, true).Build(); this.interruptPinNumber = int.Parse(configuration.GetSection("InterruptPinNumber").Value); startupInformation.AddInt32("Interrupt pin", this.interruptPinNumber); this.interruptTriggerOn = (GpioPinEdge)Enum.Parse(typeof(GpioPinEdge), configuration.GetSection("interruptTriggerOn").Value); startupInformation.AddString("Interrupt Trigger on", this.interruptTriggerOn.ToString()); this.displayPinNumber = int.Parse(configuration.GetSection("DisplayPinNumber").Value); startupInformation.AddInt32("Display pin", this.interruptPinNumber); this.azureIoTHubConnectionString = configuration.GetSection("AzureIoTHubConnectionString").Value; startupInformation.AddString("AzureIoTHubConnectionString", this.azureIoTHubConnectionString); this.transportType = (TransportType)Enum.Parse(typeof(TransportType), configuration.GetSection("TransportType").Value); startupInformation.AddString("TransportType", this.transportType.ToString()); } catch (Exception ex) { this.logging.LogMessage("JSON configuration file load or settings retrieval failed " + ex.Message, LoggingLevel.Error); return; } #region AzureIoT Hub connection string creation try { this.azureIoTHubClient = DeviceClient.CreateFromConnectionString(this.azureIoTHubConnectionString, this.transportType); } catch (Exception ex) { this.logging.LogMessage("AzureIOT Hub DeviceClient.CreateFromConnectionString failed " + ex.Message, LoggingLevel.Error); return; } #endregion #region Report device and application properties to AzureIoT Hub try { TwinCollection reportedProperties = new TwinCollection(); // This is from the OS reportedProperties["Timezone"] = TimeZoneSettings.CurrentTimeZoneDisplayName; reportedProperties["OSVersion"] = Environment.OSVersion.VersionString; reportedProperties["MachineName"] = Environment.MachineName; reportedProperties["ApplicationDisplayName"] = package.DisplayName; reportedProperties["ApplicationName"] = packageId.Name; reportedProperties["ApplicationVersion"] = string.Format($"{version.Major}.{version.Minor}.{version.Build}.{version.Revision}"); // Unique identifier from the hardware SystemIdentificationInfo systemIdentificationInfo = SystemIdentification.GetSystemIdForPublisher(); using (DataReader reader = DataReader.FromBuffer(systemIdentificationInfo.Id)) { byte[] bytes = new byte[systemIdentificationInfo.Id.Length]; reader.ReadBytes(bytes); reportedProperties["SystemId"] = BitConverter.ToString(bytes); } this.azureIoTHubClient.UpdateReportedPropertiesAsync(reportedProperties).Wait(); } catch (Exception ex) { this.logging.LogMessage("Azure IoT Hub client UpdateReportedPropertiesAsync failed " + ex.Message, LoggingLevel.Error); return; } #endregion #region Retrieve device twin settings try { LoggingFields configurationInformation = new LoggingFields(); Twin deviceTwin = this.azureIoTHubClient.GetTwinAsync().GetAwaiter().GetResult(); if (!deviceTwin.Properties.Desired.Contains("ImageUpdateDue") || !TimeSpan.TryParse(deviceTwin.Properties.Desired["ImageUpdateDue"].value.ToString(), out imageUpdateDue)) { this.logging.LogMessage("DeviceTwin.Properties ImageUpdateDue setting missing or invalid format", LoggingLevel.Warning); return; } configurationInformation.AddTimeSpan("ImageUpdateDue", imageUpdateDue); if (!deviceTwin.Properties.Desired.Contains("ImageUpdatePeriod") || !TimeSpan.TryParse(deviceTwin.Properties.Desired["ImageUpdatePeriod"].value.ToString(), out imageUpdatePeriod)) { this.logging.LogMessage("DeviceTwin.Properties ImageUpdatePeriod setting missing or invalid format", LoggingLevel.Warning); return; } configurationInformation.AddTimeSpan("ImageUpdatePeriod", imageUpdatePeriod); if (!deviceTwin.Properties.Desired.Contains("ModelType") || (!Enum.TryParse(deviceTwin.Properties.Desired["ModelType"].value.ToString(), out modelType))) { this.logging.LogMessage("DeviceTwin.Properties ModelType setting missing or invalid format", LoggingLevel.Warning); return; } configurationInformation.AddString("ModelType", modelType.ToString()); if (!deviceTwin.Properties.Desired.Contains("ModelPublishedName") || (string.IsNullOrWhiteSpace(deviceTwin.Properties.Desired["ModelPublishedName"].value.ToString()))) { this.logging.LogMessage("DeviceTwin.Properties ModelPublishedName setting missing or invalid format", LoggingLevel.Warning); return; } modelPublishedName = deviceTwin.Properties.Desired["ModelPublishedName"].value.ToString(); configurationInformation.AddString("ModelPublishedName", modelPublishedName); if (!deviceTwin.Properties.Desired.Contains("ProjectID") || (!Guid.TryParse(deviceTwin.Properties.Desired["ProjectID"].value.ToString(), out projectId))) { this.logging.LogMessage("DeviceTwin.Properties ProjectId setting missing or invalid format", LoggingLevel.Warning); return; } configurationInformation.AddGuid("ProjectID", projectId); if (!deviceTwin.Properties.Desired.Contains("ProbabilityThreshold") || (!Double.TryParse(deviceTwin.Properties.Desired["ProbabilityThreshold"].value.ToString(), out probabilityThreshold))) { this.logging.LogMessage("DeviceTwin.Properties ProbabilityThreshold setting missing or invalid format", LoggingLevel.Warning); return; } configurationInformation.AddDouble("ProbabilityThreshold", probabilityThreshold); if (!deviceTwin.Properties.Desired.Contains("AzureCognitiveServicesEndpoint") || (string.IsNullOrWhiteSpace(deviceTwin.Properties.Desired["AzureCognitiveServicesEndpoint"].value.ToString()))) { this.logging.LogMessage("DeviceTwin.Properties AzureCognitiveServicesEndpoint setting missing or invalid format", LoggingLevel.Warning); return; } azureCognitiveServicesEndpoint = deviceTwin.Properties.Desired["AzureCognitiveServicesEndpoint"].value.ToString(); configurationInformation.AddString("AzureCognitiveServicesEndpoint", modelPublishedName); if (!deviceTwin.Properties.Desired.Contains("AzureCognitiveServicesSubscriptionKey") || (string.IsNullOrWhiteSpace(deviceTwin.Properties.Desired["AzureCognitiveServicesSubscriptionKey"].value.ToString()))) { this.logging.LogMessage("DeviceTwin.Properties AzureCognitiveServicesSubscriptionKey setting missing or invalid format", LoggingLevel.Warning); return; } azureCognitiveServicesSubscriptionKey = deviceTwin.Properties.Desired["AzureCognitiveServicesSubscriptionKey"].value.ToString(); configurationInformation.AddString("AzureCognitiveServicesSubscriptionKey", azureCognitiveServicesSubscriptionKey); if (!deviceTwin.Properties.Desired.Contains("DebounceTimeout") || !TimeSpan.TryParse(deviceTwin.Properties.Desired["DebounceTimeout"].value.ToString(), out debounceTimeout)) { this.logging.LogMessage("DeviceTwin.Properties DebounceTimeout setting missing or invalid format", LoggingLevel.Warning); return; } configurationInformation.AddTimeSpan("DebounceTimeout", debounceTimeout); this.logging.LogEvent("Configuration settings", configurationInformation); } catch (Exception ex) { this.logging.LogMessage("Azure IoT Hub client GetTwinAsync failed or property missing/invalid" + ex.Message, LoggingLevel.Error); return; } #endregion try { this.customVisionClient = new CustomVisionPredictionClient(new System.Net.Http.DelegatingHandler[] { }) { ApiKey = this.azureCognitiveServicesSubscriptionKey, Endpoint = this.azureCognitiveServicesEndpoint, }; } catch (Exception ex) { this.logging.LogMessage("Azure Cognitive Services Custom Vision Client configuration failed " + ex.Message, LoggingLevel.Error); return; } try { this.mediaCapture = new MediaCapture(); this.mediaCapture.InitializeAsync().AsTask().Wait(); } catch (Exception ex) { this.logging.LogMessage("Camera configuration failed " + ex.Message, LoggingLevel.Error); return; } this.displayOffTimer = new Timer(this.TimerCallback, null, Timeout.Infinite, Timeout.Infinite); #region Wire up interupt handler for image capture request if (this.interruptPinNumber != 0) { try { GpioController gpioController = GpioController.GetDefault(); this.interruptGpioPin = gpioController.OpenPin(this.interruptPinNumber); this.interruptGpioPin.SetDriveMode(GpioPinDriveMode.InputPullUp); this.interruptGpioPin.ValueChanged += this.InterruptGpioPin_ValueChanged; this.displayGpioPin = gpioController.OpenPin(this.displayPinNumber); this.displayGpioPin.SetDriveMode(GpioPinDriveMode.Output); this.displayGpioPin.Write(GpioPinValue.Low); } catch (Exception ex) { this.logging.LogMessage("Digital input configuration failed " + ex.Message, LoggingLevel.Error); return; } } #endregion #region Wire up command handler for image capture request try { this.azureIoTHubClient.SetMethodHandlerAsync("ImageCapture", this.ImageUpdateHandler, null); } catch (Exception ex) { this.logging.LogMessage("Azure IoT Hub client ImageCapture SetMethodHandlerAsync failed " + ex.Message, LoggingLevel.Error); return; } #endregion #region Wire up command handler for device reboot request try { this.azureIoTHubClient.SetMethodHandlerAsync("DeviceReboot", this.DeviceRebootAsync, null); } catch (Exception ex) { this.logging.LogMessage("Azure IoT Hub client DeviceReboot SetMethodHandlerAsync failed " + ex.Message, LoggingLevel.Error); return; } #endregion if ((imageUpdateDue != TimeSpan.MinValue) || (imageUpdatePeriod != TimeSpan.MinValue)) { this.imageUpdatetimer = new Timer(this.ImageUpdateTimerCallback, null, imageUpdateDue, imageUpdatePeriod); } this.logging.LogEvent("Application started", startupInformation); // enable task to continue running in background this.backgroundTaskDeferral = taskInstance.GetDeferral(); }
public void Run(IBackgroundTaskInstance taskInstance) { // TaskManager.Register(taskInstance); Debug.WriteLine($"CrossDeviceAppService#Run called: {taskInstance.InstanceId}"); }
public async void Run(IBackgroundTaskInstance taskInstance) { serviceDeferral = taskInstance.GetDeferral(); taskInstance.Canceled += TaskInstance_Canceled; var triggerDetails = taskInstance.TriggerDetails as AppServiceTriggerDetails; if (triggerDetails != null && triggerDetails.Name == "GeneralQueryVoiceCommandService") { try { voiceCommandServiceConnection = VoiceCommandServiceConnection.FromAppServiceTriggerDetails(triggerDetails); voiceCommandServiceConnection.VoiceCommandCompleted += VoiceCommandServiceConnection_VoiceCommandCompleted; VoiceCommand voiceCommand = await voiceCommandServiceConnection.GetVoiceCommandAsync(); switch (voiceCommand.CommandName) { case "On": await Class1.showProgressScreen(voiceCommandServiceConnection, "正在打开" + voiceCommand.Properties["rooms"][0] + "的灯"); var OnRoom = voiceCommand.Properties["rooms"][0]; switch (OnRoom) { case "卧室": helper1.SendMessagesToRasp("1-100-50", ipAddress); helper1.ReportSuccess(voiceCommandServiceConnection); break; case "厨房": helper1.SendMessagesToRasp("2-100-50", ipAddress); helper1.ReportSuccess(voiceCommandServiceConnection); break; default: helper1.ReportSuccess(voiceCommandServiceConnection); break; } break; case "Off": await Class1.showProgressScreen(voiceCommandServiceConnection, "正在关闭" + voiceCommand.Properties["rooms"][0] + "的灯"); var OffRoom = voiceCommand.Properties["rooms"][0]; switch (OffRoom) { case "卧室": helper1.SendMessagesToRasp("1-0-50", ipAddress); break; case "厨房": helper1.SendMessagesToRasp("2-0-50", ipAddress); break; default: break; } helper1.ReportSuccess(voiceCommandServiceConnection); break; case "Brighter": await Class1.showProgressScreen(voiceCommandServiceConnection, "正在增加" + voiceCommand.Properties["rooms"][0] + "的亮度"); var BrighterRoom = voiceCommand.Properties["rooms"][0]; switch (BrighterRoom) { case "卧室": helper1.SendMessagesToRasp("1-210-50", ipAddress); helper1.ReportSuccess(voiceCommandServiceConnection); break; case "厨房": helper1.SendMessagesToRasp("2-210-50", ipAddress); helper1.ReportSuccess(voiceCommandServiceConnection); break; default: helper1.ReportSuccess(voiceCommandServiceConnection); break; } break; case "Darker": await Class1.showProgressScreen(voiceCommandServiceConnection, "正在降低" + voiceCommand.Properties["rooms"][0] + "的亮度"); var DarkerRoom = voiceCommand.Properties["rooms"][0]; switch (DarkerRoom) { case "卧室": helper1.SendMessagesToRasp("1-211-50", ipAddress); helper1.ReportSuccess(voiceCommandServiceConnection); break; case "厨房": helper1.SendMessagesToRasp("2-211-50", ipAddress); helper1.ReportSuccess(voiceCommandServiceConnection); break; default: helper1.ReportSuccess(voiceCommandServiceConnection); break; } break; default: helper1.ReportSuccess(voiceCommandServiceConnection); break; } } catch (Exception) { throw; } } }
/// <summary> /// Background task entrypoint. Voice Commands using the <VoiceCommandService Target="..."> /// tag will invoke this when they are recognized by Cortana, passing along details of the /// invocation. /// /// Background tasks must respond to activation by Cortana within 0.5 seconds, and must /// report progress to Cortana every 5 seconds (unless Cortana is waiting for user /// input). There is no execution time limit on the background task managed by Cortana, /// but developers should use plmdebug (https://msdn.microsoft.com/en-us/library/windows/hardware/jj680085%28v=vs.85%29.aspx) /// on the Cortana app package in order to prevent Cortana timing out the task during /// debugging. /// /// Cortana dismisses its UI if it loses focus. This will cause it to terminate the background /// task, even if the background task is being debugged. Use of Remote Debugging is recommended /// in order to debug background task behaviors. In order to debug background tasks, open the /// project properties for the app package (not the background task project), and enable /// Debug -> "Do not launch, but debug my code when it starts". Alternatively, add a long /// initial progress screen, and attach to the background task process while it executes. /// </summary> /// <param name="taskInstance">Connection to the hosting background service process.</param> public async void Run(IBackgroundTaskInstance taskInstance) { serviceDeferral = taskInstance.GetDeferral(); // 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 += OnTaskCanceled; var triggerDetails = taskInstance.TriggerDetails as AppServiceTriggerDetails; // Load localized resources for strings sent to Cortana to be displayed to the user. cortanaResourceMap = ResourceManager.Current.MainResourceMap.GetSubtree("Resources"); // Select the system language, which is what Cortana should be running as. cortanaContext = ResourceContext.GetForViewIndependentUse(); var lang = Windows.Media.SpeechRecognition.SpeechRecognizer.SystemSpeechLanguage.LanguageTag; cortanaContext.Languages = new string[] { Windows.Media.SpeechRecognition.SpeechRecognizer.SystemSpeechLanguage.LanguageTag }; // Get the currently used system date format dateFormatInfo = CultureInfo.CurrentCulture.DateTimeFormat; // This should match the uap:AppService and VoiceCommandService references from the // package manifest and VCD files, respectively. Make sure we've been launched by // a Cortana Voice Command. if (triggerDetails != null && triggerDetails.Name == "AdventureWorksVoiceCommandService") { try { voiceServiceConnection = VoiceCommandServiceConnection.FromAppServiceTriggerDetails( triggerDetails); voiceServiceConnection.VoiceCommandCompleted += OnVoiceCommandCompleted; VoiceCommand voiceCommand = await voiceServiceConnection.GetVoiceCommandAsync(); // Depending on the operation (defined in AdventureWorks:AdventureWorksCommands.xml) // perform the appropriate command. switch (voiceCommand.CommandName) { case "whenIsTripToDestination": var destination = voiceCommand.Properties["destination"][0]; await SendCompletionMessageForDestination(destination); break; case "cancelTripToDestination": var cancelDestination = voiceCommand.Properties["destination"][0]; await SendCompletionMessageForCancellation(cancelDestination); break; default: // As with app activation VCDs, we need to handle the possibility that // an app update may remove a voice command that is still registered. // This can happen if the user hasn't run an app since an update. LaunchAppInForeground(); break; } } catch (Exception ex) { System.Diagnostics.Debug.WriteLine("Handling Voice Command failed " + ex.ToString()); } } }
public void Run(IBackgroundTaskInstance taskInstance) { BackgroundTaskDeferral deferral = taskInstance?.GetDeferral(); //BlynkLogManager.BlynkLogger = new ConsoleBlynkLogger( ConsoleBlynkLogger.LogLevels.LogExceptions // | ConsoleBlynkLogger.LogLevels.LogWarnings // | ConsoleBlynkLogger.LogLevels.LogInformation ); var connection = new BlynkConnection("blynk-cloud.com", 8442, "-secret here-"); if (connection.Connect()) { InitializePins(); connection.AnalogPinNotification.PinWriteNotification = pin => { //Console.WriteLine( "Analog pin received A{0} : {1}", pin.PinNumber, pin.Value ); analogPinList[pin.PinNumber].Value = pin.Value; }; connection.DigitalPinNotification.PinWriteNotification = pin => { //Console.WriteLine( "Digital pin received D{0} : {1}", pin.PinNumber, pin.Value ); digitalPinList[pin.PinNumber].Value = pin.Value; }; connection.AnalogPinNotification.PinReadRequest = pinNumber => { //Console.WriteLine( "Analog pin A{0} requested", pinNumber ); var result = analogPinList[pinNumber]; result.Value = ( short )((result.Value + 1) % 16); return(result); }; connection.DigitalPinNotification.PinReadRequest = pinNumber => { //Console.WriteLine( "Digital pin D{0} requested", pinNumber ); var result = digitalPinList[pinNumber]; result.Value = !result.Value; return(result); }; connection.VirtualPinNotification.PinReadRequest = pinNumber => { //Console.WriteLine( "Virtual pin V{0} requested", pinNumber ); var result = virtualPinList[pinNumber]; result.Values.Clear(); result.Values.Add("255"); return(result); }; //connection.PinModeNotification = ( pinNumber, pinMode ) => Console.WriteLine( "PinMode {0} : {1}", pinNumber, pinMode ); //connection.ResponseReceivedNotification = ( code ) => Console.WriteLine( "Response : {0}", code ); //Console.WriteLine( "hit a key to exit" ); //Console.ReadKey(); //connection.Disconnect(); } else { deferral?.Complete(); } //Console.WriteLine( "exiting" ); //System.Threading.Thread.Sleep( 2000 ); }
private void TaskInstance_Canceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason) { CompleteDeferral(); }
private void OnTaskCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason) => _taskDeferral?.Complete();
private void TaskInstance_Canceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason) { _bootstrapper.Dispose(); }
public void Run(IBackgroundTaskInstance taskInstance) { Debug.WriteLine("Background " + taskInstance.Task.Name + " Starting..."); }
private void TaskInstance_Canceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason) { // Maybe do something... }
private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason) { _cancelRequested = true; _cancelReason = reason; Debug.WriteLine("Background " + sender.Task.Name + " Cancel Requested..."); }
public async void Run(IBackgroundTaskInstance taskInstance) { BackgroundTaskDeferral Deferral = taskInstance.GetDeferral(); taskInstance.Canceled += TaskInstance_Canceled; try { await ClearUselessLogTask(Cancellation.Token).ConfigureAwait(true); using (SqliteConnection Connection = GetSQLConnection()) { await ClearAddressBarHistory(Connection).ConfigureAwait(true); await UpdateSQLiteDataBase(Connection).ConfigureAwait(true); } //The following code is used to update the globalization problem of the ContextMenu in the old version if (!ApplicationData.Current.LocalSettings.Values.ContainsKey("GlobalizationStringForContextMenu")) { if (ApplicationData.Current.LocalSettings.Values["LanguageOverride"] is int LanguageIndex) { switch (LanguageIndex) { case 0: { ApplicationData.Current.LocalSettings.Values["GlobalizationStringForContextMenu"] = "使用RX文件管理器打开"; break; } case 1: { ApplicationData.Current.LocalSettings.Values["GlobalizationStringForContextMenu"] = "Open in RX-Explorer"; break; } case 2: { ApplicationData.Current.LocalSettings.Values["GlobalizationStringForContextMenu"] = "Ouvrir dans RX-Explorer"; break; } case 3: { ApplicationData.Current.LocalSettings.Values["GlobalizationStringForContextMenu"] = "使用RX文件管理器打開"; break; } } } } //To-Do: Do more things as needed when users update the app to newer version } catch (Exception ex) { Debug.WriteLine($"An exception threw in MaintenanceTask, message: {ex.Message}"); } finally { taskInstance.Canceled -= TaskInstance_Canceled; Cancellation?.Dispose(); Cancellation = null; Deferral.Complete(); } }
public void SubscribeToEvents(IBackgroundTaskInstance taskInstance) { taskInstance.Canceled += new BackgroundTaskCanceledEventHandler(OnCanceled); }
private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason) { // Relinquish our task deferral taskDeferral.Complete(); }
public void Run(IBackgroundTaskInstance taskInstance) { }
private void OnTaskCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason) { appServiceDeferral?.Complete(); }
public Task RunAsync(IBackgroundTaskInstance taskInstance) { SubscribeToEvents(taskInstance); return(RunAsyncInternal(taskInstance)); }
public void Run(IBackgroundTaskInstance taskInstance) { System.Diagnostics.Debug.WriteLine("Hello From Quick actions bg"); _deferal = taskInstance.GetDeferral(); taskInstance.Canceled += TaskInstance_Canceled; taskInstance.Task.Completed += Task_Completed; var details = taskInstance.TriggerDetails as ToastNotificationActionTriggerDetail; if (details != null) { try { string arguments = details.Argument; var userInput = details.UserInput; string title = (string)userInput["title"]; string detail = (string)userInput["detail"]; var notify = (byte)int.Parse(userInput["notification"].ToString()); var Time = int.Parse(userInput["snoozeTime"].ToString()); DateTimeOffset now = DateTimeOffset.Now; if (Time == 15) { DateTime nulll = new DateTime(now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second); now = now.AddMinutes(15); } else if (Time == 60) { DateTime nulll = new DateTime(now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second); now.AddHours(1); } else if (Time == 140) { DateTime nulll = new DateTime(now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second); now.AddHours(4); } else if (Time == 160) { DateTime nulll = new DateTime(now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second); now.AddHours(8); } else if (Time == 190) { DateTime nulll = new DateTime(now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second); now.AddDays(1); } DateTime pocker = new DateTime(now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second); var todo = new Todo() { Subject = title, Detail = detail, StartTime = pocker, Notify = notify, Status = 2 }; _service.AddTodo(todo); } catch (Exception ex) { } try { Update(); } catch { } } _deferal.Complete(); }
public void Run(IBackgroundTaskInstance taskInstance) { var work = new Action <CancellationToken>(async(ct) => await Platform.Current.TimedBackgroundWorkAsync(ct)); Platform.Current.ExecuteBackgroundWork(taskInstance, work); }
private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason) { //Clean up and get ready to exit }
private void OnTaskCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason) { System.Diagnostics.Debug.WriteLine("Task cancelled, clean up"); _serviceDeferral?.Complete(); }
public static void Start(IBackgroundTaskInstance instance) { Stage2Notifications backgroundActivity = new Stage2Notifications(); backgroundActivity.Run(instance); }
private void TaskInstance_Canceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason) => _deferal.Complete();
void TaskInstance_Canceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason) { // システムに完了を通知する _appServiceDeferral?.Complete(); }
private void Instance_Canceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason) { _cancelRequested = true; }