Xamarin Android IntentService calling OnDestroy while performing large async operation

Question

Im trying to perform a synchronization task without blocking UI thread. I have implemented a Android Service to do so, but I found out, if the synchronization task needs too much computational time, the UI thread was blocked. So I tried the migration to IntentService. This is how my IntentService looks like:

[Service]
    public class SynchronizeIntentService : IntentService
    {
        static readonly string TAG = typeof(SynchronizeIntentService).FullName;
        private NotificationCompat.Builder Builder;
        private NotificationManagerCompat NotificationManager;

        public SynchronizeIntentService() : base("SynchronizeIntentService")
        {
        }

        public override void OnDestroy()
        {
            var tmp = 5;
            base.OnDestroy();
        }

        private NotificationChannel createNotificationChannel()
        {
            var channelId = Constants.NOTIFICATION_CHANNELID;
            var channelName = "My Notification Service";
            var Channel = new NotificationChannel(channelId, channelName, Android.App.NotificationImportance.Default);
            Channel.LightColor = Android.Resource.Color.HoloBlueBright;
            Channel.LockscreenVisibility = NotificationVisibility.Public;
            return Channel;
        }

        private void createForegroundService()
        {
            var mNotificationManager = GetSystemService(Context.NotificationService) as NotificationManager;
            if (Build.VERSION.SdkInt >= Android.OS.BuildVersionCodes.O)
            {
                mNotificationManager.CreateNotificationChannel(createNotificationChannel());
            }
            var notificationBuilder = new NotificationCompat.Builder(this, Constants.NOTIFICATION_CHANNELID);
            GenerateNotification();
            StartForeground(Constants.SERVICE_RUNNING_NOTIFICATION_ID, Builder.Notification);

        }

        private void GenerateNotification()
        {
            NotificationManager = NotificationManagerCompat.From(this);
            Builder = new NotificationCompat.Builder(this, Constants.NOTIFICATION_CHANNELID);
            Builder.SetContentTitle(ContaScan.Classes.Localize.GetString("Global_SynchProcess", ""))
                    .SetSmallIcon(Resource.Drawable.icon)
                    .SetPriority(NotificationCompat.PriorityLow);

        }

        protected async override void OnHandleIntent(Intent intent)
        {
            Log.Debug(TAG, "Service Started!");

            await Synch();

            Log.Debug(TAG, "Service Stopping!");
            StopForeground(true);
            this.StopSelf();
        }


        public override StartCommandResult OnStartCommand(Intent intent, [GeneratedEnum] StartCommandFlags flags, int startId)
        {
            base.OnStartCommand(intent, flags, startId);
            createForegroundService();
            return StartCommandResult.Sticky;
        }

        private async Task Synch()
        {
            //Large synch process
        }
    }

And this is how the service is getting started:

startServiceIntent = new Intent(Android.App.Application.Context, typeof(SynchronizeIntentService));
        startServiceIntent.SetAction(Constants.ACTION_START_SERVICE);
        ContextWrapper contextWrapper = new ContextWrapper(Android.App.Application.Context);
        contextWrapper.StartService(startServiceIntent);

The problem is OnDestroy() method is called while the Synch() task is being performed and looks like the IntentService is being killed before ending the process.

What am I doing wrong?

Answer 1

First, check your API level. This class was deprecated in API level 30.

And then, when you use the OnHandleIntent, do not call Service.stopSelf().

This method is invoked on the worker thread with a request to process. Only one Intent is processed at a time, but the processing happens on a worker thread that runs independently from other application logic. So, if this code takes a long time, it will hold up other requests to the same IntentService, but it will not hold up anything else. When all requests have been handled, the IntentService stops itself, so you should not call Service.stopSelf().

For more details, please check the link below. https://developer.android.com/reference/android/app/IntentService#onHandleIntent(android.content.Intent)