RxJava Android方向更改和网络请求

Question

I'm new to RxJava and I need to integrate it into an existing project. I need to refactor the existing code, adding Observables for networking (Socket IO).

Currently when a network request is made (client -> server) a callback (interface) is added to a HashMap and once the request is completed, it will deliver the data back to the caller:

// Singleton
public class API {

   public void checkTicket(String ticketId, final String networkRequestId, Callback callback) {
      // Add the callback to the hashmap
      registerCallback(networkRequestId, callback);

      JSONObject json = RequestFactory.createTicketCheckerRequest(ticketId);

      // Make the network request
      getSocket().checkTicket(json, new Callback() {
          @Override
          public void onRequestDone(Response response) {

              // Retrieve the callback
              callback = getCallback(networkRequestId);

              // Don't keep reference, remove from hashmap
              unsubscribeCallback(networkRequestId);

              // Check if it's unsuccessful and build the corresponding error response
              if (!response.isSuccess()) {
                  // build custom error response
                  response = ResponseFactory.buildError(response);
              }

              // Deliver response from server
              callback.onRequestDone(response);
          }
      });
  }

}

It can be called from Activities and Fragments :

private void checkTicket() {
   String ticketId = editText.getText().toString();

   API.getInstance().checkTicket(ticketId, REQUEST_ID_CHECK_TICKET, new Callback() {
      @Override
      protected void onRequestDone(Response response) {
         textView.setText(response.getData());
      }
   });
}

@Override
public void onDestroy() {
   super.onDestroy();

   // Removes callback from HashMap in case of the UI is destroyed before the arrives
   API.getInstance().unsubscribe(REQUEST_ID_CHECK_TICKET);
}

The above code works but it's really tight with the UI's lifecycle and sometimes it's causing memory leak, because onDestroy() is not getting called (if you navigate between activities and Android OS kills the "paused" activities from the stack) or because the anonymous inner classes (callbacks) which are holding a reference to the UI, and from now on I need to support orientation change .

This is the code that I have implemented using RxJava :

API :

public Observable<Response> checkTicket(String ticketId) {
   return Observable.create(subscriber -> {
      JSONObject json = RequestFactory.createTicketCheckerRequest(ticketId);

      // Make the network request
      getSocket().checkTicket(json, new Callback() {
         @Override
         public void onRequestDone(Response response) {
            subscriber.onNext(response);
            subscriber.onComplete();
         }
      });
   });
}

This is how it's called from the UI:

private CompositeDisposable mDisposables = new CompositeDisposable();

private void checkTicket() {
   //////

   Disposable disposable = API.getInstance().checkTicket(ticketId)
      .observeOn(AndroidSchedulers.mainThread())
      .subscribeOn(Schedulers.io())
      .subscribe(result -> {
         textView.setText(result.getData());
      });

   mDisposables.add(disposable);
}

@Override
public void onStop() {
   super.onStop();

   if (!mDisposables.isDisposed()) {
      mDisposables.dispose();
   }
}

The above RxJava is working, however if an orientation change occurs the data is not returned because the Observer is unsubscribed.

1. Is the above implementation correct?
2. How should I subscribe without executing the request? Subscribe and wait for data change.

Another alternative would be EventBus but this is just Plan B. EventBus fits exactly my requirements, subscribe and wait for data change, but I want to evict boilerplate.

I have read other articles by using Fragment 's setRetainInstance(true) but what if I need to use it from an Activity ? What if I don't want to retain the state of the Fragment ? People suggested to use MVVM or MVP architecture, but I don't have the time to refactor the entire project.

Answer 1

I will suggest you move to MVVM. With your presented code, it is not that hard. Here is a sample code of how it will look like

Your ModelView

public class MyViewModel extends ViewModel {
    private CompositeDisposable mDisposables = new CompositeDisposable();
    private MutableLiveData<Response> response;

    public LiveData<Response> getResponse() {
        if (response == null) {
            response = new MutableLiveData<Response>();
            loadData();
        }
        return response;
    }

    private void loadData() {
        Disposable disposable = API.getInstance().checkTicket(ticketId)
          .observeOn(AndroidSchedulers.mainThread())
          .subscribeOn(Schedulers.io())
          .subscribe(result -> {
             response.postValue(result.getData());
          });

       mDisposables.add(disposable);
    }

    void onCleared()
    {
        super.onCleared();
        mDisposables.clear(); //no more leaks. It takes care of lifecycle for you
    }
}

Your Activity

public class MyActivity extends AppCompatActivity {
    public void onCreate(Bundle savedInstanceState) {

        MyViewModel model = ViewModelProviders.of(this).get(MyViewModel.class);
        model.getResponse().observe(this, response -> {
            // update UI
            textView.setText(response); //response = Response object from Live data
        });
    }
}

Answer 2

If you don't want to handle configuration changes and want to cache data from observables, you can use BehaviorSubjects and a hot observable. This will allow you to get the most recent item that the observable published.

Other than that, I suggest you use the ViewModel from the architecture components. It will allow you to create a component that is bound to the activity but will not be affected by the lifecycle (except termination, obviously). Surprisingly enough, ViewModelProviders are implemented as fragments with setRetainInstance(true) . You don't have to completely refactor the entire app. Just move the ones that you want to preserve during configuration changes.

Answer 3

You need to consider the logical scope of your network requests, and this is entirely separate from whether you're using RxJava. Background tasks like network requests need to be owned by an Android component ( Application , Activity , etc.) with the appropriate lifetime. The usual way to make activity-scoped background tasks survive a config change is to host them in a retained fragment . You would still do that if you were using RxJava.

Android OS kills the "paused" activities from the stack

This doesn't happen unless something has changed in Android 8 or newer. The documentation suggests that the framework could destroy individual activities in the backstack, but currently it only destroys the entire task when it's in the background. Your app is correct and future-proof if and only if it works with the "don't keep activities" developer option on.