事件分发机制源码分析

上一篇讲解了事件分发机制的基本流程，如果还有对基本流程都不熟悉的童鞋请先参考一下这篇文章，点我查看

下面我们就对事件分发机制的源码做一个简单的了解

Activity对点击事件的分发过程

点击事件用MotionEvent来表示，当一个点击操作发生时，事件最先传递给Activity，由Activity的dispatchTouchEvent来进行分发。我们就先从Activity的dispatchTouchEvent开发分析↓

public boolean dispatchTouchEvent(MotionEvent ev) {
        if (ev.getAction() == MotionEvent.ACTION_DOWN) {
            onUserInteraction();
        }
        if (getWindow().superDispatchTouchEvent(ev)) {
            return true;
        }
        return onTouchEvent(ev);
    }

从上面的代码可以看出，先用getWindow方法获取到了Activity所附属的Window，然后调用superDispatchTouchEvent进行分发，如果返回true，那么整个事件就结束了，返回false，就表示这个事件没有人处理，所有View的onTouchEvent都返回了false，事件就会交由Activity的onTouchEvent处理。


我们再来看看Window的superDispatchTouchEvent是如何实现的?通过源码我们发现Window是一个抽象类，superDispatchTouchEvent也是一个抽象方法，因此我们就只有找到Window的实现类才能分析。在Window类的说明中，有这么一段话↓

/**
 * Abstract base class for a top-level window look and behavior policy.  An
 * instance of this class should be used as the top-level view added to the
 * window manager. It provides standard UI policies such as a background, title
 * area, default key processing, etc.
 *
 * <p>The only existing implementation of this abstract class is
 * android.policy.PhoneWindow, which you should instantiate when needing a
 * Window.  Eventually that class will be refactored and a factory method
 * added for creating Window instances without knowing about a particular
 * implementation.
 */

 通过这段说明，我们知道Window的实现类为PhoneWindow，接下来就找到PhoneWindow的superDispatchTouchEvent是如何处理的
 public boolean superDispatchTouchEvent（MotionEvent ev）{
        return mDecor.superDispatchTouchEvent(ev);
 }
 PhoneWindow中直接将事件传递给了DecorView,那么DecorView又是什么呢?

 private final class DecorView extends FrameLayout implements RootViewSurfaceTaker{
        private DecorView mDecor;
        @Override
        public final View getDecorView(){
            if(mDecor == null){
                instanllDecor();
            }
            return mDecor;
        }
 }

 ((ViewGroup)getWindow().getDecorView().findViewById(android.R.id.content)).getChildAt(0);我们可以通过这种方式获取Activity所设置的View,这个mDecor就是

getWindow().getDecorView()获取到的View,我们通过setContentView设置的View就是它的子一个子元素。事件传递到这里的时候

 就已经传递到了我们的顶级View了，顶级View一般来说都是ViewGroup。

顶级View对点击事件的分发过程

首先我们来看下ViewGroup对点击事件的分发过程，主要实现就在dispatchTouchEvent中,因为这个方法实现比较长，我们就分段来分析好了，先看一下下面这一段↓

  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。ACTION_DOWN很好理解，那么mFirstTouchTarget != null是什么

呢？当事件由ViewGroup的子元素成功处理时，mFirstTouchTarget 会被赋值并指向子元素，意思就是说，当ViewGroup不拦截事件

并将事件交由子元素处理时mFirstTouchTarget != null。那么当ACTION_MOVE和ACTION_UP事件到来时，由于(actionMasked == MotionEvent.ACTION_DOWN|| 

mFirstTouchTarget != null)为false，就会导致ViewGroup的onInterceptTouchEvent不会再被调用，并且同一序列中的其他事件都会默认交给他处理。

下面我们再来看ViewGroup不拦截事件，事件向下分发交由它的子元素处理是如何实现的？请看下面的源码↓

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 (!canViewReceivePointerEvents(child)
                                    || !isTransformedTouchPointInView(x, y, child, null)) {
                                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;
                            }
                        }

首先遍历ViewGroup的子元素，然后判断子元素是否可以接收点击事件。是否能够接收点击事件主要由两点来衡量：子元素是否在播放动画和点击事件的坐标是否落在子元素的

区域内。如果某个子元素满足这个条件，就会把事件传递给他处理。dispatchTransformedTouchEvent方法实际上调用的就是子元素的

dispatchTouchEvent方法，关键代码如下↓

private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
            View child, int desiredPointerIdBits) {
    ...
  if (child == null) {
                    handled = super.dispatchTouchEvent(event);
                } else {
                    final float offsetX = mScrollX - child.mLeft;
                    final float offsetY = mScrollY - child.mTop;
                    event.offsetLocation(offsetX, offsetY);


                    handled = child.dispatchTouchEvent(event);


                    event.offsetLocation(-offsetX, -offsetY);
                }
   ...              
｝

如果子元素的dispatchTouchEvent返回了true，则会调用addTouchTarget方法对mFirstTouchTarget赋值并跳出for循环，

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

从代码中可以看出，mFirstTouchTarget其实是一种单链表结构，mFirstTouchTarget是否被赋值，将直接影响到ViewGroup对事件的拦截策略，如果mFirstTouchTarget为null，

那么ViewGroup就默认拦截接下来同一序列中所有的点击事件。

如果遍历所有的子元素后事件都没有被处理，这包含两种情况：第一种是ViewGroup没有子元素；第二种是子元素处理了点击事件，但是在dispatchTouchEvent中返回了

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

可以看到，在调用dispatchTransformedTouchEvent方法的时候第三个参数传的null，通过上面分析的dispatchTransformedTouchEvent方法知道，它会调用

super.dispatchTouchEvent，这里就赚到了View的dispatchTouchEvent方法，即点击事件开始交由View来处理。

View对点击事件的处理过程

View对点击事件的处理就比较简单，这里的View是不包含ViewGroup的。先看一下它的dispatchTouchEvent方法，如下↓
 

public boolean dispatchTouchEvent(MotionEvent event) {
        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对点击事件的处理过程，首先会判断有没有设置onTouchListener，如果onTouchListener中的onTouch返回了true，那么onTouchEvent就不会被调用。

下面在来看一下onTouchEvent中对点击事件的处理，如下↓
      

public boolean onTouchEvent(MotionEvent event) {
            final float x = event.getX();
            final float y = event.getY();
            final int viewFlags = mViewFlags;
    
            if ((viewFlags & ENABLED_MASK) == DISABLED) {
                if (event.getAction() == 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));
            }
    
            if (mTouchDelegate != null) {
                if (mTouchDelegate.onTouchEvent(event)) {
                    return true;
                }
            }
    
            if (((viewFlags & CLICKABLE) == CLICKABLE ||
                    (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)) {
                switch (event.getAction()) {
                    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) {
                                // 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();
                        }
                        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();
                        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;
        }

        

只要View的CLICKABLE和LONG_CLICKABLE有一个为true，那么它就会消耗这个事件，即onTouchEvent返回true。当ACTION_UP事件发生时，会触发performClick方法，

如果View设置了onClickListener，那么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;
        }

        

  好了，到这里其实整个事件分发的流程就差不多，上面的代码分析主要是分析了一下事件分发的流程，也有很多地方其实小弟也不是很明白。希望大家多多交流。