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;
@Override
public 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的话，会把事件继续向上层传递进行处理。