Android开发——View事件分发机制

当我们在手机屏幕上按下、移动、抬起时将会形成一个手势，该一系列动作将会经过Activity->Window->View的顺序传到我们操作的View。比如说滑动ViewPager，那么ViewPager将会滑动页面；点击按钮，按钮将会发生变化、跳转界面等。事件从Activity到View，再到特定的某一个View的过程就是事件分发的过程。这篇博客主要说明事件分发机制。

传递规则

在View和ViewGroup中，有几个方法与事件分发有关，分别是：
boolean dispatchTouchEvent(MotionEvent ev) (View和ViewGroup均有实现，且实现不同)
用来进行事件的分发。该方法会将事件向下传递到目标View或者当前View就是目标View。返回true表示事件被当前View消耗了，否则返回false。
boolean onInterceptTouchEvent(MotionEvent event) (只有ViewGroup有该方法)
用来判断是否拦截某个事件，如果当前View拦截了某个事件，那么在同一个事件序列当中，此方法不会被再次调用，返回结果表示是否拦截当前事件。
boolean onTouchEvent(MotionEvent event) (View和ViewGroup实现相同)
在dispatchTouchEvent()方法中调用，用来处理事件，返回结果表示是否消耗当前事件，如果不消耗，则在同一个事件序列中，当前View无法再次接受到事件。
当一个ViewGroup需要处理事件时，它的dispatchTouchEvent方法将会被调用，其伪代码如下：

// ViewGroup中dispatchTouchEvent的处理流程
public boolean dispatchTouchEvent(MotionEvent ev){

   boolean consume=false;
   if(onInterceptTouchEvent(ev)){
       consume=onTouchEvent(ev);
   }else{
       consume=child.dispatchTouchEvent(ev);
   }

   return consume;

}

从上面的代码可以看到，对于一个根ViewGroup来说，dispatchTouchEvent主要确定事件是分发给子View处理还是分发给自己处理。 点击事件产生后，首先会传递给它，这时它的dispatchTouchEvent就会被调用，如果这个ViewGroup的onInterceptTouchEvent方法返回true表示它要拦截该事件，接着事件就会交给这个ViewGroup处理，即它的onTouchEvent方法就会被调用；如果这个ViewGroup的onInterceptTouchEvent方法返回false就表示它不拦截当前事件，这时当前事件就会继续传递给它的子元素，接着子元素的dispatchTouchEvent方法将会被调用，如此反复直到事件被最终处理。
当一个View需要处理事件时，它的dispatchTouchEvent方法会被调用，其伪代码如下：

// View中dispatchTouchEvent的处理流程
public boolean dispatchTouchEvent(MotionEvent ev){

    boolean consume=false;
    if(mOnTouchListener!=null){
         consume=mOnTouchListener.onTouch(ev);
    }
    if(!consume)
        consume=onTouchEvent(ev);

    return consume;

}

从上面的代码可以看到，对于一个View来说，dispatchTouchEvent主要确定事件是分发给设置的OnTouchListener处理还是分发给自己处理，优先级是OnTouchListener优先于onTouchEvent方法。

结论

关于事件传递的就机制，这里给出一些结论，根据这些结论可以更好地理解整个传递机制，如下所示：
1. 同一个事件序列是指从手指接触屏幕的那一刻起，到手指离开屏幕的那一刻结束，在这个过程中所产生的一系列事件，这个事件序列以down事件开始，中间含有数量不定的move事件，最终以up事件结束。
2. 正常情况下，一个事件序列只能被一个View拦截且消耗。这一条的原因可以参考（3），因为一旦一个元素拦截了某此事件，那么同一个事件序列内的所有事件都会直接交给它处理，因此同一个事件序列中的事件不能分别由两个View同时处理，但是通过特殊手段可以做到，比如一个View将本该自己处理的事件通过onTouchEventq强行传递给其他View处理。
3. 某个ViewGroup一旦决定拦截，那么这一个事件序列都只能由它来处理（如果事件序列能够传递给它的话），并且它的onInterceptTouchEvent不会再被调用。这条也很好理解，就是说当一个View决定拦截一个事件后，那么系统会把同一个事件序列内的其他方法都直接交给它来处理，因此就不再调用这个ViewGroup的onInterceptTouchEvent去询问它是否要拦截了。
4. 某个View一旦开始处理事件，如果它不消耗ACTION_DOWN事件（onTouchEvent返回了false），那么同一事件序列中的其他事件都不会再交给它来处理，并且事件将重新交给它的父元素去处理，即父元素的onTouchEvent会被调用。意思就是事件一旦交给一个View处理，那么它就必须消耗掉，否则同一事件中剩下的事件就不再交给它来处理了，这就好比上级交给程序员一件事，如果这件事没有处理好，短期内上级就不敢再把事件交给这个程序员做了，二者是类似的道理。（可从ViewGroup的dispatchTouchEvent的处理流程得出该条）
5. 如果View不消耗除ACTION_DOWN以外的其他事件，那么这个点击事件会消失，此时父元素的onTouchEvent并不会被调用，并且当前View可以持续收到后续的事件，最终这些消失的点击事件会传递给Activity处理。
6. ViewGroup默认不拦截任何事件。
7. View没有onInterceptTouchEvent方法，一旦有事件传递给它，那么它的onTouchEvent方法就会被调用。
8. View的onTouchEvent默认都会消耗事件（返回true），除非不可点击。
9. View的enable属性不影响onTouchEvent的默认返回值。哪怕一个View是disable状态的，只要它的clickable、longclickable或者contextclickable有一个为true，那么它的onTouchEvent就返回true。
10. onClick会发生的前提是当前View是可点击的，并且它收到了down和up事件。
11. 事件传递过程是由内向外的，即事件总是先传递给父元素，然后再由父元素分发给View，通过requestDisallowInterceptTouchEvent方法可以在子元素中干预父元素的事件分发过程，但是ACTION_DOWN事件除外。

以上结论引用自”Android开发艺术探索”

事件分发的源码解析

Activity对点击事件的分发过程

当一个点击事件发生后，首先会传给Activity的dispatchTouchEvent来进行事件分发，具体的工作是由Activity内部的Window来完成的。Window会将事件传递给decor view。下面是Activity的dispatchTouchEvent方法的实现：

public boolean dispatchTouchEvent(MotionEvent ev) {
        if (ev.getAction() == MotionEvent.ACTION_DOWN) {
            onUserInteraction();
        }
        if (getWindow().superDispatchTouchEvent(ev)) {
            return true;
        }
        return onTouchEvent(ev);
    }

从上面的代码可以看到，Activity的dispatchTouchEvent完成的分发工作是分发给Window处理还是自己的onTouchEvent，Window优先，如果Window处理不来，那就只有自己上了。

Window对点击事件的分发过程

我们知道PhoneWindow是Window的唯一实现，Activity的getWindow()方法返回的就是PhoneWindow对象，下面是PhoneWindow的superDispatchTouchEvent方法：

 @Override
    public boolean superDispatchTouchEvent(MotionEvent event) {
        return mDecor.superDispatchTouchEvent(event);
    }

从上面可以看到，调用了mDecor的superDispatchTouchEvent方法。mDecor是DecorView，是Activity布局的根布局，是setContentView中ContentView的父布局，也就是通常我们所写的XML的顶层布局的父布局。
Window直接将事件分发交给了DecorView处理，这样就从Activity->Window->DecorView完成了点击事件的分发。

根View对点击事件的分发

Window的superDispatchTouchEvent方法中，调用了DecorView的superDispatchTouchEvent方法，DecorView的实现如下：

public boolean superDispatchTouchEvent(MotionEvent event) {
            return super.dispatchTouchEvent(event);
        }

可以看到，直接调用了父类的dispatchTouchEvent方法，DecorView继承自FrameLayout，而FrameLayout没有重写dispatchTouchEvent方法，其父类ViewGroup实现了该方法。在前面内容说到了ViewGroup的dispatchTouchEvent完成的分发是将事件分发给子View还是分发给自己。ViewGroup的dispatchTouchEvent代码很长，这里分段说明，先看下面一段，下面的代码描述了View是否拦截点击事件这个逻辑：

            // 检查拦截
            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 {
                // There are no touch targets and this action is not an initial down
                // so this view group continues to intercept touches.
                intercepted = true;
            }

从上面的代码可以看到，ViewGroup在如下两种情况下会判断是否要拦截当前事件：事件类型为ACTION_DOWN或者mFirstTouchTarget!=null。ACTION_DOWN表示是事件序列的开始，自然要去判断；从后面的代码可以看出，当事件由ViewGroup的子View成功处理时，mFirstTouchTarget会被赋值并被指向该子View，也就是说如果有子View可以处理事件，那么就需要判断是否拦截，如果没有子View可以处理事件，那么拦截不拦截都无所谓了。而如果没有子View可以处理事件，那么mFirstTouchTarget就为null，那么在后面的事件序列中，intercepted就直接为true，也不会再调用onInterceptTouchEvent了。所以看来子View要想处理事件，就得在ACTION_DOWN事件时好好表现，否则就没机会了。
当然，这里有一种特殊情况，那就是FLAG_DISALLOW_INTERCEPT标记位，这个标记位是通过requestDisallowInterceptTouchEvent方法来设置的，一般用于子View中。FLAG_DISALLOW_INTERCEPT一旦设置后，ViewGroup将无法拦截除了ACTION_DOWN以外的其他点击事件。
从上面的源码可以得出结论：当ViewGroup决定拦截事件后，那么后续的点击事件将会默认交给它处理并且不再调用它的onInterceptTouchEvent方法。FFLAG_DISALLOW_INTERCEPT这个标志的作用是让ViewGroup不再拦截事件，当前前提是ViewGroup不拦截ACTION_DOWN事件。
接着再看ViewGroup不拦截事件的时候，事件会向下分发交由它的子View进行处理，这段源码如下所示：

if (!canceled && !intercepted) {

                // If the event is targeting accessiiblity focus we give it to the
                // view that has accessibility focus and if it does not handle it
                // we clear the flag and dispatch the event to all children as usual.
                // We are looking up the accessibility focused host to avoid keeping
                // state since these events are very rare.
                View childWithAccessibilityFocus = ev.isTargetAccessibilityFocus()
                        ? findChildWithAccessibilityFocus() : null;

                if (actionMasked == MotionEvent.ACTION_DOWN
                        || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
                        || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
                    final int actionIndex = ev.getActionIndex(); // always 0 for down
                    final int idBitsToAssign = split ? 1 << ev.getPointerId(actionIndex)
                            : TouchTarget.ALL_POINTER_IDS;

                    // Clean up earlier touch targets for this pointer id in case they
                    // have become out of sync.
                    removePointersFromTouchTargets(idBitsToAssign);

                    final int childrenCount = mChildrenCount;
                    //newTouchTarget初始为null，有子View，那么需要遍历
                    if (newTouchTarget == null && childrenCount != 0) {
                        final float x = ev.getX(actionIndex);
                        final float y = ev.getY(actionIndex);
                        // Find a child that can receive the event.
                        // Scan children from front to back.
                        final ArrayList preorderedList = buildOrderedChildList();
                        final boolean customOrder = preorderedList == null
                                && isChildrenDrawingOrderEnabled();
                        final View[] children = mChildren;
                        //遍历View
                        for (int i = childrenCount - 1; i >= 0; i--) {
                            final int childIndex = customOrder
                                    ? getChildDrawingOrder(childrenCount, i) : i;
                            final View child = (preorderedList == null)
                                    ? children[childIndex] : preorderedList.get(childIndex);

                            // If there is a view that has accessibility focus we want it
                            // to get the event first and if not handled we will perform a
                            // normal dispatch. We may do a double iteration but this is
                            // safer given the timeframe.
                            if (childWithAccessibilityFocus != null) {
                                if (childWithAccessibilityFocus != child) {
                                    continue;
                                }
                                childWithAccessibilityFocus = null;
                                i = childrenCount - 1;
                            }

                            if (!canViewReceivePointerEvents(child)
                                    || !isTransformedTouchPointInView(x, y, child, null)) {
                                ev.setTargetAccessibilityFocus(false);
                                continue;
                            }

                            //从View得到触摸目标
                            newTouchTarget = getTouchTarget(child);
                            //如果该View已是触摸目标，那么直接跳出遍历
                            if (newTouchTarget != null) {
                                // Child is already receiving touch within its bounds.
                                // Give it the new pointer in addition to the ones it is handling.
                                newTouchTarget.pointerIdBits |= idBitsToAssign;
                                break;
                            }

                            resetCancelNextUpFlag(child);
                            //如果可以成功分发给该View
                            if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
                                // Child wants to receive touch within its bounds.
                                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;
                            }

                            // The accessibility focus didn't handle the event, so clear
                            // the flag and do a normal dispatch to all children.
                            ev.setTargetAccessibilityFocus(false);
                        }
                        if (preorderedList != null) preorderedList.clear();
                    }


                    if (newTouchTarget == null && mFirstTouchTarget != null) {
                        // Did not find a child to receive the event.
                        // Assign the pointer to the least recently added target.
                        newTouchTarget = mFirstTouchTarget;
                        while (newTouchTarget.next != null) {
                            newTouchTarget = newTouchTarget.next;
                        }
                        newTouchTarget.pointerIdBits |= idBitsToAssign;
                    }
                }
            }

上面这段代码，首先遍历ViewGroup的所有子元素，然后判断子元素是否能够接受到点击事件。是否能够接受到点击事件主要由两点来衡量：子元素是否在播放动画和点击事件的坐标是否落在子元素的区域内。如果某个子元素满足这两个条件，那么事件将会传递给它来处理。可以看到，dispatchTransformedTouchEvent实际上调用的就是子元素的dispatchTouchEvent方法，在它的内部有如下一段内容，而在上面的代码中child传递的不是null，因此它会直接调用子元素的dispatchTouchEvent方法，这样事件就交由子元素处理了，从而完成了一轮事件分发。

 if (child == null) {
                handled = super.dispatchTouchEvent(event);
            } else {
                handled = child.dispatchTouchEvent(event);
            }

如果子元素的dispatchTouchEvent返回true，那么mFirstTouchTarget就会被赋值同时跳出for循环。其中addTouchTarget完成了mFirstTouchTarget的赋值。如下所示：

 private TouchTarget addTouchTarget(View child, int pointerIdBits) {
        TouchTarget target = TouchTarget.obtain(child, pointerIdBits);
        target.next = mFirstTouchTarget;
        mFirstTouchTarget = target;
        return target;
    }

mFirstTouchTarget内部是一个单链表结构，mFirstTouchTarget是否被赋值，将直接影响到ViewGroup对事件的拦截策略。
如果遍历所有的子元素后事件都没有被合适地处理，这包含两种情况，ViewGroup没有子元素；第二种是子元素处理了点击事件，但是在dispatchTouchEvent中返回了false，这一般是因为子元素在onTouchEvent中返回了false。在这两种情况，ViewGroup会自己处理点击事件，代码如下：

// Dispatch to touch targets.
            if (mFirstTouchTarget == null) {
                // No touch targets so treat this as an ordinary view.
                handled = dispatchTransformedTouchEvent(ev, canceled, null,
                        TouchTarget.ALL_POINTER_IDS);
            }

上面这段代码调用了dispatchTransformedTouchEvent方法，并且第三个参数为null，从前面可以知道将会调用父类View的dispatchTouchEvent方法，也就意味着ViewGroup将会自己处理这个事件。
当ViewGroup自己决定处理事件时，也会调用View的dispatchTouchEvent方法，下面我们再来看View的分发过程。

View对点击事件的处理过程

在前面的分析中提到过，View的dispatchTouchEvent完成是分发是将事件分发给OnTouchListener还是onTouchEvent方法。下面首先看View的dispatchTouchEvent方法：

public boolean dispatchTouchEvent(MotionEvent event) {

       ...

       boolean result = false;

       ...

        if (onFilterTouchEventForSecurity(event)) {
            //noinspection SimplifiableIfStatement
            ListenerInfo li = mListenerInfo;
            //如果OnTouchListener成功处理，直接返回true
            if (li != null && li.mOnTouchListener != null
                    && (mViewFlags & ENABLED_MASK) == ENABLED
                    && li.mOnTouchListener.onTouch(this, event)) {
                result = true;
            }

            //没有成功处理，那么会调用onTouchEvent方法
            if (!result && onTouchEvent(event)) {
                result = true;
            }
        }

        ...

        return result;
    }

View对点击事件的处理过程就比较简单了，因为View是一个单独的元素，他没有子元素因此无法向下传递事件，所以它只能自己处理事件。从上面的代码可以看到首先判断OnTouchListener是不是null，不是则先调用其onTouch方法，如果监听器成功处理了，那么就不会再调用onTouchEvent方法了，否则会调用onTouchEvent方法。而onTouchEvent中则是对点击事件的处理逻辑。
分析onTouchEvent时，先看当View处于不可用状态下点击事件的处理过程，如下所示。很显然，不可用状态下的View照样会消耗点击事件，尽管它看起来不可用。

if ((viewFlags & ENABLED_MASK) == DISABLED) {
            if (action == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {
                setPressed(false);
            }
            // A disabled view that is clickable still consumes the touch
            // events, it just doesn't respond to them.
            return (((viewFlags & CLICKABLE) == CLICKABLE
                    || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
                    || (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE);
        }

接着，如果View设置有代理，那么还会执行TouchDelegate的onTouchEvent方法，机制和OnTouchListener类似：

 if (mTouchDelegate != null) {
            if (mTouchDelegate.onTouchEvent(event)) {
                return true;
            }
        }

下面再看一下onTouchEvent中对点击事件的具体处理，如下所示：

if (((viewFlags & CLICKABLE) == CLICKABLE ||
                (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE) ||
                (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE) {
            switch (action) {
                case MotionEvent.ACTION_UP:
                    boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;
                    if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) {
                        // take focus if we don't have it already and we should in
                        // touch mode.
                        boolean focusTaken = false;
                        if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {
                            focusTaken = requestFocus();
                        }

                        if (prepressed) {
                            // The button is being released before we actually
                            // showed it as pressed.  Make it show the pressed
                            // state now (before scheduling the click) to ensure
                            // the user sees it.
                            setPressed(true, x, y);
                       }

                        if (!mHasPerformedLongPress && !mIgnoreNextUpEvent) {
                            // This is a tap, so remove the longpress check
                            removeLongPressCallback();

                            // Only perform take click actions if we were in the pressed state
                            if (!focusTaken) {
                                // Use a Runnable and post this rather than calling
                                // performClick directly. This lets other visual state
                                // of the view update before click actions start.
                                if (mPerformClick == null) {
                                    mPerformClick = new PerformClick();
                                }
                                if (!post(mPerformClick)) {
                                    performClick();
                                }
                            }
                        }

                        if (mUnsetPressedState == null) {
                            mUnsetPressedState = new UnsetPressedState();
                        }

                        if (prepressed) {
                            postDelayed(mUnsetPressedState,
                                    ViewConfiguration.getPressedStateDuration());
                        } else if (!post(mUnsetPressedState)) {
                            // If the post failed, unpress right now
                            mUnsetPressedState.run();
                        }

                        removeTapCallback();
                    }
                    mIgnoreNextUpEvent = false;
                    break;

                    ...
            }
            return true;
    }

从上面的代码来看，主要View的CLICKABLE、LONG_CLICKABLE和CONTEXT_CLICKABLE只要有一个为true，那么它就会消耗这个事件，即onTouchEvent返回true。然后就是当ACTION_UP事件发生时，会触发performClick方法，如果View设置了OnClickListener，那么performClick方法内部会调用它的onClick方法，如下所示：

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);
        return result;
    }

View的LONG_CLICKABLE属性默认为false，而CLICKABLE属性是否为false和具体的View有关。

总结

经过上面的源码分析，在这儿重申几点关于View和ViewGroup的分发规则：
1. Activity完成的分发是Window处理还是自己处理，Window优先处理，处理不了再自己处理；
2. Window完成的分发是直接交给DecorView处理；
3. ViewGroup完成的分发是交给子View处理还是自己处理（即onTouchEvent方法），借助于onInterceptTouchEvent可以区分出到底是谁执行；
4. View完成的分发是OnTouchListener处理还是自己处理（即onTouchEvent方法）。

在明白上述的分发规则后，理解起整个Android的事件分发机制就会容易很多。