Android 事件分发机制源码攻略（三） —— View篇

继上篇Android 事件分发机制源码攻略（二） —— ViewGroup篇的介绍后，我们知道事件如何从Activity的dispatchTouchEvent经由顶层ViewDecorView 再到ViewGroup的dispatchTouchEvent，ViewGroup层的分发，我个人觉得是整个事件分发最为关键的一部分，理解透了ViewGroup层的事件传递，相当于对整个事件分发传递也就差不多了。现在事件传递到View层，这一篇，我们将对分析事件在View层的dispatchTouchEvent、onTouchEvent、OnTouchListener、OnClickListener这些方法的传递顺序。首先，我们来看下dispatchTouchEvent这个方法。

  /**     * Pass the touch screen motion event down to the target view, or this     * view if it is the target.     *     * @param event The motion event to be dispatched.     * @return True if the event was handled by the view, false otherwise.     */    public boolean dispatchTouchEvent(MotionEvent event) {        // If the event should be handled by accessibility focus first.        if (event.isTargetAccessibilityFocus()) {        // We don't have focus or no virtual descendant has it, do not handle the event.            if (!isAccessibilityFocusedViewOrHost()) {                return false;            }            // We have focus and got the event, then use normal event dispatch.            event.setTargetAccessibilityFocus(false);        }        boolean result = false;        if (mInputEventConsistencyVerifier != null) {            mInputEventConsistencyVerifier.onTouchEvent(event, 0);        }        final int actionMasked = event.getActionMasked();        if (actionMasked == MotionEvent.ACTION_DOWN) {            // Defensive cleanup for new gesture            stopNestedScroll();        }        //跟ViewGroup层的一样，都是安全策略        if (onFilterTouchEventForSecurity(event)) {           //鼠标拖拉处理，不是分发的重点            if ((mViewFlags & ENABLED_MASK) == ENABLED && handleScrollBarDragging(event)) {                result = true;            }            //noinspection SimplifiableIfStatement            //内部类，包含各种触摸监听            ListenerInfo li = mListenerInfo;            //优先判断mOnTouchListener是否为空，为空的话就跳过，不为空的话，就走到onTouchEvent方法            if (li != null && li.mOnTouchListener != null                    && (mViewFlags & ENABLED_MASK) == ENABLED                    && li.mOnTouchListener.onTouch(this, event)) {                result = true;            }            //result为false的情况            if (!result && onTouchEvent(event)) {                result = true;            }        }        if (!result && mInputEventConsistencyVerifier != null) {            mInputEventConsistencyVerifier.onUnhandledEvent(event, 0);        }        // Clean up after nested scrolls if this is the end of a gesture;        // also cancel it if we tried an ACTION_DOWN but we didn't want the rest        // of the gesture.        if (actionMasked == MotionEvent.ACTION_UP ||                actionMasked == MotionEvent.ACTION_CANCEL ||                (actionMasked == MotionEvent.ACTION_DOWN && !result)) {            stopNestedScroll();        }        return result;    }

View的dispatchTouchEvent方法相对简单，没有复杂的逻辑。整个方法最为关键的地方是从第41行开始，先对OnTouchListener这个监听进行判断。
如果给这个View设置了OnTouchListener监听并且返回true，那result就直接为true了，这直接导致事件没有进到onTouchEvent方法就结束分发了。如果没有设置OnTouchListener监听，那就会进到onTouchEvent方法，然后View的dispatchTouchEvent方法到此也就结束了。接着，我们再来看看onTouchEvent()方法。

/**         * Implement this method to handle touch screen motion events.         * <p>         * If this method is used to detect click actions, it is recommended that         * the actions be performed by implementing and calling         * {@link #performClick()}. This will ensure consistent system behavior,         * including:         * <ul>         * <li>obeying click sound preferences         * <li>dispatching OnClickListener calls         * <li>handling {@link AccessibilityNodeInfo#ACTION_CLICK ACTION_CLICK} when         * accessibility features are enabled         * </ul>         *         * @param event The motion event.         * @return True if the event was handled, false otherwise.         */        public boolean onTouchEvent(MotionEvent event) {            final float x = event.getX();            final float y = event.getY();            final int viewFlags = mViewFlags;            final int action = event.getAction();            //如果View的状态是DISABLED，那返回值将由View可点击性（单点、长按等）决定            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);            }            if (mTouchDelegate != null) {                if (mTouchDelegate.onTouchEvent(event)) {                    return true;                }            }            //如果View是可点击的，返回true，即是事件默认消费了。否则返回false;            if (((viewFlags & CLICKABLE) == CLICKABLE ||                    (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE) ||                    (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE) {                switch (action) {                    case MotionEvent.ACTION_UP:                        //在ACTION_DOWN选项里会设置mPrivateFlags的状态                        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);                           }                            //如果这事件是从ACTION_DOWN开始，那mHasPerformedLongPress应该为false                            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();                            }                            // 取消View的Press状态                            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:                        //设置长按的触发位置标签为false                        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                            //设置View为Pressed,并触发长按事件                            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                        //移动的位置是否已经不在该View的范围内                        if (!pointInView(x, y, mTouchSlop)) {                            // Outside button                            //移除CheckForTap                            removeTapCallback();                            if ((mPrivateFlags & PFLAG_PRESSED) != 0) {                                // Remove any future long press/tap checks                                // 移除长按任务                                removeLongPressCallback();                                // 取消View的Press状态                                   setPressed(false);                            }                        }                        break;                }                return true;            }            return false;        }

哇，初看这个方法很长，以为很麻烦。其实里面很简单，依旧是没什么麻烦的逻辑的。以上方法可以总结成以下两点

1、如果View是可点击、可长按的，则返回true；否则返回false;

2、如果View是可点击、可长按的，优先触发performLongClick()长按事件，当抬起来时，触发onClick()事件（前提是你设置了OnClickListener监听）。

整个方法的话，除了上面说的前提外，剩下的要点就是分析在ACTION_DOWN、ACTION_MOVE、ACTION_UP所做的处理了。首先来看下ACTION_DOWN里面做了那些操作。

看到第110行有这么个方法isInScrollingContainer，我们进去看看是做了什么。

      /**         * @hide 隐藏的方法         */        public boolean isInScrollingContainer() {            ViewParent p = getParent();            while (p != null && p instanceof ViewGroup) {                if (((ViewGroup) p).shouldDelayChildPressedState()) {                    return true;                }                p = p.getParent();            }            return false;        }

这个方法是调用其父布局的shouldDelayChildPressedState方法，那再去看看这个方法做了什么

    /**         * Return true if the pressed state should be delayed for children or descendants of this         * ViewGroup. Generally, this should be done for containers that can scroll, such as a List.         * This prevents the pressed state from appearing when the user is actually trying to scroll         * the content.         *         * The default implementation returns true for compatibility reasons. Subclasses that do         * not scroll should generally override this method and return false.         */        public boolean shouldDelayChildPressedState() {            return true;        }

这个注释大概的意思是父布局如果是可滑动的，应该返回true；否则，返回False；这个不属于我们这次讨论的问题，有兴趣的同学可以自行深入探究。

接着我们再看上面的第117行-124行，这几句代码的主要的用途是延迟执行CheckForTap这个任务，我们再看看这个CheckForTap做了那些操作。

     private final class CheckForTap implements Runnable {            public float x;            public float y;            @Override            public void run() {                //更改flag                mPrivateFlags &= ~PFLAG_PREPRESSED;                //设置pressed为true                setPressed(true, x, y);                //检查并执行长按                checkForLongClick(ViewConfiguration.getTapTimeout(), x, y);            }        }

这是一个实现Runnable接口的类，后面我们会看到很多的执行操作都是实现Runnable接口；这块代码跟128处的代码差不多，也就是说，两者的区别在于是否延迟执行后续任务了。好了，我们再来看看checkForLongClick这个方法做了什么。

     private void checkForLongClick(int delayOffset, float x, float y) {            //该View是否可以长按            if ((mViewFlags & LONG_CLICKABLE) == LONG_CLICKABLE) {                mHasPerformedLongPress = false;                if (mPendingCheckForLongPress == null) {                    //实例长按任务                    mPendingCheckForLongPress = new CheckForLongPress();                }                //设置锚点                mPendingCheckForLongPress.setAnchor(x, y);                //修改WindowAttachCount                mPendingCheckForLongPress.rememberWindowAttachCount();                //延迟执行长按任务                postDelayed(mPendingCheckForLongPress,                        ViewConfiguration.getLongPressTimeout() - delayOffset);            }        }

这个方法很简单，先是判断这个View是否可以长按，为true的话，将当前位置设置下去，并修改相应的View所关联的window数量。紧接着延迟执行长按任务。

     private final class CheckForLongPress implements Runnable {            private int mOriginalWindowAttachCount;            private float mX;            private float mY;            @Override            public void run() {              //pressed为true并且父布局不为空                if (isPressed() && (mParent != null)                        //基本上有调用rememberWindowAttachCount这个方法基本是相等的                        && mOriginalWindowAttachCount == mWindowAttachCount) {                    if (performLongClick(mX, mY)) {                        mHasPerformedLongPress = true;                    }                }            }            public void setAnchor(float x, float y) {                mX = x;                mY = y;            }            public void rememberWindowAttachCount() {                mOriginalWindowAttachCount = mWindowAttachCount;            }        }        /**         * Calls this view's OnLongClickListener, if it is defined. Invokes the         * context menu if the OnLongClickListener did not consume the event,         * anchoring it to an (x,y) coordinate.         *         * @param x x coordinate of the anchoring touch event, or {@link Float#NaN}         *          to disable anchoring         * @param y y coordinate of the anchoring touch event, or {@link Float#NaN}         *          to disable anchoring         * @return {@code true} if one of the above receivers consumed the event,         *         {@code false} otherwise         */        public boolean performLongClick(float x, float y) {            mLongClickX = x;            mLongClickY = y;            final boolean handled = performLongClick();            mLongClickX = Float.NaN;            mLongClickY = Float.NaN;            return handled;        }    /**         * Calls this view's OnLongClickListener, if it is defined. Invokes the         * context menu if the OnLongClickListener did not consume the event.         *         * @return {@code true} if one of the above receivers consumed the event,         *         {@code false} otherwise         */        public boolean performLongClick() {            return performLongClickInternal(mLongClickX, mLongClickY);        }       /**         * Calls this view's OnLongClickListener, if it is defined. Invokes the         * context menu if the OnLongClickListener did not consume the event,         * optionally anchoring it to an (x,y) coordinate.         *         * @param x x coordinate of the anchoring touch event, or {@link Float#NaN}         *          to disable anchoring         * @param y y coordinate of the anchoring touch event, or {@link Float#NaN}         *          to disable anchoring         * @return {@code true} if one of the above receivers consumed the event,         *         {@code false} otherwise         */        private boolean performLongClickInternal(float x, float y) {            sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_LONG_CLICKED);            boolean handled = false;            final ListenerInfo li = mListenerInfo;            //触发长按监听事件            if (li != null && li.mOnLongClickListener != null) {                handled = li.mOnLongClickListener.onLongClick(View.this);            }            if (!handled) {                final boolean isAnchored = !Float.isNaN(x) && !Float.isNaN(y);                handled = isAnchored ? showContextMenu(x, y) : showContextMenu();            }            if (handled) {                performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);            }            return handled;        }

上面的代码没有太多的逻辑，最终的实现是最后面这一块。从最后这里可以看出，View的onTouchEvent事件处理首个ACTION_DOWN事件，优先响应的是长按监听（如果你有设置的话），如果该布局是可滑动的（比如listView这类），会有相应的延迟。好了，到这里ACTION_DOWN的事件到此就结束了。接着，我们来看下ACTION_MOVE事件的处理流程。

从上面的代码的第145-157行，观察注释就基本了解了。在View的范围内，基本不处理。那我们再来看看ACTION_UP做了哪些处理。

我们可以直接看第74行PerformClick，其他的代码基本上都是一些简单的判断，主要的就是PerformClick这个类。

private final class PerformClick implements Runnable {            @Override            public void run() {                performClick();            }        }        /**         * Call this view's OnClickListener, if it is defined.  Performs all normal         * actions associated with clicking: reporting accessibility event, playing         * a sound, etc.         *         * @return True there was an assigned OnClickListener that was called, false         *         otherwise is returned.         */        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;        }

看到这里我们知道，ACTION_UP事件最终会走到OnClickListener这个监听去。自此我们可以得出当首个ACTION_DOWN事件下来，在View的这一层首先是

OnTouchListener->onTouchEvent->OnLongClickListener->OnClickListener。

我们来做对View层的事件分发做个小结。

至此，View事件分发就到此结束了。