IssueTracker

There is a problem in the code.
liveData builder gives you a scope as long as the block runs.
By calling viewModelScope.launch, you are kicking off another async operation which does not block live data scope from being destroyed. So calling emit does nothing in a destroyed scope.
I'll see if we can  add a lint check to detect this issue, meanwhile, you can fix your code as follows:

option a:
val state: LiveData<State> = liveData(viewModelScope.coroutineContext){
        emit(latestValue ?: makeInitState())
        coroutineScope {
            val results = actionTransform(eventTransform(events))
            for (result in results) {
                val newState = (latestValue ?: makeInitState()) + result
                emit(newState)
            }
        }
    }

option b:
    val state: LiveData<State> = liveData{
        emit(latestValue ?: makeInitState())
        val job = viewModelScope.launch {
            val results = actionTransform(eventTransform(events))
            for (result in results) {
                val newState = (latestValue ?: makeInitState()) + result
                emit(newState)
            }
        }
        job.join()
    }

i guess for starters, we can probably put a warning when `emit` is called after scope is cancelled.
Not sure if we can do any more since, unlike flow, liveData builder does not require context preservation as dispatch coroutine is always on the main thread.

Thanks for the reply, I am not surprised I had a fundamental misunderstanding of how this is supposed to work. Your response is very helpful!
I appreciate your suggestions especially. However, the documentation warns against using the coroutineScope builder I'm not clear why it is okay to use in this case. I found that switching to flows worked nicely.

        events.consumeAsFlow()
            .eventTransform()
            .actionTransform()
            .map {
                (latestValue ?: makeInitState()) + it
            }
            .onEach {
                emit(it)
            }
            .collect()

    protected abstract fun Flow<E>.eventTransform() : Flow<A>
    protected abstract fun Flow<A>.actionTransform() : Flow<R>

which documentation are you referring to ? It would be good for us to avoid any confusion.

I'm referring to this bit of documentation saying to use the coroutineScope builder as a last resort
https://kotlinlang.org/docs/reference/coroutines/basics.html#extract-function-refactoring

And this article by Roman
https://medium.com/@elizarov/coroutine-context-and-scope-c8b255d59055

I think the primary difference here is that in these no-no examples they are public functions where this is wrapped inside your existing liveData builder and won't be exposed so we have control over it. I think I'm wrapping my head around this now :-)

Or actually both of these examples are not using the lowercase builder class.

oh i thought you were referring to liveData documentation :)
I was just trying to make your sample work the way you wrote without changing it much.

Otherwise, I would say don't even use channels there :) You can just create a channel where you can offer and then use Flow which you've already did i guess based on #4.
You actually won't even need that source channel when StateFlow becomes a thing.
https://github.com/Kotlin/kotlinx.coroutines/pull/1354

Awesome thanks for the feedback! Looking forward to the upcoming flow
developments!

On Mon, Nov 18, 2019, 12:06 PM <buganizer-system@google.com> wrote: