如何使用Retrofit，RxJava等待回调

Question

I am making multiple Retrofit requests and with every request I need to generate new client with new token. The problem is it is not waiting for it to finish so the client is null . I tried to add callback to generatePrivateToken() as well but it did not work.

public void generatePrivateToken(){
        mNewControl.obstest(GETTOKEN)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<Response<ResponseBody>>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                    }
                    @Override
                    public void onNext(Response<ResponseBody> responseBodyResponse) {
                        key = responseBodyResponse.headers().get("Token");
                        new ApiKeys().encryptToken(key, new GeneralCallback() {
                            @Override
                            public void onSuccess(String token) {
                                Log.e("Token", token);
                                client = new HttpClient(USERNAME,token, emptyTag, emptyTag).getClient();
                            }
                        });
                    }
                    @Override
                    public void onError(Throwable e) {
                    }
                    @Override
                    public void onComplete() {

                    }
                });
    }

public void getControlData(){
    generatePrivateToken();

    Retrofit retrofit = new Retrofit.Builder()
            .baseUrl(HOST_URL)
            .client(client)
            .addConverterFactory(GsonConverterFactory.create())
            .build();
    newControl service = retrofit.create(newControl.class);
    Call<List<GetControlData>> call = service.controlData(CONTROL);
    call.enqueue(new Callback<List<GetControlData>>() {
        @Override
        public void onResponse(Call<List<GetControlData>> call, Response<List<GetControlData>> response) {
            //do something, start new retrofit method
        }
        @Override
        public void onFailure(Call<List<GetControlData>> call, Throwable t) {
        }
    });

}

Answer 1

Your problem is well known and is why we need rx Observable over normal callback in Retrofit. See this answer .

Let's say you not want to make multiple retrofit requests and wait for all request have been finished, you can use the zip operator

Let's first define our Retrofit object

Retrofit repo = new Retrofit.Builder()
        .baseUrl("https://api.github.com")
        .addConverterFactory(GsonConverterFactory.create())
        .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
        .build();

Observable<JsonObject> userObservable = repo
        .create(GitHubUser.class)
        .getUser(loginName)
        .subscribeOn(Schedulers.newThread())
        .observeOn(AndroidSchedulers.mainThread());

Observable<JsonArray> eventsObservable = repo
        .create(GitHubEvents.class)
        .listEvents(loginName)
        .subscribeOn(Schedulers.newThread())
        .observeOn(AndroidSchedulers.mainThread());

simple POJO to combine the two objects:

public class UserAndEvents {
  public UserAndEvents(JsonObject user, JsonArray events) {
    this.events = events;
    this.user = user;
  }

  public JsonArray events;
  public JsonObject user;
}

then use RxJava's zip method to combine our two Observables and wait for them to complete before creating a new Observable.

Observable<UserAndEvents> combined = Observable.zip(userObservable, eventsObservable, new Func2<JsonObject, JsonArray, UserAndEvents>() {
  @Override
  public UserAndEvents call(JsonObject jsonObject, JsonArray jsonElements) {
    return new UserAndEvents(jsonObject, jsonElements);
  }
});

For more details, visit the answer a give above, it's nice and fully explain.