Android事件派发源码阅读

前言

Android事件派发最开始从Activity派发给Window，Window又派发给了内部的DecorView也就是视图树，在视图树内部事件派发主要就是ViewGroup和View内部流转，这些执行流程在前面的示例初探中已经讲过，现在通过ViewGorup和View的实现源码来查看视图树内部的事件派发逻辑。

源码分析

事件序列最开始从ACTION_DOWN开始，由Activity从dispatchTouchEvent传入，查看ViewGroup的dispatchTouchEvent实现源代码。

@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    ...
    boolean handled = false;
    final int action = ev.getAction();
    final int actionMasked = action & MotionEvent.ACTION_MASK;

    // 处理最初的ACTION_DOWN事件
    if (actionMasked == MotionEvent.ACTION_DOWN) {
        // 清理以前的事件序列记录的内容
        cancelAndClearTouchTargets(ev);
        resetTouchState();
    }

    // 查看当前ViewGroup是否拦截当前事件，只有在ACTION_DOWN和已经有事件接收者才会做判断
    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;
        }
    }
   ...
}

在ViewGroup的dispatchTouchEvent最开始在ACTION_DOWN事件发生时一定会做拦截判断，mFirstTouchEvent只有在后续有子控件消费当前事件才不会为空，初始情况下是空的。如果onInterceptTouchEvent返回了false就代表当前事件不会被拦截，接着查看后续的源码。

// 如果不是取消事件而且没有被当前的ViewGroup拦截
if (!canceled && !intercepted) {

    View childWithAccessibilityFocus = ev.isTargetAccessibilityFocus()
            ? findChildWithAccessibilityFocus() : null;

    // 如果是ACTION_DOWN或者多指触摸
    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;

       removePointersFromTouchTargets(idBitsToAssign);

        final int childrenCount = mChildrenCount;
        if (newTouchTarget == null && childrenCount != 0) {
            final float x = ev.getX(actionIndex);
            final float y = ev.getY(actionIndex);

            // 遍历当前ViewGroup的所有子控件，查看是否有处理当前事件的子控件
            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);

                // 查看当前触摸位置是否在child子控件里，而且当前子控件能够接收触摸事件
                if (!canViewReceivePointerEvents(child)
                        || !isTransformedTouchPointInView(x, y, child, null)) {
                    ev.setTargetAccessibilityFocus(false);
                    continue;
                }

                // 查看当前子控件是否是上次记录的处理对象，这只在ACTION_POINTER_DOWN和ACTION_HOVER_MOVE事件时才会出现为真的情况，如果发现之前有处理对象跳出查询
                newTouchTarget = getTouchTarget(child);
                if (newTouchTarget != null) {
                    newTouchTarget.pointerIdBits |= idBitsToAssign;
                    break;
                }

                resetCancelNextUpFlag(child);

                // 如果当前对象既能处理触摸事件，事件发生位置又在子控件位置，将ACTION_DOWN事件派发给子控件看它是否会消费
                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;
                }
            }
        }
    }
}

这里主要考虑单指的触摸事件，多指事件就忽略掉，可以发现ViewGroup只会在ACTION_DOWN事件发生的时候遍历自己的子控件并且将事件派发给处于触摸位置而且能够接受触摸操作的child。查看canViewReceivePointerEvents实现发现能接受触摸事件的控件就是可见并且没有在执行动画的View，而isTransformedTouchPointInView会将事件发生时记录的坐标值转换到ViewGroup本地的坐标系中，在判断改点位置是否处于Child位置。注意alreadyDispatchedToNewTouchTarget这个变量，代表当前记录的子控件对象已经消费过这个事件，不必再派发给子控件了。

private static boolean canViewReceivePointerEvents(@NonNull View child) {
    return (child.mViewFlags & VISIBILITY_MASK) == VISIBLE
            || child.getAnimation() != null;
}

protected boolean isTransformedTouchPointInView(float x, float y, View child,
    PointF outLocalPoint) {
final float[] point = getTempPoint();
point[0] = x;
point[1] = y;
transformPointToViewLocal(point, child);
final boolean isInView = child.pointInView(point[0], point[1]);
if (isInView && outLocalPoint != null) {
    outLocalPoint.set(point[0], point[1]);
}
return isInView;
}

注意子控件调用dispatchTouchEvent事件在if处，如果返回值是true就代表子控件会消费当前ACTION_DOWN事件，并且将child记录到mFirstTouchTarget属性值中，这样后续的ACTION_MOVE和ACTION_UP就都不用在遍历查子控件是否消费事件了，只需要直接向mFirstTouchTarget派发事件就可以了；不过如果遍历操作没有发现有任何子控件消费了当前事件mFirstTouchTarget就会为空.

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

前面讨论的是interceptTouchEvent返回值为false的情况，如果interceptTouchEvent返回值是true，前面的代码都不会被执行，这时mFirstTouchTarget就会为空，因为没有子控件被遍历查看是否消费当前事件。

// 如果没有子控件消费事件，该事件直接由当前ViewGroup消费
if (mFirstTouchTarget == null) {
    handled = dispatchTransformedTouchEvent(ev, canceled, null,
            TouchTarget.ALL_POINTER_IDS);
} else {
    // 如果有子控件消费
    TouchTarget predecessor = null;
    TouchTarget target = mFirstTouchTarget;
    while (target != null) {
        final TouchTarget next = target.next;
        // 如果子控件消费过了，这个是在ACTION_DOWN判断哪个子控件会消费的时候已经派发过了，不必再做派发操作
        if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
            handled = true;
        } else {
            // 如果当前ViewGroup拦截事件，cancelChild就是true
            // 如果不拦截cancelChild就是false
            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;
    }
}

上面的代码在ACTION_DOWN执行完遍历操作后如果没有发现有子控件需要消费事件，就直接由ViewGroup自己查看是否需要消费当前事件。如果前面查找到有子控件消费了ACTION_DOWN事件就不再做其他操作，从ViewGroup.dispatchTouchEvent返回true。不过如果是后来发送过来的ACTION_MOVE或者ACTION_UP事件，就会接着调用dispatchTransformedTouchEvent方法。

private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
            View child, int desiredPointerIdBits) {
    final boolean handled;
    final int oldAction = event.getAction();
    // 如果第二个参数是true的话
    if (cancel || oldAction == MotionEvent.ACTION_CANCEL) {
        event.setAction(MotionEvent.ACTION_CANCEL);
        if (child == null) {
            handled = super.dispatchTouchEvent(event);
        } else {
            handled = child.dispatchTouchEvent(event);
        }
        event.setAction(oldAction);
        return handled;
    }

    ...
}

前面代码分析中说道如果ViewGroup.interceptTouchEvent返回true的画，第二个参数的值就是true，它会直接调用child.dispatchTouchEvent并且传入ACTION_CANCEL事件。不过如果ViewGorup没有拦截那么第二个参数就是false，它会执行下面的代码。

// Perform any necessary transformations and dispatch.
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);
}

首先将事件在ViewGroup中的坐标值转换到child控件的坐标系中，并且将当前转换过坐标系之后的触摸事件派发给子控件对象。前面主要描述的是事件如何在ViewGroup中做派发，最终还是要有具体的View做处理操作，接着查看View的dispatchTouchEvent方法。

public boolean dispatchTouchEvent(MotionEvent event) {
    ...
    if (onFilterTouchEventForSecurity(event)) {
        // 如果enable==true
        if ((mViewFlags & ENABLED_MASK) == ENABLED && handleScrollBarDragging(event)) {
            result = true;
        }
        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是否为空，如果不为空就回调onTouch接口，返回值代表onTouch是否会消费掉当前的事件，如果返回值为true那么直接从dispatchTouchEvent返回不再做其他操作，如果返回false还会调用onTouchEvent方法来继续处理。

public boolean onTouchEvent(MotionEvent event) {
        final float x = event.getX();
        final float y = event.getY();
        final int viewFlags = mViewFlags;
        final int action = event.getAction();

        if ((viewFlags & ENABLED_MASK) == DISABLED) {
            if (action == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {
                setPressed(false);
            }
            return (((viewFlags & CLICKABLE) == CLICKABLE
                    || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
                    || (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE);
        }
        ...
}

首先判断当前的View是disable状态，如果是Button或者ImageButton类clickable为true的View，就会默认消费当前的触摸事件，否则需要判断当前View处于Enable状态如果View不是clickable或者longClickable状态直接默认不消费当前事件，如果是就按照如下的逻辑处理。

if (((viewFlags & CLICKABLE) == CLICKABLE ||
        (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE) ||
        (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE) {
    switch (action) {

        case MotionEvent.ACTION_DOWN:
            mHasPerformedLongPress = false;

            if (performButtonActionOnTouchDown(event)) {
                break;
            }

            boolean isInScrollingContainer = isInScrollingContainer();
            // 判断是否处于可滚动的容器布局内
            if (isInScrollingContainer) {
                mPrivateFlags |= PFLAG_PREPRESSED;
                if (mPendingCheckForTap == null) {
                    mPendingCheckForTap = new CheckForTap();
                }
                mPendingCheckForTap.x = event.getX();
                mPendingCheckForTap.y = event.getY();
                // 如果是就需要稍后再判断用户是点击还是滚动操作
                postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
            } else {
                // 如果不是在可滚动容器内直接设置按下状态
                setPressed(true, x, y);
                checkForLongClick(0, x, y);
            }
            break;


        case MotionEvent.ACTION_MOVE:
            drawableHotspotChanged(x, y);
            // 如果用户手指移动到了当前选中控件外部，取消对其长按事件监控
            if (!pointInView(x, y, mTouchSlop)) {
                // Outside button
                removeTapCallback();
                if ((mPrivateFlags & PFLAG_PRESSED) != 0) {
                    // Remove any future long press/tap checks
                    removeLongPressCallback();

                    setPressed(false);
                }
            }
            break;

        case MotionEvent.ACTION_UP:
            boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;
            // 在用户离开屏幕时，View在非滚动容器中处于按下状态或者在滚动容器中处于prepressed状态，也就是
            // 说用户没有滚动外部容器就离开了屏幕
            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();
                    if (!focusTaken) {
                        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)) {
                    mUnsetPressedState.run();
                }

                removeTapCallback();
            }
            mIgnoreNextUpEvent = false;
            break;


        case MotionEvent.ACTION_CANCEL:
            // 清空各种状态和检查回调
            setPressed(false);
            removeTapCallback();
            removeLongPressCallback();
            mInContextButtonPress = false;
            mHasPerformedLongPress = false;
            mIgnoreNextUpEvent = false;
            break;

    }
    return true;
}

从View的onTouchEvent回调中可以看出只有默认的可点击和可长按点击类型会在ACTION_DOWN时判断此次触摸是滚动还是点击事件，之后ACTION_MOVE阶段会更新View的展示状态，在ACTION_UP时如果确定用户是点击View直接执行performClick事件。

总结

ViewGroup在接受到ACTION_DOWN事件后首先调用onInterceptTouchEvent判断是否需要执行拦截，如果不拦截就会遍历自己的子控件将可见且未执行动画的并且处在事件发生位置的View作为试探对象派发ACTION_DOWN事件，如果该子View消费了当前ACTION_DOWN事件就记录下这个子View并且以后的ACTION_MOVE和ACTION_UP都会继续传递给它，在这些传递过程中ViewGroup还会不断调用onInterceptTouchEvent来检查自己是否需要拦截当前事件，如果不拦截这些事件都会传递给子View，子View内部会先判断设置的OnTouchListener是否消费当前事件，如果不消费才会直接调用onTouchEvent来判断是否触发OnClickListener和OnLongClickListener监听回调；
如果ViewGroup需要拦截事件就会将当前事件修改成ACTION_CANCEL发送给之前的子View，并且之后所有的事件都有ViewGroup来处理。