Rxlifecycle 源码解析

Rxlifecycle (https://github.com/trello/RxLifecycle)是基于RxJava对Android生命周期管理的一个库。
gradle引用库，components包下结构

implementation 'com.trello.rxlifecycle2:rxlifecycle-components:2.2.1'

支持Activity、Fragment以及期子类和support包下分别对应，RxFragment和RxActivity内部原理一样只是多了几个Fragment生命周期的方法，选取RxActivity进行查看源码。

public abstract class RxActivity extends Activity implements LifecycleProvider {
    private final BehaviorSubject lifecycleSubject = BehaviorSubject.create();
    public final Observable lifecycle() {
        return lifecycleSubject.hide();
    }
    public final  LifecycleTransformer bindUntilEvent(@NonNull ActivityEvent event) {
        return RxLifecycle.bindUntilEvent(lifecycleSubject, event);
    }
    public final  LifecycleTransformer bindToLifecycle() {
        return RxLifecycleAndroid.bindActivity(lifecycleSubject);
    }
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        lifecycleSubject.onNext(ActivityEvent.CREATE);
    }
    protected void onStart() {
        super.onStart();
        lifecycleSubject.onNext(ActivityEvent.START);
    }
    protected void onResume() {
        super.onResume();
        lifecycleSubject.onNext(ActivityEvent.RESUME);
    }
    protected void onPause() {
        lifecycleSubject.onNext(ActivityEvent.PAUSE);
        super.onPause();
    }
    protected void onStop() {
        lifecycleSubject.onNext(ActivityEvent.STOP);
        super.onStop();
    }
    protected void onDestroy() {
        lifecycleSubject.onNext(ActivityEvent.DESTROY);
        super.onDestroy();
    }
}

RxActivity中一个BehaviorSubject对象，三个公共方法，还有根据Activity生命周期发射ActivityEvent事件。
首先分析BehaviorSubject有何作用

public final class BehaviorSubject extends Subject {
    ...
}
public abstract class Subject extends Observable implements Observer {
    ...
}

BehaviorSubject继承Subject，Subject集成Observable实现Observer，Subject的官方介绍：Subject可以看成是一个桥梁或者代理，在某些ReactiveX实现中（如RxJava），它同时充当了Observer和Observable的角色。因为它是一个Observer，它可以订阅一个或多个Observable；又因为它是一个Observable，它可以转发它收到(Observe)的数据，也可以发射新的数据。也就是Subject既可以作为被观察者，也可以作为观察者。
BehaviorSubject
当观察者订阅BehaviorSubject时，它开始发射原始Observable最近发射的数据（如果此时还没有收到任何数据，它会发射一个默认值），然后继续发射其它任何来自原始Observable的数据。

public void testBehavior() {
    final BehaviorSubject lifecycleSubject = BehaviorSubject.createDefault(99);
    lifecycleSubject.subscribe(new Consumer() {
        @Override
        public void accept(Integer integer) throws Exception {
            System.out.println("accept()--" + integer);//此时还没有收到任何数据，所以收到默认值99
            //然后会受到后续发射的所有值0，1，2，3
        }
    });
    lifecycleSubject.onNext(0);
    lifecycleSubject.onNext(1);
    lifecycleSubject.subscribe(new Consumer() {
        @Override
        public void accept(Integer integer) throws Exception {
            System.out.println("after 1 accept()--" + integer);//只能收到最近发射的数据1
            //然后会受到后续发射的所有值2，3
        }
    });
    lifecycleSubject.onNext(2);
    lifecycleSubject.subscribe(new Consumer() {
        @Override
        public void accept(Integer integer) throws Exception {
            System.out.println("after 2 accept()--" + integer);//只能收到最近发射的数据2
            //然后会受到后续发射的所有值3
        }
    });
    lifecycleSubject.onNext(3);
}

RxActivity 中lifecycleSubject 在Activity生命周期的每个方法都发送了ActivityEvent数据，此时订阅lifecycleSubject 就可以收到Activity周期方法的回调
查看RxActivity中的三个方法，Observable lifecycle()，LifecycleTransformer bindUntilEvent(@NonNull ActivityEvent event)，LifecycleTransformer bindToLifecycle()
首先来看Observable lifecycle()方法

public final Observable lifecycle() {
    return lifecycleSubject.hide();
}

Observable hide()方法官方解释隐藏这个Observable的身份及其一次性。即lifecycle()方法返回一个Observable对象然后来看LifecycleTransformer bindUntilEvent(@NonNull ActivityEvent event)方法

public final  LifecycleTransformer bindUntilEvent(@NonNull ActivityEvent event) {
    //调用RxLifecycle.bindUntilEvent(lifecycleSubject, event)方法
    return RxLifecycle.bindUntilEvent(lifecycleSubject, event);
}
public static  LifecycleTransformer bindUntilEvent(@Nonnull final Observable lifecycle,
                                                            @Nonnull final R event) {
    //先调用takeUntilEvent(lifecycle, event)
    //然后调用bind(@Nonnull final Observable lifecycle) 
    return bind(takeUntilEvent(lifecycle, event));
}
private static  Observable takeUntilEvent(final Observable lifecycle, final R event) {
    //filter操作符根据ActivityEvent 进行过滤，在指定的ActivityEvent 事件时才往下游执行
    return lifecycle.filter(new Predicate() {
        @Override
        public boolean test(R lifecycleEvent) throws Exception {
            return lifecycleEvent.equals(event);
        }
    });
}
public static  LifecycleTransformer bind(@Nonnull final Observable lifecycle) {
    //把Observable转为LifecycleTransformer，返回LifecycleTransformer对象
    return new LifecycleTransformer<>(lifecycle);
}

bindUntilEvent(@NonNull ActivityEvent event) 最终返回一个根据ActivityEvent 过滤的Observable转换为LifecycleTransformer对象，LifecycleTransformer实现了ObservableTransformer。
bindUntilEvent常用于网络请求，然后监听Activity onDestroy()时，结束网络请求，避免Activity销毁后网络请求返回成功刷新界面View空指针。模拟网络请求代码，10秒后返回数据

    BehaviorSubject lifecycleSubject = BehaviorSubject.create();
    Observable.timer(10, TimeUnit.SECONDS)
            .compose(RxLifecycle.bindUntilEvent(lifecycleSubject, ActivityEvent.DESTROY))
            .subscribe(new Consumer