public async void Run(IBackgroundTaskInstance taskInstance)
{
serviceDeferral = taskInstance.GetDeferral();
taskInstance.Canceled += OnTaskCanceled;
var triggerDetails = taskInstance.TriggerDetails as AppServiceTriggerDetails;
if (triggerDetails == null)
{
serviceDeferral.Complete();
return;
}
try
{
voiceServiceConnection = VoiceCommandServiceConnection.FromAppServiceTriggerDetails(triggerDetails);
voiceServiceConnection.VoiceCommandCompleted += OnVoiceCommandCompleted;
var voiceCommand = await voiceServiceConnection.GetVoiceCommandAsync();
//Find the command name witch should match the VCD
if (voiceCommand.CommandName == "buildit_help")
{
var props = voiceCommand.Properties;
await CortanaHelpList();
}
await Task.Delay(1000);
await ShowProgressScreen();
}
catch
{
Debug.WriteLine("Unable to process voice command");
}
serviceDeferral.Complete();
}
//
// 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();
}
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();
}
/// <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)
{
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;
}
}
/// <summary>
/// Hệ thống gọi đến hàm này khi association backgroundtask được bật
/// </summary>
/// <param name="taskInstance"> hệ thống tự tạo và truyền vào đây</param>
public async void Run(IBackgroundTaskInstance taskInstance)
{
//System.Diagnostics.Debug.WriteLine("background run");
taskInstance.Canceled += new BackgroundTaskCanceledEventHandler(BackgroundTaskCanceled);
taskInstance.Task.Completed += new BackgroundTaskCompletedEventHandler(BackgroundTaskCompleted);
_backgroundstarted.Set();//
_deferral = taskInstance.GetDeferral();
//Playlist = new BackgroundPlaylist();
_smtc = initSMTC();
this._foregroundState = this.initForegroundState();
BackgroundMediaPlayer.Current.CurrentStateChanged += BackgroundMediaPlayer_CurrentStateChanged;
//Playlist = await BackgroundPlaylist.LoadBackgroundPlaylist("playlist.xml");
Playlist = new BackgroundPlaylist();
Playlist.ListPathsource = await BackgroundPlaylist.LoadCurrentPlaylist(Constant.CurrentPlaylist);
if (_foregroundState != eForegroundState.Suspended)
{
ValueSet message = new ValueSet();
message.Add(Constant.BackgroundTaskStarted, "");
BackgroundMediaPlayer.SendMessageToForeground(message);
}
Playlist.TrackChanged += Playlist_TrackChanged;
BackgroundMediaPlayer.MessageReceivedFromForeground += BackgroundMediaPlayer_MessageReceivedFromForeground;
BackgroundMediaPlayer.Current.MediaEnded +=Current_MediaEnded;
ApplicationSettingHelper.SaveSettingsValue(Constant.BackgroundTaskState, Constant.BackgroundTaskRunning);
isbackgroundtaskrunning = true;
_loopState = eLoopState.None;
}
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 ConnectTheDots Settings
localSettings.ServicebusNamespace = "iotbuildlab-ns";
localSettings.EventHubName = "ehdevices";
localSettings.KeyName = "D1";
localSettings.Key = "iQFNbyWTYRBwypMtPmpfJVz+NBgR32YHrQC0ZSvId20=";
localSettings.DisplayName = GetHostName();
localSettings.Organization = "IoT Build Lab";
localSettings.Location = "USA";
SaveSettings();
// Initialize WeatherShield
await shield.BeginAsync();
// Create a timer-initiated ThreadPool task to read data from I2C
i2cTimer = ThreadPoolTimer.CreatePeriodicTimer(PopulateWeatherData, TimeSpan.FromSeconds(i2cReadIntervalSeconds));
// Start the server
server = new HttpServer(port);
var asyncAction = ThreadPool.RunAsync((w) => { server.StartServer(shield, weatherData); });
// Task cancellation handler, release our deferral there
taskInstance.Canceled += OnCanceled;
// Create a timer-initiated ThreadPool task to renew SAS token regularly
SasTokenRenewTimer = ThreadPoolTimer.CreatePeriodicTimer(RenewSasToken, TimeSpan.FromMinutes(15));
}
public async void Run(IBackgroundTaskInstance taskInstance) {
try {
// Ensure our background task remains running
taskDeferral = taskInstance.GetDeferral();
// Initialize cloud connection
azureConnector = new AzureConnector();
await azureConnector.InitAsync();
// Initialize WeatherShield
await shield.BeginAsync();
// Create a timer-initiated ThreadPool task to read data from I2C
ThreadPoolTimer.CreatePeriodicTimer(async (source) => {
await readAndSendWeatherRecord();
}, TimeSpan.FromSeconds(weatherShieldReadInterval));
// Task cancellation handler, release our deferral there
taskInstance.Canceled += OnCanceled;
} catch(Exception ex) {
await LogExceptionAsync(nameof(Run), ex);
if(Debugger.IsAttached) {
Debugger.Break();
}
// If it goes to shit here, rethrow which will terminate the process - but at least we have it logged!
throw;
}
}
public async void Run( IBackgroundTaskInstance taskInstance )
{
Deferral = taskInstance.GetDeferral();
XParameter[] Params = SavedChannels.Parameters( "channel" );
if ( Params.Length == 0 )
{
Deferral.Complete();
return;
}
// Associate a cancellation handler with the background task.
taskInstance.Canceled += new BackgroundTaskCanceledEventHandler( OnCanceled );
foreach ( XParameter Param in Params )
{
CurrentTask = new XParameter( DateTime.Now.ToFileTime() + "" );
CurrentTask.SetValue( new XKey[] {
new XKey( "name", taskInstance.Task.Name )
, new XKey( "start", true )
, new XKey( "end", false )
} );
PushNotificationChannel channel = await PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync();
if ( channel.Uri != Param.GetValue( "uri" ) )
{
await RenewChannel( Param.GetValue( "provider" ), Param.Id, Uri.EscapeDataString( channel.Uri ) );
}
}
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 ConnectTheDots Settings
localSettings.ServicebusNamespace = "windowactuator-ns";
localSettings.EventHubName = "ehdevices";
localSettings.KeyName = "D1";
localSettings.Key = "1uMOwjURpgGX9l5JqnYeatBkIRoLzP7qH8YGFUeAIrU=";
localSettings.DisplayName = GetHostName();
localSettings.Organization = "Ulster University";
localSettings.Location = "North Europe";
SaveSettings();
// Initialize WeatherShield
await shield.BeginAsync();
// Create a timer-initiated ThreadPool task to read data from I2C
i2cTimer = ThreadPoolTimer.CreatePeriodicTimer(PopulateWeatherData, TimeSpan.FromSeconds(i2cReadIntervalSeconds));
// Start the server
server = new HttpServer(port);
var asyncAction = ThreadPool.RunAsync((w) => { server.StartServer(shield, weatherData); });
// Task cancellation handler, release our deferral there
taskInstance.Canceled += OnCanceled;
// Create a timer-initiated ThreadPool task to renew SAS token regularly
SasTokenRenewTimer = ThreadPoolTimer.CreatePeriodicTimer(RenewSasToken, TimeSpan.FromMinutes(15));
}
public void Run(IBackgroundTaskInstance taskInstance)
{
_deferral = taskInstance.GetDeferral();
Init();
temperatureTimer = ThreadPoolTimer.CreatePeriodicTimer(temperatureTimer_Tick, TimeSpan.FromMinutes(5));
thermostatStatusTimer = ThreadPoolTimer.CreatePeriodicTimer(thermostatStatusTimer_Tick, TimeSpan.FromMilliseconds(500));
}
public void Run(IBackgroundTaskInstance taskInstance)
{
deferral = taskInstance.GetDeferral();
InitGPIO();
GetBusArrivalData();
}
/// <summary>
/// Entry point for the background task.
/// </summary>
public async void Run(IBackgroundTaskInstance taskInstance)
{
var triggerDetails = taskInstance.TriggerDetails as AppServiceTriggerDetails;
if (null != triggerDetails && triggerDetails.Name == "LightControllerVoiceCommandService")
{
_deferral = taskInstance.GetDeferral();
taskInstance.Canceled += (s, e) => _deferral.Complete();
if (true != await InitializeAsync(triggerDetails))
{
return;
}
// These command phrases are coded in the VoiceCommands.xml file.
switch (_voiceCommand.CommandName)
{
case "changeLightsState": await ChangeLightStateAsync(); break;
case "changeLightsColor": await SelectColorAsync(); break;
case "changeLightStateByName": await ChangeSpecificLightStateAsync(); break;
default: await _voiceServiceConnection.RequestAppLaunchAsync(
CreateCortanaResponse("Launching HueLightController")); break;
}
// keep alive for 1 second to ensure all HTTP requests sent.
await Task.Delay(1000);
_deferral.Complete();
}
}
/// <summary>
/// Background task entry point.
/// </summary>
/// <param name="taskInstance"></param>
public void Run(IBackgroundTaskInstance taskInstance)
{
Accelerometer = Accelerometer.GetDefault();
if (null != Accelerometer)
{
SampleCount = 0;
// Select a report interval that is both suitable for the purposes of the app and supported by the sensor.
uint minReportIntervalMsecs = Accelerometer.MinimumReportInterval;
Accelerometer.ReportInterval = minReportIntervalMsecs > 16 ? minReportIntervalMsecs : 16;
// Subscribe to accelerometer ReadingChanged events.
Accelerometer.ReadingChanged += new TypedEventHandler<Accelerometer, AccelerometerReadingChangedEventArgs>(ReadingChanged);
// Take a deferral that is released when the task is completed.
Deferral = taskInstance.GetDeferral();
// Get notified when the task is canceled.
taskInstance.Canceled += new BackgroundTaskCanceledEventHandler(OnCanceled);
// Store a setting so that the app knows that the task is running.
ApplicationData.Current.LocalSettings.Values["IsBackgroundTaskActive"] = true;
}
}
/// <summary>
/// Performs the work of a background task. The system calls this method when the associated
/// background task has been triggered.
/// </summary>
/// <param name="taskInstance">
/// An interface to an instance of the background task. The system creates this instance when the
/// task has been triggered to run.
/// </param>
public void Run(IBackgroundTaskInstance taskInstance)
{
Debug.WriteLine("Background Audio Task " + taskInstance.Task.Name + " starting");
this.systemMediaTransportControl = SystemMediaTransportControls.GetForCurrentView();
this.systemMediaTransportControl.IsEnabled = true;
this.systemMediaTransportControl.IsPauseEnabled = true;
this.systemMediaTransportControl.IsPlayEnabled = true;
this.systemMediaTransportControl.IsNextEnabled = true;
this.systemMediaTransportControl.IsPreviousEnabled = true;
// Wire up system media control events
this.systemMediaTransportControl.ButtonPressed += this.OnSystemMediaTransportControlButtonPressed;
this.systemMediaTransportControl.PropertyChanged += this.OnSystemMediaTransportControlPropertyChanged;
// Wire up background task events
taskInstance.Canceled += this.OnTaskCanceled;
taskInstance.Task.Completed += this.OnTaskcompleted;
// Initialize message channel
BackgroundMediaPlayer.MessageReceivedFromForeground += this.OnMessageReceivedFromForeground;
// Notify foreground that we have started playing
BackgroundMediaPlayer.SendMessageToForeground(new ValueSet() { { "BackgroundTaskStarted", "" } });
this.backgroundTaskStarted.Set();
this.backgroundTaskRunning = true;
this.deferral = taskInstance.GetDeferral();
}
public void Run(IBackgroundTaskInstance taskInstance)
{
deferral = taskInstance.GetDeferral();
ConnectToScreen(0x4a);
car = new SerialCarHardwareInterface(null);
}
//TemperatureSensors tempSensors;
public void Run(IBackgroundTaskInstance taskInstance)
{
//if (!_started)
//{
// tempSensors = new TemperatureSensors();
// tempSensors.InitSensors();
// _started = true;
//}
// Associate a cancellation handler with the background task.
taskInstance.Canceled += TaskInstance_Canceled;
// Get the deferral object from the task instance
serviceDeferral = taskInstance.GetDeferral();
var appService = taskInstance.TriggerDetails as AppServiceTriggerDetails;
if (appService != null && appService.Name == "App2AppComService")
{
appServiceConnection = appService.AppServiceConnection;
appServiceConnection.RequestReceived += AppServiceConnection_RequestReceived; ;
}
// just run init, maybe don't need the above...
Initialize();
}
public Task RunAsync(IBackgroundTaskInstance taskInstance)
{
if (taskInstance == null) throw new ArgumentNullException(nameof(taskInstance));
_deferral = taskInstance.GetDeferral();
return RunAsync();
}
public async void Run(IBackgroundTaskInstance taskInstance)
{
System.Diagnostics.Debug.WriteLine("WE are @ Background");
_deferral = taskInstance.GetDeferral();
_taskInstance = taskInstance;
_taskInstance.Canceled += new BackgroundTaskCanceledEventHandler(OnCanceled);
GattCharacteristicNotificationTriggerDetails details = (GattCharacteristicNotificationTriggerDetails)taskInstance.TriggerDetails;
//get the characteristics data and get heartbeat value out from it
byte[] ReceivedData = new byte[details.Value.Length];
DataReader.FromBuffer(details.Value).ReadBytes(ReceivedData);
HeartbeatMeasurement tmpMeasurement = HeartbeatMeasurement.GetHeartbeatMeasurementFromData(ReceivedData);
System.Diagnostics.Debug.WriteLine("Background heartbeast values: " + tmpMeasurement.HeartbeatValue);
// send heartbeat values via progress callback
_taskInstance.Progress = tmpMeasurement.HeartbeatValue;
//update the value to the Tile
LiveTile.UpdateSecondaryTile("" + tmpMeasurement.HeartbeatValue);
//Check if we are within the limits, and alert by starting the app if we are not
alertType alert = await checkHeartbeatLevels(tmpMeasurement.HeartbeatValue);
_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 ConnectTheDots Settings
localSettings.ServicebusNamespace = "YOURSERVICEBUS-ns";
localSettings.EventHubName = "ehdevices";
localSettings.KeyName = "D1";
localSettings.Key = "YOUR_KEY";
localSettings.DisplayName = "YOUR_DEVICE_NAME";
localSettings.Organization = "YOUR_ORGANIZATION_OR_SELF";
localSettings.Location = "YOUR_LOCATION";
SaveSettings();
// Initialize WeatherShield
await shield.BeginAsync();
// Create a timer-initiated ThreadPool task to read data from I2C
i2cTimer = ThreadPoolTimer.CreatePeriodicTimer(PopulateWeatherData, TimeSpan.FromSeconds(i2cReadIntervalSeconds));
// Start the server
server = new HttpServer(port);
var asyncAction = ThreadPool.RunAsync((w) => { server.StartServer(weatherData); });
// Task cancellation handler, release our deferral there
taskInstance.Canceled += OnCanceled;
// Create a timer-initiated ThreadPool task to renew SAS token regularly
SASTokenRenewTimer = ThreadPoolTimer.CreatePeriodicTimer(RenewSASToken, TimeSpan.FromMinutes(15));
}
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;
}
//
// The Run method is the entry point of a background task.
//
public void Run(IBackgroundTaskInstance taskInstance)
{
var details = taskInstance.TriggerDetails as ToastNotificationActionTriggerDetail;
if (details != null)
{
string arguments = details.Argument;
var userInput = details.UserInput;
}
Debug.WriteLine("Background " + taskInstance.Task.Name + " Starting...");
//
// 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;
_deferral.Complete();
// _periodicTimer = ThreadPoolTimer.CreatePeriodicTimer(new TimerElapsedHandler(PeriodicTimerCallback), TimeSpan.FromSeconds(1));
}
public void Run(IBackgroundTaskInstance taskInstance)
{
deferral = taskInstance.GetDeferral();
InitGPIO();
timer = ThreadPoolTimer.CreatePeriodicTimer(Timer_Tick, TimeSpan.FromMilliseconds(500));
}
public void Run(IBackgroundTaskInstance taskInstance)
{
deferral = taskInstance.GetDeferral();
//Motor starts off
currentPulseWidth = 0;
//The stopwatch will be used to precisely time calls to pulse the motor.
stopwatch = Stopwatch.StartNew();
GpioController controller = GpioController.GetDefault();
//Buttons are attached to pins 5 and 6 to control which direction the motor should run in
//Interrupts (ValueChanged) events are used to notify this app when the buttons are pressed
forwardButton = controller.OpenPin(5);
forwardButton.DebounceTimeout = new TimeSpan(0, 0, 0, 0, 250);
forwardButton.SetDriveMode(GpioPinDriveMode.Input);
forwardButton.ValueChanged += _forwardButton_ValueChanged;
backwardButton = controller.OpenPin(6);
backwardButton.SetDriveMode(GpioPinDriveMode.Input);
forwardButton.DebounceTimeout = new TimeSpan(0, 0, 0, 0, 250);
backwardButton.ValueChanged += _backgwardButton_ValueChanged;
servoPin = controller.OpenPin(13);
servoPin.SetDriveMode(GpioPinDriveMode.Output);
//You do not need to await this, as your goal is to have this run for the lifetime of the application
Windows.System.Threading.ThreadPool.RunAsync(this.MotorThread, Windows.System.Threading.WorkItemPriority.High);
}
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)
{
InitializeAndSetMediaTransportControl();
taskInstance.Canceled += new BackgroundTaskCanceledEventHandler(OnCanceled);
taskInstance.Task.Completed += Taskcompleted;
var value = ApplicationSettingsHelper.ReadResetSettingsValue(ConstantValues.AppState);
if (value == null)
_foregroundAppState = ForegroundAppStatus.Unknown;
else
_foregroundAppState = (ForegroundAppStatus)Enum.Parse(typeof(ForegroundAppStatus), value.ToString());
BackgroundMediaPlayer.Current.CurrentStateChanged += Current_CurrentStateChanged;
UpdateQueue();
_queue.TrackChanged += playList_TrackChanged;
BackgroundMediaPlayer.MessageReceivedFromForeground += BackgroundMediaPlayer_MessageReceivedFromForeground;
if (_foregroundAppState != ForegroundAppStatus.Suspended)
{
ValueSet message = new ValueSet { { ConstantValues.BackgroundTaskStarted, "" } };
BackgroundMediaPlayer.SendMessageToForeground(message);
}
_backgroundTaskStarted.Set();
_backgroundtaskrunning = true;
ApplicationSettingsHelper.SaveSettingsValue(ConstantValues.BackgroundTaskState, ConstantValues.BackgroundTaskRunning);
_deferral = taskInstance.GetDeferral();
}
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)
{
_settingsUtility = new SettingsUtility();
_foregroundMessenger = new ForegroundMessenger();
_smtcWrapper = new SmtcWrapper(BackgroundMediaPlayer.Current.SystemMediaTransportControls);
_playerWrapper = new PlayerWrapper(_smtcWrapper, _foregroundMessenger, _settingsUtility);
_settingsUtility.Write(ApplicationSettingsConstants.BackgroundTaskState,
BackgroundTaskState.Running);
// Send information to foreground that background task has been started if app is active
if (_playerWrapper.ForegroundAppState != AppState.Suspended)
MessageHelper.SendMessageToForeground(new BackgroundAudioTaskStartedMessage());
// This must be retrieved prior to subscribing to events below which use it
_deferral = taskInstance.GetDeferral();
// Mark the background task as started to unblock SMTC Play operation (see related WaitOne on this signal)
TaskStarted.Set();
// Associate a cancellation and completed handlers with the background task.
taskInstance.Task.Completed += TaskCompleted;
// event may raise immediately before continung thread excecution so must be at the end
taskInstance.Canceled += OnCanceled;
}
public void Run(IBackgroundTaskInstance taskInstance)
{
deferral = taskInstance.GetDeferral();
Initialize();
Start();
}
public async void Run(IBackgroundTaskInstance taskInstance)
{
deferral = taskInstance.GetDeferral();
Services.IoC.Register();
var container = Container.Instance;
logger = container.Resolve<ILogger>();
taskInstance.Task.Completed += onTaskCompleted;
taskInstance.Canceled += onTaskCanceled;
logger.LogMessage("BackgroundUpdater: Task initialized.", LoggingLevel.Information);
var episodeListManager = container.Resolve<IEpisodeListManager>();
await episodeListManager.Initialization;
var oldEpisodeList = EpisodeList.Instance.ToList();
await episodeListManager.LoadEpisodeListFromServerAsync();
var diff = EpisodeList.Instance.Except(oldEpisodeList).ToList();
if (diff.Any())
{
var downloadManager = container.Resolve<IDownloadManager>();
await downloadManager.Initialization;
foreach (var episode in diff)
{
await downloadManager.DownloadEpisode(episode);
}
}
deferral.Complete();
}