Xamarin AndroidX WorkManager not working when app is killed

Question

Xamarin AndroidX WorkManager not working when app is killed

I'm trying to setup a WorkManager that executes a task every 15 minutes. For now I'm doing this test adding an entry in a firebase database.

I'm using the nuget package Xamarin.AndroidX.Work.Runtime (2.5.0.2)

This works fine if the app is in foreground or background, but if I kill the app it stops working.

I'm doing this test with a Nokia 8 Sirocco (api 28) and with a Samsung Galaxy A21S (api 30) that both mount Android Stock.

This is how I launch the work:

private void StartParallelWorkManager(int minutes)
    {
        PeriodicWorkRequest taskLauncher = PeriodicWorkRequest.Builder.From<UniquePeriodicWorker>(TimeSpan.FromMinutes(minutes)).Build();
        WorkManager.GetInstance(Xamarin.Essentials.Platform.AppContext).EnqueueUniquePeriodicWork("TestTask", ExistingPeriodicWorkPolicy.Keep, taskLauncher);
    }

and this is my Worker class:

public class UniquePeriodicWorker : Worker
    {
        public UniquePeriodicWorker(Context context, WorkerParameters workerParameters) : base(context, workerParameters)
        {
        }

        public override Result DoWork()
        {

            System.Console.WriteLine("{0} DO WORK", DateTime.Now.ToString("dd/MM HH:mm:ss"));
            try
            {
                _ = CrossCloudFirestore.Current
                             .Instance
                             .Collection("WorkManagerRuns")
                             .AddAsync<DateTime>(DateTime.Now);
            }
            catch(Exception ex)
            {
                System.Diagnostics.Debug.WriteLine(ex);
            }
            return Result.InvokeSuccess();
        }
    }

Doing the same test with native code in android studio works like a charm.

Am I missing something in Xamarin side or is Xamarin.AndroidX.Work.Runtime bugged?
Any suggestion?

Answer 1

Hello,

Welcome to our Microsoft Q&A platform!

Starting in Android 8.0 (API level 26), an Android application no longer have the ability to run freely in the background. When an application moves into the background, Android will grant the app a certain amount of time to start and use services. Once that time has elapsed, the app can no longer start any services and any services that were started will be terminated. At this point it is not possible for the app to perform any work.

To keep the service working even when the app is closed, try using a ForegroundService instead. Here is the sample code:

   [Service(Enabled = true)]  
   public class CustomService : Service  
   {  
       private Handler handler;  
       private Action runnable;  
       private bool isStarted;  
       private int DELAY_BETWEEN_LOG_MESSAGES = 5000;  
       private int NOTIFICATION_SERVICE_ID = 1001;  
       private int NOTIFICATION_AlARM_ID = 1002;  
       private string NOTIFICATION_CHANNEL_ID = "1003";  
       private string NOTIFICATION_CHANNEL_NAME = "MyChannel";  
       public override void OnCreate()  
       {  
           base.OnCreate();  
     
           handler = new Handler();  
           //here is what you want to do always  
           runnable = new Action(() =>  
           {  
               if (isStarted)  
               {  
                   DispatchNotificationThatAlarmIsGenerated("I'm running");  
                   //the function  
                   handler.PostDelayed(runnable, DELAY_BETWEEN_LOG_MESSAGES);  
               }  
           });  
       }  
     
       public override StartCommandResult OnStartCommand(Intent intent, StartCommandFlags flags, int startId)  
       {  
           if (isStarted)  
           {  
               // service is already started  
           }  
           else  
           {  
               CreateNotificationChannel();  
               DispatchNotificationThatServiceIsRunning();  
     
               handler.PostDelayed(runnable, DELAY_BETWEEN_LOG_MESSAGES);  
               isStarted = true;  
           }  
           return StartCommandResult.Sticky;  
       }  
     
       private void DispatchNotificationThatServiceIsRunning()  
       {  
           var notificationManager = (NotificationManager)GetSystemService(NotificationService);  
     
           if (Build.VERSION.SdkInt > BuildVersionCodes.O)  
           {  
               var chan = new NotificationChannel(NOTIFICATION_CHANNEL_ID, GetString(Resource.String.abc_action_bar_home_description), NotificationImportance.Default);  
               chan.LightColor = Android.Graphics.Color.Green;  
               chan.LockscreenVisibility = NotificationVisibility.Private;  
     
               notificationManager.CreateNotificationChannel(chan);  
     
               NotificationCompat.Builder builder = new NotificationCompat.Builder(this, NOTIFICATION_CHANNEL_ID)  
                  .SetAutoCancel(false)  
                  .SetSmallIcon(Resource.Drawable.abc)  
                  .SetContentTitle("Mobile")  
                  .SetContentText("My service started");  
               StartForeground(NOTIFICATION_SERVICE_ID, builder.Build());  
           }  
           else  
           {  
               NotificationCompat.Builder builder = new NotificationCompat.Builder(this, NOTIFICATION_CHANNEL_ID)  
                  .SetDefaults((int)NotificationDefaults.All)  
                  .SetSmallIcon(Resource.Drawable.abc)  
                  .SetVibrate(new long[] { 100, 200, 300, 400, 500, 400, 300, 200, 400 })  
                  .SetSound(null)  
                  .SetPriority(NotificationCompat.PriorityDefault)  
                  .SetAutoCancel(false)  
                  .SetContentTitle("Mobile")  
                  .SetContentText("My service started")  
                  .SetOngoing(true);  
     
               StartForeground(NOTIFICATION_SERVICE_ID, builder.Build());  
           }  
       }  
     
       private void DispatchNotificationThatAlarmIsGenerated(string message)  
       {  
           var intent = new Intent(this, typeof(MainActivity));  
           intent.AddFlags(ActivityFlags.ClearTop);  
           var pendingIntent = PendingIntent.GetActivity(this, 0, intent, PendingIntentFlags.OneShot);  
     
           var notificationManager = (NotificationManager)GetSystemService(NotificationService);  
     
           if (Build.VERSION.SdkInt > BuildVersionCodes.O)  
           {  
               NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(this, "default")  
               .SetContentTitle("Alarm")  
               .SetContentText(message)  
               .SetSmallIcon(Resource.Drawable.abc)  
               .SetAutoCancel(true);  
     
               var chan = new NotificationChannel(NOTIFICATION_CHANNEL_ID, GetString(Resource.String.abc_action_bar_home_description), NotificationImportance.Default);  
               chan.LightColor = Android.Graphics.Color.Green;  
               chan.LockscreenVisibility = NotificationVisibility.Private;  
     
               notificationManager.CreateNotificationChannel(chan);  
               notificationManager.Notify(NOTIFICATION_AlARM_ID, notificationBuilder.Build());  
           }  
           else  
           {  
               NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(this, NOTIFICATION_CHANNEL_ID)  
                  .SetDefaults((int)NotificationDefaults.All)  
                  .SetSmallIcon(Resource.Drawable.abc)  
                  .SetVibrate(new long[] { 100, 200, 300, 400, 500, 400, 300, 200, 400 })  
                  .SetSound(null)  
                  .SetPriority(NotificationCompat.PriorityDefault)  
                  .SetAutoCancel(false)  
                  .SetContentTitle("Mobile")  
                  .SetContentText("My service started")  
                  .SetOngoing(true);  
     
               notificationManager.Notify(NOTIFICATION_AlARM_ID, notificationBuilder.Build());  
           }  
       }  
     
       public override void OnTaskRemoved(Intent rootIntent)  
       {  
           //base.OnTaskRemoved(rootIntent);  
       }  
     
       public override IBinder OnBind(Intent intent)  
       {  
           // Return null because this is a pure started service. A hybrid service would return a binder that would  
           // allow access to the GetFormattedStamp() method.  
           return null;  
       }  
     
       public override void OnDestroy()  
       {  
           // Stop the handler.  
           handler.RemoveCallbacks(runnable);  
           // Remove the notification from the status bar.  
           var notificationManager = (NotificationManager)GetSystemService(NotificationService);  
           notificationManager.Cancel(NOTIFICATION_SERVICE_ID);  
           isStarted = false;  
           base.OnDestroy();  
       }  
     
       private void CreateNotificationChannel()  
       {  
           //Notification Channel  
           NotificationChannel notificationChannel = new NotificationChannel(NOTIFICATION_CHANNEL_ID, NOTIFICATION_CHANNEL_NAME, NotificationImportance.Max);  
           notificationChannel.EnableLights(true);  
           notificationChannel.EnableVibration(true);  
           notificationChannel.SetVibrationPattern(new long[] { 100, 200, 300, 400, 500, 400, 300, 200, 400 });  
     
           NotificationManager notificationManager = (NotificationManager)this.GetSystemService(Context.NotificationService);  
           notificationManager.CreateNotificationChannel(notificationChannel);  
       }  
   }

Check the doc: https://learn.microsoft.com/en-us/xamarin/android/app-fundamentals/services/foreground-services

Best Regards,

Jarvan Zhang

If the response is helpful, please click "Accept Answer" and upvote it.

Note: Please follow the steps in our documentation to enable e-mail notifications if you want to receive the related email notification for this thread.

Alessandro Severa 11 Reputation points

2021-07-05T09:36:07.677+00:00

Hello JarvanZhang-MSFT,
Thank You for your response.

Unfortunally a foreground service is not an option for us, the requirements of our customer is to limitate the battery usage and perform this task without showing any notification.

Anyway, with the WorkManager in Xamarin I'm already able to perform this periodic task when the app is in background. My problem is that this task is not performed when the app is killed.

I'm pretty confused with what You said because if I do the exact same test with Android Studio (using Kotlin), my task is performed even if the app is killed. I tested it in Android Studio just to verify the capability, but in the end I have to do it in an already existent Xamarin app.

My question is if I'm missing something in the xamarin side or if the Xamarin.AndroidX.Work.Runtime package is in some way bugged and not able to achieve the same behavior of the native equivalent.

Someone has any suggestion about it? Should I open a issue on the xamarin/AndroidX github?

Thank You all.
JarvanZhang 23,866 Reputation points

2021-07-06T09:28:29.953+00:00

Xamarin.Android is just a layer of packaging for the Android native library, without additional operations. I tested the function in a basic Xamarin.Android project, it does work when the app is killed.
Alessandro Severa 11 Reputation points

2021-08-02T13:47:47.747+00:00

Hello JarvanZhang-MSFT,

This I know:

Xamarin.Android is just a layer of packaging for the Android native library, without additional operations. I tested the function in a basic Xamarin.Android project, it doesn't work when the app is killed.

But as a further test I created a native Android project that simply starts a periodic task that writes a timestamp to a db firestore every 15 minutes.
The strange thing is that using this native kotlin project, the workmanager continues to work even when the application is removed from the system recent menu.

If you want to try this too, I am sending you the source of the native mini-app attached from google drive uri, just open it with Android Studio and replace the google-services.json file inside the app folder with a file generated by the console firebase for firestore databases.

https://drive.google.com/file/d/1T0HfNLWpJpiujtHKTVIkCyiInECbUWzy/view?usp=sharing

I tested it on my personal device: Samsung Galaxy A21S (Android 11).

Thank you so much, again.
JarvanZhang 23,866 Reputation points

2021-08-03T09:38:57.203+00:00

Did you use the same device to test the Xamarin.Android project and the kotlin project? WorkManager seems only work on all manufacturers. Here is the related link, please check: https://stackoverflow.com/questions/55349488/work-manager-not-working-when-app-is-killed-by-the-user-why

Xamarin AndroidX WorkManager not working when app is killed

1 answer

Activity