---

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

• 非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.

也即能过滤出一定间隔内的事件。
考虑如下代码：
```java
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
```java
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如何实现点击次数统计。最终对比了二者实现。

本文相关代码已上传到github：RxDemo。如果文中有纰漏或理解不正确之处，欢迎指正。