七、suspendCoroutine与suspendCancellableCoroutine —— 回调转挂起函数

在协程出现之前，异步操作通常用回调接口来处理结果。以 Retrofit 的网络请求为例：

// 传统回调式写法
private fun callbackStyle() {
    apiService.getResult("params")
        .enqueue(object : Callback<Result> {
            override fun onResponse(
                call: Call<Result>,
                response: Response<Result>
            ) {
                showResult(response.body()!!)   // 成功回调
            }

            override fun onFailure(
                call: Call<Result>,
                t: Throwable
            ) {
                t.printStackTrace()              // 失败回调
            }
        })
}

这种写法的典型问题：

• 成功和失败的逻辑分散在两个回调方法里
• 如果有多个请求需要串行，就会形成"回调地狱"
• 无法使用 try-catch 统一处理异常
• 生命周期管理困难

suspendCoroutine 是一个挂起函数，你在它的 lambda 里面调用传统回调式的函数，就可以把这个回调式的函数转换成挂起函数。

// 用 suspendCoroutine 将回调转成挂起
lifecycleScope.launch {
    val result = suspendCoroutine { continuation ->
        apiService.getResult("params")
            .enqueue(object : Callback<Result> {
                override fun onResponse(
                    call: Call<Result>,
                    response: Response<Result>
                ) {
                    continuation.resume(response.body()!!)   // 成功：恢复协程，返回结果
                }

                override fun onFailure(
                    call: Call<Result>,
                    t: Throwable
                ) {
                    continuation.resumeWithException(t)      // 失败：恢复协程并抛出异常
                }
            })
    }
    // result 直接可用，像同步代码一样
    showResult(result)
}

直接在 launch 中写 suspendCoroutine 会让调用方代码臃肿。最佳实践是把转换逻辑封装为一个独立的挂起函数：

// 调用方：像同步代码一样干净
lifecycleScope.launch {
    try {
        val result = callbackToSuspend()
        showResult(result)
    } catch (e: Exception) {
        textView.text = e.message       // 统一异常处理
    }
}

// 封装：将 Retrofit 回调转为挂起函数
private suspend fun callbackToSuspend() = suspendCoroutine { continuation ->
    apiService.getResult("params")
        .enqueue(object : Callback<Result> {
            override fun onResponse(
                call: Call<Result>,
                response: Response<Result>
            ) {
                continuation.resume(response.body()!!)
            }

            override fun onFailure(
                call: Call<Result>,
                t: Throwable
            ) {
                continuation.resumeWithException(t)
            }
        })
}

这样封装的好处：

• 调用方只关心业务逻辑，不关心底层是 Retrofit 还是别的什么
• 异常可以通过 try-catch 统一处理，和同步代码一样自然
• 如果将来换成其他网络库（如 OkHttp 直接调用），只需改 callbackToSuspend 内部实现
• 函数可以被多处复用

suspendCoroutine 有一个重要局限：它不响应协程的取消。当外部调用 job.cancel() 时，suspendCoroutine 内部发起的网络请求仍然在进行，不会自动中断。

如果希望协程被取消时也能中断底层的网络请求，应该使用 suspendCancellableCoroutine，它支持取消回调。

// 调用方：支持取消
lifecycleScope.launch {
    try {
        val result = callbackToSuspend()
        showResult(result)
    } catch (e: Exception) {
        textView.text = e.message
    }
}

// 封装：使用 suspendCancellableCoroutine
private suspend fun callbackToSuspend() = suspendCancellableCoroutine { cont ->
    val call = apiService.getResult("params")

    // 核心：协程取消时，同步取消底层网络请求
    cont.invokeOnCancellation {
        call.cancel()     // 取消 OkHttp 的 Call
    }

    call.enqueue(object : Callback<Result> {
        override fun onResponse(
            call: Call<Result>,
            response: Response<Result>
        ) {
            cont.resume(response.body()!!)
        }

        override fun onFailure(
            call: Call<Result>,
            t: Throwable
        ) {
            cont.resumeWithException(t)
        }
    })
}