为什么我不能在 lambda 函数下调用 kotlin 挂起函数

Question

Let me start with example code snippets

suspend fun executeLive(result: MutableLiveData<Person>) {

    val response = ... //suspend api request

    mediatorLiveData.removeSource(response)

    mediatorLiveData.addSource(response) {
        result.value = sortData(it) // sortData is also suspend function which sortData at Dispatcher.Default
    }

}

In this example, sortData can't call under lambda function (in this case addSource ).And also I already declare executeLive as suspend , that why suspend api request can start at first. But sortData function show compile time error

Suspend function can only be called from a coroutine body

So how do I change my code structure to solve this problems?

Update: Is there any article about this?

Answer 1

A lambda is generally a callback function. Callback functions are so called because we wrap a block of code in a function, and pass it to someone else (or some place else) to be executed. It is a basic inversion of control where the code is not for you to execute, but someone else to do it (example the framework).

For example when you set a onClickListener on a button, we don't know when it will get called, we pass a lambda for the framework which takes care of the user interaction to call the specified action.

In your case similarly the suspend function is not calling the sortdata , it is passing it to the mediatorLiveData object to call it in its own context. It is not necessary the lambda you passed would be called from a coroutine body, as such this is not allowed.

Answer 2

You can solve this by converting the mediatorLiveData.addSource call into a suspending call itself with suspendCoroutine :

suspend fun executeLive(result: MutableLiveData<Person>) {

    val response = ... //suspend api request

    mediatorLiveData.removeSource(response)

    val data = suspendCoroutine<TypeOfData> { cont ->
        mediatorLiveData.addSource(response) { cont.resume(it) }
    }

    result.value = sortData(data)
}

I've used TypeOfData as a placeholder for whatever the type of data emitted by response is. Note that this will only work if the you're intending for a single emission to happen, though.

If you need to track multiple values, you can experiment with callbackFlow :

suspend fun executeLive(result: MutableLiveData<Person>) {

    val response = ... //suspend api request

    mediatorLiveData.removeSource(response)

    callbackFlow<TypeOfData> {
        mediatorLiveData.addSource(response) { offer(it) }

        awaitClose { mediatorLiveData.removeSource(response) }
    }
        .collect { result.value = sortData(it) }
}