RxLifecycle – Automatically pauses network requests when an Activity is destory

RxLifecycle address: github.com/trello/RxLi… . This project was created to prevent memory leaks caused by Subscription in RxJava. The idea is to automatically disconnect Subscription to prevent memory leaks by listening to the lifecycle of activities and fragments.

The basic usage is as follows:

myObservable
    .compose(RxLifecycle.bindUntilEvent(lifecycle, ActivityEvent.DESTROY))
    .subscribe();
    Copy the code

MyObservable can be regarded as a time-consuming network request. By binding to Activityevent. DESTROY, once the Activity completes its DESTORY life cycle, the data will no longer be transferred to subscriber, that is, no processing or UI drawing will be performed on the data. Thus improving security.

Android development often has a scenario like this:

1. Send the network request -> 2. The server processes the request and returns the data -> 3. The client receives the data and draws the UI.

In the first two steps, there is usually no problem, but in the third step, when the data is returned to the client, if the page is already gone, then the UI cannot be drawn, which may lead to unintended problems. Therefore, to solve this problem, it is a good idea to automatically disconnect the network request data processing when the page is gone, that is, the data is returned without any processing.

As you can see, there is a core function to implement first: the ability to listen for Activity lifecycle events and transmit them externally, and to receive each lifecycle event and make a judgment. To do this, think of Subject in RxJava, which can both transmit and receive data.

Readers of Subject can skip this section.

How to understand Subject?

Easy. In RxJava, an Observable is a data transmitter. It sends data to the outside world, and then passes it to the Observer, the data receiver, after data processing such as map and flatMap. Therefore, regardless of the intermediate data processing, it can be seen that an Observable emits data externally, which is the beginning of data flow. An Observer receives data and is the end of the data flow.

What about Subject? Take a look at the source code:

 * Represents an object that is both an Observable and an Observer. */
public abstract class Subject extends Observable implements Observer {}
Copy the code

First, it extends Observable, which means that the Subject has the ability to transmit data externally, i.e. from(), just(), etc. It implements Observer, implements data, onNext(), onCompleted, and so on.

After all, Subject is just an abstract class, so how do we use it?

Here is one of the simplest:

PublishSubject subject = PublishSubject.create();
// myObserver will receive "one" & "two" and onCompleted events
subject.subscribe(myObserver);
subject.onNext("one");
subject.onNext("two");
subject.onCompleted();
Copy the code

To do this, simply create a PublishSubject -> bind a myObserver, where the subject acts as an Observable. The data is sent to myObserver -> then the subject process receives two pieces of data, one and two -> Finally both of these data are passed to myObserver. Therefore, the role of subject is:

dataone,two => (Observer) subject (Observable) => myObserver

In simple terms, we feed the Subject data one and two, which in turn emits to myObserver.

Our typical network request looks like this:

networkObservable
 .subscribe(new Observer(  handleUI()  ));
 Copy the code

NetworkObservable represents a common network request that receives network data and passes it to the Observer to draw the UI.

Now we want the networkObservable to listen for the Activity’s DESTORY event, disconnect the Observer when it happens, and not pass the network data back to the Observer to draw the UI. That is:

networkObservable
 .compose(bindUntilEvent(ActivityLifeCycleEvent.DESTORY))
  .subscribe(new Observer(  handleUI()  ));
  Copy the code

Therefore, we need to implement

bindUntilEvent(ActivityLifeCycleEvent.DESTORY)
Copy the code

This method, how do you implement it?

We know that lifecycleSubject emits lifecycle events, so we can tell networkObservable to check the lifecycle emitted by lifecycleSubject. If the lifecycle emitted by lifecycleSubject is the same as the bound lifecycle event, it stops automatically.

1. Add it in BaseActivitylifecycleSubjectAnd pass each lifecycle event on time tolifecycleSubject

2. Add a bindUntilEvent method to the BaseActivity:

   @NonNull @Override public Observable.Transformer bindUntilEvent(@NonNull final ActivityLifeCycleEvent event) { return new Observable.Transformer() { @Override public Observable call(Observable sourceObservable) { Observable compareLifecycleObservable = lifecycleSubject.takeFirst(new Func1() { @Override public Boolean call(ActivityLifeCycleEvent activityLifeCycleEvent) { return activityLifeCycleEvent.equals(event); }}); return sourceObservable.takeUntil(compareLifecycleObservable); }}; }Copy the code

3. Requests improvements from networkObservable on any network

   networkObservable
     .compose(bindUntilEvent(ActivityLifeCycleEvent.DESTORY))
     .subscribe(new Observer(  handleUI()  ));
     Copy the code