Keeping the UWP working in the background using ExtendedExecution or ExtendedExecutionForeground.

[AhmedMustafa505]

I'm implementing a new UWP real-time chat application that I need to keep the app working in the background with the same behavior as it's in the foreground.

I tried to use ExtendedExecution andExtendedExecutionForeground as I'm not intending to push my application on the store, both approaches are working fine when running the application attached with a debugger, but not working without a debugger attached and always getting access denied.

here's my code:

private async void OnEnteredBackground(object sender, EnteredBackgroundEventArgs e)
        {
            await AppendLogAsync("App entering background.");
            StartExtendedExecution();
        }

        private async void OnLeavingBackground(object sender, LeavingBackgroundEventArgs e)
        {
            await AppendLogAsync("App leaving background.");
            StopExtendedExecution();
        }

        private async void StartExtendedExecution()
        {
            StopExtendedExecution();

            _session = new ExtendedExecutionSession
            {
                Reason = ExtendedExecutionReason.Unspecified
            };

            _session.Revoked += SessionRevoked; // The handler type will automatically match
            var result = await _session.RequestExtensionAsync();

            if (result == ExtendedExecutionResult.Allowed)
            {
                await AppendLogAsync("Extended Execution allowed.");
            }
            else
            {
                await AppendLogAsync("Extended Execution denied.");
                StopExtendedExecution();
            }
        }


        private void StopExtendedExecution()
        {
            if (_session != null)
            {
                _session.Dispose();
                _session = null;
            }
        }

        private async void SessionRevoked(object sender, ExtendedExecutionRevokedEventArgs args)
        {
            // Notice the change in the EventArgs type
            await AppendLogAsync($"Extended Execution revoked: {args.Reason}");
            StopExtendedExecution();
        }

when the app running with a debugger attached, the app keeps running while minimized and the suspended state provoked and getting the access of extended execution allowed as follows:

1/13/2024 12:40:13 PM +02:00: App entering background.
1/13/2024 12:40:19 PM +02:00: Extended Execution allowed.
1/13/2024 12:40:19 PM +02:00: App leaving background.

but without a debugger I get:

1/13/2024 12:40:21 PM +02:00: App entering background.
1/13/2024 12:42:45 PM +02:00: Extended Execution denied.
1/13/2024 12:42:45 PM +02:00: App leaving background.

[chrisglein]

There's nothing specific to React Native for Windows here. The question here is about the function of UWP and the requirements for the extended execution options. A quick naive search didn't come up with anything obvious about how the debugger state affects this, but you might be able to find better:

• https://learn.microsoft.com/en-us/windows/uwp/launch-resume/run-in-the-background-indefinetly
• https://learn.microsoft.com/en-us/windows/uwp/launch-resume/run-minimized-with-extended-execution
• https://learn.microsoft.com/en-us/samples/microsoft/windows-universal-samples/extendedexecution/
• https://stackoverflow.com/questions/37411668/understanding-extended-execution-session-in-windows-universal-app-uwp

You might have better luck hitting a larger audience with a UWP Stackoverflow query.

Essentially... this is outside our expertise and outside the scope of this repo. But best of luck to you!