Question

Android 的触摸事件是 Android 开发进阶必须了解的机制以及面试中必问的问题之一。涉及的方法有 dispatchTouchEvent、onInterceptTouchEvent、onTouchEvent。而这一整套机制的真正实现，便是在 ViewGroup 的 dispatchTouchEvent 内部。下面是简化后的触摸事件流程图：

触摸事件发生后，在 Activity 内最先接收到事件的是 Activity 自身的 dispatchTouchEvent，然后 Activity 传递给 Activity 的 Window。接着 Window 传递给最顶端的 View，也就是 DecorView。接下来才是我们熟悉的触摸事件流程：首先是最顶端的 ViewGroup(这边便是 DecorView) 的 dispatchTouchEvent 接收到事件。并通过 onInterceptTouchEvent 判断是否需要拦截。

如果拦截则分配到 ViewGroup 自身的 onTouchEvent，如果不拦截则查找位于点击区域的子 View(当事件是 ACTION_DOWN 的时候，会做一次查找并根据查找到的子 View 设定一个 TouchTarget，有了 TouchTarget 以后，后续的对应 id 的事件如果不被拦截都会分发给这一个 TouchTarget)。

查找到子 View 以后则调用 dispatchTransformedTouchEvent 把 MotionEvent 的坐标转换到子 View 的坐标空间，这不仅仅是 x，y 的偏移，还包括根据子 View 自身矩阵的逆矩阵对坐标进行变换（这就是使用 setTranslationX,setScaleX 等方法调用后，子 View 的点击区域还能保持和自身绘制内容一致的原因。使用 Animation 做变换点击区域不同步是因为 Animation 使用的是 Canvas 的矩阵而不是 View 自身的矩阵来做变换)。

下面我们来看一下 ViewGroup 的 dispatchTouchEvent 方法的源码：

public boolean dispatchTouchEvent(MotionEvent ev) {
    ...

    boolean handled = false;
    if (onFilterTouchEventForSecurity(ev)) {
      final int action = ev.getAction();
      final int actionMasked = action & MotionEvent.ACTION_MASK;

      if (actionMasked == MotionEvent.ACTION_DOWN) {
        // 触摸事件流开始，重置触摸相关的状态
        cancelAndClearTouchTargets(ev);
        resetTouchState();
      }

      // 检测当前是否需要拦截事件。
      final boolean intercepted;
      if (actionMasked == MotionEvent.ACTION_DOWN
          || mFirstTouchTarget != null) {
        
        // 处理调用 requestDisallowInterceptTouchEvent 来防止 ViewGroup 拦截事件的情况
        final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
        if (!disallowIntercept) {
          intercepted = onInterceptTouchEvent(ev);
          ev.setAction(action); 
        } else {
          intercepted = false;
        }
      } else {
        // 当前没有 TouchTarget 也不是事件流的起始的话，则直接默认拦截，不通过 onInterceptTouchEvent 判断。
        intercepted = true;
      }

      final boolean canceled = resetCancelNextUpFlag(this)
          || actionMasked == MotionEvent.ACTION_CANCEL;

      // 检测是否需要把多点触摸事件分配给不同的子 View
      final boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0;
      
      // 当前事件流对应的 TouchTarget 对象
      TouchTarget newTouchTarget = null;
      boolean alreadyDispatchedToNewTouchTarget = false;
      if (!canceled && !intercepted) {

        View childWithAccessibilityFocus = ev.isTargetAccessibilityFocus()
            ? findChildWithAccessibilityFocus() : null;

        if (actionMasked == MotionEvent.ACTION_DOWN
            || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
            || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
          final int actionIndex = ev.getActionIndex(); // always 0 for down
          final int idBitsToAssign = split ? 1 << ev.getPointerId(actionIndex)
              : TouchTarget.ALL_POINTER_IDS;

          // 当前事件是事件流的初始事件（包括多点触摸时第二、第三点灯的 DOWN 事件)，清除之前相应的 TouchTarget 的状态
          removePointersFromTouchTargets(idBitsToAssign);

          final int childrenCount = mChildrenCount;
          if (newTouchTarget == null && childrenCount != 0) {
            final float x = ev.getX(actionIndex);
            final float y = ev.getY(actionIndex);
            final ArrayList<View> preorderedList = buildTouchDispatchChildList();
            final boolean customOrder = preorderedList == null
                && isChildrenDrawingOrderEnabled();
            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);
              
              ...

              // 判断当前遍历到的子 View 能否接受事件，如果不能则直接 continue 进入下一次循环
              if (!canViewReceivePointerEvents(child)
                  || !isTransformedTouchPointInView(x, y, child, null)) {
                ev.setTargetAccessibilityFocus(false);
                continue;
              }

              // 当前子 View 能接收事件，为子 View 创建 TouchTarget
              newTouchTarget = getTouchTarget(child);
              if (newTouchTarget != null) {
                newTouchTarget.pointerIdBits |= idBitsToAssign;
                break;
              }

              resetCancelNextUpFlag(child);
              // 调用 dispatchTransformedTouchEvent 把事件分配给子 View
              if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
                mLastTouchDownTime = ev.getDownTime();
                if (preorderedList != null) {
                  for (int j = 0; j < childrenCount; j++) {
                    if (children[childIndex] == mChildren[j]) {
                      mLastTouchDownIndex = j;
                      break;
                    }
                  }
                } else {
                  mLastTouchDownIndex = childIndex;
                }
                mLastTouchDownX = ev.getX();
                mLastTouchDownY = ev.getY();
                
                // 把 TouchTarget 添加到 TouchTarget 列表的第一位
                newTouchTarget = addTouchTarget(child, idBitsToAssign);
                alreadyDispatchedToNewTouchTarget = true;
                break;
              }

              ev.setTargetAccessibilityFocus(false);
            }
            if (preorderedList != null) preorderedList.clear();
          }

          if (newTouchTarget == null && mFirstTouchTarget != null) {
            newTouchTarget = mFirstTouchTarget;
            while (newTouchTarget.next != null) {
              newTouchTarget = newTouchTarget.next;
            }
            newTouchTarget.pointerIdBits |= idBitsToAssign;
          }
        }
      }

      if (mFirstTouchTarget == null) {
        // 目前没有任何 TouchTarget，所以直接传 null 给 dispatchTransformedTouchEvent
        handled = dispatchTransformedTouchEvent(ev, canceled, null,
            TouchTarget.ALL_POINTER_IDS);
      } else {
        // 把事件根据 pointer id 分发给 TouchTarget 列表内的所有 TouchTarget，用来处理多点触摸的情况
        TouchTarget predecessor = null;
        TouchTarget target = mFirstTouchTarget;
        // 遍历 TouchTarget 列表
        while (target != null) {
          final TouchTarget next = target.next;
          if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
            handled = true;
          } else {
            final boolean cancelChild = resetCancelNextUpFlag(target.child)
                || intercepted;
            
            // 根据 TouchTarget 的 pointerIdBits 来执行 dispatchTransformedTouchEvent
            if (dispatchTransformedTouchEvent(ev, cancelChild,
                target.child, target.pointerIdBits)) {
              handled = true;
            }
            if (cancelChild) {
              if (predecessor == null) {
                mFirstTouchTarget = next;
              } else {
                predecessor.next = next;
              }
              target.recycle();
              target = next;
              continue;
            }
          }
          predecessor = target;
          target = next;
        }
      }

      // 处理 CANCEL 和 UP 事件的情况
      if (canceled
          || actionMasked == MotionEvent.ACTION_UP
          || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
        resetTouchState();
      } else if (split && actionMasked == MotionEvent.ACTION_POINTER_UP) {
        final int actionIndex = ev.getActionIndex();
        final int idBitsToRemove = 1 << ev.getPointerId(actionIndex);
        removePointersFromTouchTargets(idBitsToRemove);
      }
    }

    if (!handled && mInputEventConsistencyVerifier != null) {
      mInputEventConsistencyVerifier.onUnhandledEvent(ev, 1);
    }
    return handled;
  }

再来看一下 dispatchTransformedMotionEvent 方法：

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

    final int oldAction = event.getAction();
    // 处理 CANCEL 的情况，直接把 MotionEvent 的原始数据分发给子 View 或者自身的 onTouchEvent
  		// (这边调用 View.dispatchTouchEvent，而 View.dispatchTouchEvent 会再调用 onTouchEvent 方法，把 MotionEvent 传入)
    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;
    }

    // 对 MotionEvent 自身的 pointer id 和当前我们需要处理的 pointer id 做按位与，得到共有的 pointer id
    final int oldPointerIdBits = event.getPointerIdBits();
    final int newPointerIdBits = oldPointerIdBits & desiredPointerIdBits;

    // 没有 pointer id 需要处理，直接返回
    if (newPointerIdBits == 0) {
      return false;
    }

    final MotionEvent transformedEvent;
    if (newPointerIdBits == oldPointerIdBits) {
      // MotionEvent 自身的 pointer id 和当前处理 pointer id 相同
      if (child == null || child.hasIdentityMatrix()) {
        if (child == null) {
          // 子 View 为空，直接交还给自身的 onTouchEvent 处理
          handled = super.dispatchTouchEvent(event);
        } else {
          // 子 View 矩阵是单位矩阵，说明子 View 并没有做过任何变换，直接对 x、y 做偏移并分配给子 View 处理
          final float offsetX = mScrollX - child.mLeft;
          final float offsetY = mScrollY - child.mTop;
          event.offsetLocation(offsetX, offsetY);

          handled = child.dispatchTouchEvent(event);

          event.offsetLocation(-offsetX, -offsetY);
        }
        return handled;
      }
      transformedEvent = MotionEvent.obtain(event);
    } else {
      // MotionEvent 自身的 pointer id 和当前需要处理的 pointer id 不同，把不需要处理的 pointer id 相关的信息剔除掉。
      transformedEvent = event.split(newPointerIdBits);
    }

    if (child == null) {
      // 子 View 为空，直接交还给自身的 onTouchEvent 处理
      handled = super.dispatchTouchEvent(transformedEvent);
    } else {
      // 根据当前的 scrollX、scrollY 和子 View 的 left、top 对 MotionEvent 的触摸坐标 x、y 进行偏移
      final float offsetX = mScrollX - child.mLeft;
      final float offsetY = mScrollY - child.mTop;
      transformedEvent.offsetLocation(offsetX, offsetY);
      if (! child.hasIdentityMatrix()) {
        // 获取子 View 自身矩阵的逆矩阵，并对 MotionEvent 的坐标相关信息进行矩阵变换
        transformedEvent.transform(child.getInverseMatrix());
      }
      
      // 把经过偏移以及矩阵变换的事件传递给子 View 处理
      handled = child.dispatchTouchEvent(transformedEvent);
    }

    transformedEvent.recycle();
    return handled;
  }