Android View事件分发源码分析

引言

　　上一篇文章我们介绍了View的事件分发机制，今天我们从源码的角度来学习下事件分发机制。

Activity对点击事件的分发过程

　　事件最先传递给当前Activity，由Activity的dispatchTouchEvent进行事件分发，具体的工作是有Activity内部的Window来完成的。Window会将事件传递给DecorView，DecorView一般就是当前界面的底层容器（即setContentView所设置的View的父容器）。下面我们来看一下Activity的dispatchTouchEvent方法的源码。源代码如下：

     /**
      * Called to process touch screen events.  You can override this to
      * intercept all touch screen events before they are dispatched to the
      * window.  Be sure to call this implementation for touch screen events
      * that should be handled normally.
      *
      * @param ev The touch screen event.
      *
      * @return boolean Return true if this event was consumed.
      */
     public boolean dispatchTouchEvent(MotionEvent ev) {
         if (ev.getAction() == MotionEvent.ACTION_DOWN) {
             onUserInteraction();
         }
         if (getWindow().superDispatchTouchEvent(ev)) {
             return true;
         }
         return onTouchEvent(ev);
     }

　　我们分析上面的源代码，事件首先交给Activity所属的Window进行分发，如果返回true,那么说明事件被子View拦截并且处理了。如果返回false说明事件没人处理，所有的View的onTouchEvent都返回false，那么这时候只有Activity的onTouchEvent会被调用了（还记得上一篇文章写的那些结论吗？看看第5条）。

　　那么Window是如何将事件传递给ViewGroup的呢？我们看源代码会知道，Window是一个抽象类，Window的superDispatchTouchEvent方法也是一个抽象方法，我们需要找到Window的实现类才行。Window的实现类是PhoneWindow类，我们来看PhoneWindow是如何处理点击事件的。代码如下：

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

　　看到这里，逻辑变得很清晰了，PhoneWindow将事件直接传递给DecorView，那DecorView又是什么呢？在上一篇文章中，我们聊到过，DecorView是顶层的View。我们接着方法往下看，我们看到如下代码：

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

　　DecorView事件分发也是要依靠父类方法的，DecorView继承自FrameLayout，而后者继承自ViewGroup。很显然DecorView的事件分发过程调用的是ViewGroup里面的方法。

ViewGroup对事件分发过程

　　上面的分析已经讲明，事件到达顶层View后会调用ViewGroup的dispatchTouchEvent方法进行分发。下面的逻辑要分两种情况来说：

　　第一种：如果ViewGroup的onInterceptTouchEvent方法返回true，表示ViewGroup需要拦截该事件，这个事件会由ViewGroup来进行处理。

　　第二种：如果ViewGroup的onInterceptTouchEvent方法返回false，表示ViewGroup不需要拦截该事件，这时候这个事件会传递给它所在的点击事件链上的子View，这时候子View的dispatchTouchEvent会被调用，这时候事件就有顶级View传递到了下一级的View。接下来的传递过程和上面的过程类似，如此往复，直到整个事件的分发。

　　下面我们来看下ViewGroup中事件分发代码的逻辑，先看第一段。

 // Check for interception.
 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;
 }

　　从上面的代码我们知道，ViewGroup在如下两种情况下会判断是否要拦截当前事件：事件类型为ACTION_DOWN或者mFirstTouchTarget!=null。那么什么情况下mFirstTouchTarget!=null这个条件成立呢？通过后面的代码逻辑我们知道，当ViewGroup不拦截事件，并将事件交给子View处理时，mFirstTouchTarget!=null这个条件就是成立的。反过来说，一旦事件由ViewGroup拦截并且自己来处理时，mFirstTouchTarget!=null就是不成立的，那么当ACTION_MOVE和ACTION_UP事件到来时，由于if (actionMasked == MotionEvent.ACTION_DOWN || mFirstTouchTarget != null)这个条件为false就导致ViewGroup的onInterceptTouchEvent方法不会被调用，并且同一事件序列中的其他事件都会默认交给他来处理。

　　这里还有一种特殊情况，就是FLAG_DISALLOW_INTERCEPT标记位，这个标记位是通过requestDisallowInterceptTouchEvent这个方法来设置的，一般用于子View中。FLAG_DISALLOW_INTERCEPT设置后，ViewGroup将无法拦截除ACTION_DOWN以外的其他点击事件。在进行事件分发时，如果是ACTION_DOWN事件，会重置这个标记位，这导致子View中设置的这个标记位无效，因此，当面对ACTION_DOWN事件时，ViewGroup总会调用自己的dispatchTouchEvent方法来询问自己是否要拦截事件。代码如下：

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

　　注意这段代码是在上面一个代码段之前的哦，去源码看就知道了。

　　下面我们来看ViewGroup不拦截事件的时候，事件会向下分发交给它子View进行处理，这段代码如下：

 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 = buildOrderedChildList();
     final boolean customOrder = preorderedList == null
             && isChildrenDrawingOrderEnabled();
     final View[] children = mChildren;
     for (int i = childrenCount - 1; i >= 0; i--) {
         final int childIndex = customOrder
                 ? getChildDrawingOrder(childrenCount, i) : i;
         final View child = (preorderedList == null)
                 ? children[childIndex] : preorderedList.get(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.
         if (childWithAccessibilityFocus != null) {
             if (childWithAccessibilityFocus != child) {
                 continue;
             }
             childWithAccessibilityFocus = null;
             i = childrenCount - 1;
         }
 
         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);
         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();
 }

　　这段代码逻辑是这样的，首先遍历ViewGroup的所有子元素，然后判断子元素时候能够接收到点击事件。能否接收到点击事件主要由两点来衡量：子元素是否在播放动画和点击事件的坐标是否落在子元素的区域内。如果某一个子元素满足这两个条件，那么事件就会传递给它。

　　我们看代码第44行，dispatchTransformedTouchEvent实际上调用的就是子元素的dispatchTouchEvent方法。后面会介绍child这个参数时候为null带来的影响。我们来看这段代码：

 if (child == null) {
     handled = super.dispatchTouchEvent(event);
 } else {
     handled = child.dispatchTouchEvent(event);
 }

　　从上面的代码我们看出来，如果child为null那么就直接调用View的dispatchTouchEvent方法，进行事件的处理。如果child!=null就调用child.dispatchTouchEvent方法进行下一轮的事件分发。如果子元素的dispatchTouchEvent方法返回true，那么mFirstTouchTarget会被赋值，并且跳出for循环（第60行代码），代码如下：

 newTouchTarget = addTouchTarget(child, idBitsToAssign);
 alreadyDispatchedToNewTouchTarget = true;
 break;

　　如果子元素的dispatchTouchEvent返回false，ViewGroup会把事件分发给下一个子元素进行处理（结合前两段代码）。

　　其实mFirstTouchTarget真正的赋值过程是在addTouchTarget方法内部完成的，mFirstTouchTarget是一种单链表结构，其是否被赋值，将直接影响到ViewGroup对事件的拦截策略，如果mFirstTouchTarget为null，那么ViewGroup就默认拦截接下来同一序列中的所有点击事件，这一点在前面已经介绍过。

　　如果遍历ViewGroup后事件都没有被合适的处理，那么这包含两种情况，第一种是ViewGroup没有子元素；第二种是子元素处理了点击事件，但是在dispatchTouchEvent中返回false，这一般是onTouchEvent方法返回false，在这两种情况下，ViewGroup会自己处理点击事件。看下面代码：

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

　　看到第三个参数传递的null了吗？上面我们分析过，会调用View的dispatchTouchEvent方法。这时候点击事件就交给View来处理了。

View对点击事件的处理

　　View对点击事件的处理稍微简单一些，注意这里的View不包括ViewGroup。我们来看它的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();
         }
 
         if (onFilterTouchEventForSecurity(event)) {
             //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;
             }
         }
 
         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（这里不包括ViewGroup）是一个单独的元素，它没有子元素因此无法向下传递事件，所以他只能自己处理事件。从上面的代码中，我们可以看出View对点击事件的处理过程，首先会判断有没有设置OnTouchListener。如果OnTouchListener中的onTouch方法返回true，那么onTouchEvent就不会被调用，可见OnTouchListener优先级是高于onTouchEvent的。

　　接下来我们来分析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处于不可用状态下时View照样会消耗点击事件。如果View设置有代理，那么还会执行TouchDelagate的onTouchEvent方法，这个onTouchEvent的工作机制应该和OnTouchListener类似。代码如下：

 if (mTouchDelegate != null) {
     if (mTouchDelegate.onTouchEvent(event)) {
         return true;
     }
 }

　　下面我们再来看一下onTouchEvent方法对点击事件的具体处理，代码如下：

 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);
             }
             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;
 }

　　我们从上面的代码中看到，只要View的CLICKABLE和LONG_CLICKABLE其中有一个true，就会消耗掉事件。即onTouchEvent方法true，不管是不是DISABLE状态。然后就是当ACTION_UP事件发生时，会触发performClick方法。如果View设置了OnClickListener，那么performClick方法内部会调用它的onClick方法。代码如下：

 /**
  * 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;
 }

　　最后再说一句，调用setOnClickListener和setOnLongClickListener可以改变View的CLICKABLE和LONG_CLICKABLE属性。

　　最后再说一句，下一篇文章通过一个简单的例子来介绍滑动冲突。(*^__^*)