What’s more idiomatic: ``` fun events(channel: Sen...

# coroutines

[ansman]

What’s more idiomatic:

fun events(channel: SendChannel<Event>)
fun events(scope: CoroutineScope): ReceiveChannel<Event>

In my case I need to add a listener when calling events and remove it when the channel is closed

[Dominaezzz]

Have you considered a https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.channels/-broadcast-channel/ ?

[ansman]

I don’t have multiple consumers and I need the caller to be the one to close the channel

[Dominaezzz]

Then using https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.channels/-broadcast-channel/open-subscription.html as your events function.

[ansman]

Oh, I’ll try that.

[Dominaezzz]

But to answer your actual question, I think the second one is more idiomatic. 🙂

[ansman]

Hmm, I don’t really think BroadcastChannel would fit my use case because I need a clear open and close event

[Dominaezzz]

Makes sense.

[Dominaezzz]

Even fun CoroutineScope.events(): ReceiveChannel<Event> is more idiomatic if you're a spawning a coroutine in the function.

[ansman]

It’s really strange though, my producer is closed instantly and I can’t figure out why:

override fun events(scope: CoroutineScope): ReceiveChannel<Unit> =
        scope.produce(capacity = Channel.CONFLATED) {
            val listener = { offer(Unit) }
            addListener(listener)
            invokeOnClose { removeListener(listener) }
        }

[Dominaezzz]

Oh, I don't think you need the produce.

[Dominaezzz]

Just create a channel and return it.

[ansman]

The reason why I need it is because it will be closed when the scope’s job is cancelled

[ansman]

If I have a channel I need to close it manually

[Dominaezzz]

Hmm, there's a way to register a callback with the scope's context to handle closing but I don't know how atm.

[Dominaezzz]

You definitely don't need a coroutine for this.

[ansman]

Well I don’t want the caller to have to worry about closing the channel

[ansman]

https://github.com/Kotlin/kotlinx.coroutines/issues/256#issuecomment-367808765

[Dico]

This is a common problem indeed, where the channel is closed when the produce coroutine completes, when that is not the intention.

Here is a potential workaround:

produce {
    // your stuff, done with procuding ...
    suspendCoroutineCancellable<Unit> { cont ->
        channel.invokeOnClose { cont.resume(Unit) }
    }   
}

[ansman]

Oh right, of course. The coroutine completes. What would be the best way to have this behavior then?

[Dico]

well, there are 2 options for you, the one above or to manually close the channel when the scope is cancelled.

[Dico]

I'm actually confused now, as channels should only be closed for sending when the producer completes. Any sent items should still be receivable.

[Dico]

Ah, it's because of the listener thing you're doing.

[ansman]

Yeah, I’m trying to bridge a callback API

[Dico]

I see