Android——View事件分发机制

我们经常使用的控件，如：TextView，Button，ListVIew等控件，他们都是继承自View的，当我们点击一个View控件后，会触发控件的一些行为，那这些行为是如何通过Activity传递到View中的，下面我们通过源码来进行了解：

首先，当我们在一个Activity上点击一个控件的时候，会触发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);
    }

注解说，这个方法是用来处理在屏幕上的触摸事件的，可以重写这个方法来让事件不能分发到window，如果这个事件被消耗掉的话，应该返回true。

当有ACTION_DOWN事件来的时候，会调用onUserInteraction

   /**
     * Called whenever a key, touch, or trackball event is dispatched to the
     * activity.  Implement this method if you wish to know that the user has
     * interacted with the device in some way while your activity is running.
     * This callback and {@link #onUserLeaveHint} are intended to help
     * activities manage status bar notifications intelligently; specifically,
     * for helping activities determine the proper time to cancel a notfication.
     *
     * <p>All calls to your activity's {@link #onUserLeaveHint} callback will
     * be accompanied by calls to {@link #onUserInteraction}.  This
     * ensures that your activity will be told of relevant user activity such
     * as pulling down the notification pane and touching an item there.
     *
     * <p>Note that this callback will be invoked for the touch down action
     * that begins a touch gesture, but may not be invoked for the touch-moved
     * and touch-up actions that follow.
     *
     * @see #onUserLeaveHint()
     */
    public void onUserInteraction() {
    }

这个方法是空实现，回调的时机是当按键、触屏或者轨迹球事件初始化时

然后再看onUserLeaveHint，他们两个是相铺相成的

  /**
     * Called as part of the activity lifecycle when an activity is about to go
     * into the background as the result of user choice.  For example, when the
     * user presses the Home key, {@link #onUserLeaveHint} will be called, but
     * when an incoming phone call causes the in-call Activity to be automatically
     * brought to the foreground, {@link #onUserLeaveHint} will not be called on
     * the activity being interrupted.  In cases when it is invoked, this method
     * is called right before the activity's {@link #onPause} callback.
     *
     * <p>This callback and {@link #onUserInteraction} are intended to help
     * activities manage status bar notifications intelligently; specifically,
     * for helping activities determine the proper time to cancel a notfication.
     *
     * @see #onUserInteraction()
     */
    protected void onUserLeaveHint() {
    }

注解上说，这个方法调用的时机是activity有意图去进入后台中，比如：当用户按下“home”或者后退键，它会在onPause方法调用之前进行调用的，如果是因为一个Activity进入而使其进入到后台中，这种情况onUserLeaveHint是不会调用的。

onUserInteraction 与 onUserLeaveHint方法一般是用于对通知栏进行管理。

好了，回过来继续看dispatchTouchEvent

if (getWindow().superDispatchTouchEvent(ev)) {
            return true;
        }
通过getWindow得到当前Activity的window，window是抽象类，下面是Window的注解

 * <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.superDispathTouchEvent()

 @Override
    public boolean superDispatchTouchEvent(MotionEvent event) {
        return mDecor.superDispatchTouchEvent(event);
    }
mDecor就是DecorView的一个对象：

private final class DecorView extends FrameLayout implements RootViewSurfaceTaker {}
DecorView就是Activity中的顶级View，可以通过getWindow().getDecoreView()来获得

然后看DecorView中的superDispatchTouchEvent():

public boolean superDispatchTouchEvent(MotionEvent event) {
            return super.dispatchTouchEvent(event);
        }
可以看到它是回到父类的方法，FrameLayout又是继承自GroupView的，我们直接看GroupView中的dispatchTouchEvent():

这个方法中的代码比较多，但我们只是分析View事件的分发机制，所有我就一部分一部分的截：

 // 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;
            }
这一段逻辑是检查是否要中断，有两种情况会判断是否要进行中断检查，第一种是当触发MotionEvent.ACTION_DOWN,第二种是判断mFristTouchTarget是否为null，第一种好理解，第二种mFristTouchTarget这个字段，从后面源码我们会了解到，先在这里说一下，这个字段会在当有View消了MotionEvent.Action_DOWN事件,mFristTouchTarget就会不为null，如果没有View消耗Motion.ACTION_DOWN事件，那么mFristTouchTarget == null，在ACTION_MOVE、ACTION_UP事件中，就会执行else语句，也就是把intercepted设为ture，这样ACTION_DOWN之后的事件都会交由它处理，而不会向下进行分发。

要想执行onIntercepTouchEvent()，disallowIntercept得为false，disallowIntercept是通过FLAG_DISALLOW_INTERCEPT标记位进行控制的，这个标记位可以通过requestDisallowInterceptTouchEvent来进行设置，这个方法是ViewParent中的方法，在ViewParent中实现了这个方法，在子view中使用。当dispatchIntercept被设置了，viewGroup就中断不了除了ACTION_DOWN的其他事件，所以在这里给我们提供一个处理滑动冲突的解决方法。

为什么说除了ACTION_DOWN，看下面一段代码：

// 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事件到来时，会调用resetTouchState()

/**
     * Resets all touch state in preparation for a new cycle.
     */
    private void resetTouchState() {
        clearTouchTargets();
        resetCancelNextUpFlag(this);
        mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;
        mNestedScrollAxes = SCROLL_AXIS_NONE;
    }
这里面，就是重置触摸的一些状态，首先在clearTouchTargets()会把mFristTouchTarget制为null，然后会对FLAG_DISALLOW_INTERCEPT进行重置，这样就不会对ACTION_DOWN事件就行中断，而是调用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 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;
                            }
}
这一段代码，是当ViewGroup不中断事件，就会对ViewGroup中的子View进行遍历，要得到能够接受事件的子元素，必须要满足两个条件：

1，canViewReceivePointerEvents(child),判断子元素是否在用户点击的区域内

2，isTransformedTouchPointInView()，判断子元素是否在播放动画

 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;
                            }
这段代码也是在for语句里，先看 dispatchTransformedTouchEvent();

 private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
            View child, int desiredPointerIdBits) {
        final boolean handled;

        // Canceling motions is a special case.  We don't need to perform any transformations
        // or filtering.  The important part is the action, not the contents.
        final int oldAction = event.getAction();
        if (cancel || oldAction == MotionEvent.ACTION_CANCEL) {
            event.setAction(MotionEvent.ACTION_CANCEL);
            if (child == null) {
                handled = super.dispatchTouchEvent(event);
            } else {
                handled = child.dispatchTouchEvent(event);
            }
            event.setAction(oldAction);
            return handled;
        }
}
如果child不为null，就调用子View的dispathchTouchEvent（）来进行分发，完成一轮事件分发，否则就直接执行View类中的dispathTouchEvent来对事件进行处理，如果dispatchTransformedTouchEvent返回true，说明子View消耗了触摸事件，如果返回false，说明所有的子元素都没有被合适的处理，这种情况有两种：

1）ViewGroup中没有子元素

2）子元素处理了事件，但是在dispathTouchEvent中返回可false，一般都是在onTouchEvent中返回了false。

还记得上面我们说的，当子View消耗了触摸事件，就会对mFristTouchTarget进行赋值，这个过程就是在

addTouchTarget()方法中进行的

    /**
     * Adds a touch target for specified child to the beginning of the list.
     * Assumes the target child is not already present.
     */
    private TouchTarget addTouchTarget(View child, int pointerIdBits) {
        TouchTarget target = TouchTarget.obtain(child, pointerIdBits);
        target.next = mFirstTouchTarget;
        mFirstTouchTarget = target;
        return target;
    }
可以看到，把target赋给了mFirstTouchTarget

可以看到，view事件分发是从Activity-->Window-->View

到此，view事件的分发机制差不多就分析完了，至于view对点击事件的处理过程以及view的onTouch、onTouchEvent、onClick调用的机制等在下一篇博文中进行分析。

感谢大家的阅读，如有不足之处，还望指出！