RxAndroid / RxLifeCycle - 处理处置 onError 而不是 onComplete

Question

我目前正在尝试将 RxLifeCycle 实施到我的 RxJava 网络中。我一直在使用 Consumer 的子类，但是对于 RxLifeCycle，您需要处理 onError。所以我搬到了 Observer.

这个问题是，当调用被处理时，它调用 onComplete 而不是我更喜欢的 onError。

buildle.gradle:

 // RxJava
    compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
    compile 'io.reactivex.rxjava2:rxjava:2.0.3'
    compile 'com.trello.rxlifecycle2:rxlifecycle-kotlin:2.2.1'
    compile 'com.trello.rxlifecycle2:rxlifecycle-android-lifecycle-kotlin:2.2.1'

我之前的NetworkConsumer结构是这样的，我会处理accept中的所有结果。

网络消费者：

abstract class NetworkConsumer<T> : Consumer<NetworkResponse<T>> {

    @Throws(Exception::class)
    override fun accept(response: NetworkResponse<T>) {
         ...
    }

    // to override
    open fun onSuccess(response: T) {}
    open fun onComplete() {}


}

我的网络调用都使用相同的方式构建 Single。

fun getFavorites(): Single<NetworkResponse<Array<MyObject>>>

我就是这样用的。

service.getFavorites(...)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(object : NetworkConsumer<Array<MyObject>>() {
                    override fun onSuccess(response: Array<MyObject>) {
                         // use response
                    }

                    override fun onComplete() {
                         // do whatever, like hiding the loading view.
                         loading_view.visibility = View.GONE
                    }
 })

我真的很喜欢这种设置，因为它允许我将很多逻辑从调用 Activity 移到 NetworkConsumer 中，而只担心处理结果。

但是，对于 RxLifeCycle，您需要使用 Observable 而不是 Single。所以我创建了一个 NetworkObserver 来处理这个变化。

网络观察者：

abstract class NetworkObserver<T> : Observer<NetworkResponse<T>> {

    override fun onSubscribe(d: Disposable) {}

    override fun onNext(response: NetworkResponse<T>) {}

    override fun onError(e: Throwable) {}

    override fun onComplete() {}

   // other functions from NetworkConsumer
}

但是，问题是处理网络调用时正在调用 onComplete，我更愿意处理 onComplete 中的任何 UI 更改。

例如，我在网络呼叫开始时显示一个加载屏幕，我想在完成时隐藏该加载屏幕，无论它是否失败。

我相信我只需要为此使用不同的 Class 而不是 Observer，但我不确定哪个 Class 最适合这个。

Answer 1

正确答案是 SingleObserver，这非常适合网络。

abstract class NetworkObserver<T> : SingleObserver<NetworkResponse<T>> {

    override fun onSubscribe(d: Disposable) {
        ...
    }

    override fun onSuccess(response: NetworkResponse<T>) {
        ... handle onSuccess
    }

    override fun onError(e: Throwable) {
        ... cancelled or an error
    }
}

RxAndroid / RxLifeCycle - 处理处置 onError 而不是 onComplete

RxAndroid / RxLifeCycle - Handling dispose onError instead of onComplete

android

android-lifecycle

rx-java

rx-android