Xamarin / Maui: Worker.DoWork, how to launch a long-running, event-driven task

Question

In my .NET Maui Android app, I'm trying to use an AndroidX.Work.Worker to fire up a long running process that listens for events from the Accelerometer. Problem I'm having is that as soon as the DoWork method exits, the Worker terminates. So I need to keep the Worker running by preventing DoWork from exiting, but can't figure out the code for this.

    public class DropDetectorWorker : AndroidX.Work.Worker
    {
        public override Result DoWork()
        {
            CreateInitialNotificationChannel();
            
            var foregroundInfo = new ForegroundInfo(NotificationId++, BuildInitialNotification());
            SetForegroundAsync(foregroundInfo);
            
            InitialiseDropDetector();
            
            // TODO - prevent DoWork from exiting
            return Result.InvokeSuccess();
        }
        
        private void InitialiseDropDetector()
        {
            _dropDetector.DropDetected += DropDetector_DropDetected;
            _dropDetector.Start();
        }
        
        private void DropDetector_DropDetected(object sender, DropDetectedEventArgs e)
        {
            _lastDropDetected = SystemDate.UtcNow;
            TriggerAutoclaimNotification(e.Magnitude);
        }
        
        private void CreateInitialNotificationChannel()
        {
            NotificationChannel channel = new(INITIAL_NOTIFICATION_CHANNEL_ID, INITIAL_NOTIFICATION_CHANNEL_NAME, NotificationImportance.Default)
            {
                LightColor = Microsoft.Maui.Graphics.Color.FromRgba(0, 0, 255, 0).ToInt(),
                LockscreenVisibility = NotificationVisibility.Public
            };
        
            _notificationManager.CreateNotificationChannel(channel);
        }
        
        private void TriggerAutoclaimNotification(double magnitude)
        {
            var foregroundInfo = new ForegroundInfo(NotificationId, BuildMakeClaimNotification(magnitude));
            SetForegroundAsync(foregroundInfo);
        }
    }

Answer 1

Your question is about how to launch a long-running, event-driven task.

Could the same approach that keeps a Task from completing be adapted and used in your DropDetectorWorker constuctor? I'll show what I was thinking which may or may not be a good fit.

This sample keeps it simple for demonstration purposes. A clean, minimal example of such a task would be a clock updater that (without blocking the UI thread) samples the current time ~10x a second and fires an event when the second changes. This code snippet shows how one might launch this task in the App constructor, letting it run in the background.

This general approach could be easily adapted to the Accelerometer monitoring you want your app to do.

---

public partial class App : Application
{
    public App()
    {
        InitializeComponent();

        MainPage = new AppShell();
        _ = Task.Run(() => longRunningEventDrivenTask(LongRunningTskCanceller.Token));
    }
    CancellationTokenSource LongRunningTskCanceller { get; } = new CancellationTokenSource();

    private async Task longRunningEventDrivenTask(CancellationToken token)
    {
        int prevSecond = -1;
        while(!token.IsCancellationRequested)
        {
            var now = DateTime.Now;
            if (now.Second != prevSecond)
            {
                OnSecondChanged(new SecondChangedEventArgs(timestamp: now));
                prevSecond= now.Second;
            }
            await Task.Delay(TimeSpan.FromSeconds(0.1), token);
        }
    }
    public event SecondChangedEventHandler SecondChanged;
    protected virtual void OnSecondChanged(SecondChangedEventArgs e)
    {
        SecondChanged?.Invoke(this, e);
    }
}

Event

public delegate void SecondChangedEventHandler(Object sender, SecondChangedEventArgs e);
public class SecondChangedEventArgs : EventArgs
{
    public SecondChangedEventArgs(DateTime timestamp)
    {
        Timestamp = timestamp;
    }
    public DateTime Timestamp { get; }
}

Answer 2

Ultimately I just needed to start a long-running task on Android. I had gone the Worker approach as I'd had problems with the Foreground Service approach not having permissions to create a Notification. I've since discovered how to get round these restrictions:

• Android needs the user to open the app at least once using the app's home screen icon before Notifications can be created.
• When prompted, the user will must allow Notifications; this happens the first time the app calls NotificationManager.CreateNotificationChannel

once these have been satisfied, the Foreground service fires up and I can run my accelerometer watcher.