【问题标题】:How to call a coroutine usecase from a rxjava flat map如何从 rxjava flatmap 调用协程用例
【发布时间】:2021-01-07 17:05:56
【问题描述】:

您好,我有一个 rxjava 平面图,我想在其中调用协程用例 onStandUseCase,这是一个 api 调用

最初的用例也是基于 rxjava 的,它曾经返回 Observable<GenericResponse> 并且运行良好 现在我将使用更改为基于协同程序,它只返回GenericResponse

如何修改平面图以在协程用例中正常工作

        subscriptions += view.startFuellingObservable
        .onBackpressureLatest()
        .doOnNext { view.showLoader(false) }
        .flatMap {
            if (!hasOpenInopIncidents()) {
                //THIS IS WHERE THE ERROR IS IT RETURNS GENERICRESPONSE
                onStandUseCase(OnStandUseCase.Params("1", "2", TimestampedAction("1", "2", DateTime.now()))) {
                    
                }
               
            } else {
                val incidentOpenResponse = GenericResponse(false)
                incidentOpenResponse.error = OPEN_INCIDENTS
                Observable.just(incidentOpenResponse)
            }
        }
        .subscribe(
            { handleStartFuellingClicked(view, it) },
            { onStartFuellingError(view) }
        )

OnStandUseCase.kt

class OnStandUseCase @Inject constructor(
    private val orderRepository: OrderRepository,
    private val serviceOrderTypeProvider: ServiceOrderTypeProvider
) : UseCaseCoroutine<GenericResponse, OnStandUseCase.Params>() {

    override suspend fun run(params: Params) = orderRepository.notifyOnStand(
        serviceOrderTypeProvider.apiPathFor(params.serviceType),
        params.id,
        params.action
    )

    data class Params(val serviceType: String, val id: String, val action: TimestampedAction)
}

UseCaseCoroutine

abstract class UseCaseCoroutine<out Type, in Params> where Type : Any {

    abstract suspend fun run(params: Params): Type

    operator fun invoke(params: Params, onResult: (type: Type) -> Unit = {}) {
        val job = GlobalScope.async(Dispatchers.IO) { run(params) }
        GlobalScope.launch(Dispatchers.Main) { onResult(job.await()) }
    }
}

startFuellingObservable 是

val startFuellingObservable: Observable<Void>

这是错误的图像

请对如何解决此问题提出任何建议

提前致谢 回复

【问题讨论】:

  • 使用integration library。然后写rxSingle { ... }.toObservable()。而且由于你不需要 observables,你可以写 concatMapSingle 而不是 flatMap。
  • 你好@GeorgeLeung startFuellingObservable 仍然是一个可观察的,我不想改变那一面
  • Observable#concatMapSingle returns 和 Observable。 “不需要 observables”,我的意思是挂起函数对应于 Single 而不是 Observable。
  • 能否请您建议我的代码需要如何更改,我对此很陌生

标签: android kotlin rx-java kotlin-coroutines use-case


【解决方案1】:

integration library 链接 RxJava 和 Kotlin 协程。

rxSingle 可用于将挂起函数转换为Single。 OP 想要一个Observable,所以我们可以调用toObservable() 进行转换。

.flatMap {
    if (!hasOpenInopIncidents()) {
        rxSingle {
            callYourSuspendFunction()
        }.toObservable()
    } else {
        val incidentOpenResponse = GenericResponse(false)
        incidentOpenResponse.error = OPEN_INCIDENTS
        Observable.just(incidentOpenResponse)
    }
}

请注意,两个分支中的Observables 只包含一个元素。我们可以通过使用Observable#concatMapSingle 使这一事实更加明显。

.concatMapSingle {
    if (!hasOpenInopIncidents()) {
        rxSingle { callYourSuspendFunction() }
    } else {
        val incidentOpenResponse = GenericResponse(false)
        incidentOpenResponse.error = OPEN_INCIDENTS
        Single.just(incidentOpenResponse)
    }
}

【讨论】:

    猜你喜欢
    • 1970-01-01
    • 2021-05-29
    • 1970-01-01
    • 2021-03-22
    • 2021-04-02
    • 2018-06-29
    • 1970-01-01
    • 1970-01-01
    • 2018-11-22
    相关资源
    最近更新 更多