共计 3199 个字符，预计需要花费 8 分钟才能阅读完成。
添加依赖
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))
