How to use StateFlow instead of Value?

[mr-kew]

Hello,

I wanna combine multiplatform decompse combined with KMP-ObservableViewModel library. The advantage should be that I won't have to implement the constructor manually in each view. Also my models are already done using that library, so I would prefer not having to rework them all.

And for that I would wanna use StateFlow instead of Value for the child stack or child slot. What is the best way to do it? I came up with the following code, but I am not sure if doing local MutableStateFlow is ok.

abstract class ObservableComponent(
    componentContext: ComponentContext,
) : ViewModel(), ComponentContext by componentContext {

    protected inline fun <reified T : Any> Value<T>.toStateFlow(mode: ObserveLifecycleMode = ObserveLifecycleMode.START_STOP): StateFlow<T> {
        val state = MutableStateFlow(viewModelScope, this.value)
        this.subscribe(lifecycle, mode) { value ->
            state.value = value
        }
        return state.asStateFlow()
    }
}

Usage:
(of course the toStateFlow could be hidden inside a childSlot overload)

class SlotComponent(
    componentContext: ComponentContext,
) : ObservableComponent(componentContext) {
    private val navigation = SlotNavigation<Config>()

    @NativeCoroutinesState
    val slot: StateFlow<ChildSlot<*, Child>> = childSlot(
        source = navigation,
        serializer = Config.serializer(),
        initialConfiguration = { null },
        handleBackButton = true,
        childFactory = ::child,
    ).toStateFlow()

    ...

[CXwudi]

This might help?

https://gist.github.com/CXwudi/2c4084eb0e82c05fd943b040fc73c2f9#file-decomposevalueutil-kt-L72-L85

[arkivanov]

Oops, seems like I missed this question. Sorry about that.
In addition to what was suggest before, there is also the following way:

import com.arkivanov.decompose.value.Value
import kotlinx.coroutines.flow.FlowCollector
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow

fun <T : Any> Value<T>.asStateFlow(): StateFlow<T> =
    ValueStateFlow(this)

private class ValueStateFlow<out T : Any>(
    private val v: Value<T>,
) : StateFlow<T> {

    override val value: T get() = v.value
    override val replayCache: List<T> get() = listOf(v.value)

    override suspend fun collect(collector: FlowCollector<T>): Nothing {
        val stateFlow = MutableStateFlow(v.value)
        val cancellation = v.subscribe { stateFlow.value = it }

        try {
            stateFlow.collect(collector)
        } finally {
            cancellation.cancel()
        }
    }
}

[YektaDev]

Hi! I hate to nitpick, but as someone who's all in on StateFlows in all Components, this feels too much for the sole purpose of holding a value. By that, I mean the sum cost of below items per ValueStateFlow:

• The locking mechanism inside Value + StateFlows suspending collect.
• Object creations: Value internals (MutableValue, Lock, observers map) + Mapper internals (replayCache list, MutableStateFlow in collect) + StateFlow internals (I have no idea)

This is merely a thought that I felt the need to share. I know it might be a negligible cost in the grand scheme of things, and I'm ok with the current solution as I can't think of a better alternative (that's without wishing the Value didn't exist in the first place😃).

[arkivanov]

Thanks for sharing! The overhead is indeed negligible, taking into account that asStateFlow is supposed to be called only once per component per Value. Though, migration to StateFlow is tentatively planned for Decompose 4.0.

[YektaDev]

Oh, I didn't know that. That's perfect!

[YektaDev]

@arkivanov I know this is a bit off-topic, but I was curious about your mention of Decompose 4.0. Is there maybe a public roadmap or a list of potential breaking changes available?

[arkivanov]

No roadmap yet, but I'm thinking about creating one. The biggest possible breaking change so far (still unsure about it) is migration from BackHandlerOwner to the new NavigationEventDispatcherOwner. And there will be a few minor API changes and clean-up.