关于Android事件分发机制的宏观理解(简单)

我尽量不打错别字，用词准确，不造成阅读障碍。

之所以说是宏观，是因为我不会写demo，一步步截图给你看，我会拿源码然后剔除暂时用不到的部分，让你从大脉络上理解事件分发机制，这样你会发现，很简单。

首先在脑海中应该有一个例子，一个LinearLayout里面有一个button，没了，然后你设置了button的setOnClickListener方法，很简单的例子，也是最能接受的例子。

事件序列： 这是一个集合概念，一个完整的事件序列包含点击、移动、抬起等事件，一般就是down、move、up这三个。

这时你点击了button，就是最普通的点击，这时传递了一个down事件和一个up事件，普通点击一般不会触发move事件。

先说down事件，down通过屏幕传递给你的Activity(怎么传的不纠结)，Activity会传递给你的LinearLayout，并触发了dispatchTouchEvent(MotionEvent ev)，dispatch是分发的意思，这中间是怎么传的先忽略，总之就是down传到了你的LinearLayout，要求触发dispatchTouchEvent(MotionEvent ev)方法(down就保存在其中的MotionEvent中)，看一下LinearLayout，发现没有这个方法，但是它继承了ViewGroup，ViewGroup是有这个方法的，所以根据继承规则会调用ViewGroup的dispatchTouchEvent方法去分发事件，disaptchTouchEvent方法很长，我们截取重要部分：

@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    boolean handled = false;
    //...省略部分代码
    final boolean intercepted;
    if (actionMasked == MotionEvent.ACTION_DOWN || mFirstTouchTarget != null) {
        final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
        if (!disallowIntercept) {
           intercepted = onInterceptTouchEvent(ev); //首先是这里的拦截
           ev.setAction(action); // restore action in case it was changed
        } else {
             intercepted = false;
        }
     } else {
          intercepted = true;
     }
     final boolean canceled = resetCancelNextUpFlag(this)
                    || actionMasked == MotionEvent.ACTION_CANCEL;
    
  //***************************省略部分代码&&分界线***********************************//
    
          if (!canceled && !intercepted) {//如果拦截了，这方法根本进不来
             //...省略部分代码
             if (newTouchTarget == null && childrenCount != 0) {
                 //...省略部分代码
                 final View[] children = mChildren;
               //循环子View
                 for (int i = childrenCount - 1; i >= 0; i--) {
                     final int childIndex = getAndVerifyPreorderedIndex(
                                    childrenCount, i, customOrder);
                     final View child = getAndVerifyPreorderedView(
                                    preorderedList, children, childIndex);
                     //...
                     if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
                         mLastTouchDownTime = ev.getDownTime();
                         if (preorderedList != null) {
                              // childIndex points into presorted list, find original index
                               for (int j = 0; j < childrenCount; j++) {
                                    if (children[childIndex] == mChildren[j]) {
                                       mLastTouchDownIndex = j;
                                       break;
                                      }
                                }
                          } else {
                               mLastTouchDownIndex = childIndex;
                          }
                          mLastTouchDownX = ev.getX();
                          mLastTouchDownY = ev.getY();
                          newTouchTarget = addTouchTarget(child, idBitsToAssign);
                          alreadyDispatchedToNewTouchTarget = true;
                          break;
                       }
                    }
                }
          }
        return handled;
    }

省略了好些代码，这个其实分两部分看，我用线画出来了，上半部分，down事件会传递进来，然后执行onInterceptTouchEvent(ev); 这是拦截方法，Intercept是拦截的意思，默认执行结果是false，就是不拦截，而且这个方法是ViewGroup的内部方法不是继承而来的，所以只有它有拦截，这个知识点主要是针对ViewGroup的父类——View，它是没有这个方法的。其中的mFirstTouchTarget在down事件不拦截后就!=null，如果down事件被viewGroup拦截了，就会==null，intercepted就为true，之后的move、up等后续事件进不去那个if判断，就不会分发给子view，自己消耗。

好，不拦截，然后往下走，横线下面的if判断中的canceled正常都是false，取反，intercepted又是false，好，进来了，下面的if正常也是会进去的(看变量名就可以知道一些)，其中有一个for循环子view，马上任务就要交给子view了，ViewGroup就歇会儿了。

重点看dispatchTransformedTouchEvent:

private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
            View child, int desiredPointerIdBits) {
        final boolean handled;
        //省...
        // Perform any necessary transformations and dispatch.
        if (child == null) {
            handled = super.dispatchTouchEvent(transformedEvent);
        } else {
            //省...
            handled = child.dispatchTouchEvent(transformedEvent);
        }
        transformedEvent.recycle();
        return handled;
    }

代码要少一些，dispatchTouchEvent(分发)中的dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)传递的参数是ev、false、child、idBitsToAssign，也就是cancel永远为false，child一般不为null，所以正常会调用child.dispatchTouchEvent方法，也就是View的dispatchTouhEvent方法，分发，这样就从父布局转移到子view了。

public boolean dispatchTouchEvent(MotionEvent event) {
        final int actionMasked = event.getActionMasked();
       //省...
        if (onFilterTouchEventForSecurity(event)) {
            ListenerInfo li = mListenerInfo;
            if (li != null && li.mOnTouchListener != null
                    && (mViewFlags & ENABLED_MASK) == ENABLED
                    && li.mOnTouchListener.onTouch(this, event)) {
                result = true;
            }
            if (!result && onTouchEvent(event)) {
                result = true;
            }
        }
       //省...
        return result;
    }

走到这里我们已经经历两个dispatchTouchEvent了，希望不要弄混，一个是ViewGroup的，一个是View的，虽然ViewGroup继承自View，但是对布局而言，我们要先执行父布局(ViewGroup)的dispatchTouchEvent，然后在执行自己的dispatchTouchEvent，因为自己没有这个方法，但自己的父布局View是有的，所以会执行View的dispatchTouchEvent。

其中的if一般也是可以进来的，然后又是2个if判断，第一个if判断的result决定了第二个if判断会不会执行，在本文中，因为没有setOnTouchListener，所以第一个if进不来，就会到下一个if，也就会执行onTouchEvent方法：

 public boolean onTouchEvent(MotionEvent event) {
        //...省
        if (clickable || (viewFlags & TOOLTIP) == TOOLTIP) {
            switch (action) {
                case MotionEvent.ACTION_UP:
                    //...省
                    if (!post(mPerformClick)) {
                         performClick();
                     } 
                    //...省
                    mIgnoreNextUpEvent = false;
                    break;
                case MotionEvent.ACTION_DOWN:
                    //...省
                    break;
                case MotionEvent.ACTION_CANCEL:
                    //...省
                    break;
                case MotionEvent.ACTION_MOVE:
                    //...省
                    break;
            }
            return true;
        }
        return false;
    }

当在DOWN事件中，其实从宏观角度没什么要特别解释的，包括一些长按判断等等，就省略了，重点是那个UP事件，当手指抬起的时候UP事件就会被触发，它也会像down事件一样经过层层筛选进来最后到view的onTouchEvent这里，会执行performClick()，看一下代码：

public boolean performClick() {
        final boolean result;
        final ListenerInfo li = mListenerInfo;
        if (li != null && li.mOnClickListener != null) {
            playSoundEffect(SoundEffectConstants.CLICK);
            li.mOnClickListener.onClick(this);
            result = true;
        } else {
            result = false;
        }
        sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);
        notifyEnterOrExitForAutoFillIfNeeded(true);
        return result;
    }

这是所有代码，没有省略，其它的也不用管，主要看if判断中的一句，li.mOnClickListener.onClick(this);是不是看着眼熟？li.mOnClickListener就是我们设置的监听，当Button设置了setOnClickListener后，我们看看它干了什么，首先：button继承自TextView，TextView继承自View，button和TextView都没有这个方法，所以最后会执行view的setOnClickListener，看代码：

public void setOnClickListener(@Nullable OnClickListener l) {
        if (!isClickable()) {
            setClickable(true);  //如果clickable为false就设为true
        }
        getListenerInfo().mOnClickListener = l;
    }

这样就把我们设置的onClickListener对象赋值给getListenerInfo().mOnClickListener，当执行li.mOnClickListener.onClick(this);时就会执行我们写的操作。

其实前期可以把View和ViewGroup看成是两个独立的类，方便理解，但是很快就应该认识到两者是继承关系，并不独立。

一句话说明就是：事件总会先传给父元素，父元素进行分发(循环)和拦截判断，不拦截就传递给子元素，子元素如果可以点击就会消耗事件，反之则返回给父元素处理。

正常情况下，down事件要经过这个循环(但没有performClick)，up事件也要走这个循环(有performClick)，中间要是有move，就要走多次这个循环，挺繁琐的，所以中间那些省略的代码中做了很多处理的，优化了操作步骤，比如：如果down事件被ViewGroup拦截了，整个事件序列要怎么处理？每个方法都是有boolean类型的返回值的，这些返回值是干嘛的？这些其实都在源码里，包括我省略的部分，说一千，道一万都不如自己看源码理解的透彻。