My background service stops when the screen turns off on my Moto G6

Question

I created an app to work on my Moto G6 android device. Basically, this app that start a local service to periodically access a web site. Everything looks good but when the screen turns off, the service is paused. It become active again when the screen turns on. I found a lot of discussions about this kind of behaviour in the forums and among the things suggested, here is what I tried:

1. I tried to set the battery saving mode OFF. Same result.
2. I tried to use the workmanager instead of the service. My worker is also paused like my service.
3. I tried to use the powermanager in my service to acquire PARTIAL_WAKE_LOCK but it still doesn't change anything.

Is there something particular with the Moto G6 ?... Here is my manifest file:

?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.coininverst">
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
    <uses-permission android:name="android.permission.WAKE_LOCK"/>

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.CoinInverst">
        <service android:name=".CoinGeckoService" />
        <activity
            android:name=".MainActivity"
            android:label="@string/app_name"
            android:theme="@style/Theme.CoinInverst.NoActionBar">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

And here is how I start the service (in main activity):

mServiceIntent = new Intent(this, CoinGeckoService.class);
startService(mServiceIntent);
bindService(mServiceIntent, Connection, Context.BIND_AUTO_CREATE);

Still in main activity, a nested class:

private ServiceConnection Connection = new ServiceConnection()
{
    @Override
    public void onServiceConnected(ComponentName className, IBinder service)
    {
        // We've bound to LocalService, cast the IBinder and get LocalService instance
        CoinGeckoService.LocalBinder oBinder = (CoinGeckoService.LocalBinder) service;
        mService = oBinder.getService();
        mBound   = true;
    }

    @Override
    public void onServiceDisconnected(ComponentName arg0)
    {
        mBound = false;
    }
};

On the service side :

    public class CoinGeckoService extends Service
    {
        private Looper                        m_oServiceLooper     = null;
        private ServiceHandler                m_oServiceHandler    = null;
        private HandlerThread                 m_oHandlerThread     = null;
        private boolean                       m_bExitFlag          = false;
        private boolean                       m_bExitEcho          = false;
        private int                           m_iSnapshotPeriodSec = 300;
        private final IBinder                 m_oBinder            = new LocalBinder();
        private Intent                        m_oIntent            = null;
        private Thread                        m_oStillRunningProc  = null;
        private Message                       m_oHandleMessage     = null;
        private PowerManager                  m_oPowerManager      = null;
        private PowerManager.WakeLock         m_oWakeLock          = null;
        private Context                       m_oContext           = null;
    
        // Handler that receives messages from the thread
        private final class ServiceHandler extends Handler
        {
            public ServiceHandler(Looper oLooper)
            {
                super(oLooper);
            }
            @Override
            public void handleMessage(Message msg)
            {
                m_oHandleMessage = msg;
    
                m_oStillRunningProc = new Thread()
                {
                    public void run()
                    {
                        InfiniteProcees();
                    }
                };
                m_oStillRunningProc.start();
            }
        }
        private void InfiniteProcees()
        {
            while (!m_bExitFlag)
            {
                long lStartTimeMs         = System.currentTimeMillis();
                long lElapsedTimeMs       = 0L;
                long lWakeLockTimeoutMSec = 10 * 60 * 1000L;
    
                m_oWakeLock.acquire(lWakeLockTimeoutMSec);
    
    ....
    
                m_oWakeLock.release();
    
                lElapsedTimeMs = (System.currentTimeMillis() - lStartTimeMs);
    
                if ((m_iSnapshotPeriodSec * 1000) > (int)lElapsedTimeMs)
                    SleepMSec((m_iSnapshotPeriodSec * 1000) - (int)lElapsedTimeMs);
                //do
                //{
                //    SleepMSec(1000);
                //    lElapsedTimeMs = (System.currentTimeMillis() - lStartTimeMs);
                //}
                //while (!m_bExitFlag && (lElapsedTimeMs < (m_iSnapshotPeriodSec * 1000)));
            }
            // Stop the service using the startId, so that we don't stop
            // the service in the middle of handling another job
            stopSelf(m_oHandleMessage.arg1);
    
            m_bExitEcho = m_bExitFlag;
        }
    
        public void onCreate()
        {
            int iNbPage = 3;
            // Start up the thread running the service. Note that we create a
            // separate thread because the service normally runs in the process's
            // main thread, which we don't want to block. We also make it
            // background priority so CPU-intensive work doesn't disrupt our UI.
            m_oLogPath      = getExternalFilesDir(null) + "/CoinDBase" ;
            m_oImgPath      = getExternalFilesDir(null) + "/CoinImages";
            m_aoPages       = new String[iNbPage];
            m_oSyncExport   = new Object();
            m_oContext      = this;
            m_oPowerManager = (PowerManager)m_oContext.getSystemService(Context.POWER_SERVICE);
            m_oWakeLock     = m_oPowerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "CoinGeckoService:WakeLock");

....    
            m_oHandlerThread = new HandlerThread("ServiceStartArguments", Process.THREAD_PRIORITY_BACKGROUND);
            m_oHandlerThread.start();
    
            // Get the HandlerThread's Looper and use it for our Handler
            m_oServiceLooper  = m_oHandlerThread.getLooper();
            m_oServiceHandler = new ServiceHandler(m_oServiceLooper);
        }
    
        @Override
        public int onStartCommand(Intent intent, int flags, int startId)
        {
            Toast.makeText(this, "CoinGeckoService starting", Toast.LENGTH_SHORT).show();
    
            m_oIntent = intent;
    
            // For each start request, send a message to start a job and deliver the
            // start ID so we know which request we're stopping when we finish the job
            Message msg = m_oServiceHandler.obtainMessage();
            msg.arg1 = startId;
            m_oServiceHandler.sendMessage(msg);
    
            // If we get killed, after returning from here, restart
            return START_STICKY;
        }
    
        @Override
        public IBinder onBind(Intent intent)
        {
            return m_oBinder;
        }
    
        @Override
        public void onDestroy()
        {
            super.onDestroy();
    
            m_bExitFlag = true;
    
            int iTimeoutMsec = 2000;
            while (!m_bExitEcho && (iTimeoutMsec > 0) && SleepMSec(100))
            {
                iTimeoutMsec -= 100;
            }
            //Toast.makeText(this, "CoinGeckoService done", Toast.LENGTH_SHORT).show();
    
            Intent oBroadcastIntent = new Intent();
            oBroadcastIntent.setAction("RestartService");
            oBroadcastIntent.setClass(this, ServiceRestarter.class);
            this.sendBroadcast(oBroadcastIntent);
        }
        public class LocalBinder extends Binder
        {
            CoinGeckoService getService()
            {   // Return this instance of LocalService so clients can call public methods
                return CoinGeckoService.this;
            }
        }
    }

Notice that the service always stop when the app is closed. Even if that wasn't expected, it is something I can live with for now. Every suggestion or comment will be greatly appreciate. Thank you in advance.

Answer 1

Hybrid Service : You want a started service but with the capabilities to communicate between client and service like a bound service.The way this works is by having the bound service implement the onStartCommand(). Typically, a started service implements the onStartCommand() to receive the intent from a client. But a bound service typically does not implement the onStartCommand, and instead, implements the onBind() hook method. However, if a bound service implements onStartCommand, that's an indication to the Android Activity Manager Service Framework that this service should not be destroyed when all the clients that are bound to it unbind.

It looks like you are using a hybrid service model.Usually background media player apps use this model.Things u can do to solve your problem are following:

1. Instead of bind and unbind your bound service in onStart() and onStop() use onCreate() and onDestroy() respectively.
2. Use Foreground services by startForeground() method if necessary otherwise AMS(Activity Manager Service) might destroy your background service.Use stopForeground(true) in onRebind() and onBind() method as your client component is in active stage and startForeground() in onUnbind() method.