当触摸事件发生时，Activity先接受到事件。

  1. public boolean dispatchTouchEvent(MotionEvent ev) {
  2.     if (ev.getAction() == MotionEvent.ACTION_DOWN) {
  3.     //在Activity可以实现该方法，处理必要的逻辑
  4.     //当此activity在栈顶时，触屏点击按home，back，menu键等都会触发此方法
  5.         onUserInteraction();
  6.     }
  7.    // 若返回true
  8.     if (getWindow().superDispatchTouchEvent(ev)) {
  9.      //1. 获取到的是window的唯一实现类PhoneWindow;
  10.     //2.该方法由其唯一子类PhoneWindow类实现，
  11.     // 3.PhoneWindow内部有DecorWindow类，其继承自FrameLayout，是所有界面的父类，
  12. //4.FrameLayout继承自ViewGroup类，最终调用到ViewGroup的super.dispatchTouchEvent(event);
  13. //实现从Activity到内部View的传递，即内部可优先处理事件，若未true，再由Activity处理。
  14.         return true;
  15.     }
  16.    // 否则：继续往下调用Activity.onTouchEvent
  17.     return onTouchEvent(ev);

DecorView内的dispatchToucEvent（可以通过Activity内的onTouchEvent打开DecorView）

  1. @Override
  2. public boolean dispatchTouchEvent(MotionEvent ev) {
  3.     final Window.Callback cb = mWindow.getCallback();
  4.  //cb.dispatchTouchEvent(ev) :调用Activity的dispatchTouchEvent（）
  5. // super.dispatchTouchEvent(ev):交给ViewGroup处理。
  6.     return cb != null && !mWindow.isDestroyed() && mFeatureId < 0
  7.             ? cb.dispatchTouchEvent(ev) : super.dispatchTouchEvent(ev);

关于Activity的内的onTouchEvent

最后当触摸屏事件未被其下的任何视图处理时调用，这对于处理发生在窗口边界之外的触摸事件非常有用，因为在那里没有接收它的视图。

  1. public boolean onTouchEvent(MotionEvent event) {
  2.    //处理发生在Window边界外的触摸事件。
  3.     if (mWindow.shouldCloseOnTouch(this, event)) {
  4.         finish();
  5.         return true;
  6.     }
  8.     return false;
  9. }
  1. // 主要是对于处理边界外点击事件的判断：是否是DOWN事件，event的坐标是否在边界内等
  2. public boolean shouldCloseOnTouch(Context context, MotionEvent event) {
  3.     if (mCloseOnTouchOutside && event.getAction() == MotionEvent.ACTION_DOWN
  4.             && isOutOfBounds(context, event) && peekDecorView() != null) {
  5.       //说明事件在边界外，消费事件  
  6.       return true;
  7.     }

回到getWindow().superDispatchTouchEvent(ev)向内ViewGroup内传递的分析。

ViewGroup内dispatchTouchEvent

  1. @Override
  2. public boolean dispatchTouchEvent(MotionEvent ev) {
  3.     if (mInputEventConsistencyVerifier != null) {
  4.         mInputEventConsistencyVerifier.onTouchEvent(ev, 1);
  5.     }
  7.     //如果事件以可访问且可聚焦的view为目标，则启动正常事件调度。否则交给子view处理点击。
  8.     if (ev.isTargetAccessibilityFocus() && isAccessibilityFocusedViewOrHost()) {
  9.         ev.setTargetAccessibilityFocus(false);
  10.     }
  11.     boolean handled = false;
  12.     if (onFilterTouchEventForSecurity(ev)) {
  13.         final int action = ev.getAction();
  14.         final int actionMasked = action & MotionEvent.ACTION_MASK;
  16.         // Handle an initial down.
  17.         if (actionMasked == MotionEvent.ACTION_DOWN) {
  18.          //当开始一个新的触摸手势时，删除原先的状态。
  19.          //重置状态，（由于应用程序切换、ANR或其他一些状态改变，底层可能已经取消事件）
  20.             cancelAndClearTouchTargets(ev);
  21.             resetTouchState();
  22.         }
  24.         //判断是否被打断
  25.         final boolean intercepted;
  26.         if (actionMasked == MotionEvent.ACTION_DOWN
  27.                 || mFirstTouchTarget != null) {
  28.  //判断值1：disallowIntercept = 是否禁用事件拦截的功能(默认是false)，
  29.   //可通过调用requestDisallowInterceptTouchEvent（）修改
  30.             final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
  31.             if (!disallowIntercept) {
  32. // 对onInterceptTouchEvent()返回值取反
  33. // a. 若在onInterceptTouchEvent()中返回false（即不拦截事件）,则为true
  34.                 intercepted = onInterceptTouchEvent(ev);
  35.                 ev.setAction(action);
  36.             } else {
  37. // b. 若在onInterceptTouchEvent()中返回true（即拦截事件），则为false，
  38.                 intercepted = false;
  39.             }
  40.         } else {
  41.             intercepted = true;
  42.         }
  43.         //.......此处省略部分代码
  44.         final boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0;
  45.         TouchTarget newTouchTarget = null;
  46.         boolean alreadyDispatchedToNewTouchTarget = false;
  47.         if (!canceled && !intercepted) {
  48.             View childWithAccessibilityFocus = ev.isTargetAccessibilityFocus()
  49.                     ? findChildWithAccessibilityFocus() : null;
  50.             if (actionMasked == MotionEvent.ACTION_DOWN
  51.                     || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
  52.                     || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
  53.           //.......此处省略部分代码
  54.                 final int childrenCount = mChildrenCount;
  55.                 if (newTouchTarget == null && childrenCount != 0) {
  56.                     final float x = ev.getX(actionIndex);
  57.                     final float y = ev.getY(actionIndex);
  58.                     final ArrayList<View> preorderedList = buildTouchDispatchChildList();
  59.                     final boolean customOrder = preorderedList == null
  60.                             && isChildrenDrawingOrderEnabled();
  61.                     final View[] children = mChildren;
  62.                //遍历所有的子view，寻找可以传递事件的view
  63.                     for (int i = childrenCount - 1; i >= 0; i--) {
  64.                         final int childIndex = getAndVerifyPreorderedIndex(
  65.                                 childrenCount, i, customOrder);
  66.                         final View child = getAndVerifyPreorderedView(
  67.                                 preorderedList, children, childIndex);
  68.                        //如果找到一个可达且可获取焦点的view，让其先获得事件，  
  69.                     //如果没有处理，执行异常调度。在在给定的时间范围内，进行双重迭代，这是比较安全的。
  70.                         if (childWithAccessibilityFocus != null) {
  71.                             if (childWithAccessibilityFocus != child) {
  72.                                 continue;
  73.                             }
  74.                             childWithAccessibilityFocus = null;
  75.                             i = childrenCount - 1;
  76.                         }
  77.                         if (!canViewReceivePointerEvents(child)
  78.                                 || !isTransformedTouchPointInView(x, y, child, null)) {
  79.                             ev.setTargetAccessibilityFocus(false);
  80.                             continue;
  81.                         }
  82.                      //.......此处省略部分代码
  83.                         resetCancelNextUpFlag(child);
  84.               //将事件转换成特定子view的坐标空间，过滤掉无关的指针ID，并在必要时重写其事件。
  85.              //如果子view为空，事件将转交给其父类处理。
  86.                         if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
  87.                             //将事件分发给子view
  88.                             mLastTouchDownTime = ev.getDownTime();
  89.                             if (preorderedList != null) {
  90.                                 for (int j = 0; j < childrenCount; j++) {
  91.                                     if (children[childIndex] == mChildren[j]) {
  92.                                         mLastTouchDownIndex = j;
  93.                                         break;
  94.                                     }
  95.                                 }
  96.                             } else {
  97.                                 mLastTouchDownIndex = childIndex;
  98.                             }
  99.                             mLastTouchDownX = ev.getX();
  100.                             mLastTouchDownY = ev.getY();
  101.                             newTouchTarget = addTouchTarget(child, idBitsToAssign);
  102.                             alreadyDispatchedToNewTouchTarget = true;
  103.                             break;
  104.                         }
  105.                   //此处省略N行........
  106.                     }
  107.                     if (preorderedList != null) preorderedList.clear();
  108.                 }
  109.                //mFirstTouchTarget:触摸目标链表中的第一次触摸目标。
  110.                 if (newTouchTarget == null && mFirstTouchTarget != null) {
  111.                     //若没有找到可以传递事件的子view，将指针分配到最近最少添加的view。
  112.                     newTouchTarget = mFirstTouchTarget;
  113.                     while (newTouchTarget.next != null) {
  114.                         newTouchTarget = newTouchTarget.next;
  115.                     }
  116.                     newTouchTarget.pointerIdBits |= idBitsToAssign;
  117.                 }
  118.             }
  119.         }
  120.         if (mFirstTouchTarget == null) {
  121.             // No touch targets so treat this as an ordinary view.
  122.             handled = dispatchTransformedTouchEvent(ev, canceled, null,
  123.                     TouchTarget.ALL_POINTER_IDS);
  124.         } else {
  125.             TouchTarget predecessor = null;
  126.             TouchTarget target = mFirstTouchTarget;
  127.             while (target != null) {
  128.                 final TouchTarget next = target.next;
  129.                 if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
  130.                     handled = true;
  131.                 } else {
  132.                     final boolean cancelChild = resetCancelNextUpFlag(target.child)
  133.                             || intercepted;
  134.                     if (dispatchTransformedTouchEvent(ev, cancelChild,
  135.                             target.child, target.pointerIdBits)) {
  136.                         handled = true;
  137.                     }
  138.                  //此处省略N行........
  139.                 }
  140.                 predecessor = target;
  141.                 target = next;
  142.             }
  143.         }
  144.         // Update list of touch targets for pointer up or cancel, if needed.
  145.          //此处省略N行........
  146.     return handled;
  147. }

前面判断完分发条件后，对可以获取的view分发事件，主要是通过以下方法：

  1. private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
  2.         View child, int desiredPointerIdBits) {
  3.     final boolean handled;
  4.     final int oldAction = event.getAction();
  5.     if (cancel || oldAction == MotionEvent.ACTION_CANCEL) {
  6.         event.setAction(MotionEvent.ACTION_CANCEL);
  7.         if (child == null) {
  8.             //若子view为null，执行其父view的dispatchTouchEvent
  9.             handled = super.dispatchTouchEvent(event);
  10.         } else {
  11.            //若不为null，则传递事件。
  12.             handled = child.dispatchTouchEvent(event);
  13.         }
  14.         event.setAction(oldAction);
  15.         return handled;
  16.     }
  17.     // 计算要传递的指针的数量。
  18.     final int oldPointerIdBits = event.getPointerIdBits();
  19.     final int newPointerIdBits = oldPointerIdBits & desiredPointerIdBits;
  20.     //可能会产生一个没有指针数的事件,那么放弃该事件。
  21.     if (newPointerIdBits == 0) {
  22.         return false;
  23.     }
  24.    //如果指针的数目是相同的，并且不需要执行任何不可逆的转换，
  25.    //则恢复之前所做的更改，以重用这个调度的事件。
  26.    //否则需要复印一份。
  27.     final MotionEvent transformedEvent;
  28.     if (newPointerIdBits == oldPointerIdBits) {
  29.         if (child == null || child.hasIdentityMatrix()) {
  30.             if (child == null) {
  31.                 handled = super.dispatchTouchEvent(event);
  32.             } else {
  33.                 final float offsetX = mScrollX - child.mLeft;
  34.                 final float offsetY = mScrollY - child.mTop;
  35.                 event.offsetLocation(offsetX, offsetY);
  36.                 handled = child.dispatchTouchEvent(event);
  37.                 event.offsetLocation(-offsetX, -offsetY);
  38.             }
  39.             return handled;
  40.         }
  41.         transformedEvent = MotionEvent.obtain(event);
  42.     } else {
  43.         transformedEvent = event.split(newPointerIdBits);
  44.     }
  45.     if (child == null) {
  46.         handled = super.dispatchTouchEvent(transformedEvent);
  47.     } else {
  48.         final float offsetX = mScrollX - child.mLeft;
  49.         final float offsetY = mScrollY - child.mTop;
  50.         transformedEvent.offsetLocation(offsetX, offsetY);
  51.         if (! child.hasIdentityMatrix()) {
  52.             transformedEvent.transform(child.getInverseMatrix());
  53.         }
  54.         handled = child.dispatchTouchEvent(transformedEvent);
  55.     }
  56.     // Done.
  57.     transformedEvent.recycle();
  58.     return handled;
  59. }

View内的dispatchTouchEvent

  1. public boolean dispatchTouchEvent(MotionEvent event) {
  2.     // 如果事件可被可达到且的焦点view处理
  3.     if (event.isTargetAccessibilityFocus()) {
  4.         if (!isAccessibilityFocusedViewOrHost()) {
  5.             return false;
  6.         }
  7.         // view有焦点，且获得到事件处理
  8.         event.setTargetAccessibilityFocus(false);
  9.     }
  11.     boolean result = false;
  12.     if (mInputEventConsistencyVerifier != null) {
  13.         mInputEventConsistencyVerifier.onTouchEvent(event, 0);
  14.     }
  15.     final int actionMasked = event.getActionMasked();
  16.     if (actionMasked == MotionEvent.ACTION_DOWN) {
  17.         stopNestedScroll();
  18.     }
  19.     if (onFilterTouchEventForSecurity(event)) {
  20.     //条件1：(mViewFlags & ENABLED_MASK) == ENABLED
  21.       //a. 该条件是判断当前点击的view是否enable
  22.       // b. 由于很多View默认enable，故该条件恒定为true
  23.    //条件2：handleScrollBarDragging(event)，事件是否是拖动滚动条
  24.         if ((mViewFlags & ENABLED_MASK) == ENABLED && handleScrollBarDragging(event)) {
  25.             result = true;
  26.         }
  27.         // 说明：只有以下3个条件都为真，dispatchTouchEvent()才返回true；否则执行onTouchEvent()
  28.   //     1. mOnTouchListener != null： 是否注册触摸监听
  29.   //     2. (mViewFlags & ENABLED_MASK) == ENABLED： 当前被点击的view是否enable
  30.   //     3. mOnTouchListener.onTouch(this, event) ：监听的boolean类型回调值是否是true
  31.         ListenerInfo li = mListenerInfo;
  32.         if (li != null && li.mOnTouchListener != null
  33.                 && (mViewFlags & ENABLED_MASK) == ENABLED
  34.                 && li.mOnTouchListener.onTouch(this, event)) {
  35.          //符合条件，未被打断，则事件分发结束
  36.             result = true;
  37.         }
  38.       //若为fasle，调用view的onTouchEvent（）方法处理事件。
  39.         if (!result && onTouchEvent(event)) {
  40.             result = true;
  41.         }
  42.     }
  43.     //此处省略N行代码..........
  44.     return result;
  45. }

再看onTouchEvent方法()

  1. public boolean onTouchEvent(MotionEvent event) {
  2.     final float x = event.getX();
  3.     final float y = event.getY();
  4.     final int viewFlags = mViewFlags;
  5.     final int action = event.getAction();
  6.     if ((viewFlags & ENABLED_MASK) == DISABLED) {
  7.       //如当前view的状态是disable的
  8.         if (action == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {
  9.             setPressed(false);
  10.         }
  11.         return (((viewFlags & CLICKABLE) == CLICKABLE
  12.                 || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
  13.                 || (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE);
  14.     }
  15.     if (mTouchDelegate != null) {
  16.          //如果TouchDelegate对象不为空，将事件传递给它处理，不再往下。
  17.         if (mTouchDelegate.onTouchEvent(event)) {
  18.             return true;
  19.         }
  20.     }
  21.     if (((viewFlags & CLICKABLE) == CLICKABLE ||
  22.             (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE) ||
  23.             (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE) {
  24.         switch (action) {
  25.             case MotionEvent.ACTION_UP:
  26.               //手指抬起action
  27.                 boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;
  28.                 if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) {
  29.                     //如果view没有获取焦点，为其请求焦点
  30.                     boolean focusTaken = false;
  31.                     if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {
  32.                         focusTaken = requestFocus();
  33.                     }
  34.                     if (prepressed) {
  35.                         setPressed(true, x, y);
  36.                    }
  37.                     if (!mHasPerformedLongPress && !mIgnoreNextUpEvent) {
  38.                         removeLongPressCallback();
  39.                         if (!focusTaken) {  
  40.                             if (mPerformClick == null) {
  41.                                 mPerformClick = new PerformClick();
  42.                             }
  43.                            //执行点击事件
  44.                             if (!post(mPerformClick)) {
  45.                                 performClick();
  46.                             }
  47.                         }
  48.                     }
  49.                  //此处省略N行代码......
  50.                 break;
  52.             case MotionEvent.ACTION_DOWN:
  53.                 mHasPerformedLongPress = false;
  54.                 if (performButtonActionOnTouchDown(event)) {
  55.                     break;
  56.                 }
  57.                //此处省略N行........
  58.                 if (isInScrollingContainer) {
  59.                      //此处省略N行........
  60.                     postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
  61.                 } else {
  62.                     setPressed(true, x, y);
  63.                    //判断是不是长按
  64.                     checkForLongClick(0, x, y);
  65.                 }
  66.                 break;
  68.             case MotionEvent.ACTION_CANCEL:
  69.                 //此处省略N行........
  70.                 break;
  72.             case MotionEvent.ACTION_MOVE:
  73.                 //此处省略N行........
  74.                 break;
  75.         }
  76.         return true;
  77.     }
  78.     return false;
  79. }
  1. public boolean performClick() {
  2.     final boolean result;
  3.     final ListenerInfo li = mListenerInfo;
  4.     if (li != null && li.mOnClickListener != null) {
  5.         playSoundEffect(SoundEffectConstants.CLICK);
  6.         li.mOnClickListener.onClick(this);
  7.         result = true;
  8.     } else {
  9.         result = false;
  10.     }
  12.     sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);
  13.     return result;
  14. }

小结

Activity获取到dispacth事件，率先处理，再交给其内部的view。