Emitting Flow values without builder scope and Channel

[fluidsonic]

Currently there are two high-level approaches to emitting Flow values:

• Calling emit() in a builder scope (flow {}, channelFlow {}, callbackFlow {}).
• Sending to a Channel or BroadcastChannel and converting it into a Flow.

The former (emit()) suspends the emitter until the Flow collector has processed the emitted value.
The latter (BroadcastChannel/Channel) does not suspend the sender until the Flow collector has processed the emitted value.

In order to allow, outside of a builder scope, a value emission that suspends the emitter until the collector has processed the value it may be necessary to introduce a third way to emit values.

Use case

This is necessary to support use cases like #1901.

Very rough idea

fun <T> broadcastFlow(): BroadcastFlow<T> = …

interface BroadcastFlow<T>: Flow<T> {
   fun close()
   fun emit(value: T)
}

class MyComponent {
   private val eventBroadcast = broadcastFlow<Event>() // private, for emitting
   val events: Flow<Event> = eventBroadcast // public, for collecting

   private suspend fun doSomething() {
      // Do something.

      // Notify collectors that something was done.
      eventBroadcast.emit(SomethingEvent())

      // Wait for all collectors to react to whatever was done
      // in order to avoid concurrent state modifications.
      // E.g. an UI may depend on multiple components being in a synchronized state
      // after this work has been completed.

      // Finalize something and return.
   }

   fun onDestroy() {
      eventBroadcast.close()
   }
}

[elizarov]

But what are those use-cases? Note, that in your example MyComponent.onSomething() would be a suspending function. Where did you encounter such need?

[fluidsonic]

Thanks, I've added the suspend.
Regarding use case this is just an enabling feature for #1901.

[qwwdfsad]

Seems to be resolved with state and shared flows