Hi there! I have trouble integrating synchronous code with coroutines, in order to get that broadcasting feature I was able to implement using `RxJava`:

class Handler : MessageHandler {

    private val channel = Channel<Message>(1)

    override fun handle(message : Message) {
        // TODO send event.
    }

    fun send(event : Message) {
        
    }

/*
    fun observe() : Channel<Message>
    fun observe() : Flow<Message>
*/
}

When having `RxJava`’s

subjects

, I could call

onNext()

, let observers consume it by exposing some

Observable

. Is there a way to do the same with

Coroutines

? I need to expose some methods that allow to observe stream of events received in

handle(message : Message)

method. Thanks a lot in advance!

expose your channel into a flow (

consumeAsFlow()

or

receiveAsFlow()

)

@zak.taccardi, thanks for helping. Could I implement that without marking my method with suspend modifier?

yes

@zak.taccardi, how do you send events to your channel?

with

channel.send(..)

if I am in a coroutine or

channel.offer(..)

if I am not

thanks!

note that if you use

channel.offer(..)

, the Channel’s capacity comes into play

could we implement some kind of coroutines bus using channels?

not just with Channels, you’d need

Flow<T>

Channels are for communicating between coroutines, or into one from outside of one, and

Flow<T>

is for exposing an API of multiple events of

T

check this for an event bus based on coroutines: https://github.com/Daniil-Pavenko/coroutines-event-pipe