Hey is there a non-state version of

MutableStateFlow

? I have been using

ConflatedBroadcastChannel

, but would like to move to flow completely. I know there is

Flow

itself, but I have not found a way to send values to it from outside the creation lambda.

Can’t you just expose

MutableStateFlow

as

Flow

? The former one implements the latter, so you can do it by just casting

The problem is that MSF requires an initial value. Apart from converting a Channel into a Flow you can create your own AbstractFlow implementation 🤔 But behind the scenes many Flows are implemented using Channels, as they’re perfectly fine for that.

you also can just use StateFlow with initial null and filter it before returning from your class

Also good in cases where

null

is not a valid value. In that case you could make your own

val undefined = Any()

and filter that out.

So are Channels going to be deprecated in favor of

Flow

?

No, they still have their purpose.

So I guess using

ConflatedBroadcastChannel

and then calling

.asFlow()

would still be my best bet. Maybe I can wrap that in a version of

AbstractFlow

and call it

MutableFlow

to keep with the definitions.

What’s the use case btw?

The use case is Android state management. For View-State

MutableStateFlow

works perfectly fine, it’s a fantastic addition. But there are some things that should not be retained as states but still emitted (usually called effects), for example Toast messages (small messages shown once). For this a non-stateful

Flow

works, but it has to be able to be triggered from the outside. If you used

MutableStateFlow

for effects then you would show a toast message and then upon phone rotation would show the same toast message again, which is not required.

Not really. You’d use

FlowCollector

from the wrong coroutine context and likely raise an exception.

I think this is probably the best approach then until there is some non-stateful official version of

Flow

private val _effects = ConflatedBroadcastChannel<Effect>()
    val effects: Flow<Effect> = _effects.asFlow()

Where are the Effects coming from? Why isn’t the source a Flow?

that’s good food for though. It could be anything. Could be a flow, could be a button click, could be some legacy code, could be some third party plugin.

Button clicks can also be flows 🙂

Hmm so what could I replace the

ConflatedBroadcastChannel

in the example above with?

Broadcast channels will be there for a quite long time, they not even deprecated yet

BroadcastChannel

is marked obsolete: https://github.com/Kotlin/kotlinx.coroutines/blob/1b34e1c7dd6207d7683c307bae0b934a3dc18d09/kotlinx-coroutines-core/common/src/channels/BroadcastChannel.kt#L23

https://kotlinlang.slack.com/archives/CRJCTR5PD/p1602589612024000?thread_ts=1602582807.022600&cid=CRJCTR5PD Conflated channel also has the same behavior