Hi, I see a lot of examples for attaching

CoroutineScope

to Android lifecycles with a pattern like that:

class UiLifecycleScope : CoroutineScope, LifecycleObserver {

    private lateinit var job: Job
    override val coroutineContext: CoroutineContext
        get() = job + Dispatchers.Main

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onCreate() {
        job = Job()
    }

Do you guys see any reason for constructing the context with a getter, creating a new context every time. How about making the scope

var

?

override lateinit var coroutineContext: CoroutineContext
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onCreate() {
        coroutineContext = Dispatchers.Main + Job()
    }

I think the suggested way now is using https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-main-scope.html

Sure. But all this does not work if you want to cancel in onStop. Then your activity might get restarted but your scope is cancelled. That's why you have to inject a new Job()

What you want is something like

createScope

here, or just that: https://github.com/LouisCAD/Splitties/tree/master/modules/lifecycle-coroutines

Thanks @louiscad. I'll take a look. But this does not answer the question. I am not looking for a solution but for clarification. The pattern I described is everywhere on Google but seems to be second best. That's what I am trying to understand

You should call your job/scope startedJob/Scope for explicitness.

I'd rather say rootJob. After I call cancel it is no longer started

you can also use

cancelChildren

and keep the root job around iirc

Interesting. Didn't think of it yet. But then I'd have to keep the job around

cancelChildren would let coroutines started after onStop run before onStart is called again, and until the second onStop call though