事件分发机制GroupView的事件处理学习总结

前言：上一篇学习总结没有提到一个重要的知识点：

1. View.java类中只处理事件
2. ViewGroup.java类中只分发事件
3. ViewGroup.java类中分发的事件的处理交给了View.java类

我们先来看一下ViewGroup类中是如何分发事件的：

1. 首先，我们还是以我们自己的代码从xxxActivity.java进入，xxxActivity.java继承自

   AppCompatActivity->FragmentActivity->ComponentActivity->Activity到最后也就是Activity.java根目录，里面有一个方法：dispatchTouchEvent()

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

   注意：其中代码，getWindow().superDispatchTouchEvent(ev)他是在PhoneWindow.java中的superDispatchTouchEvent（MotionEvent event）

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

2. 进一步，我们进入DecorView.java中可以看到

      public boolean superDispatchTouchEvent(MotionEvent event) {
           return super.dispatchTouchEvent(event);
       }

   它最终返回的结果是父类的dispatchTouchEvent(MotionEvent event)方法

3. 那我们就看一下它的父类是谁,点进去之后我们发现进入了ViewGroup.java中的，这里就是实现分发消息的具体逻辑，

   /**
        * ViewGroup分发消息
        * @param ev
        * @return
        */
       @Override
       public boolean dispatchTouchEvent(MotionEvent ev) {
           ...
   
               // 第一块:判断是否拦截子View
               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;
               }
   
               // If intercepted, start normal event dispatch. Also if there is already
               // a view that is handling the gesture, do normal event dispatch.
               if (intercepted || mFirstTouchTarget != null) {
                   ev.setTargetAccessibilityFocus(false);
               }
   
               // Check for cancelation.
               final boolean canceled = resetCancelNextUpFlag(this)
                       || actionMasked == MotionEvent.ACTION_CANCEL;
   
               // Update list of touch targets for pointer down, if needed.
               final boolean isMouseEvent = ev.getSource() == InputDevice.SOURCE_MOUSE;
               final boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0
                       && !isMouseEvent;
               TouchTarget newTouchTarget = null;
               boolean alreadyDispatchedToNewTouchTarget = false;
               //第二块代码：分发事件，看哪个子View处理事件
               if (!canceled && !intercepted) {
                   // If the event is targeting accessibility focus we give it to the
                   // view that has accessibility focus and if it does not handle it
                   // we clear the flag and dispatch the event to all children as usual.
                   // We are looking up the accessibility focused host to avoid keeping
                   // state since these events are very rare.
                   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;
   
                       // Clean up earlier touch targets for this pointer id in case they
                       // have become out of sync.
                       removePointersFromTouchTargets(idBitsToAssign);
   
                       final int childrenCount = mChildrenCount;
                       if (newTouchTarget == null && childrenCount != 0) {
                           final float x =
                                   isMouseEvent ? ev.getXCursorPosition() : ev.getX(actionIndex);
                           final float y =
                                   isMouseEvent ? ev.getYCursorPosition() : ev.getY(actionIndex);
                           // Find a child that can receive the event.
                           // Scan children from front to back.
                           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);
   
                               // 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 (!child.canReceivePointerEvents()
                                       || !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);
                           }
                           if (preorderedList != null) preorderedList.clear();
                       }
   
                       if (newTouchTarget == null && mFirstTouchTarget != null) {
                           // Did not find a child to receive the event.
                           // Assign the pointer to the least recently added target.
                           newTouchTarget = mFirstTouchTarget;
                           while (newTouchTarget.next != null) {
                               newTouchTarget = newTouchTarget.next;
                           }
                           newTouchTarget.pointerIdBits |= idBitsToAssign;
                       }
                   }
               }
   
               // 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);
               } else {
                   // Dispatch to touch targets, excluding the new touch target if we already
                   // dispatched to it.  Cancel touch targets if necessary.
                   TouchTarget predecessor = null;
                   TouchTarget target = mFirstTouchTarget;
                   while (target != null) {
                       final TouchTarget next = target.next;
                       if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
                           handled = true;
                       } else {
                           final boolean cancelChild = resetCancelNextUpFlag(target.child)
                                   || intercepted;
                           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;
                   }
               }
   
               // Update list of touch targets for pointer up or cancel, if needed.
               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;
       }
   

   可以看到我将这段代码分为了三块，先看第一块代码，
   intercepted = onInterceptTouchEvent(ev);这里通过我们重写的onInterceptTouchEvent(ev)这个方法的返回值赋值给intercept，它又影响着第二块代码是否执行，也就是看能否分发事件

    if (!canceled && !intercepted) {

   然后就是第三块代码，处理事件，也就是我们自定义的View执行事件的处理在这里，也就是当前View的事件处理代码

    if (mFirstTouchTarget == null) {
                   // No touch targets so treat this as an ordinary view.
                   handled = dispatchTransformedTouchEvent(ev, canceled, null,
                           TouchTarget.ALL_POINTER_IDS);
               } else

   else,里面就是子view事件处理代码，我们可以看一下当前View事件处理代码的方法是 handled = dispatchTransformedTouchEvent(ev, canceled, null,
                           TouchTarget.ALL_POINTER_IDS);在dispatchTransformedTouchEvent(）这个方法里面在child == null 的情况下，它就会去调用super.dispatchTouchEEvent()方法，也就是View的dispatchTouchEvent方法了

   handled = super.dispatchTouchEvent(event);

   然后我们就看一下，子View的处理

    if (dispatchTransformedTouchEvent(ev, cancelChild,
                                   target.child, target.pointerIdBits)) {
                               handled = true;
                           }

   最终也是去调用super.dispatchTouchEvent()方法，也就是View.dispatchTouchEvent()方法。

4. 然后就是前面所总结的View—>消费事件的流程，这里就不过多阐述了