Xamarin/Maui app still goes to sleep even though told not to

My .Net Maui app, running on Android (API 33), needs to stay running. I had thought that using an Android Foreground Service took care of this, but have now discovered that Android sends the app and its foreground service to sleep after a few minutes. Well, I believe it is sleeping, as the log file that the app should update regularly stops getting updated, and the app "wakes up" and starts logging again if I unlock the phone. If I run the app on a real device and with wireless debugging running, connected to my dev laptop, the app stays awake, but goes to sleep if not debugging.
I have tried 2 approaches and neither is keeping my app running:

1. I told Android to not apply battery optimisations to the app, by going into Settings -> Apps -> My App Name -> Battery -> select Unrestricted
2. I told Android to set my app as a never-sleeping app, by going into Settings -> Battery and device care -> Battery -> Background usage limits -> Never sleeping apps -> add My App Name (NOTE this undoes what was done in step 1)

Is there some other way to keep the app's foreground service running?

Since posting this question I've done more research found that creating a wake lock via a foreground service keeps the app running even when the screen is off.

To do this, I created a foreground service (ScreenOffService, inherited from Android.App.Service).

I also created a BroadcastReceiver (ScreenOffBroadcastReceiver, inherited from Android.Content.BroadcastReceiver) that recieves SCREEN_OFF events and, when it does, acquires an Android.OS.PowerManager.WakeLock with WakeLockFlags.Partial.

ScreenOffService calls its base class's RegisterReceiver(new ScreenOffBroadcastReceiver()).
My app stays awake now.

AndroidManifest.xml
	<uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
	<uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
	<uses-permission android:name="android.permission.WAKE_LOCK" />

    var intent = new Intent(Android.App.Application.Context, typeof(ScreenOffService));
    intent.SetAction(ScreenOffService.ActionStartScreenOffService);
    Android.App.Application.Context.StartForegroundService(intent);


    [Service(Label = nameof(ScreenOffService))]
    [RequiresApi(Api = (int)BuildVersionCodes.R)]
    public class ScreenOffService : Service
    {
        private static readonly string TypeName = typeof(ScreenOffService).FullName;
        public static readonly string ActionStartScreenOffService = TypeName + ".action.START";

        internal const int NOTIFICATION_ID = 12345678;
        private const string NOTIFICATION_CHANNEL_ID = "screen_off_service_channel_01";
        private const string NOTIFICATION_CHANNEL_NAME = "screen_off_service_channel_name";
        private NotificationManager _notificationManager;

        private bool _isStarted;

        private readonly ScreenOffBroadcastReceiver _screenOffBroadcastReceiver;

        public ScreenOffService()
        {
            _screenOffBroadcastReceiver = Microsoft.Maui.Controls.Application.Current.Handler.MauiContext.Services.GetService<ScreenOffBroadcastReceiver>();
        }

        public override void OnCreate()
        {
            base.OnCreate();

            _notificationManager = GetSystemService(Context.NotificationService) as NotificationManager;

            RegisterScreenOffBroadcastReceiver();
        }

        public override void OnDestroy()
        {
            base.OnDestroy();

            UnregisterScreenOffBroadcastReceiver();
        }

        [return: GeneratedEnum]
        public override StartCommandResult OnStartCommand(Intent intent, [GeneratedEnum] StartCommandFlags flags, int startId)
        {
            CreateNotificationChannel(); // Elsewhere we must've prompted user to allow Notifications

            if (intent.Action == ActionStartScreenOffService)
            {
                try
                {
                    StartForeground();
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Unable to start Screen On/Off foreground svc: " + ex);
                }
            }

            return StartCommandResult.Sticky;
        }

        private void RegisterScreenOffBroadcastReceiver()
        {
            var filter = new IntentFilter();
            filter.AddAction(Intent.ActionScreenOff);
            RegisterReceiver(_screenOffBroadcastReceiver, filter);
        }

        private void UnregisterScreenOffBroadcastReceiver()
        {
            try
            {
                if (_screenOffBroadcastReceiver != null)
                {
                    UnregisterReceiver(_screenOffBroadcastReceiver);
                }
            }
            catch (Java.Lang.IllegalArgumentException ex)
            {
                Console.WriteLine($"Error while unregistering {nameof(ScreenOffBroadcastReceiver)}. {ex}");
            }
        }

        private void StartForeground()
        {
            if (!_isStarted)
            {
                Notification notification = BuildInitialNotification();
                StartForeground(NOTIFICATION_ID, notification);

                _isStarted = true;
            }
        }

        private Notification BuildInitialNotification()
        {
            var intentToShowMainActivity = BuildIntentToShowMainActivity();

            var notification = new NotificationCompat.Builder(this, NOTIFICATION_CHANNEL_ID)
                .SetContentTitle(Resources.GetString(Resource.String.app_name))
                .SetContentText(Resources.GetString(Resource.String.screen_off_service_started_notification_text))
                .SetSmallIcon(Resource.Drawable.eip_logo_symbol_yellow) // Android top bar icon and Notification drawer item LHS icon
                .SetLargeIcon(global::Android.Graphics.BitmapFactory.DecodeResource(Resources, Resource.Drawable.eip_logo_yellow)) // Notification drawer item RHS icon
                .SetContentIntent(intentToShowMainActivity)
                .SetOngoing(true)
                .Build();

            return notification;
        }

        private PendingIntent BuildIntentToShowMainActivity()
        {
            var mainActivityIntent = new Intent(this, typeof(MainActivity));
            mainActivityIntent.SetAction(Constants.ACTION_MAIN_ACTIVITY);
            mainActivityIntent.SetFlags(ActivityFlags.SingleTop | ActivityFlags.ClearTask);
            mainActivityIntent.PutExtra(Constants.SERVICE_STARTED_KEY, true);

            PendingIntent pendingIntent = PendingIntent.GetActivity(this, 0, mainActivityIntent, PendingIntentFlags.UpdateCurrent | PendingIntentFlags.Immutable);

            return pendingIntent;
        }

        private void CreateNotificationChannel()
        {
            NotificationChannel chan = new(NOTIFICATION_CHANNEL_ID, NOTIFICATION_CHANNEL_NAME, NotificationImportance.Default)
            {
                LightColor = Microsoft.Maui.Graphics.Color.FromRgba(0, 0, 255, 0).ToInt(),
                LockscreenVisibility = NotificationVisibility.Public
            };

            _notificationManager.CreateNotificationChannel(chan);
        }

        public override IBinder OnBind(Intent intent)
        {
            return null;
        }
    }

    [BroadcastReceiver(Name = "com.eip.MobileApp.ScreenOffBroadcastReceiver", Label = "ScreenOffBroadcastReceiver", Exported = true)]
    [IntentFilter(new[] { Intent.ActionScreenOff }, Priority = (int)IntentFilterPriority.HighPriority)]
    public class ScreenOffBroadcastReceiver : BroadcastReceiver
    {
        private readonly ILogger<ScreenOffBroadcastReceiver> _logger;

        private PowerManager.WakeLock _wakeLock;

        public ScreenOffBroadcastReceiver()
        {
            _logger = Microsoft.Maui.Controls.Application.Current.Handler.MauiContext.Services.GetService<ILogger<ScreenOffBroadcastReceiver>>();
        }

        public override void OnReceive(Context context, Intent intent)
        {
            if (intent.Action == Intent.ActionScreenOff)
            {
                AcquireWakeLock();
            }
        }

        private void AcquireWakeLock()
        {
            _wakeLock?.Release();

            WakeLockFlags wakeFlags = WakeLockFlags.Partial;

            PowerManager pm = (PowerManager)global::Android.App.Application.Context.GetSystemService(global::Android.Content.Context.PowerService);
            _wakeLock = pm.NewWakeLock(wakeFlags, typeof(ScreenOffBroadcastReceiver).FullName);
            _wakeLock.Acquire();
        }

        protected override void Dispose(bool disposing)
        {
            base.Dispose(disposing);

            _wakeLock?.Release();
        }
    }