IssueTracker

LifecycleScope, while useful, has some edge cases where it becomes difficult to get a single CoroutineScope for each of:

1. onCreate/onDestroy
2. onStart/onStop
3. onResume/onPause

class SomeActivity constructor(
    private val stateFlow: Flow<State>
) : AppCompatActivity(){

    init {
        lifecycleScope.launchWhenCreated {
            // one might falsely assume that this scope will be active until `onDestroy()` is called
            // however it will be cancelled when this lambda completes and there are no active jobs under this scope
            // this is the default behavior of a regular `.launch` coroutine builder
            val scope: CoroutineScope = this@launchWhenCreated
        }


        lifecycleScope.launchWhenCreated {
            val scope: CoroutineScope = this@launchWhenCreated

            val ui: Ui =  Ui(
                rootView = findViewById(R.id.faq_recycler_view),
                scope = scope
            )

            // one might falsely assume that `onStart`'s `CoroutineScope` is nested under `onCreate`
            // and would keep the `onCreate` `CoroutineScope` active
            lifecycleScope.launchWhenStarted {
                stateFlow.collect { state: State ->
                    // this will throw because by the time this is called, the `CoroutineScope`
                    // from `.launchWhenCreated` will have completed
                    ui.render(state)
                }
            }
        }
    }

    private class Ui(
        private val rootView: View,
        private val scope: CoroutineScope
    ) {

        fun render(state: State) {
            scope.launch {
                // pretend we need to launch a coroutine to render some state
            }
        }
    }
}

This is similar to https://issuetracker.google.com/issues/133122585