View机制深入学习（四）View的事件分发机制

当发生点击事件后，事件会最先传递给当前的Activity，Activity调用dispatchTouchEvent来进行事件的dispatch;

事件的分发方式可以简明清晰地概括为下图所示：

通过dispatchTouchEvent进行分发，ViewGroup中会有onInterceptTouchEvent判断是否进行拦截；

如果onInterceptTouchEvent返回fasle，则不进行拦截，继续调用子View的dispatchTouchEvent进行分发；如果返回true,则直接调用其自身（因为ViewGroup是继承View的，故会调用View的）onTouchEvent来处理该Touch Event；

使用onTouchEvent处理事件时，如果返回false,则该层View并不消费该事件，而是会将该Event继续往上传递；直到有一层View的onTouchEvent的返回值为true时，该层View消耗该事件，该事件不再往上层View传递；使用View事件分发机制可以很好地处理滑动冲突等问题。

1、Activity#dispatchTouchEvent：

/** \frameworks\base\core\java\android\app\Activity.java **/public boolean dispatchTouchEvent(MotionEvent ev) {    if (ev.getAction() == MotionEvent.ACTION_DOWN) {        onUserInteraction();    }    if (getWindow().superDispatchTouchEvent(ev)) {        return true;    }    return onTouchEvent(ev);}

    代码很简单，当是ACTION_DOWN事件时，会先调用onUserInteraction方法，该方法其实就是个Activity的空函数，可以在定义Activity继承时进行Override，完成一些ACTION_DOWN事件分发前的处理工作；

/** \frameworks\base\core\java\android\app\Activity.java **/public void onUserInteraction() {}

    可以看到重写onUserInteraction方法并不会对MotionEvent的派发产生影响，但是每一个对ACTION_DOWN事件的派发都会调用onUserInteraction方法。

    接下来进而调用getWindow().superDispatchTouchEvent(ev)来派发事件，可以看到如果该方法返回true，系统将不会调用Activity中的onTouchEvent函数；

    由 Android View机制深入学习（一）知getWindow()实质上返回的是PhoneWindow类，则继续调用的是：

2、PhoneWindow#superDispatchTouchEvent:

/** \frameworks\base\policy\src\com\android\internal\policy\impl\PhoneWindow.java**/private DecorView mDecor;@Overridepublic boolean superDispatchTouchEvent(MotionEvent event) {    return mDecor.superDispatchTouchEvent(event);}

    PhoneWindow继续将事件传递给内部的DecorView;

/** \frameworks\base\policy\src\com\android\internal\policy\impl\PhoneWindow.java**/private final class DecorView extends FrameLayout implements RootViewSurfaceTaker {    public boolean superDispatchTouchEvent(MotionEvent event) {        return super.dispatchTouchEvent(event);    }}

    DecorView是PhoneWindow的子类，其会进一步调用super.dispatchTouchEvent(event),DecorView继承FrameLayout,FrameLayout中并未实现dispatchTouchEvent方法；FameLayout继承ViewGroup，则继续调用ViewGroup的dispatchTouchEvent方法；即事件从Activity传到Window进而传递到ViewGroup中；DecorView是顶层ViewGroup，可想而知，接下来的dispatch会根据View树进行逐级派发事件。

3、ViewGroup#dispatchTouchEvent:(代码较长，分段阅读如下)：

1）处理ACTION_DOWN事件：

final int action = ev.getAction();final int actionMasked = action & MotionEvent.ACTION_MASK;// 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();}

    ACTION_DOWN操作可以看做一个完整事件流程的起点，故在该系列动作开始时，会清理之前设置过状态，其中cancelAndClearTouchTargets会将下面将会看到的mFirstTouchTarget变量置为null；

2）判断是否对事件进行拦截：

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

     可以看到不拦截情况包括有ACTION_DOWN事件，或者mFirstTouchTarget不为null;

// First touch target in the linked list of touch targets.private TouchTarget mFirstTouchTarget;private static final class TouchTarget {    ......    // The next target in the target list.    public TouchTarget next;    private TouchTarget() {    }    ......}

    mFirstTouchTarget是TouchTarget对象，可以看到其其实最终形式一个链表。每一个ViewGroup中都包含一个 mFirstTouchTarget对象，其指向处理TouchEvent事件的下一个View，即该ViewGroup的子元素A如果成功处理了该TouchEvent事件，就会将mFirstTouchTarget指向A；

    其实容易理解，这些都是针对于一个完整系列的操作事件而设计的；该事件以ACTION_DOWN事件为开端，当当前事件为ACTION_DOWN时，表示又是一个新的操作，所以将所有配置全部重置，尤其是将mFirstTouchTarget置为null；此时不用管mFirstTouchTarget，因为是ACTION_DOWN事件会就直接跳入到判断是否拦截的代码中。

    而在接下来会看到，mFirstTouchTarget将会赋值，如果发生了拦截，mFirstTouchTarget将会置为null，否则将指向下一个将要传递事件的子View；当系列操作中ACTION_MOVE或者ACTION_UP事件派发时，如果已经之前事件分发时已经发生了拦截，此时mFirstTouchTarget==null也就是mFirstTouchTarget！=null条件不成立，则会直接建立拦截，无需再次调用onInterceptTouchEvent；

    所以有结论：若某个View一旦发生拦截，那么这一个事件序列都只能由它来处理，并且它的onInterceptTouchEvent方法将不再会调用。

    同时注意这里有一个标记位FLAG_DISALLOW_INTERCEPT,由字面意思就可以看出，设置它就可以使得拦截无效（从代码中可以看出，因为会直接跳到intercepted为false，即不拦截的情况。但注意，由于ACTION_DOWN的特殊性，其表示一个序列事件的起点，会对所有状态，包括FLAG_DISALLOW_INTERCEPT标志位进行重置无效化，所以设置FLAG_DISALLOW_INTERCEPT并不能拦截ACTION_DOWN事件，ACTION_DOWN事件的拦截只能发生在onInterceptTouchEvent的处理逻辑中。

    假设在该层ViewGroup并不发生拦截，即intercepted为false，ViewGroup会将事件分发给它的子View进行处理：

3）当未发生拦截，分发事件给子View：

if (actionMasked == MotionEvent.ACTION_DOWN|| (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)        || actionMasked == MotionEvent.ACTION_HOVER_MOVE){    .....    final int childrenCount = mChildrenCount; // 获取子对象    if (newTouchTarget == null && childrenCount != 0) {        final float x = ev.getX(actionIndex);        final float y = ev.getY(actionIndex);        .....        final View[] children = mChildren;        // 遍历子View        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)) {                ev.setTargetAccessibilityFocus(false);                continue;            }            newTouchTarget = getTouchTarget(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();    }}

    上面主要是对事件向子View转发的处理；系统如果采用将事件全部转发，也就是广播给所有子View，然后在子View中去判断自己是否应当处理该event，这样效率显然是相当低的。因此系统采取的做法是先进行判断，遍历所有子View，判断适合接收该event的子View，然后将该事件传递给它。上面的代码中完成就是这样的问题。

    主要涉及到的函数为canViewReceivePointerEvents和isTransformedTouchPointInView，可以看到如果两个判断均通过的话，该child即是所要寻找的结果，会调用dispatchTransformedTouchEvent方法将事件传递给它；

   I) canViewReceivePointerEvents方法是判断该View是否能够该收该event,源码如下：

private static boolean canViewReceivePointerEvents(View child) {    return (child.mViewFlags & VISIBILITY_MASK) == VISIBLE            || child.getAnimation() != null;}

    可以看到当child的状态为VISIBLE状态，或者child当前在播放动画时，此时该View是可以接受该event的；

    II)isTransformedTouchPointInView方法是判断点击事件的坐标是否在child的区域范围内：

protected boolean isTransformedTouchPointInView(float x, float y, View child,        PointF outLocalPoint) {    final float[] point = getTempPoint();    point[0] = x;    point[1] = y;    transformPointToViewLocal(point, child);    final boolean isInView = child.pointInView(point[0], point[1]);    if (isInView && outLocalPoint != null) {        outLocalPoint.set(point[0], point[1]);    }    return isInView;}

   III)当两个条件都满足，即调用dispatchTransformedTouchEvent方法将事件传递给child:

private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,                                              View child, int desiredPointerIdBits) {    final boolean handled;    ....    // Perform any necessary transformations and dispatch.    if (child == null) {        handled = super.dispatchTouchEvent(transformedEvent);    } else {        ......        handled = child.dispatchTouchEvent(transformedEvent);    }    return handled;}

    如果child为null，表示无子View或者改事件点击范围内没有满足条件的子View，则调用ViewGroup的父类View中的dispatchTouchEvent函数来处理event；否则，调用child的方法继续下一轮事件派发；

    IV)在dispatchTransformedTouchEvent函数结果值为true的情况下，会继续往下执行，执行的主要代码如下：    

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

    即如果child子元素的dispatchTouchEvent返回结果为true时，会执行addTouchTarget,

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

 这里完成对mFirstTouchTarget的初始化。

4、View对事件的处理过程：

由前面可以看到，当发生拦截或者事件分发到最底层的View时，事件会交给View的dispatchTouchEvent方法进行处理；

View#dispatchTouchEvent:

public boolean dispatchTouchEvent(MotionEvent event) {    ....    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;        }    }    ......}

    这里是对Touch事件处理的主要逻辑，由View机制深入学习（三） View中的消息传递及InputManagerService 知ListenerInfo是对View注册的一系列Listener的管理者，比如OnClickListener;这里和上文中的逻辑相同，若是View注册了onTouchListener,则先调用onTouchListener的onTouch方法处理事件，若onTouch方法返回true，则拦截事件，不再继续向下处理；若onTouch返回false，则会继续调用View中的onTouchEvent方法处理事件。

View#onTouchEvent：

I、状态为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);}

     可以看到当View为DISABLED状态时，依然会消耗点击事件，只不过是不做处理而已。View的enable属性是不影响View中onTouchEvent默认的返回值的，即使是DIABLED状态，只要其clickable或者long_clickable为true，就会返回true,消耗该点击事件。

II、主要的事务处理逻辑：

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;

     View会针对TouchEvent事件类型的不同进行分别处理，这里以ACTION_UP为例，可以看到最核心的响应就是触发performClick()方法:

III、View#performClick:

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

       可以看到OnClickListener的处理逻辑就在这里，如果View注册了 OnClickListener，在ACTION_UP事件到达该View时，会最终触发performClick方法，该方法中进而调用OnClickListener的onClick函数，故而在日常使用中则是重写onClick方法来实现点击的响应，并且onClick(View view)这里将this作参数传递进来，因此onClick中的view即代表被click的组件View。

5、总体而言，View的事件传递过程很简单，总共涉及到三个主要的函数dispatchTouchEvent,onInterceptTouchEvent,onTouchEvent;

dispatchTouchEvent完成对事件的派发，一般很少重载该函数；

onInterceptTouchEvent判断是否对事件进行拦截，若为true，则拦截事件继续向下分派给子View；若返回false，则继续将事件向下分派。

onTouchEvent实际上是View中的方法，因为ViewGroup是View的子类，当该层ViewGroup拦截事件，则需要调用其父类super即View中的onTouchEvent进行处理；onTouchEvent返回true的话，则事件在本层View中消耗，否则返回false的话，会把事件继续向上层传递进行处理。