如何从协程返回响应值

Question

我最近与 Kotlin 一起工作，并且真的被这个问题困住了。 我正在尝试返回浮点值接收协程 api 调用函数的 onResponse。 我正在尝试创建一个处理 api 调用的类并在片段上使用它。

函数A.kt

class FunctionA(val context: Context?, val A: Float?, val B: String?){

   private var cardApi: CardApi = ApiClient.createApi().create(CardApi::class.java)

   ....

   func getBalance(cardNo: String): Float?{
       val cardBalance: Float = null

       GlobalScope.launch(Dispatchers.Main) {
            val cardDetails = cardApi.getCardBalance(cardNo)
            cardDetails.enqueue(object : Callback<Card> {
                override fun onFailure(call: Call<Card>, t: Throwable) {
                    trackEvent(API_READ_CARD_BALANCE_ERROR, ERROR to t.message!!)
                }

                override fun onResponse(call: Call<Card>, response: Response<Card>) {
                    if (response.isSuccessful) {
                        val card = response.body()!!
                        cardBalance = card.cardAvailableBalance

                    } else {
                        val error: ApiError = ErrorUtils.parseError(response)
                        val message = error.code + error.message
                        trackEvent(API_READ_CARD_BALANCE_ERROR, ERROR to message)
                        context!!.toast("Errror: " + message)

                        promptErrorDialog(error)
                    }
                }
            })
        }}

        return cardBalance
   }
   ....
   ....

}

片段类.kt

class FragmentClass : BaseFragment(){

    val galA = 10.5f
    val galB = "Test"
    private var pass = FunctionA(context!!, valA ,valB)

    ....

    val point = "sasd12125"
    private fun gooToo(){
        val B = pass.getBalance(point)
        print("TEST")
        println("value B: " + B)
    }
    ....

}

现在发生了什么，因为协程在后台需要一些时间， val B为空并且没有得到 onResponse 获得的值。 只有在我再次尝试调用该 functionA 之后，才会更新该值。 我不确定我是否做得对，我已经尝试寻找解决方案，但它不适合我目前的情况。 可能我的搜索技巧太糟糕了。

输出

TEST
value B: null

在返回cardBalance值之前，我应该如何等待协程完成？

Answer 1

从协程返回单个值的正确方法是使用await() 。

现在，由于您使用协程来包装一些回调 API，因此效果不佳。 所以我建议使用这样的方法：

val scope = CoroutineScope(Dispatchers.IO)

suspend fun getBalance(cardNo: String): Float{
    val res = CompletableDeferred<Float>()

    scope.launch {
        val cardDetails = cardApi.getCardBalance(cardNo)
        cardDetails.enqueue(object : Callback<Card> {
            override fun onFailure(call: Call<Card>, t: Throwable) {
                trackEvent(API_READ_CARD_BALANCE_ERROR, ERROR to t.message!!)
            }

            override fun onResponse(call: Call<Card>, response: Response<Card>) {
                if (response.isSuccessful) {
                    val card = response.body()!!
                    res.complete(card.cardAvailableBalance)

                } else {
                    val error: ApiError = ErrorUtils.parseError(response)
                    val message = error.code + error.message
                    trackEvent(API_READ_CARD_BALANCE_ERROR, ERROR to message)
                    res.completeExceptionally(message)

                    withContext(Dispatchers.Main) {
                        promptErrorDialog(error)    
                    }
                }
            }
        })
    }

    return res.await()
}

需要考虑的几点。 首先，我使用Dispatchers.IO而不是Dispatchers.Main ，并仅在需要时使用withContext(Dispatchers.Main)切换到Main线程。 否则，您只是在主线程上运行您的 IO，无论是否是协程。

其次，使用GlobalScope是一种不好的做法，你应该不惜一切代价避免它。 相反，我创建了一个自定义范围，您可以使用.cancel()来防止协程泄漏。

第三，最正确的方法是返回Deferred<Float> ，而不是Float ，因为await()是阻塞的。 但为了简单起见，我留下了它。

Answer 2

为了解决我的小问题，我最终使用回调来传递响应数据。 我发现这种方法非常有效，而且就我的理解水平而言更容易理解。 这个方法框架也可以重用于我以后想要使用的任何 api 服务调用。

函数A.kt

class FunctionA(val context: Context?, val A: Float?, val B: String?){

   private var cardApi: CardApi = ApiClient.createApi().create(CardApi::class.java)
   private var card: Card? = null

   interface CardBalanceCallback {
       fun processFinish(output: Boolean, cardBalance: Float?)
   }

   fun getCardBalance(cardNo: String, callback: CardBalanceCallback) = runBlocking {
       getBalance(cardNo, callback)
   }

   private fun getBalance(cardNo: String, callback: CardBalanceCallback) = CoroutineScope(Dispatchers.Main).launch {
        try {
            val response = cardApi.getCardBalance(cardNo).await()
            if (response.isSuccessful) {
                card = response.body()
                callback.processFinish(true, card!!.cardAvailableBalance)
            } else {
                callback.processFinish(false, null)
                val error: ApiError = ErrorUtils.parseError(response)
                val message = when {
                    error.error.code.isNotEmpty() -> error.error.code + error.error.message
                    else -> error.code + error.message
                }
                trackEvent(API_READ_CARD_BALANCE_ERROR, ERROR to message)
                promptErrorDialog(error)
            }
        } catch (e: HttpException) {
            callback.processFinish(false, null)
            trackEvent(API_READ_CARD_BALANCE_ERROR, ERROR to e.message!!)
            context!!.toast(e.message.toString())
        } catch (e: Throwable) {
            callback.processFinish(false, null)
            trackEvent(API_READ_CARD_BALANCE_ERROR, ERROR to e.message!!)
            context!!.toast( e.message.toString())
        }
    }
   ....
   ....

}

片段类.kt

class FragmentClass : BaseFragment(){

    private var funcService = FunctionA(null, null ,null)

    ....

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        (activity!!.application as App).component.inject(this)

        val valA = 10.5f
        val valB = "Test"
        val cardNo = "4001526976443264"
        val cardExpDate = "1119"

        funcService = FunctionA(context!!, valA ,valB)
        getCardBalanceApi(cardNo, cardExpDate)

    }

    .... 

    private fun getCardBalanceApi(cardNo: String, cardExpDate: String?) {
        showLoadingDialog()
        funcService.getCardBalance(cardNo, object : SmartPayService.CardBalanceCallback {
            override fun processFinish(output: Boolean, cardBalance: Float?) {
                dismissLoadingDialog()
                if (cardBalance != null) {
                    checkBalance(cardNo, cardBalance, cardExpDate)
                }
            }
        })
    }

    ....

}

这是我在第一篇文章中针对这个特定问题所做的一些简单更改。 这种方法可能不像我还在学习的那样好或不够流畅。 希望对你们中的一些人有所帮助。 干杯

Answer 3

使getBalance()成为挂起函数，然后在片段中使用lifecycleScope调用

private fun gooToo(){
   lifecycleScope.launch {
       val B = pass.getBalance(point)
       print("TEST")
       println("value B: " + B)
   }
}

getBalance()函数签名类似于

suspend fun getBalance(): Float = withContext(Dispatchers.IO)