Kotlin 在所有应用程序执行期间运行协程

Question

I am investigating and learning a bit about Kotlin coroutines . My main thought is to try to create a function (coroutine) that is NOT running on main thread and is being executed all the time while the app is running. It shall be finished or killed when the app terminates. This is like trying to run a background task, if I understood coroutines correctly.

I made a first attempt to get this to work, and it seems like it actually works, but looks not optimal for me, I was wondering if there is a better way to do that:

I basically just created a coroutine scope for the coroutine, and then simply used an infinite while loop for the coroutine...like this:

in my MainActivity.kt I have

override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        CoroutineScope(Default).launch {
            runContinuousFunction()
        }
}

private suspend fun runContinuousFunction(){
        while (true){
            Log.d("debug", "Running continuous function")
            delay(2000)
        }
    }

As I mentioned, this seems to work just fine...I can see the Log periodically being printed in logcat, and at the same time I can interact with the UI without any problem but...

Is this the best optimal way to do this?

Answer 1

I would suggest delegating this off to a Worker to handle this task. It isn't really your Activities responsibility to have really any knowledge of what this work is; and if your activity gets destroyed / recreated, this work will start all over again.

Refer to: Android WorkManager and Coroutine Worker

You could also make use of Androids LifecycleObserver to ensure this work only gets carried out when the application is in the foreground. Heres a quick sample for you:

Your Application Class

class MyApp: Application(), LifecycleObserver {

    companion object {
        private var isAppForeground = true

        @Synchronized
        fun isAppInForeground(): Boolean = isAppForeground
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    private fun onAppBackground() {
        // Each time our app goes into the background this function 
        // will be called. Set the static boolean variable to false.
        isAppForeground = false
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    private fun onAppForeground() {
        // Each time our app comes into the foreground this function 
        // will be called. Set the static boolean variable to true.
        isAppForeground = true
    }
}

Your Custom Worker

class MyWorker(
    context: Context, 
    workerParams: WorkerParameters
) : CoroutineWorker(context, workerParams) {

    companion object {
        const val WORK_TAG = "MyWorkerTag"
    }

    override suspend fun doWork(): Result {
        if (MyApp.isAppInForeground) {
        // Do your work here that you want to repeat.
        // You can return either Result.success()
        // Result.failure()
        // of Result.retry() if you want to retry this specific instance.
        } else {
            return Result.failure()
        }
    }
}

MainActivity

override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        initWorker()
}

private fun initWorker() {
    val workManager = WorkManager.getInstance(this)

    /* You can define whatever constraints are required for this
    work to run. Here I have just set a constraint that the device
    must have a valid network connection. Useful if your work will
    require API calls or upload / downloading data */
    val constraints = Constraints.Builder()
        .setRequiredNetworkType(NetworkType.CONNECTED)
        .build()

    /* Work can be scheduled on whatever repeating interval you define, with a
    minimum being every 15 minutes. */
    val myWorkRequest = PeriodicWorkRequestBuilder<MyWorker>(
            repeatInterval = 15L,
            repeatIntervalTimeUnit = TimeUnit.MINUTES
        ).setConstraints(constraints).build()

    /* You can define the existing work policy when enqueueing the work, to determine
    what will happen the next time this code is run. You can either REPLACE 
    the existing scheduled work or KEEP the existing work. */
    workManager.enqueueUniquePeriodicWork(
        MyWorker.WORK_TAG,
        ExistingPeriodicWorkPolicy.REPLACE,
        myWorkRequest
    )
}