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的所有结果。

NetworkConsumer：

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来处理这个变化。

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
    }
}