带有RX顺序请求的Android Retrofit2

Question

I'm using retrofit2 with Rx. I have two API calls. If first call returns empty response with code 400 I need to make second API call, if not then just to show result. I've implemented custom error handling how shown here . Here is my solution:

getResponse1(token)
            .subscribeOn(Schedulers.newThread())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new ObserverErrorImpl<Response1, BaseError>(BaseError.class) {
                @Override
                public void onNext(Response1 response) {
                    view.onSuccess(response);
                }

                @Override
                public void onClientError(BaseError response) {
                    getResponse2(token)
                            .subscribeOn(Schedulers.newThread())
                            .observeOn(AndroidSchedulers.mainThread())
                            .subscribe(new ObserverErrorImpl<Response2, BaseError>(BaseError.class) {

                                @Override
                                public void onNext(Response2 response) {
                                    view.onSuccess(response);
                                    view.hideProgress();
                                }

                                @Override
                                public void onError(Throwable throwable) {
                                    super.onError(throwable);
                                    view.hideProgress();
                                }
                            });
                }

                @Override
                public void onError(Throwable throwable) {
                    super.onError(throwable);
                    view.hideProgress();
                }
            });

Is it possible to simplify this code that goes inside method onClientError ? Is it good solution to like that?

Answer 1

1). To simplify it, it would be better that Response1 and Response2 will extend some base class, so in your chain, you can operate with base class, which can be casted to certain type when needed

So, let's assume, that you have BaseResponse :

public abstract class BaseResponse{

    public static int TYPE_RESPONSE_1 = 1;
    public static int TYPE_RESPONSE_2 = 2;

    public abstract int getType();    //every class MUST override this method
}

Response1 and Response2 should override BaseResponse

2). getResponse1 and getResponse2 should return Observable<BaseResponse>

3). Your target code:

    getResponse1(token)
            .onErrorResumeNext(new Func1<Throwable, Observable<BaseResponse>>() {
                @Override
                public Observable<BaseResponse> call(Throwable throwable) {
                    // I use Retrofit 1.9
                    // And in Retrofit 1.9 I have class RetrofitError, which may provide me all info about error
                    // I'm absolutelly sure Retrofit 2 also have such class,
                    // but it may have another name
                    if(/* is your target error */){
                        //cast it tour target error
                        return getResponse2(token);
                    }
                    return Observable.error(throwable);
                }
            })
            .subscribeOn(Schedulers.newThread())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new ObserverErrorImpl<Response1, BaseError>(BaseError.class) {
                @Override
                public void onNext(BaseResponse response) {
                    if(response.getType() == BaseResponse.TYPE_RESPONSE_1){
                        view.onSuccess(response);
                    } else {
                        view.onSuccess(response);
                        view.hideProgress();
                    }
                }

                @Override
                public void onError(Throwable throwable) {
                    super.onError(throwable);
                    view.hideProgress();
                }
            });

Answer 2

Jeesh, why does everyone make it so complicated? In practice I've felt that every time I needed to subscribe to an Observable in the subscribe of another, there is an operator that will do it much more cleanly for me:

 <T,E extends Throwable> Observable<T>
 whenExceptionIs(Class<E> what, Func1<E,Observable<T>> result) {
     return t -> {
        return what.isInstance(t) ? result.call(t) : Observable.error(t);
     };
 }

 getResponse1(token)
 .onErrorResumeNext(whenExceptionIs(BaseError.class, getResponse2(token)))
 .subscribeOn(Schedulers.newThread())
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe(view::onSuccess, view::hideProgress, err -> view.hideProgress());

If you have special error handling needs, create a custom Subscriber that handles that, but make sure that error handling in general is

• handled in the Observable chain if it can do anything about it (ignore it, retry the calls etc)
• propagated downstream.