RxPresenter浅析

(注：由于手机号验证问题，n6323438的博文转移至此)
今天要介绍的是github上一个Android开源框架: android-starter-kit (Rx部分)

链接: https://github.com/qijitech/android-starter-kit

先看变量:

private final BehaviorSubject<View> views = BehaviorSubject.create();
private final HashMap<Integer, Func0<Subscription>> restartables = new HashMap<>(); //请求
private final HashMap<Integer, Subscription> restartableSubscriptions = new HashMap<>(); 请求subscribe后的subscription
private final ArrayList<Integer> requested = new ArrayList<>(); 已经开始的请求对应的id

看第一个方法restartable

 public void restartable(int restartableId, Func0<Subscription> factory) {
        restartables.put(restartableId, factory);
        if (requested.contains(restartableId))
            start(restartableId);
    }

参数有Id和一个返回Subscription的Func0接口.
先put进去restartables这个HashMap中, 然后检查requested这个ArrayList中有没有传进来的restartableId, 如果有, 就会取消这个请求并重新开始.

stop方法

源码比较简单, 我就不贴了
从requested中去除传入的restartableId, 然后在restartableSubscriptions找到对应的subscription, 并调用unsubscribe.

start方法

首先调用stop方法, 然后把restartableId放进requested中, 然后取出对应的Func0接口并调用, 得到的subscription放进restartableSubscriptions中.

一般并不会直接用restartable方法, 因为这里提供了3个经过封装的方法:

1: restartableFirst方法

public <T> void restartableFirst(int restartableId, final Func0<Observable<T>> observableFactory,
        final Action2<View, T> onNext, @Nullable final Action2<View, Throwable> onError) {

        restartable(restartableId, new Func0<Subscription>() {
            @Override
            public Subscription call() {
                return observableFactory.call()
                    .compose(RxPresenter.this.<T>deliverFirst())
                    .subscribe(split(onNext, onError));
            }
        });
    }

这个方法可以对observable进行处理, 从源码可以看出, 调用了observableFactory的call方法, 经过compose再subscribe.
那么这个compose做了什么呢? 变换就在DeliverFirst这个类中.
先看构造方法:

public DeliverFirst(Observable<View> view) {
        this.view = view;
    }

传入了observable, 这个observable其实就是RxPresenter中的一个变量 BehaviorSubject<View> views = BehaviorSubject.create();
BehaviourSubject简单来说就是, 当有Observer订阅的时候, 在这个订阅之前的一个事件也会发射出去. 具体自行搜索
关键就在call方法 :

public Observable<Delivery<View, T>> call(Observable<T> observable) {
        return observable.materialize()
            .take(1)
            .switchMap(new Func1<Notification<T>, Observable<? extends Delivery<View, T>>>() {
                @Override
                public Observable<? extends Delivery<View, T>> call(final Notification<T> notification) {
                    return view.map(new Func1<View, Delivery<View, T>>() {
                        @Override
                        public Delivery<View, T> call(View view) {
                            return view == null ? null : new Delivery<>(view, notification);
                        }
                    });
                }
            })
            .filter(new Func1<Delivery<View, T>, Boolean>() {
                @Override
                public Boolean call(Delivery<View, T> delivery) {
                    return delivery != null;
                }
            })
            .take(1);
    }

首先进行materialize变换(这个就不解释了), 之后只取第一个notification, 然后要把notificatiion变成Observable, 这里有点绕.
看里面的call方法, 那个BehaviourSubject原来是发射View泛型的, 现在通过map转变为发射Delivery
如果原来发射的View泛型为null, 那这个Delivery就为null. (这里不太好解释, 仔细看看源码应该能明白)
最后来个filter再取第一个, 完成了.
小结: 这个变换的作用其实是, 如果View泛型已经脱离了Presenter, 那结果就不会传递到处理的方法中.
在之前介绍NucleusSupportFragment时已经提到, 当fragment进入onPause, presenter就会放弃对fragment的引用.

现在回到restartableFirst方法, subscribe的参数是一个Action1接口, 这个Action1就是调用了delivery的split方法, 参数为restartableFirst的参数onNext和onError.
这个delivery是含有一个notification的, 那split方法就是根据notification是onNext还是onError, 执行相应的方法.

2: restartableReplay方法

其实和restartableFirst很类似, 不同在于它用的是DeliverReplay
DeliverReplay的call方法:

public Observable<Delivery<View, T>> call(Observable<T> observable) {
        final ReplaySubject<Notification<T>> subject = ReplaySubject.create();
        final Subscription subscription = observable
            .materialize()
            .filter(new Func1<Notification<T>, Boolean>() {
                @Override
                public Boolean call(Notification<T> notification) {
                    return !notification.isOnCompleted();
                }
            })
            .subscribe(subject);
        return view
            .switchMap(new Func1<View, Observable<Delivery<View, T>>>() {
                @Override
                public Observable<Delivery<View, T>> call(final View view) {
                    return view == null ? Observable.<Delivery<View, T>>never() : subject
                        .map(new Func1<Notification<T>, Delivery<View, T>>() {
                            @Override
                            public Delivery<View, T> call(Notification<T> notification) {
                                return new Delivery<>(view, notification);
                            }
                        });
                }
            })
            .doOnUnsubscribe(new Action0() {
                @Override
                public void call() {
                    subscription.unsubscribe();
                }
            });
    }

首先也是materialize变换, 然后onComplete事件不会被传递, 订阅的是一个ReplaySubject.
ReplaySubject就是, 当有Observer订阅的时候, 会发射所有的事件.
这里其实就是把除了onComplete的所有事件存到ReplaySubject中.
返回的是对view进行map变换, 和上面讲的类似.

3: restartableLatestCache方法

不同的地方在于它用了DeliverLatestCache

public Observable<Delivery<View, T>> call(Observable<T> observable) {
        return Observable
            .combineLatest(
                view,
                observable
                    .materialize()
                    .filter(new Func1<Notification<T>, Boolean>() {
                        @Override
                        public Boolean call(Notification<T> notification) {
                            return !notification.isOnCompleted();
                        }
                    }),
                new Func2<View, Notification<T>, Delivery<View, T>>() {
                    @Override
                    public Delivery<View, T> call(View view, Notification<T> notification) {
                        return view == null ? null : new Delivery<>(view, notification);
                    }
                })
            .filter(new Func1<Delivery<View, T>, Boolean>() {
                @Override
                public Boolean call(Delivery<View, T> delivery) {
                    return delivery != null;
                }
            });
    }
}

首先调用Observable.combineLatest, 简单解释一下, 这个方法可以把两个Observable发射的事件, 通过自定的方法合并成一个新事件.
第一个Observable就是view, 第二个是对传入的observable进行materialize变换,再过滤掉onComplete事件;
自定方法是, 如果发射的泛型View不为null,则返回Delivery; 为null, 就返回null
最后也是过滤.

这3个方法各有不同,
restartableFirst方法只会取发射的第一个事件;
restartableReplay会先把所有事件存起来,再一起发射;
restartableLatestCache每发射一个事件, 都会对应到当时的view状态

最后看一下 onTakeView和onDropView

    protected void onTakeView(View view) {
        views.onNext(view);
    }
      protected void onDropView() {
        views.onNext(null);
    }    

现在知道为什么可以获取到实时View的状态了吧