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

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完整的分发机制，然后，看懂上面的代码，回过头再看这图片，是不是非常简单了呢？祝各位进步！