CoroutineWorker 中的 Kotlin 协程

Question

我正在使用 CoroutineWorker 从房间数据库中获取一些数据，然后 post 将其发送到服务器，然后再次从数据库中删除该特定答案。我正在使用存储库模式。

class SendLocalAnswerToServer(ctx: Context, val params: WorkerParameters) :
    CoroutineWorker(ctx, params) {

var useCaseHandler: UseCaseHandler? = null
var deleteAnswerFromTable: DeleteAnswerFromTable? = null
private var uploadAutoSavedAnswer: UploadAutoSavedAnswer? = null
val TAG:String= "SendLocalAnswerToServer"

override suspend fun doWork(): Result = runBlocking {
    val questionID = params.inputData.getLong("questionID", 0)
    val answerDao = UserDatabase.getDatabase(App.getInstance()).answerDao()
    val answerAPIRepo = NetWorkUtil.provideRetrofit().create(AnswerAPI::class.java)
    uploadAutoSavedAnswer = UploadAutoSavedAnswer(this, answerDao, answerAPIRepo)
    deleteAnswerFromTable = DeleteAnswerFromTable(this, answerDao)
    useCaseHandler = InjectionUtils.provideUseCaseHandler()
    val requestValues = UploadAutoSavedAnswer.RequestValues()
    requestValues.questionID = questionID
    Log.e(TAG, " Main 1")

    launch {
        useCaseHandler!!.execute(uploadAutoSavedAnswer!!, requestValues,
                object :
                        UseCase.UseCaseCallback<UploadAutoSavedAnswer.ResponseValues> {
                    override fun onSuccess(response: UploadAutoSavedAnswer.ResponseValues) {
                                Log.e(TAG, " onSuccess 1")
                                response.observable?.subscribeOn(Schedulers.io())?.observeOn(
                                        AndroidSchedulers.mainThread())!!.subscribeWith(

                                        object :
                                                DisposableObserver<UserAnswerResponseModel>() {
                                            override fun onComplete() {
                                            }

                                            override fun onNext(t: UserAnswerResponseModel) {

                                                Log.e("TAG", " onNext ")
                                                val requestValues = DeleteAnswerFromTable.RequestValues()
                                                requestValues.answerID = t.question.id!!
                                                useCaseHandler?.execute(
                                                        deleteAnswerFromTable!!,
                                                        requestValues,
                                                        object :
                                                                UseCase.UseCaseCallback<DeleteAnswerFromTable.ResponseValues> {
                                                            override fun onSuccess(
                                                                    response: DeleteAnswerFromTable.ResponseValues) {
                                                                Log.e("TAG", " onSuccess 2")
                             // I want to return Result.Success() from here
                                                            }

                                                            override fun onError(
                                                                    throwable: Throwable) {
                            // I want to return Result.Error() from here
                                                            }
                                                        })
                                            }

                                            override fun onError(e: Throwable) {
                                            }
                                        })


                    }

                    override fun onError(throwable: Throwable) {
                    }
                })
    }
    Log.e(TAG, " MAIN 2")
    Result.success()

}
}

输出打印

E/SendLocalAnswerToServer:  Main 1
E/SendLocalAnswerToServer:  MAIN 2

我如何 return 上次成功或 return 方法的值，现在它进入第一个函数 useCaseHandler!!.execute() 哪个进一步启动一个新线程，因此协程只是 return 从那里任何解决方案，这样当整个 api 调用和从 table 进一步删除已经完成时，它应该 return成功

Answer 1

当您使用useCaseHandler.execute(...)时，它在哪个线程上执行请求？问题是您实际上根本没有使用协程。您正在混合基于 API 的回调和基于 API 的 Rx（不正确）。

你有2个选项。要么正确使用协程，要么使用 CountDownLatch。

CoroutineWorker 中的 Kotlin 协程

Kotlin coroutines in CoroutineWorker

multithreading

android-workmanager

kotlin-coroutines