Hi guys. I got a strange situation with

suspend

function which I can't solve: I got function

suspend fun one()

which executes some code and then calls a function that accepts a callback function as a param. But, this param function is not suspend. The issue is that I need to call another suspend fun from that callback param function. Here's an example:

suspend fun one() {
    doSomething()
    funWithNonSuspendCallback("data") {
        two() // I need to call it from here but this is not suspend scope anymore
    }
}

suspend fun two() {
}

try wrapping funWithNonSuspendCallback into a coroutine: https://github.com/Kotlin/KEEP/blob/master/proposals/coroutines.md#wrapping-callbacks After that your code will look like that:

suspend fun one() {
    doSomething()
    suspendingWrappedFunWithNonSuspendCallback("data")
    two() // Back into coroutine scope after callback was called
    }
}

@uli Thank you Uli. I will take a look into this solution (I didn't know about this feature)

@Dmytro TOLSTYI Just use this:

suspendCoroutine { continuation ->
    // call continuation.resume(Unit) when callback is invoked
}

If you support cancellation, you can also use this;

suspendCancellableCoroutine { continuation ->
    continuation.invokeOnCancellation {
        // unregister callback
    }
    // call continuation.resume(Unit) when callback is invoked
}

Thank you @louiscad

@Dmytro TOLSTYI Your code will not block, it will suspend (hence the name), until

resume

is called back on the

Continuation

. You register the callback in the lambda passed to

suspendCoroutine

or

suspendCancellableCoroutine

, which will be called immediately, and will then suspend waiting for your callback to invoke

resume

.

OK. Maybe block was incorrect word, I just tried to explain the flow:

fun one()
suspendCoroutine {}
fun two()

In this case

fun two()

is not going to be executed unless

suspendCoroutine

is not resumed, right?

@Dmytro TOLSTYI Your snippet is not syntactically correct if I follow what you're saying, hence my misunderstanding. If you mean such a snippet:

one()
suspendCoroutine { c ->
    // Some code
}
two()

then yes, just like all suspend function calls, it will suspend until it's resumed, and only then,

two()

wil be executed.

@louiscad But in case of binding event listener variant:

one()
bindEventListenerWithCallback(callback)
two()

The flow is

one()

->

bindEventListenerWithCallback()

->

two()

->

callback()

Looks like the flow is different in this case

I think I'm missing some context here, and I don't see any call to

callback()

in your snippet…

@louiscad

callback

is going to be called when appropriate event is fired

@Dmytro TOLSTYI If

bindEventListenerWithCallback

is a suspend function but behaves the way you tell me, then it's not implemented correctly (using

suspendCoroutine

or

suspendCancellableCoroutine

properly should fix this)

@louiscad

bindEventListenerWithCallback

is not a

suspend

function. What it does is just register handler that will be called when some kind of event occurs

@Dmytro TOLSTYI So you need to wrap it and the callback you pass to it into

suspendCoroutine

or its cancellable version if supported.

Like this:

suspend fun suspendingWrappedFunWithNonSuspendCallback(data: String): Value = suspendCoroutine { cont ->
    funWithNonSuspendCallback("data") { cont.resume(it) }
}

Thank you for the help. I will try to implement it in my case