如何从 Kotlin 异步关闭中保存数据？

Question

I am calling an API in an asynchronous function, and would like to store the response from the callback.

Specifically, I am using the API category of AWS Amplify in an Android app, and would like to assign the return value to a LiveData variable in a ViewModel .

fun getMuscleGroup(id: String): ExampleData {
    var exampleData = ExampleData.builder().name("").build()

    Amplify.API.query(
        ModelQuery.get(ExampleData::class.java, id),
        { response ->
            Log.d("AmplifyApi", response.data.name)
            exampleData = response.data
        },
        { error -> Log.e("AmplifyApi", "Query failure", error) }
    )

    return exampleData
}

I can receive the response and it gets logged correctly, but the response is not assigned to the exampleData variable, since the function returns early.

In Android Studio, the variable exampleData is highlighted with the text:

Wrapped into a reference object to be modified when captured in a closure

As I am not that familiar with the multithreading APIs in kotlin, I am not sure, how to block the function until the remote API returns its asynchronous response.

Answer 1

The most basic way of doing this would be with standard Java thread safety constructs.

fun getMuscleGroup(id: String): ExampleData {
    var exampleData = ExampleData.builder().name("").build()
    val latch = CountDownLatch(1)
    Amplify.API.query(
        ModelQuery.get(ExampleData::class.java, id),
        { response ->
            Log.d("AmplifyApi", response.data.name)
            exampleData = response.data
            latch.countDown()
        },
        { error -> 
            Log.e("AmplifyApi", "Query failure", error)
            latch.countDown()
        }
    )

    latch.await()
    return exampleData
}

Since this is on Android, this is probably a bad solution. I'm going to guess that getMuscleGroup is being called on the UI thread, and you do not want this method to actually block. The UI would freeze until the network call completes.

The more Kotlin way of doing this would be to make the method a suspend method.

suspend fun getMuscleGroup(id: String): ExampleData {
    return suspendCoroutine { continuation ->
      Amplify.API.query(
        ModelQuery.get(ExampleData::class.java, id),
        { response ->
            Log.d("AmplifyApi", response.data.name)
            continuation.resume(response.data)
        },
        { error -> 
            Log.e("AmplifyApi", "Query failure", error)
            // return default data
            continuation.resume(ExampleData.builder().name("").build())
        }
    }
}

This use Kotlin coroutines to suspend the coroutine until an answer is ready and then return the results.

Other options would be to use callbacks instead of return values or an observable pattern like LiveData or RxJava.

Answer 2

You cannot block to wait for the asynchronous result. At worst it can cause an Application Not Responding (ANR) error message to appear for the user, and at best makes your app look stuttery and feel unresponsive.

You can instead add a callback for this function:

fun getMuscleGroup(id: String, callback: (ExampleData) -> Unit) {
    var exampleData = ExampleData.builder().name("").build()

    Amplify.API.query(
        ModelQuery.get(ExampleData::class.java, id),
        { response ->
            Log.d("AmplifyApi", response.data.name)
            callback(response.data)
        },
        { error -> Log.e("AmplifyApi", "Query failure", error) }
    )
}

And then in the spot where you call the code, you put your subsequent actions in the callback:

fun onMuscleGroupClicked(id: String) {
    getMuscleGroup(id) { exampleData ->
        // do something with the data after it arrives
    }
}

Coroutines are another option. They're nice because you don't have to nest your sequential actions in callbacks. To set it up, I would create a suspend extension function version of the API library query function by using suspendCancellableCoroutine . Then you can freely use it in other suspend functions in an orderly way. But you'll need to read the documentation on coroutines. It's to much to explain here from scratch.