Is it possible to use channels to wait for a signal to do work? Something like: ``` suspend fun wai...

# coroutines

[rook]

Is it possible to use channels to wait for a signal to do work?

Something like:

suspend fun waitForUpdates(): ReceiveChannel<Update> = produce {
  onUpdateHook { update ->
    send(update)
  }
}

fun startWaitingForUpdates() {
  launch {
    waitForUpdates().onReceive { update ->
      doUpdate(update)
    }
  }
}

[streetsofboston]

Absolutely.

Be sure that the `produce`’s lambda does not return to keep the channel open. (see the suspendCoroutine call in waitForUpdates.

fun CoroutineScope.waitForUpdates(): ReceiveChannel<Update> = produce {
    onUpdateHook { update ->
        send(update)
        suspendCoroutine<Nothing> { /* do nothing */ }
    }
}

fun CoroutineScope.startWaitingForUpdates() {
    launch {
        waitForUpdates().apply {
            select {
                onReceive { update ->
                    doUpdate(update)
                }
            }
        }
    }
}

[rook]

suspendCoroutine<Nothing> { /* do nothing */ }

^ this right here was the missing link, thank you!

[streetsofboston]

If you need to be able to close the channel on a failure/update-close signal, use something like this:

E.g.:

fun CoroutineScope.waitForUpdates(): ReceiveChannel<Update> = produce {
    suspendCoroutine<Unit> { cont ->
        onUpdateHook { update ->
            send(update)
        }
        onUpdateTermination { error ->
            if (error != null) {
                cont.resumeWithException(error)
            }
            else {
                cont.resume(Unit)
            }
        }
    }
}

[rook]

Great! Thanks so much!

[Dico]

send won't work in some of these contexts, use offer with a conflated channel.

[rook]

yeah, I was just realizing that I lose my coroutine body in the context of the lambda

[streetsofboston]

It would depend on how the signature of onUpdateHook looks like. You can make its lambda-parameter suspend (and make it an extension-function of CoroutineScope) if synchronization is important. Otherwise, just call offer like Dico said 🙂

[rook]

Unfortunately, I don’t have control over onUpdateHook. Thanks for all the help!

[rook]

A quick follow-up question, is there a way to use something like produce without a CoroutineScope?

I’m trying to get my repository interface to return a channel, but if I declare waitForUpdates() as an extension of CoroutineScope, I can’t call the function unless it’s from within the context of the repository object

[bdawg.io]

You could manage the lifecycle of the channel yourself. Channels can be created using the Channel() function

[bdawg.io]

produce and actor are implementations that ensure that the Channel's lifecycle is tied to the lifecycle of your coroutine so it doesn't leak

[rook]

How would I go about tying my channel’s lifecycle to the lifecycle of a coroutine in which it’s containing suspend function is invoked?

[streetsofboston]

suspend fun waitForUpdates(): ReceiveChannel<Update> = coroutineScope { ... }.
The lambda of the coroutineScope has a this receiver that is a CoroutineScope instance.