本文主要分四部分进行阐述：

非rxJava方式实现多次点击检测
如何将点击事件转化为事件源(Obseravable)
如何统计点击次数
实现对比分析

非rxJava方式实现多次点击检测

要实现多次点击检测，需要考虑以下几个方面：

定义每次点击的时间间隔s
每次点击判断距离上一次点击的时间间隔，超过该间隔则认为该次点击检测已结束
单次点击结束，延迟s判断是否需要统计总点击次数,借助Handler来处理

下面是实现的关键代码：

private long mLastClickTime;

private int mClickCount;

private static final long TIME_SPACE = 600;

MyHandler mHandler;

private void initNoRxEvents() {
    mHandler = new MyHandler(mShowNoRxClick);

    mShowNoRxClick.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            long curTime = System.currentTimeMillis();
            if (mLastClickTime != 0 && curTime - mLastClickTime > TIME_SPACE) {
                mClickCount = 0;
            }
            
            mClickCount++;
            mLastClickTime = curTime;
            
            mHandler.removeMessages(MyHandler.WHAT_UPDATEUI);

            Message message = Message.obtain(mHandler,MyHandler.WHAT_UPDATEUI);
            Bundle bundle = new Bundle();
            bundle.putInt(MyHandler.KEY_NUMBER,mClickCount);
            message.setData(bundle);
            mHandler.sendMessageDelayed(message, TIME_SPACE);
        }
    });
}

static class MyHandler extends Handler {

    public static final int WHAT_UPDATEUI = 0x001;
    public static final java.lang.String KEY_NUMBER = "number";
    
    private Button mButton;

    public MyHandler(Button mButton) {
        this.mButton = mButton;
    }

    @Override
    public void handleMessage(Message msg) {
        super.handleMessage(msg);
        int what = msg.what;
        Bundle bundle = msg.getData();
        if(what == WHAT_UPDATEUI){
            mButton.setText(bundle.getInt(KEY_NUMBER)+"click");
        }
    }
}

可以看到实现起来代码非常的绕，并且需要定义好几个属性，同时借助Handler来实现延迟判断。接下来就让我们看看rxJava如何实现该效果吧。

如何将点击事件转化为事件源(Observable)

为何要将点击事件转化为事件源呢？因为它是整个逻辑的起始点，一切判断都是以它为起点。

创建Observable可以通过以下方式进行：

Observable.create(new OnSubscribe(){...})

其中关键在OnSubscribe中，当有事件产生的时候，OnSubscribe中去通知对应的Subscriber.

那么这个OnSubscribe如何与View的OnClickListener建立关联呢？考虑在onClick发生的时候，通知OnSubscribe的Subscriber对象，触发事件。

view.setOnClickListener(new View.OnClickListener(){
    @Override
    public void onClick(View view){
        mSubscriber.onNext(...);
    }
}

那么这个Subscriber如何来的呢？答案就在OnSubscribe的call函数。

class SomeOnSubscribe implements rx.OnSubscribe{
    @Override
    public void call(Subscriber<? super T> subsriber){
        //此处的subscriber即为我们所需的subscriber
    }
}

结合上面三个步骤：

class SomeOnSsubscribe implements rx.OnSubscribe{
    @Override
    public void call(Subscriber<? super T> subscriber){
        mView.setOnClickListener(new View.OnClickListener(){
            @Override
            public void onClick(View view){
                subscriber.onNext(...);
            }
        });
    }
}

Button mButton = findViewById(R.id.click);
Observable mClickStream = Observable.create(new SomeOnSubscribe(mButton));

mClickStream即为我们所需Observable。

如何统计点击次数

喝杯茶，再来思考下，统计点击次数，还是需要关键的几个点：

每次点击时间间隔
计数
何时一次判断结束

单每次点击时间间隔

rxJava实现时间间隔内事件过滤有以下几种方式：

debounce

The Debounce operator filters out items emitted by the source Observable that are rapidly followed by another emitted item.

也即能过滤出一定间隔内的事件。
考虑如下代码：

    mClickStream.debounce(600,TimeUnit.MILLISECONDS)
    .subscribe(new Action1<Void>(){
        @Override
        public void call(Void s) {
            Log.d(TAG,s+"click");
        }
    });

连续点击两次，观察输出：

    07-28 07:15:40.386 16317-16439/com.jasonmrazw.rxdemo D/Multi: click

为何就输出了一条日志？时间间隔600ms,其实它是判断两次事件间隔，如果少于600ms，就刷新等待时间，继续等待下一次事件；如果多于600ms，就认为本次事件判断结束，然后输出最后一次事件。这部分逻辑和通过Handler实现点击事件判断一样,只不过它缺少了统计累计次数的功能：

   mHandler.removeMessages(MyHandler.WHAT_UPDATEUI);
   Message message = Message.obtain(mHandler,MyHandler.WHAT_UPDATEUI);

小结一下，debounce可以为我们所用，但是要实现需求还不够完整。

throttleFirst

观察其定义可知，是按固定间隔过滤事件，但是只取这段事件间隔内的第一次事件。也就是每次点击开始就发送事件，之后600ms内，不会再发送事件。和需求正好相反。
throttleLast

和楼上相反，过滤一段事件间隔内，只取时间间隔内最后一次事件，也能满足需求。

统计时间间隔，可以使用debounce或者throttleLast。

计数

说是计数，其实是响应缓存每次点击事件，然后到一定触发条件(时间，缓存的数目，自定义条件)后再发送给监听者。

buffer

periodically gather items emitted by an Observable into bundles and emit these bundles rather than emitting the items one at a time

一次缓存多个结果，然后打包发送给Subscriber。

buffer示意图

结合需求，缓存点击事件，两次点击超过600ms后，统计点击结果。可以使用buffer+debounce或者buffer+throttleLast来实现。
```
mClickStream.buffer(mClickStream.debounce(600,TimeUnit.MILLISECONDS)).subscribe(new Action1<List<Void>>(){
    @Override
    public void call(List<Void> list){
        Log.d(TAG,list.size()+"click");
    }
});
```

观察输出：

07-28 08:19:15.114 14247-14331/com.jasonmrazw.rxdemo D/Multi: 1click
07-28 08:19:16.753 14247-14331/com.jasonmrazw.rxdemo D/Multi: 3click
07-28 08:19:20.627 14247-14331/com.jasonmrazw.rxdemo D/Multi: 5click
07-28 08:19:23.845 14247-14331/com.jasonmrazw.rxdemo D/Multi: 13click

到这，功能也即完全实现了。

等等，这个代码看着有点不太舒服，最后我想要的只是点击次数，而不是一个每次点击事件的列表。能不能把List<Void>转换成Integer呢？答案是可以的。祭出Rx神奇的操作符之一：map

    mClickStream.buffer(mClickStream.debounce(600,TimeUnit.MILLISECONDS))
                .map(new Func1<List<Void>, Integer>() {
                    @Override
                    public Integer call(List<Void> integers) {
                        return integers.size();
                    }
                })
                .subscribe(new Action1<Integer>(){
                    @Override
                    public void call(Integer s) {
                        Log.d(TAG,s+"click");
                    }
                });

是不感觉舒服了多了呢。

实现对比分析

第一种方式

优点：代码直接，一目了然。
缺点：不利于扩展，如果扩展可能会改动原来的判断逻辑，同时需要借助很多临时变量。

rxJava实现：

优点：说不出的优雅，如果不考虑将Click事件转化为Observable对象的实现，只需要简单的13行代码即可搞定。扩展性强。可以在最终的subscribe前做任何处理而不动之前的逻辑。
缺点：代码不直接，不一目了然。

附：实现事件转化，其实已经有第三方库做好了，万变不离其宗，原理都是一样的。
请看gradle:

    compile 'com.jakewharton.rxbinding:rxbinding:0.4.0'

总结

本文首先使用常用方式实现统计多次点击需求，后介绍如何将点击事件转化为Observable对象。然后介绍rxJava如何实现点击次数统计。最终对比了二者实现。

如果文中有纰漏或理解不正确之处，欢迎指正。

rxJava应用-检测多次点击