What would be the idiomatic way to emit a `Flow<Unit>` every 40 milliseconds? old solution: ...

# coroutines

[zak.taccardi]

What would be the idiomatic way to emit a Flow<Unit> every 40 milliseconds?

old solution:

channelFlow<Unit> {
  while (isActive) {
    delay(40)
    send(Unit)
  }
}

new, better solution:

flow {
    while (true) {
        delay(40)
        emit(Unit)
    }
}

[Farhan Khan]

This may be of relevance here.
https://github.com/Kotlin/kotlinx.coroutines/issues/1186

[zak.taccardi]

updated original message with my current solution

[zak.taccardi]

I guess isActive doesn’t matter because delay suspends

[Dico]

What's wrong with using flow and emit?

[zak.taccardi]

flow and emit is cleaner

[octylFractal]

issue with flow & emit is that it does not account for the time spent in emit, so the question is do you want fixed rate or fixed delay. the former is better for fixed rate, latter for fixed delay, though you would probably need more code for a perfect fixed rate emission

[zak.taccardi]

I'm just trying to emulate Oberservable.timer(..)

[zak.taccardi]

I'm trying to poll every 40ms to check some state, and once I have hit the correct state, terminate the flow (which I am doing via filter { isInCorrectState}.first()

[zak.taccardi]

emit(..) suspends though right?

[octylFractal]

emit suspends, yes.

[zak.taccardi]

Oh. I think I want to not poll again until my logic to check if I am in the correct state completes

[octylFractal]

probably if you're polling, fixed delay is fine, and you can use flow/emit. reason being that you want to wait 40ms after the last result, regardless of how long it takes.

[zak.taccardi]

As the whole flow is just one Coroutine I think it achieves that

[louiscad]

I guess isActive doesn’t matter because delay suspends

No, it's because delay is cancellable.

[gildor]

Version with channel is less efficient and you just don't need it. Use flow, not channel flow in this case, you can have exactly same semantics, if you want. Channel flow is needed if you want to emit from different threads or from non-suspend context (like if you write flow adapter for some callback)