Android事件分发机制源码分析

说到Android的事件机制，相信很多人都不陌生。详细了解事件在Android中传递的规则，使得我们能够更加清楚事件处理逻辑，更好的处理滑动冲突之类复杂的问题。本文主要分析事件在各个View层级中的分发规则，从Activity接收到事件到一个事件被成功消费的详细过程。

Activity的分发过程

当有触摸事件发生在一个Activity时，这个事件首先会被传递给Activity，即调用Activity的dispatchTouchEvent方法，然后开始事件的分发过程。现在我们可以知道，如果我们想要拦截所有的事件，那么可以通过重写Activity的dispatchTouchEvent方法实现。下面我们看一下Activity的dispatchTouchEvent方法：

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

首先，如果是ACTION_DOWN事件的话，会调用onUserInteraction方法，该方法在Activity中实现为一个空方法，可以通过覆盖该方法在一个事件序列到来时做一些事情。getWindow方法返回该Activity方法所关联的Window对象，Window是一个抽象类，而它的具体实现是PhoneWindow（在Activity类的attach方法中可以看到：mWindow = new PhoneWindow(this, window);）。因此，我们可以知道，Activity只是简单的将事件交给Window的superDispatchTouchEvent方法处理，如果Window未能成功处理该事件，则交给Activity自身的onTouchEvent方法处理。然后看一下Window的处理过程。

Window的分发过程

首先看一下PhoneWindow中superDispatchTouchEvent方法的实现：

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

PhoneWindow的superDispatchTouchEvent方法很简单，就是直接将事件交给mDecor。而mDecor正是DecorView（实现为PhoneWindow中的内部类）的实例，即是Activity 中的顶级View，它是FrameLayout的子类，而它的superDispatchTouchEvent方法也直接调用了super.dispatchTouchEvent方法。而FrameLayout、LinearLayout、RelativeLayout等布局管理器的事件分发都继承自ViewGroup，因此，此时，事件交由ViewGroup处理。下面我们看一下ViewGroup如何分发事件。

ViewGroup的分发过程

ViewGroup中的dispatchTouchEvent方法比较长，有二百多行，因此这里将忽略逻辑不相关部分，按照事件分发逻辑逐步进行分析。

我们都知道，Android中以一个事件序列为单位进行处理，一个事件序列以ACTION_DOWN事件开始，以ACTION_UP事件结束，中间会有数个ACTION_MOVE事件。现在，我们看一下当一个事件到来时ViewGroup的处理逻辑：

            if (actionMasked == MotionEvent.ACTION_DOWN) {                // Throw away all previous state when starting a new touch gesture.                // The framework may have dropped the up or cancel event for the previous gesture                // due to an app switch, ANR, or some other state change.                cancelAndClearTouchTargets(ev);                resetTouchState();            }

首先，如果到来的事件是ACTION_DOWN，也即当一个新的事件序列到来时，会执行初始化操作，清除上个事件序列的touchTarget及其状态等。如果不是一个新的事件序列（即到来的不是ACTION_DOWN事件），就跳过此操作，然后开始事件分发：

    // Check for interception.    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会判断是否拦截该事件（拦截则不再向下层View分发）。ViewGroup的onInterceptTouchEvent默认返回false，因此当actionMasked == MotionEvent.ACTION_DOWN或者mFirstTouchTarget != null时，ViewGroup不拦截该事件，否则intercepted = true。更进一步，也即如果一个新的事件序列到来，或者该事件序列已经被子View处理（也即mFirstTouchTarget != null）时，ViewGroup就不拦截该事件，将该事件向下层分发，否则拦截该事件（因为没有子View处理该事件序列，因此无需继续分发），交由ViewGroup来处理。然后看一下当ViewGroup不拦截事件时的处理逻辑：

    final View[] children = mChildren;    for (int i = childrenCount - 1; i >= 0; i--) {        final int childIndex = getAndVerifyPreorderedIndex(                childrenCount, i, customOrder);        final View child = getAndVerifyPreorderedView(                preorderedList, children, 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;        }        newTouchTarget = getTouchTarget(child);        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);        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判断：

    if ( actionMasked == MotionEvent.ACTION_DOWN            || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)            || actionMasked == MotionEvent.ACTION_HOVER_MOVE )

不考虑鼠标和多指事件，那么只有ACTION_DOWN事件到来时才会进入上述循环进行分发，那么也就是说，因为进入循环的一定是ACTION_DOWN事件，此时已经清除了touchTargets，所以进入上述循环时getTouchTarget方法一定返回null，那么分发过程如下：

遍历该ViewGroup的所有子View，然后判断该子View是否能接收该事件（通过判断该View是否可见或者正在播放动画和该事件是否落在该View所在区域两个条件来决定），不满足条件则执行continue继续该循环。然后调用dispatchTransformedTouchEvent方法将事件依次分发给子View，寻找新的touchTarget。如果有子View处理了该事件，则通过addTouchTarget将新的target加到touchTargets链中，并赋值mFirstTouchTarget，然后结束循环。

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

现在看一下mFirstTouchTarget == null时的处理。此时有两种情况，第一种：ViewGroup拦截了该事件，也即该事件不是ACTION_DOWN，并且mFirstTouchTarget == null，也就是说该事件序列的ACTION_DOWN事件没有被子View处理。第二种：该事件是ACTION_DOWN事件，并且该事件没有成功分发给子View，那么mFirstTouchTarget也会等于null。此时，调用dispatchTransformedTouchEvent方法将事件交由自己来处理（注意：此时第三个参数为null表示自己处理）。

dispatchTransformedTouchEvent方法的一部分如下：

    if (child == null) {        handled = super.dispatchTouchEvent(event);    } else {        final float offsetX = mScrollX - child.mLeft;        final float offsetY = mScrollY - child.mTop;        event.offsetLocation(offsetX, offsetY);        handled = child.dispatchTouchEvent(event);        event.offsetLocation(-offsetX, -offsetY);    }    return handled;

上面这部分代码展示了dispatchTransformedTouchEvent方法的主要逻辑，也即如果child（该方法的第三个参数）为null，则调用父类（也即View类）的dispatchTouchEvent方法， 否则调用child的dispatchTouchEvent方法，将事件向下传递。如果child是一个ViewGroup，则将再次进行上述分发过程，而如果child只是一个View（此处的View不包含Viewgroup），则交给View类的dispatchTouchEvent处理。

如果到来的不是ACTION_DOWN事件，而且没有被拦截，那么此时一定有子View处理了该事件，那么就直接将事件分发给该子View，该子View保存在以mFirstTouchTarget为首的TouchTarget链表中：

    TouchTarget predecessor = null;    TouchTarget target = mFirstTouchTarget;    while (target != null) {        final TouchTarget next = target.next;        if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {            handled = true;        } else {            final boolean cancelChild = resetCancelNextUpFlag(target.child)                    || intercepted;            if (dispatchTransformedTouchEvent(ev, cancelChild,                    target.child, target.pointerIdBits)) {                handled = true;            }            if (cancelChild) {                if (predecessor == null) {                    mFirstTouchTarget = next;                } else {                    predecessor.next = next;                }                target.recycle();                target = next;                continue;            }        }        predecessor = target;        target = next;    }

至此，ViewGroup对事件的分发过程就结束了，如果子View仍然是ViewGroup，那么就由子View重复上述过程，如果子View不是ViewGroup，那么就进入View（此处的View不包括ViewGroup）对事件的处理过程。

View的分发过程

由于View不包含子View，所以不用继续分发，收到事件时自己处理就好了。因此View中也没有事件拦截逻辑，也不包含onInterceptTouchEvent方法，当有事件分发给View时，该View就要处理该事件（但不一定成功处理）。View类的dispatchTouchEvent方法的处理逻辑如下：

    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;    }

首先，View检查是否设置了OnTouchListener，如果设置了OnTouchListener则执行它的onTouch方法，如果OnTouchListener返回了true，则处理结束。否则执行View的onTouchEvent方法。由上可见，OnTouchListener的优先级比onTouchEvent高，并且如果OnTouchListener返回了true，则不会再执行onTouchEvent方法。

View类的onTouchEvent方法里会根据不同的事件进行相应的处理，比如在接收到ACTION_UP事件时通过performClick来完成OnClickListener（如果设置的有的话）的onClick等。需要注意的是，如果一个View被setEnable(false)，那么该View的OnTouchListener、onTouchEvent都不会被调用。但是，只要该View的clickable==true或者longClickable==true，那么该View都会消耗该事件，从onTouchEvent方法中位于头部的以下代码可以看出：

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

规律总结

通过上面的分析，我们能总结以下规律：

1. ViewGroup一旦拦截事件，那么整个事件序列（如果还能传递给它）都将被拦截；
2. 如果一个View没有处理ACTION_DOWN事件，那么该事件序列的后续事件都不会交给它处理；
3. 如果一个View处理了ACTION_DOWN事件，但没有处理后续事件，那么该事件序列的后续事件将会最终交由Activity处理；
4. View的onTouchEvent默认都会消耗事件，除非它的clickable和longClickable同时为false。