I would be very interested to see a simpler solution. Barring that, you can put in place an arbitration mechanism. Something along these lines:
public class AppSynchronization
{
// Called by the main app on launch or on resume. It will signal the main app's intention to start.
// The main app will not perform any significant actions before this method returns.
public void ActivateMainApp() {...}
// Called by the main app. It will signal the fact that the main app is "going away".
public async Task MainAppSuspended() {...}
// Called by the background agent.
// It will signal the background agent intention to start.
// This method will only return if the main app is out of the way.
// It will return a cancellation token that will be used to cancel the activity of the background agent when the main app advertises its intention to start.
public async Task<CancellationToken> ActivateBackgroundAgent(CancellationToken cancelWait)
{
// Make sure the main app is not started or wait until the main app is out of the way
// Start a thread that is on the lookout for the main app announcing that it wants to start.
// When that happens it will cancel the cancellation token returned.
}
// <summary>
// Called by the background agent.
// It will signal the fact that the background agent completed its actions.
public async Task DeactivateBackgroundAgent()
}
In the main app:
private AppSynchronization appSynchronization;
public App()
{
...
this.appSynchronization = new AppSynchronization();
}
protected async override void OnLaunched(LaunchActivatedEventArgs e)
{
...
if (rootFrame.Content == null)
{
// Advertise the fact that the main app wants to start.
// The background agent will know to cancel whatever its doing.
// ActivateMainApp may have to be async although you need to make sure that OnLaunched supports that
this.appSynchronization.ActivateMainApp();
...
}
}
private async void OnResuming(object sender, object e)
{
...
// Advertise the fact that the main app wants to resume.
// The background agent will know to cancel whatever its doing.
this.appSynchronization.ActivateMainApp();
}
private async void OnSuspending(object sender, SuspendingEventArgs e)
{
var deferral = e.SuspendingOperation.GetDeferral();
...
// Advertise the fact that the main app is suspending.
// The background agent will know it is allowed to start doing work.
await _mainAppSynchronization.MainAppSuspended();
...
deferral.Complete();
}
private void OnUnhandledException(object sender, UnhandledExceptionEventArgs e)
{
...
// Advertise the fact that the main app is going away.
// The background agent will know it is allowed to start doing work.
_mainAppSynchronization.MainAppSuspended().Wait();
}
And in the background agent:
public sealed class BackgroundTask : IBackgroundTask
{
public async void Run(IBackgroundTaskInstance taskInstance)
{
...
AppSynchronization appSynchronization = new AppSynchronization();
BackgroundTaskDeferral deferral = taskInstance.GetDeferral();
// Make sure that the main app is not started. If it is started then wait until the main app gets out of the way.
// It he main app is running this will wait indefinitely.
// Use backgroundAgentCancellationToken to cancel the actions of the background agent when the main app advertises its intention to start.
CancellationToken backgroundAgentCancellationToken = await appSynchronization.ActivateBackgroundAgent();
await DoBackgroundAgentWork(backgroundAgentCancellationToken)
// Advertise the fact that the background agent is out.
// DeactivateBackgroundAgent will make sure that the synchronization mechanism advertised the fact that the background agent is out.
// DeactivateBackgroundAgent may have to be declared async in case the synchronization mechanism uses async code to do what is needed.
await appSynchronization.DeactivateBackgroundAgent();
deferral.Complete();
}
I am not sure if there is any way to communicate across processes in UWP. The arbitration mechanism itself may have to be based on files on the local storage.
The arbitration mechanism may have to include a heartbeat mechanism in the event that one or the other process crashes in a catastrophic way.
