Is there a nice way to trigger a restart of a flow that is turned into a StateFlow using

statein

? I’ll show you my use case and try to explain what I mean in the thread 🧵

Just a quick idea, you could have a

restartTrigger.flatMap { yourFlow() }

and emit from the trigger somehow?

Thanks for the suggestion, playing around with this a bit, I am now looking at this:

private val retryChannel = Channel<Unit>()
val viewState: StateFlow<ClaimDetailViewState> = retryChannel.receiveAsFlow().transformLatest { // same code }

init {
    viewModelScope.launch {
        retryChannel.send(Unit)
    }
}

fun retry() {
    viewModelScope.launch {
        retryChannel.send(Unit)
    }
    // Or maybe 
    retryChannel.trySend(Unit)
    // But I think the suspending `send` is a better idea, even if someone spams the retry() function, the transformLatest should just take in the last one anyway.
}

But it’s a bit weird, since we now have an extra channel in the class, which might not be 100% obvious to a dev seeing it for the first time, plus the need to add an element in the

init

function 🤔 Do you think we could have this

restartTrigger

be something a bit nicer? I thought of it being a

Channel<Unit>

but maybe it shouldn’t? Or did you mean something a bit different?

Yep I meant

Channel<Unit>

or something along that, but I can’t play around with it right now to suggest something with a default value and I don’t remember what could be used instead

Awesome, thank you so much for the help! It does work at the moment with the limited testing I’ve done, so I’ll leave it like this for now and see if it fits my needs as I wanted it to. If you (or someone else) do at some point come up with something nicer I would really appreciate if you shared it with me though!

instead of setting it up in init, you can add the initial element at the consumer:

retryChannel.receiveAsFlow()
    .onStart { emit(Unit) }
    .flatMap { // ... }

Nice, that sounds better. This does put the burden on the call-site though, which I could negate by adding it to be done automatically inside my

RetryChannel

class. But I wonder, this is the second time I see the

flatMap

being mentioned on the flow, but as I see it in my IDE, it is deprecated. Is it a simple mis-spell, or am I missing something here?

ah you probably want

.flatMapLatest()

for this use case. it's deprecated to make it clearer what behavior you want (compare to

.flatMapConcat()

and

.flatMapMerge()

)

Made it work like this actually:

class RetryChannel private constructor(private val channel: Channel<Unit>) {
    suspend fun retry() { channel.send(Unit) }

    fun <R> transformLatest(@BuilderInference transform: suspend FlowCollector<R>.(value: Unit) -> Unit): Flow<R> {
        return channel
            .receiveAsFlow()
            .onStart { emit(Unit) }
            .transformLatest(transform)
    }

    companion object {
        operator fun invoke() = RetryChannel(Channel(Channel.CONFLATED))
    }
}

And it’s quite straight-forward to use on the call-site. I am not quite sure what I am missing and how flatMap would help here 🤔 Call-site code now looks like this and it seems to suit my needs now:

private val retryChannel = RetryChannel()
val viewState: StateFlow<ViewState> = retryChannel.transformLatest {
    someUseCase.invoke(claimId).fold(
        ifLeft = { emit(ViewState.Error) },
        ifRight = { emit(ViewState.Content(it)) },
    )
}.stateIn(
    viewModelScope,
    SharingStarted.WhileSubscribed(5000),
    ViewState.Loading
)

fun retry() { viewModelScope.launch { retryChannel.retry() } }