Kotlin coroutine不等待完成

Question

I have a legacy project where I want to use coroutines when contacting the backend. The backend have been handle by a sdk delivered by Hybris. It use volley for instance, and with some callbacks. What I want is to wrap those callbacks with a coroutine. But the problem I have is that the coroutine doesn't wait to be done, it start the coroutine, and keep going to next lines, and method returns a value, and long after that the coroutine finish. My code:

suspend  fun ServiceHelper.getList(): ListOfWishes {

    return suspendCancellableCoroutine { continuation ->

        getAllLists(object : ResponseReceiver<ListOfWishes> {
            override fun onResponse(response: Response<ListOfWishes>?) {
                continuation.resume(response?.data!!)

            }

            override fun onError(response: Response<ErrorList>?) {
                val throwable = Throwable(Util.getFirstErrorSafe(response?.data))
                continuation.resumeWithException(throwable)
            }
        }, RequestUtils.generateUniqueRequestId(), false, null, object : OnRequestListener {
            override fun beforeRequest() {}
            override fun afterRequestBeforeResponse() {}
            override fun afterRequest(isDataSynced: Boolean) {}
        })
    }
}

The helper method:

suspend fun ServiceHelper.wishLists(): Deferred<ListOfWishes> {
    return async(CommonPool) {
        getWishList()
    }
}

And where the coroutine is called:

    fun getUpdatedLists(): ListOfWishes? {
    val context = Injector.getContext()
    val serviceHelper = Util.getContentServiceHelper(context) 
    var list = ListOfWishLists()
    launch(Android) {
        try {
            list = serviceHelper.wishLists().await()
        } catch (ex: Exception){
            Timber.d("Error: $ex")
        }
    }
    return list

So instead of waiting for serviceHelper.wishLists().await() is done, it return list. I have also tried to make the method return a runBlocking{} , but that only block the UI thread and doesn't end the coroutine.

Answer 1

You can do something like this:

class Presenter : CoroutineScope { // implement CoroutineScope to create local scope
    private var job: Job = Job()

    // local coroutine context
    override val coroutineContext: CoroutineContext
        get() = Dispatchers.Main + job

    // call this when activity or fragment is destroyed to cancel the job
    fun detachView() {
        job.cancel()
    }

    fun updateLists() = wishLists().then(this) {

        // update your UI here

        // `it` contains the ListOfWishes

    }

    private fun wishLists(): Deferred<ListOfWishes> = async(Dispatchers.IO) {
        getWishList()
    }

    private suspend  fun getWishList(): ListOfWishes = suspendCancellableCoroutine { continuation ->
        getAllLists(object : ResponseReceiver<ListOfWishes> {
            override fun onResponse(response: Response<ListOfWishes>?) {
                continuation.resume(response?.data!!)
            }

            override fun onError(response: Response<ErrorList>?) {
                val throwable = Throwable(Util.getFirstErrorSafe(response?.data))
                continuation.resumeWithException(throwable)
            }
        }, RequestUtils.generateUniqueRequestId(), false, null, object : OnRequestListener {
            override fun beforeRequest() {}
            override fun afterRequestBeforeResponse() {}
            override fun afterRequest(isDataSynced: Boolean) {}
        })
    }
}

Extension function then :

fun <T> Deferred<T>.then(scope: CoroutineScope = GlobalScope, uiFun: (T) -> Unit) {
    scope.launch { uiFun(this@then.await()) }
}

To use Dispatchers.Main add dependency to app's gradle.build file:

implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.0.1'

Hope it will point you in the right direction.