浅析事件分发

所谓事件分发，就是对MotionEvent的分发过程，当一个MotionEvent产生了以后，系统需要把这个事件传递给一个具体的View，而这个传递的过程就是分发过程。引用一个《Android开发艺术探索》里的概念：

同一个事件序列是指手指接触屏幕的那一刻起，到手指离开屏幕的那一刻结束，在这个工程中所产生的一系列事件，这个事件序列以down事件开始，中间含有数量不定的move事件，最终以up事件结束。

一个事件产生之后，先由Activity处理，activity交给window来处理

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

window又交给了mDecor处理

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

mDecor是一个继承了FrameLayout的对象，它会调用ViewGroup的dispatchTouchEvent，真正干活的是ViewGroup同学

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

下面来看看这位同学

            final int action = ev.getAction();
            final int actionMasked = action & MotionEvent.ACTION_MASK;

            // Handle an initial down.
            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的时候把上一个事件序列修改的变量置为默认状态，包括重置子控件通过requestDisallowInterceptTouchEvent方法设置的不让父控件拦截它的状态。

            // intercepted代表父控件是否拦截事件，true代表拦截，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 {
                // There are no touch targets and this action is not an initial down
                // so this view group continues to intercept touches.
                intercepted = true;
            }

满足actionMasked == MotionEvent.ACTION_DOWN和mFirstTouchTarget != null的其中一个条件时才会计算intercepted的值，不然直接就是true。mFirstTouchTarget != null代表父控件没有拦截事件，子控件处理消耗了事件。所以在整个事件序列里如果子控件没有在刚开始的ACTION_DOWN中消耗事件就是返回true的话，以后就没有机会再处理事件了。

事件序列的以一个ACTION_DOWN开始，所以会进入if里，disallowIntercept的值代表子控件是否告诉了ViewGroup不拦截事件，但是上面已经清除了这个状态，所以这里一定为false，所以intercepted的值取决于onInterceptTouchEvent，onInterceptTouchEvent的默认值是false。

    public boolean onInterceptTouchEvent(MotionEvent ev) {
        // 这里是鼠标相关
        if (ev.isFromSource(InputDevice.SOURCE_MOUSE)
                && ev.getAction() == MotionEvent.ACTION_DOWN
                && ev.isButtonPressed(MotionEvent.BUTTON_PRIMARY)
                && isOnScrollbarThumb(ev.getX(), ev.getY())) {
            return true;
        }
        return false;
    }

如果ViewGroup要处理事件，需要重写这个方法，而且如果子控件没有在ACTION_DOWN中消耗事件的话，mFirstTouchTarget != null不成立，在整个事件序列的其他事件中，ViewGroup不再判断onInterceptTouchEvent，直接拦截事件，子控件再也收不到事件 。

final int childrenCount = mChildrenCount;
        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<View> preorderedList = buildTouchDispatchChildList();
            final boolean customOrder = preorderedList == null
                    && isChildrenDrawingOrderEnabled();
            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 (!canViewReceivePointerEvents(child)
                        || !isTransformedTouchPointInView(x, y, child, null)) {
                    ev.setTargetAccessibilityFocus(false);
                    continue;
                }

                // 省略代码

                // 标记二
                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();
        }

标记一处。canViewReceivePointerEvents用来判断是否正在播放动画，isTransformedTouchPointInView用来判断点击事件的坐标是否落在子元素的区域内。满足条件处理事件，不满足遍历下一个子控件。

扫描二维码关注公众号，回复： 3488492 查看本文章

标记二处。调用dispatchTransformedTouchEvent方法。主要在这里

    private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
            View child, int desiredPointerIdBits) {
        final boolean handled;
        // 省略代码
        if (child == null) {
            handled = super.dispatchTouchEvent(transformedEvent);
        } else {
            final float offsetX = mScrollX - child.mLeft;
            final float offsetY = mScrollY - child.mTop;
            transformedEvent.offsetLocation(offsetX, offsetY);
            if (! child.hasIdentityMatrix()) {
                transformedEvent.transform(child.getInverseMatrix());
            }

            handled = child.dispatchTouchEvent(transformedEvent);
        }

        // Done.
        transformedEvent.recycle();
        return handled;
    }

如果child不为空，调用child的dispatchTouchEvent方法，child继续分发事件。
如果child为空，调用super.dispatchTouchEvent，自己处理事件。
这里child不为空，事件交给了child去处理，如果child消耗了事件返回了true，mFirstTouchTarget被赋值。

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

可以看出TouchTarget是一个链表格式的类，返回mFirstTouchTarget，赋值给newTouchTarget，循环结束。

            // 标记三
            if (mFirstTouchTarget == null) {
                // No touch targets so treat this as an ordinary view.
                handled = dispatchTransformedTouchEvent(ev, canceled, null,
                        TouchTarget.ALL_POINTER_IDS);
            } else {
                // Dispatch to touch targets, excluding the new touch target if we already
                // dispatched to it.  Cancel touch targets if necessary.
                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;
                }
            }

标记三处，mFirstTouchTarget == null有三种情况
其一，ViewGroup没有子控件
其二，ViewGroup拦截子控件
其三，事件分发给了子控件，子控件没有消耗事件，返回了false
上面dispatchTransformedTouchEvent返回true，子控件消耗了事件的话，执行标记四。之后事件序列的其他事件除了不需要再去循环遍历children，直接执行标记五处的dispatchTransformedTouchEvent。
ViewGroup就结束了，下面看View。
ViewGroup在分发事件的时候会分发给View的dispatchTouchEvent

    public boolean dispatchTouchEvent(MotionEvent event) {
        // 省略代码
        if (onFilterTouchEventForSecurity(event)) {
            if ((mViewFlags & ENABLED_MASK) == ENABLED && handleScrollBarDragging(event)) {
                result = true;
            }
            //noinspection SimplifiableIfStatement
            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;
    }

View的dispatchTouchEvent比较简单，handleScrollBarDragging主要是鼠标的处理，返回false。所以是否执行onTouchEvent取决于onTouch的返回结果。
如果设置了mOnTouchListener并且返回值为true，直接返回结果，然后当前MotionEvent就结束了，接着处理下一个MotionEvent，onClick，onLongClick都没机会执行了。
如果不设置mOnTouchListener或者onTouch的返回值为false，接着执行onTouchEvent

    public boolean onTouchEvent(MotionEvent event) {
        // 省略
        final boolean clickable = ((viewFlags & CLICKABLE) == CLICKABLE
                || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
                || (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE;

        if ((viewFlags & ENABLED_MASK) == DISABLED) {
            if (action == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {
                setPressed(false);
            }
            mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
            // A disabled view that is clickable still consumes the touch
            // events, it just doesn't respond to them.
            return clickable;
        }
        if (mTouchDelegate != null) {
            if (mTouchDelegate.onTouchEvent(event)) {
                return true;
            }
        }
        // 省略
    }

view的LONG_CLICKABLE默认为false，部分view的CLICKABLE为true，部分view的的CLICKABLE为false。当setOnClickListener或者setOnLongClickListener的时候，都会先置为true。
如果view是DISABLED的，直接返回，如果clickable为ture，即使DISABLED也会消耗事件。
如果有设置代理，处理代理。
如果clickable为true，onTouchEvent返回值默认true，clickable为false，不作处理，返回值false。

case MotionEvent.ACTION_DOWN:
    if (event.getSource() == InputDevice.SOURCE_TOUCHSCREEN) {
        mPrivateFlags3 |= PFLAG3_FINGER_DOWN;
    }
    mHasPerformedLongPress = false;

    // 省略代码

    boolean isInScrollingContainer = isInScrollingContainer();

    if (isInScrollingContainer) {
    // 设置为PFLAG_PREPRESSED状态，代表按下之前的状态
        mPrivateFlags |= PFLAG_PREPRESSED;
        if (mPendingCheckForTap == null) {
            mPendingCheckForTap = new CheckForTap();
        }
        mPendingCheckForTap.x = event.getX();
        mPendingCheckForTap.y = event.getY();
        // 延迟发送一个CheckForTap，CheckForTap负责将状态再重置回来，然后再发送一个长按的延迟事件
        postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
    } else {
        // 直接发送一个延时的长按事件，如果在延迟时间内没有被取消，则回调onLongClick
        setPressed(true, x, y);
        checkForLongClick(0, x, y);
    }

ACTION_DOWN里判断是否在一个可滚动的ViewGroup里，这里会递归判断所有的ViewGroup。
如果在一个可滚动的ViewGroup里，延迟发送一个CheckForTap，CheckForTap负责将状态再重置回来，然后再发送一个长按的延迟事件。不在可滚动的ViewGroup，直接发送一个延时的长按事件，如果在延迟时间内没有被取消，则回调onLongClick。setPressed用来处理view的状态，按下，需不需要重绘。
onLongClick的默认处理时间是500毫秒。

    private static final int DEFAULT_LONG_PRESS_TIMEOUT = 500;

case MotionEvent.ACTION_MOVE:
    // 省略
    if (!pointInView(x, y, mTouchSlop)) {
        // Outside button
        // Remove any future long press/tap checks
        removeTapCallback();
        removeLongPressCallback();
        if ((mPrivateFlags & PFLAG_PRESSED) != 0) {
            setPressed(false);
        }
        mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
    }
    break;

ACTION_MOVE比较简单，如果事件在控件范围外，移除所有延迟消息。

case MotionEvent.ACTION_UP:
    // 如果mPrivateFlags不为0，预按下或者按下状态
    boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;
    if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) {
        // 如果允许获取焦点，并且当前没有获取到焦点
        boolean focusTaken = false;
        if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {
            // 获取焦点
            focusTaken = requestFocus();
        }

        if (prepressed) {
            // 置为按下状态，重绘
            setPressed(true, x, y);
        }

        if (!mHasPerformedLongPress && !mIgnoreNextUpEvent) {
            // 如果长按没有触发，说明是点击事件，移除长按
            removeLongPressCallback();

            // Only perform take click actions if we were in the pressed state
            if (!focusTaken) {
                // 在这里回调onClick事件
                if (mPerformClick == null) {
                    mPerformClick = new PerformClick();
                }
                if (!post(mPerformClick)) {
                    performClick();
                }
            }
        }

        // 用来设置view不同状态下的背景
        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;

ACTION_UP比较长，用注释的方式解释了。主要是判断长按事件有没有回调，没有说明不到500毫秒，移除长按，回调onClick事件，设置view不同状态下的背景。事件就结束了。

case MotionEvent.ACTION_CANCEL:
    if (clickable) {
        setPressed(false);
    }
    removeTapCallback();
    removeLongPressCallback();
    mInContextButtonPress = false;
    mHasPerformedLongPress = false;
    mIgnoreNextUpEvent = false;
    mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
    break;

ACTION_CANCEL，系统控制，取消所有回调，重置所有状态。

onTouchEvent执行结束，默认返回true消耗事件，然后返回到ViewGroup的dispatchTouchEvent，层层返回，最后回到activity的dispatchTouchEvent中。

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

一般情况下getWindow().superDispatchTouchEvent(ev)都为true，事件结束了。如果所有的view都没有消耗事件，最后由Activity的onTouchEvent处理。