RxLifecycle原理分析

RxLifecycle源碼地址

RxLifecycle有兩種使用方法:
1、bindToLifecycle直接綁定生命周期

  Observable.interval(1, TimeUnit.SECONDS)
            .doOnDispose(new Action() {
                @Override
                public void run() throws Exception {
                    Log.i(TAG, "Unsubscribing subscription from onStart()");
                }
            })
            .compose(this.<Long>bindToLifecycle())//使用bindToLifecycle
            .subscribe(new Consumer<Long>() {
                @Override
                public void accept(Long num) throws Exception {
                    Log.i(TAG, "Started in onStart(), running until in onStop(): " + num);
                }
            });

2、bindUntilEvent綁定特定的ActivityEvent

Observable.interval(1, TimeUnit.SECONDS)
            .doOnDispose(new Action() {
                @Override
                public void run() throws Exception {
                    Log.i(TAG, "Unsubscribing subscription from onCreate()");
                }
            })
            .compose(this.<Long>bindUntilEvent(ActivityEvent.PAUSE))//使用bindUntilEvent
            .subscribe(new Consumer<Long>() {
                @Override
                public void accept(Long num) throws Exception {
                    Log.i(TAG, "Started in onCreate(), running until onPause(): " + num);
                }
            });

原理其實一樣,只分析bindToLifecycle是怎么綁定Activity的生命周期的。
首先bindToLifecycle是通過compose操作的,compose比較常見,比如切換線程的時候,用compose操作符讓代碼更好看些,compose操作的是個Transformer,跟進去看,bindToLifecycle果然返回一個封裝了的LifecycleTransformer:

public final <T> LifecycleTransformer<T> bindToLifecycle() {
     return RxLifecycleAndroid.bindActivity(lifecycleSubject);
}

public static <T> LifecycleTransformer<T> bindActivity(@NonNull final Observable<ActivityEvent> lifecycle) {
        return bind(lifecycle, ACTIVITY_LIFECYCLE);
}

好,這里出現了兩個重要的東西lifecycleSubject和ACTIVITY_LIFECYCLE,bind方法將這兩個東西處理后,返回的LifecycleTransformer。lifecycleSubject和ACTIVITY_LIFECYCLE是什么?看源碼:

private final BehaviorSubject<ActivityEvent> lifecycleSubject = BehaviorSubject.create();

lifecycleSubject原來是個BehaviorSubject,BehaviorSubject可以當做Observable來發射消息,查看RxActivity或RxAppCompatActivity類的生命周期回調方法,lifecycleSubject都發送了該生命周期標識,比如:

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();
}

我們來想下,一般情況下我們都是希望在Activiy退出(onDestroy)后,取消訂閱消息,那么 lifecycleSubject.onNext(ActivityEvent.DESTROY)在onDestroy中發射后,就要通知該取消訂閱消息了,正好takeUntil操作符可以滿足要求,takeUntil操作符簡要說明如下:

//Observable1發射數據,但是當Observable2也發射數據時,訂閱就取消了。
Observable1
 .takeUntil(Observable2)
 .subscribe(new Consumer);

我們想要的正是在ActivityEvent.DESTROY消息發送后,訂閱取消。回到上面,我們知道了lifecycleSubject是干什么用的了,lifecycleSubject就是發射生命周期標識,通過這個來監控Activity生命周期。
那ACTIVITY_LIFECYCLE是干什么用的?ACTIVITY_LIFECYCLE是個Function:

  private static final Function<ActivityEvent, ActivityEvent> ACTIVITY_LIFECYCLE =
        new Function<ActivityEvent, ActivityEvent>() {
            @Override
            public ActivityEvent apply(ActivityEvent lastEvent) throws Exception {
                switch (lastEvent) {
                    case CREATE:
                        return ActivityEvent.DESTROY;
                    case START:
                        return ActivityEvent.STOP;
                    case RESUME:
                        return ActivityEvent.PAUSE;
                    case PAUSE:
                        return ActivityEvent.STOP;
                    case STOP:
                        return ActivityEvent.DESTROY;
                    case DESTROY:
                        throw new OutsideLifecycleException("Cannot bind to Activity lifecycle when outside of it.");
                    default:
                        throw new UnsupportedOperationException("Binding to " + lastEvent + " not yet implemented");
                }
            }
        };

這個Function的作用就是返回訂閱消息所對應的生命周期,意思是如果你在onCreate訂閱,那么就返回DESTROY,意味只有在Activity onDestroy的時候取消訂閱。以下分析都依在DESTROY中取消訂閱為例。
lifecycleSubject和ACTIVITY_LIFECYCLE作用明白了,繼續往下走,bind方法里面是:

 public static <T, R> LifecycleTransformer<T> bind(@Nonnull Observable<R> lifecycle, @Nonnull final Function<R, R> correspondingEvents) {
        return bind(takeUntilCorrespondingEvent(lifecycle.share(), correspondingEvents));
    }

輸入的lifecycleSubject和ACTIVITY_LIFECYCLE被takeUntilCorrespondingEvent處理了,這個方法才是RxLifecycle最精華的地方:

private static <R> Observable<Boolean> takeUntilCorrespondingEvent(final Observable<R> lifecycle, final Function<R, R> correspondingEvents) {
        return Observable.combineLatest(
            lifecycle.take(1).map(correspondingEvents),
            lifecycle.skip(1),
            new BiFunction<R, R, Boolean>() {
                @Override
                public Boolean apply(R bindUntilEvent, R lifecycleEvent) throws Exception {
                    return lifecycleEvent.equals(bindUntilEvent);
                }
            })
            .onErrorReturn(Functions.RESUME_FUNCTION)
            .filter(Functions.SHOULD_COMPLETE);
    }

拆開看:

//這兩個其實就是lifecycleSubject,可以理解為兩個Observable
lifecycle.take(1).map(correspondingEvents),//map操作符調用correspondingEvents(就是上面的ACTIVITY_LIFECYCLE)的作用上面說了,類似輸入CREATE,輸出DESTROY
lifecycle.skip(1),//跳過之前發射的生命周期,比如在onStart里發射,跳過去,只操作onStart之后的生命周期

combineLatest操作符的作用就是操作這兩個Observable(其實都是lifecycleSubject),再回到takeUntil操作符,只有在onDestroy的時候發射,才能取消訂閱,而在其他生命周期,比如onPause,onStop這些不能取消,這時候我們有了第一個數據源lifecycle.take(1).map(correspondingEvents)返回的DESTROY,還有第二個數據源lifecycle.skip(1)返回的PAUSE,STOP,DESTROY這些訂閱后的生命周期,那么就可以操作:只有第二個數據等于第一個數據才會取消訂閱,于是回到源碼,通過combineLatest的第三個參數來完成這個比較:

new BiFunction<R, R, Boolean>() {
     @Override
     public Boolean apply(R bindUntilEvent, R lifecycleEvent) throws Exception{
          return lifecycleEvent.equals(bindUntilEvent);//兩個數據源比較
      }
 })

好了,到了這一步,我們得到了每個生命周期回調時,takeUntil操作符操作的Observable,類型是Boolean,只有DESTROY時返回true,其他生命周期來時返回false。但是false不能返回啊,因為takeUntil一旦把false發射出去,那訂閱就取消了,我們只想在true的時候才發射出去,filter操作符上場了:

Observable\\前面已經得到的false或true,通過filter,只有true才發射
.filter(Functions.SHOULD_COMPLETE);

static final Predicate<Boolean> SHOULD_COMPLETE = new Predicate<Boolean>() {
        @Override
        public boolean test(Boolean shouldComplete) throws Exception {
            return shouldComplete;
        }
};

SHOULD_COMPLETE很簡單,輸入輸出一樣,但是完成了只有true才發射的要求。
至此,RxLifecycle通過bindToLifecycle綁定生命周期的原理應該清楚了,再總結下:
1、在Activiy的每個生命周期回調里通過lifecycleSubject發射當前生命周期標識,比如發射A
2、通過ACTIVITY_LIFECYCLE得到想要取消訂閱的生命周期標識B
3、在takeUntilCorrespondingEvent方法里比較A和B,得到是否相等的結果C
4、通過filter操作符只發射3中結果是true的C
5、因為使用了takeUntil操作符,一旦4里發射了,那訂閱就取消了。

最后takeUntil是在哪里調用的呢,回到開始的LifecycleTransformer:

public final class LifecycleTransformer<T> implements ObservableTransformer<T, T>,
                                                      FlowableTransformer<T, T>,
                                                      SingleTransformer<T, T>,
                                                      MaybeTransformer<T, T>,
                                                      CompletableTransformer
{
 @Override
    public ObservableSource<T> apply(Observable<T> upstream) {
        return upstream.takeUntil(observable);
    }
    .........
}
最后編輯于
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明:文章內容(如有圖片或視頻亦包括在內)由作者上傳并發布,文章內容僅代表作者本人觀點,簡書系信息發布平臺,僅提供信息存儲服務。