轮询的功能很常见了，之前Android中比较常用的方式就是通过Handler来实现，发送一个Deley消息，在handlerMessage再根据条件发送消息，这种方式需要小心内存泄漏，需要自己处理这个问题。这个不是我们今天的重点，今天来看下另外一种轮询的实现方式，通过RxJava来实现。有下面两个特点：
1 自动解除轮询和订阅关系，没有内存泄漏的风险； 2 可以跟Activity或者Fragment生命周期绑定，自动停止轮询
涉及到的RxJava知识点：
1.Subject
2.takeUntil
3 filter
4 compose
这个可以参考我之前的博客RxJava部分操作符解析
1.使用
目前有两种使用方式
1.bindIntervalEvent就是绑定事件进行轮询，事件发生时将停止轮询 2.bindLifeCycle,就是绑定生命周期，在指定生命周期发生时停止轮询
在开始之前我们先定义事件Event,其中FragmentEvent对应Fragment的生命周期，ActivityEvent 对应Activity的生命周期，BizEvent对应我们自定义的事件：
INTERVAL就是对应RxJava中的interval操作符产生的周期事件，可以制定轮询间隔；
TIMER就是对应的timer事件，可以制定多长事件后产生一个事件；
STOP就是停止事件，这个是自定义的；
ALL可以匹配所有事件。
public interface Event {
enum FragmentEvent implements EventInterface{
ATTACH,
CREATE,
CREATE_VIEW,
START,
RESUME,
PAUSE,
STOP,
DESTROY_VIEW,
DESTROY,
DETACH
}
enum ActivityEvent implements EventInterface{
CREATE,
START,
RESUME,
PAUSE,
STOP,
DESTROY
}
enum BizEvent implements EventInterface{
INTERVAL,
TIMER,
STOP,
ALL
}
}
talk is cheap, show me the code, 使用起来也很简单，首先看下第一种的使用,在Activity中添加两个按钮，一个开始轮询，一个停止轮询，布局太简单了就不贴代码了哈，看下重点代码：
private static final String TAG = MainActivity.class.getSimpleName() + "_POLLING";
//开启轮询
PollingManager.getInstance().bindIntervalEvent(1, TAG, Event.BizEvent.INTERVAL, null);
//停止轮询
PollingManager.getInstance().stopPolling(TAG, Event.BizEvent.INTERVAL);
看下日志打印情况，接收到INTERVAL事件后就停止轮询了。
bindIntervalEvent.PNG
接着看下第二种使用方式，有两个步骤：
1.继承
BaseActivity,其中接口LifeInterface需要自己实现
public abstract class BaseActivity extends Activity implements LifeInterface
public interface LifeInterface {
void bindLife();
String getTag();
}
2.在需要轮询的Activity实现接口LifeInterface的两个方法，看下例子：
@Override
public String getTag() {
return TAG;
}
@Override
public void bindLife() {
PollingManager.getInstance().bindLifeCycle(getTag(), Event.ActivityEvent.PAUSE);
}
上面这个例子监听PAUSE事件，在Activity进入onPause时会停止轮询，看下日志打印情况：
bindLifeCycle.PNG 完全符合我们的预期哈。 下面我们来看下代码实现。
2.PollingManager
主要逻辑在PollingManager中，这个是这个工具的门面，有点类似于外观模式。
首先是单例模式,activeSubjectMap是Subject的仓库，所有注册的轮询Model保存的地方。
private HashMap<String, SubjectModel<EventInterface>> activeSubjectMap;
private static PollingManager manager;
private PollingManager() {
activeSubjectMap = new HashMap<>();
}
public static PollingManager getInstance() {
if (null == manager) {
synchronized (PollingManager.class) {
if (null == manager) {
manager = new PollingManager();
}
}
}
return manager;
}
对上面的轮询Model进行下说明，每个Model封装了轮询器，RxJava订阅关系disposable和Subject。disposable就是用来停止轮询的时候解除订阅关系防止内存泄漏。
//Subject
private BehaviorSubject<T> behaviorSubject;
//订阅关系
private Disposable disposable;
//轮询器
private PollingRequest pollingRequest;
public void clearSubject(){
if (null == disposable || disposable.isDisposed()) return;
disposable.dispose();
}
每个轮询需要做的工作可以抽象出来就是上面的PollingRequest,注释比较清楚就不说了，每个PollingRequest对外接口就是execute，其中doAction是在每个轮询到的时候会进行调用。
public abstract class PollingRequest {
//每个Subject的唯一标识
protected String tag;
//事件接口
protected EventInterface eventInterface;
//轮询动作
protected PollingAction pollingAction;
public PollingRequest(String tag, EventInterface eventInterface, PollingAction pollingAction) {
this.tag = tag;
this.eventInterface = eventInterface;
this.pollingAction = pollingAction;
}
public abstract Disposable execute(PollingManager pollingManager);
public String getTag() {
return tag;
}
public EventInterface getEventInterface() {
return eventInterface;
}
}
public interface PollingAction {
void doAction(Object accept);
}
看下IntervalPolling的实现方式,逻辑也比较简单，就是每隔intevals进行轮询，轮询间隔会调用doAction完成动作。
public class IntervalPolling extends PollingRequest {
private int inteval;
public IntervalPolling(int interval, String tag, EventInterface eventInterface, PollingAction action) {
super(tag, eventInterface, action);
this.inteval = interval;
}
@Override
public Disposable execute(PollingManager manager) {
return Observable.interval(inteval, TimeUnit.SECONDS).
compose(manager.composeEvent(tag, eventInterface)).
observeOn(AndroidSchedulers.mainThread()).
doOnNext(new Consumer<Long>() {
@Override
public void accept(Long aLong) throws Exception {
Timber.tag(Constants.TAG).d("emit interval polling, Tag = " + tag + ", num = " + aLong);
}
}).
subscribe(new Consumer<Long>() {
@Override
public void accept(Long num) throws Exception {
if (null != pollingAction) {
pollingAction.doAction(num);
}
Timber.tag(Constants.TAG).d("running interval polling, Tag = " + tag + ", num = " + num);
}
});
}
}
上面可能比较费解的逻辑就是这一行：
compose(manager.composeEvent(tag, eventInterface))
调用PollingManager中的composeEvent方法，跟进去看看：
public ObservableTransformer<Long, Long> composeEvent(final String tag, final EventInterface outEvent) {
BehaviorSubject<EventInterface> subject = getSubject(tag);
if (null == subject) {
Timber.tag(Constants.TAG).e("subject = null");
return new EmptyObservableTransformer();
}
final Observable observable = subject.filter(new Predicate<EventInterface>() {
@Override
public boolean test(EventInterface event) throws Exception {
Timber.tag(Constants.TAG).i("receive event: %s", event);
boolean filter = outEvent == event || event == ALL;
if (filter) clearSubject(tag);
return filter;
}
});
return new ObservableTransformer<Long, Long>() {
@Override
public ObservableSource<Long> apply(Observable<Long> upstream) {
return upstream.subscribeOn(Schedulers.io()).takeUntil(observable);
}
};
}
首先就是
takeUntil操作符，当Subject发送数据时，IntervalPolling就会停止轮询；
Subject什么时候发送数据？就是在subject.filter返回真的时候。Subject会根据接收到的Event和订阅时的Event进行相等，或者接收到的事件是ALL都会返回真。
其实上面的逻辑需要对RxJava有一定的了解，这个不在本文的范围，小伙伴们自行网上查阅哈。
轮询器，Model和触发条件都有了，剩下的问题就是创建启动和销毁的问题了，先看下创建。
3.创建启动
先看下第一种绑定事件的创建方式：
public BehaviorSubject<EventInterface> bindIntervalEvent(int interval, @NonNull String tag, @NonNull EventInterface eventInterface, PollingAction action){
//1.创建轮询器
IntervalPolling intervalPolling = new IntervalPolling(interval, tag, eventInterface, action);
//2.创建Subject
createSubject(intervalPolling);
//3.启动轮询
startPolling(tag);
//4.返回Subject
return activeSubjectMap.get(tag).getBehaviorSubject();
}
逻辑比较简单哈，其中第二步创建Subject时会将Subject和轮询器缓存到HashMap<String, SubjectModel<EventInterface>> activeSubjectMap;,其中key就是Subject的唯一标识tag。
生命周期的创建方式也是一样的四个步骤，唯一不一样的就是这里轮询器是生命周期轮询器。
public BehaviorSubject<EventInterface> bindLifeCycle(@NonNull String tag,@NonNull EventInterface eventInterface){
//1.创建轮询器
PollingRequest request = new LifePolling(tag, eventInterface, null);
//2.创建Subject
createSubject(request);
//3.启动轮询
startPolling(tag);
//4.返回Subject
return activeSubjectMap.get(tag).getBehaviorSubject();
}
创建分析完了，就看下怎么停止轮询了。
4.停止
停止的逻辑其实就是发射事件给Subject，这样Subject自己可以接收到，然后进入Filter的逻辑进行判断，和创建的时候注册事件或者ALL事件一致就会停止轮询了。
public boolean stopPolling(String tag, EventInterface event) {
BehaviorSubject<EventInterface> subject = getSubject(tag);
if (null == subject) {
Timber.tag(Constants.TAG).e("can not find subject according to the %s", tag);
return false;
}
subject.onNext(event);
Timber.tag(Constants.TAG).i("Stop Polling SubjectTag = " + tag + ", Event = " + event.toString());
return true;
}
最后再补充一点就是发射事件的逻辑，会扫描activeSubjectMap中的所有Subject，然后发射事件：
public void emitEvent( @NonNull EventInterface event){
if (null == activeSubjectMap) return;
for (Map.Entry<String, SubjectModel<EventInterface>> next : activeSubjectMap.entrySet()) {
BehaviorSubject<EventInterface> behaviorSubject = next.getValue().getBehaviorSubject();
if (null == behaviorSubject) return;
behaviorSubject.onNext(event);
}
}
5.总结
到这里基本涉及的逻辑都分析完了，希望能提供给到家另外一种轮询的实现方式，如果有什么问题欢迎留言哈，谢谢！
我的博客主页juexingzhe欢迎关注哈。
祝大家越码越开心。
