RxLifecycle笔记

添加依赖

    implementation 'com.trello.rxlifecycle2:rxlifecycle:2.2.1'
    implementation 'com.trello.rxlifecycle2:rxlifecycle-android-lifecycle:2.2.1'

在rxlifecycle依赖包下游如下几个关键类

• RxLifecycle
• LifecycleProvider
• LifecycleTransformaer

在rxlifecycle-android-lifecycle依赖包下有如下几个关键类

• AndroidLifecycle
• RxLifecycleAndroidLifecycle

不直接使用RxLifecycle,而是使用AndroidLifecycle.

如何创建AndroidLifecycle.

//AndroidLifecycle.java
LifecycleProvider<Lifecycle.Event> provider = AndroidLifecycle.createLifecycleProvider(this);

AndroidLifecycle实现了android.arch.lifecycle.LifecycleObserver.可以通过注解@OnLifecycleEvent来监听对应的Lifecycle.Event.

 @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    void onEvent(LifecycleOwner owner, Lifecycle.Event event) {
    //向下游传递
        lifecycleSubject.onNext(event);
        if (event == Lifecycle.Event.ON_DESTROY) {
        //解除观察者
            owner.getLifecycle().removeObserver(this);
        }
    }

这里的lifecycleSubject是一个BehaviorSubject对象.既可以作为观察者,也可以作为被观察对象使用.当监听到对应的Lifecycle.Event时,就会通过lifecycleSubject.onNext(event);向下游传递.

在AndroidLifecycle中定义了两个绑定相关的方法.通过这两个绑定方法,将lifecycleSubject与下游连接起来,才能确保lifecycleSubject携带的信息能传递给下游.

    /**
    * 绑定某个具体的生命周期环节
    *  event具体为
    *   ON_CREATE
    *   ON_START
    *   ON_RESUME
    *   ON_PAUSE
    *   ON_STOP
    *   ON_DESTROY
    *   ON_ANY
    */
    public <T> LifecycleTransformer<T> bindUntilEvent(@NonNull Lifecycle.Event event) {
        return RxLifecycle.bindUntilEvent(lifecycleSubject, event);
    }

    /**
    * 绑定到生命周期
    */
    public <T> LifecycleTransformer<T> bindToLifecycle() {
        return RxLifecycleAndroidLifecycle.bindLifecycle(lifecycleSubject);
    }

第一个方法使用到了RxLifecycle.bindUntilEvent方法.

public static <T, R> LifecycleTransformer<T> bindUntilEvent(@Nonnull final Observable<R> lifecycle,
                                                              @Nonnull final R event) {
      checkNotNull(lifecycle, "lifecycle == null");
      checkNotNull(event, "event == null");
      return bind(takeUntilEvent(lifecycle, event));
  }

这里的takeUntilEvent方法是判断lifecycle所携带的event是否与参数event一致.bind方法源码如下:

 public static <T, R> LifecycleTransformer<T> bind(@Nonnull final Observable<R> lifecycle) {
        return new LifecycleTransformer<>(lifecycle);
    }

创建了一个LifecycleTransformer对象.

public final class LifecycleTransformer<T> implements ObservableTransformer<T, T>,
                                                      FlowableTransformer<T, T>,
                                                      SingleTransformer<T, T>,
                                                      MaybeTransformer<T, T>,
                                                      CompletableTransformer{
    final Observable<?> observable;

    LifecycleTransformer(Observable<?> observable) {
        checkNotNull(observable, "observable == null");
        this.observable = observable;
    }

    @Override
    public ObservableSource<T> apply(Observable<T> upstream) {
        return upstream.takeUntil(observable);
    }

    @Override
    public Publisher<T> apply(Flowable<T> upstream) {
        return upstream.takeUntil(observable.toFlowable(BackpressureStrategy.LATEST));
    }

    @Override
    public SingleSource<T> apply(Single<T> upstream) {
        return upstream.takeUntil(observable.firstOrError());
    }

    @Override
    public MaybeSource<T> apply(Maybe<T> upstream) {
        return upstream.takeUntil(observable.firstElement());
    }

    @Override
    public CompletableSource apply(Completable upstream) {
        return Completable.ambArray(upstream, observable.flatMapCompletable(Functions.CANCEL_COMPLETABLE));
    }

                                                      }

先说一下takeUntil操作符的作用.

 ObservableA.takeUntil(ObservableB);

当ObservableB开始发射数据,ObservableA停止发射数据.
那么对于LifecycleTransformer,当observable开始发射数据,
upstream就会停止发射数据.这里的observable就是AndroidLifecycle中的BehaviorSubject.而upstream就是我们自己的数据源.

LifecycleTransformer通过与RxJava2的操作符compose结合使用.

 val lifecycleProvider = AndroidLifecycle.createLifecycleProvider(this)

observable.compose(lifecycleProvider.bindUntilEvent(Lifecycle.Event.ON_DESTROY))