Android 事件分发机制-源码分析

事件分发.png

说明

具体流程如图所示，
对于dispatchTouchEvent , onTouchEvent 返回 true 就是自己消费了，返回 false 就传到父View 的onTouchEvent方法
ViewGroup 想把事件分发给自己的 onTouchEvent,需要在onInterceptTouchEvent方法中返回 true 把事件拦截下来
ViewGroup 的 onInterceptTouchEvent 默认不拦截，所以 super.onInterceptTouchEvent() = false
View(这里指没有子View)没有拦截器,所以 View 的dispatchTouchEvent的super.dispatchTouchEvent(event)默认把事件分发给自己的onTouchEvent

源码解析(以下内容部分来自书籍《Android开发艺术探索》)

Activity对点击事件的分发过程

当一个点击事件发生时，事件首先传递给当前 Activity ，由 Activity 的 dispatchTouchEvent() 来进行事件的分发，具体的工作是由 Activity 内部 Window来完成。Window 会将事件传递给 decor view, decor view 一般就是当前 Activity 的顶层 View，源码如下:

Activity#dispatchTouchEvent

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

事件交给 Activity 所附属的 Window 进行分发，如果返回 true 整个循环就结束了，返回 false 就表示没有人要处理，交由 Activity 的onTouchEvent处理；可知 Activity 调用 getWindow().superDispatchTouchEvent(ev)把事件分发给ViewGroup, 所以我们来看

Windows#superDispatchTouchEvent

public abstract boolean superDispatchTouchEvent(MotionEvent event)

可以看出 Window 是个抽象类，且 Window 唯一实现的是 PhoneWindow，所以接下来我们看看 PhoneWindow 怎么处理该方法的

PhoneWindow#superDispatchTouchEvent

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

到这里清晰，是在 PhoneWidow 将事件传递给了 DecorView, 至于什么是 DercorView ，看源码里如何解释的:

// This is the top-level view of the window, containing the window decor.
    private DecorView mDecor;

这个 mDecor 显然就是getWindow().getDecorView() 所返回的 View，而我们通过 setContentView 设置的 View 就是是它的一个子 view。目前事件传递到了 DecorView 这里，由于 DecorView 继承自 FrameLayout 且又是父 View，所以最终事件会传递给我们所设置setContentView的顶级 View 一般来说都是 ViewGroup（不传递给他怎么响应用户点击事件呢��）

ViewGroup 对点击事件的分发

ViewGroup 对点击事件的分发过程主要实现在 dispatchTouchEvent 这个方法里，这个方法过程，我们分段说明，首先看看他对是否拦截的逻辑

代码位置

// 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 ，这个从后面代码可以看出，当事件由 ViewGroup 的子元素成功处理时，mFirstTouchTarget 就会被赋值并指向子元素
且当ACTION_MOVE 和 ACTION_UP 事件到来时，由于actionMasked == MotionEvent.ACTION_DOWN || mFirstTouchTarget != null这个条件为 false ，将导致 ViewGroup 的 onInterceptTouchEvent 不被调用，并且同一序列中的其他事件都会默认交给他处理。
但是这里有个特殊情况，那就是FLAG_DISALLOW_INTERCEPT标记，这个标记是子 View 通过requestDisallowInterceptTouchEvent方法来设置。一旦设置了该标记，ViewGroup 将无法拦截除了 ACTION_DOWN 以外的事件。为什么说除了ACTION_DOWN 以外的事件，这点从源码也可以看出：因为在 ViewGroup 在事件分发时，如果是ACTION_DOWN就会重置FLAG_DISALLOW_INTERCEPT标记，将导致子View 设置的这个标记失效。因此当事件为ACTION_DOWN时 ViewGroup 总是会调用自己的onInterceptTouchEvent来询问是否拦截事件。
我们看看上面代码的前一句代码就明白了:
代码位置
```
// 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 在ACTION_DOWN事件时会做重置操作：会在resetTouchState()对FLAG_DISALLOW_INTERCEPT标记进行重置，因此子 View调用requestDisallowInterceptTouchEvent方法并不能影响 ViewGroup 对ACTION_DOWN事件的处理
从上面分析我们可以总结出两点：
- onInterceptTouchEvent 不是每次事件都会被调用，如果我们想在当前的 ViewGroup 处理所有的点击事件，就要选择onInterceptTouchEvent方法中处理，只有这个方法能确保每次都被调用
- FLAG_DISALLOW_INTERCEPT 给我们提供了另一种思路去解决滑动冲突的方法：在子 View 拦截处理

接下来我们看 ViewGroup 怎么把事件传递给子 View的:
代码位置

final View[] children = mChildren;
for (int i = childrenCount - 1; i >= 0; i--) {
    final int childIndex = getAndVerifyPreorderedIndex(
            childrenCount, i, customOrder);
    final View child = getAndVerifyPreorderedView(
            preorderedList, children, 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);
}

如上面源码所示，首先操作的是遍历 ViewGroup 的所有子元素，然后判断是否能够接收到点击事件。是否能够接收点击事件主要有两点判断：

子元素是否在播放动画

点击事件的坐标是否在子元素坐标区域内
可以看到他调用了dispatchTransformedTouchEvent方法来传递事件，所以我们来看看该方法
ViewGroup#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 他会直接调用的是子元素的 dispatchTouchEvent 方法来把事件传递给子元素

再回到遍历 ViewGroup 的所有子元素的方法中，可以看到在循环的最后过程中，判断如果子元素的 dispatchTouchEvent 返回 true ，那么这个 ViewGroup 就暂时不考虑事件在子元素内部是怎么分发的，而且 mFirstTouchTarget 就会被赋值同时跳出 for 循环，如下所示：
代码位置
```
newTouchTarget = addTouchTarget(child, idBitsToAssign);
alreadyDispatchedToNewTouchTarget = true;
break;
```
- 在这里完成了mFirstTouchTarget的赋值并且终止了对子元素的遍历。其实对mFirstTouchTarget的赋值是在addTouchTarget方法里完成的:
  ViewGroup#addTouchTarget
```
  private TouchTarget addTouchTarget(@NonNull View child, int pointerIdBits) {
    final TouchTarget target = TouchTarget.obtain(child, pointerIdBits);
    target.next = mFirstTouchTarget;
    mFirstTouchTarget = target;
    return target;
}
```
- mFirstTouchTarget 其实是一种单链表结构，他是否被赋值将直接影响到 ViewGroup 对事件的拦截策略，若果mFirstTouchTarget 为 null ，那么 ViewGroup 就默认拦截接下来同一序列中所有的点击事件
如果遍历所有的子元素后事件都没有被合适处理，这里包含两种情况：
- ViewGroup 没有子元素
- 子元素处理了点击事件，但是在 dispatchTouchEvent 中返回了 false （这一般是因为子元素在 onTouch中返回了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);
}
```

View对点击事件的分发过程

View 对点击事件的处理稍微简单点，首先看他的 dispatchTouchEvent 方法
View#dispatchTouchEvent

public boolean dispatchTouchEvent(MotionEvent event) {
......
if (onFilterTouchEventForSecurity(event)) {
    if ((mViewFlags & ENABLED_MASK) == ENABLED && handleScrollBarDragging(event)) {
    result = true;
    }
     //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;
}
}

由于 View 不包含子元素，所以他无法传递事件只能自己处理。从上面的源码可以看出，View 对事件的处理首先会判断有没有设置 OnTouchListener如果设置了且 OnTouchListener中的 onTouch放回 true，那么 View 的 onTouchEvent 就不会被调用。由此可见 OnTouchListener 的优先级高于 onTouchEvent

接着我们再看onTouchEvent的实现。先看当 View 处于不可用状态下的点击事件处理过程：
View#onTouchEvent

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

很明显：不可用状态下的 View 照样会消耗点击事件，尽管它看起来不可用

接着onTouchEvent，如果 View 设置有代理，那么还会执行 TouchDelegate 的onTouchEvent方法
```
if (mTouchDelegate != null) {
if (mTouchDelegate.onTouchEvent(event)) {
    return true;
}
}
```

再看onTouchEvent中对点击事件的具体处理：

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();
                     }
                 }
             }
             .....
         }
         break;
 }
 ....
 return true;
}

可以看出只要 View 的 CLICKABLE 和 LONG_CLICKABLE 有一个为 true，那么他就会消耗这个事件，即 onTouchEvent 返回 true，不管他是不是 DISABLE 状态。然后在ACTION_UP发生时会触发 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;
}

若果 View 设置了 OnClickListener，那么performClick() 方法内部会调用它的onClick方法

End. 到此就结束了