Android源码分析–View的事件分发机制

网上关于View的事件分发机制的文章有很多，所以这次更博呢，更重要的目的是让自己重新温习一遍View的分发机制，通过文字的描述，希望自己能讲透讲明白这个过程，从头到尾从源码层面去剖析内部原理。

看了本文你能学到什么？

• View事件的分发流程；
• View事件分发过程中，源码级的分析

---

View事件的分发流程

首先我们来看一张图片，大体上了解下这整一个过程

从上图我们可以看到，最先拿到View事件的是Activity，Activity可以先下分发，也可以自己消费，向下分发这个过程，下面我们会通过源码来分析，我们主要先看下大体的一个流程。可以发现，Activity、ViewGroup、View三者都能消费事件，事件消费既在onTouchEvent中返回true。如果View和ViewGroup都不消费这个事件，最终事件会交还给Activity，由它来消费。当然，ViewGroup中还可以拦截事件，不向下继续传递。这一part先到这里，看不太不明白没关系其实，下面我们将从源码层面去一步步跟踪分析这一个过程。

---

View事件分发过程中，源码级的分析

首先，我们先得了解事件分发过程中，非常重要的三个方法：

public boolean dispatchTouchEvent(MotionEvent ev); //用来分发事件
public boolean onInterceptTouchEvent(MotionEvent ev); //用来拦截事件
public boolean onTouchEvent(MotionEvent ev); //用来处理事件

这三个方法，在事件分发过程中，起了非常重要的作用，需要注意的是，onInterceptTouchEvent是ViewGroup才有的方法。我们先要有一个大体的了解，上面我们说了，首先获得事件的是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)，这句话是调用了Window的superDispatchTouchEvent(ev)方法，事件就交给了Window，但是，问题来了，假如对源码有一定了解的话，Window是一个抽象类，该方法是空方法，那么，我们就得着Window的实现类，我们知道，Android中，PhoneWindow是Window的唯一实现类，所以，我们在PhoneWindow中查看superDispatchTouchEvent(ev)的具体实现：

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

哈哈，坑爹了吧，这里直接return的是mDecor的superDispatchTouchEvent(ev)返回值，那么，事件就传递到了mDecor上面了。什么是mDecor呢，这是PhoneWindow中的一个成员变量，是DecorView的一个对象，我们回忆一下，我们在Activity的onCreate方法里面有这一句：setContentView（view），这个View我们可以通过getWindow().getDecorView().findViewById(R.id.content)得到View的父控件，这的返回值其实是FrameLayout，我们把返回值强转为ViewGroup之后调用getChildAt(0),得到的就是setContentView中我们设置的View。
刚刚说到现在事件由PhoneWindow传递到了DecorView上面，而DecorView是继承自FrameLayout的，所以，到这一步，实际上事件就已经传递给View了。我们接下来看下DecorView中的superDispatchTouchEvent(event)方法：

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

可以看到，还是没有具体的处理case，继续往前看，刚刚说到DecorView是继承自FrameLayout的，FrameLayout是没有实现dispatchTouchEvent方法的，而FrameLayout有是继承自ViewGroup的，所以 我们可以直接看ViewGroup中的dispatchTouchEvent方法,由于这个方法实现过长，我们分开看

// Handle an initial down.//如果是down事件的话，设置的请求不拦截的FLAG_DISALLOW_INTERCEPT标记将被清空，//这个标记位是在requestDisallowInterCeptTouchEvent方法中//设置的。换句话表达，就是ViewGroup将无法拦截设置了//FLAG_DISALLOW_INTERCEPT标记的move和up事件。//下面的代码，如果是down事件，将重置标记位，所以如果down事件//设置了FLAG_DISALLOW_INTERCEPT标记，其实也是没用的，//依然会判断是否拦截。这点需要非常清楚，后续的事件冲突处理需要灵活运用。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();            }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;            }

//设置标记位 public void requestDisallowInterceptTouchEvent(boolean disallowIntercept) {        if (disallowIntercept == ((mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0)) {            // We're already in this state, assume our ancestors are too            return;        }        if (disallowIntercept) {            mGroupFlags |= FLAG_DISALLOW_INTERCEPT;        } else {            mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;        }        // Pass it up to our parent        if (mParent != null) {            mParent.requestDisallowInterceptTouchEvent(disallowIntercept);        }    }

上面的代码是关于拦截事件的判断，我们可以看到，条件是down事件或者mFirstTouchTarget不为空时，才可能拦截，也就是说，当事件是move或者up时，mFirstTouchTarget不为空才能进入这个if分支。那么mFirstTouchTarget是什么呢？看到这里我也不明白，咱暂且先放下。继续往下看

// Check for cancelation.            final boolean canceled = resetCancelNextUpFlag(this)                    || actionMasked == MotionEvent.ACTION_CANCEL;            // 是否需要拆分MotionEvent动作，默认为拆分            final boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0;            TouchTarget newTouchTarget = null;            boolean alreadyDispatchedToNewTouchTarget = false;            //MotionEvent没有被取消并且没有被拦截时进入分支            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;                //当前事件的down，或者接下来手指的down，这里需要明白//一个事情，MotionEvent.ACTION_DOWN是指出发当前MotionEvent事件的触点的down事件，//MotionEvent.ACTION_POINTER_DOWN是指有另外的触点触发的down事件，//这里其实是一个多点触控的逻辑，以下，大致理解为找出触发当前一系列MotionEvent的触点，//然后获取事件相当于父控件的X,Y坐标。                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.                    //清除触点信息，只留下动作信息，一个MotionEvent是由Action和Pointer组成的                    //一个16位值，前8位表示触点信息，后八位表示动作信息。                    removePointersFromTouchTargets(idBitsToAssign);                    final int childrenCount = mChildrenCount;                    if (newTouchTarget == null && childrenCount != 0) {                        //子View根据动作索引去获取当前触点的相当于父控件(其实就是当前这个ViewGroup)X,Y坐标                        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;                        //遍历所有子View                        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.                            //子View是否能获取焦点                            if (childWithAccessibilityFocus != null) {                                if (childWithAccessibilityFocus != child) {                                    continue;                                }                                childWithAccessibilityFocus = null;                                i = childrenCount - 1;                            }                            //子View是否能接受事件，坐标是否在当前控件范围内                            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);                            //dispatchTransformedTouchEvent实际调用的是子View（child）的dispatchTouchEvent方法。                            //实际上就是事件传递给子View的一个过程。如果子View的dispatchTouchEvent返回true，                            //mFristTouchEvent会被赋值，并且终止循环，如果返回false，那么循环继续，直至没有子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();                                //mFristTouchEvent就是在下面这个方法被赋值的。                                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();                    }                    ...                }            }

上面可以看到，当TouchEvent被传递给child时，mFristTouchEvent会被赋值。

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

可以看到 其实TouchTarget是一种单链表的结构，mFirstTouchTarget是否被赋值，将影响到ViewGroup的拦截case，那么，我们需要回过头再去想想我们放下没有解决的问题，mFirstTouchTarget在事件分发给子View之后会被赋值，就意味着，onInterCeptTouchEvent这个方法的调用时机实际上是如果ViewGroup拦截了当前的down事件的话，那么mFristTouchEvent必然为null，onInterCeptTouchEvent这个方法不会被调用，而是由它直接处理。

所以我们得出以下结论：

如果ViewGroup拦截了TouchEvent事件，那么，move和up事件也必然交由它处理，不再分发。

接下来我们继续往下看，如果mFristTouchEvent为空时如何处理的：

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

上面调用了dispatchTransformedTouchEvent方法，注意，这里是第二次调用这个方法了，第一次是在ViewGroup分发事件给子View时，child传递是的非空的，第二次是上面，我们可以看到 ，这里的第三个参数传递的是null，我们跟踪下，只看它关键部分的代码：

if (cancel || oldAction == MotionEvent.ACTION_CANCEL) {            event.setAction(MotionEvent.ACTION_CANCEL);            //child为空，事件交到View的dispatchTouchEvent处理            if (child == null) {                handled = super.dispatchTouchEvent(event);            } else {//子View处理                handled = child.dispatchTouchEvent(event);            }            event.setAction(oldAction);            return handled;        }

接下来看下View的dispatchTouchEvent的实现：

public boolean dispatchTouchEvent(MotionEvent event) {        ...        boolean result = false;        ...        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没有子View，这里的实现也比较简单，我把主要的代码贴出来了，从上面的代码可以看出，只要一个View设置了OnTouchListener，那么，将执行的是onTouch方法,通过onTouch返回true，事件到此为止消耗完毕，如何OnTouchListener为null，那么将执行View的onTouchEvent方法，执行完毕如果返回true，事件消费完毕。可以这么理解，OnTouchListener的优先级是高于onTouchEvent的。

接下来我们看下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);        }        //如果View设置有代理，将执行TouchDelegate中的onTouchEvent方法        if (mTouchDelegate != null) {            if (mTouchDelegate.onTouchEvent(event)) {                return true;            }        }

上面的代码，我们可以得出一个结论

一个View的状态即使是disable的状态下，照样是能消费点击事件的。

//只要View的CLICKABLE、LONG_CLICKABLE或者CONTEXT_CLICKABLE有一个为true，那么就会消费这个事件 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;                case MotionEvent.ACTION_DOWN:                    mHasPerformedLongPress = false;                    if (performButtonActionOnTouchDown(event)) {                        break;                    }                    // Walk up the hierarchy to determine if we're inside a scrolling container.                    boolean isInScrollingContainer = isInScrollingContainer();                    // For views inside a scrolling container, delay the pressed feedback for                    // a short period in case this is a scroll.                    if (isInScrollingContainer) {                        mPrivateFlags |= PFLAG_PREPRESSED;                        if (mPendingCheckForTap == null) {                            mPendingCheckForTap = new CheckForTap();                        }                        mPendingCheckForTap.x = event.getX();                        mPendingCheckForTap.y = event.getY();                        postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());                    } else {                        // Not inside a scrolling container, so show the feedback right away                        setPressed(true, x, y);                        checkForLongClick(0, x, y);                    }                    break;                case MotionEvent.ACTION_CANCEL:                    setPressed(false);                    removeTapCallback();                    removeLongPressCallback();                    mInContextButtonPress = false;                    mHasPerformedLongPress = false;                    mIgnoreNextUpEvent = false;                    break;                case MotionEvent.ACTION_MOVE:                    drawableHotspotChanged(x, y);                    // Be lenient about moving outside of buttons                    if (!pointInView(x, y, mTouchSlop)) {                        // Outside button                        removeTapCallback();                        if ((mPrivateFlags & PFLAG_PRESSED) != 0) {                            // Remove any future long press/tap checks                            removeLongPressCallback();                            setPressed(false);                        }                    }                    break;            }            return true;        }        return false;    }

up事件发生时，会触发调用performClick()方法，如果View设置了clickListener，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;    }

以上，就是一个TouchEvent完整的分发机制，然后，看懂上面的代码，回过头再看这图片，是不是非常简单了呢？祝各位进步！