# EventDispatchDemo

**Repository Path**: lzbgit/EventDispatchDemo

## Basic Information

- **Project Name**: EventDispatchDemo
- **Description**: 事件分发Demo
- **Primary Language**: Java
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2018-07-05
- **Last Updated**: 2020-12-19

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# EventDispatchDemo

#### 项目介绍
事件分发Demo

#### 软件架构
软件架构说明


#### 代码实行过程

1. Activity

````
    public boolean dispatchTouchEvent(MotionEvent ev) {
        if (ev.getAction() == MotionEvent.ACTION_DOWN) {
            onUserInteraction();
        }
        //getWindow返回的是phoneWindow
        if (getWindow().superDispatchTouchEvent(ev)) {
            return true;
        }
        return onTouchEvent(ev);
    }

````
2. PhoneWindow

````
    @Override
    public boolean superDispatchTouchEvent(MotionEvent event) {
        //最顶端DecorView
        return mDecor.superDispatchTouchEvent(event);
    }

````
3. DecorView

````
    public boolean superDispatchTouchEvent(MotionEvent event) {
        //调用ViewGroup中的dispatchTouchEvent函数
        return super.dispatchTouchEvent(event);
    }

````
4.ViewGroup <br>
(1)dispatchTouchEvent

````
       public boolean dispatchTouchEvent(MotionEvent ev) {
           //辅助功能支持
           if (mInputEventConsistencyVerifier != null) {
               mInputEventConsistencyVerifier.onTouchEvent(ev, 1);
           }

           // If the event targets the accessibility focused view and this is it, start
           // normal event dispatch. Maybe a descendant is what will handle the click.
           if (ev.isTargetAccessibilityFocus() && isAccessibilityFocusedViewOrHost()) {
               ev.setTargetAccessibilityFocus(false);
           }

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

               // Handle an initial down.
               if (actionMasked == MotionEvent.ACTION_DOWN) {
                   // 1.每次起始动作就重置之前的TouchTarget等参数
                   cancelAndClearTouchTargets(ev);
                   resetTouchState();
               }

               // 是否拦截
               final boolean intercepted;
               // 2.如果是起始动作才拦截，或者已经有人消费掉了事件，再去判断拦截
               // 起始动作是第一次向下分发的时候，每个view都可以决定是否拦截，然后进一步判断是否消费，很好理解
               // 如果有人消费掉了事件，那么也拦截~
               if (actionMasked == MotionEvent.ACTION_DOWN
                       || mFirstTouchTarget != null) {
                   // 3.这里可以设置一个disallowIntercept标志，如果是true，就是谁收到事件后都不准拦截！！！
                   final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
                   if (!disallowIntercept) {
                       // ViewGroup每次事件分发时，都需调用onInterceptTouchEvent()询问是否拦截事件
                       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 split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0;
               TouchTarget newTouchTarget = null;
               boolean alreadyDispatchedToNewTouchTarget = false;
               // 4.如果未拦截，只有Down动作才去子一级去找目标对象~
               // 因为找目标这个操作只有Down中才会处理
               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;

                       // 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 = ev.getX(actionIndex);
                           final float y = ev.getY(actionIndex);
                           //对子view按照层级关系进行排序
                           final ArrayList<View> preorderedList = buildTouchDispatchChildList();
                           final boolean customOrder = preorderedList == null
                                   && isChildrenDrawingOrderEnabled();
                           final View[] children = mChildren;
                           // 如果不拦截遍历所有child， 倒叙取顶层, 判断是否有分发
                           for (int i = childrenCount - 1; i >= 0; i--) {
                               final int childIndex = getAndVerifyPreorderedIndex(
                                       childrenCount, i, customOrder);
                               final View child = getAndVerifyPreorderedView(
                                       preorderedList, children, childIndex);
                               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();
                                   //如果分发事件被消耗（true） , 给设置View设置TouchTarget
                                   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) {
                   // 5.所有的child都没有消费掉事件，把自己当做目标，去判断自己的onTouchEvent是否消费
                   handled = dispatchTransformedTouchEvent(ev, canceled, null,
                           TouchTarget.ALL_POINTER_IDS);
               } else { // 6.如果有人消费掉了事件，找出他~
                   TouchTarget predecessor = null;
                   TouchTarget target = mFirstTouchTarget;
                   while (target != null) {
                       // 7.消费对象信息其实是一个链式对象，记载着一个一个传递的人的信息，遍历调用它child的分发方法
                       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;
       }

````
(2)onInterceptTouchEvent

````
    /**
     * 该方法用于拦截事件向下分发当返回值为true时，就会拦截TouchEvent不再向下传递，
     * 直接交给自己的onTouchEvent方法处理。返回false则不拦截。
     * @param ev
     * @return
     */
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        if (ev.isFromSource(InputDevice.SOURCE_MOUSE)
                && ev.getAction() == MotionEvent.ACTION_DOWN
                && ev.isButtonPressed(MotionEvent.BUTTON_PRIMARY)
                && isOnScrollbarThumb(ev.getX(), ev.getY())) {
            return true;
        }
        return false;
    }

````
(3)dispatchTransformedTouchEvent

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

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

         // Calculate the number of pointers to deliver.
         final int oldPointerIdBits = event.getPointerIdBits();
         final int newPointerIdBits = oldPointerIdBits & desiredPointerIdBits;

         // If for some reason we ended up in an inconsistent state where it looks like we
         // might produce a motion event with no pointers in it, then drop the event.
         if (newPointerIdBits == 0) {
             return false;
         }

         // If the number of pointers is the same and we don't need to perform any fancy
         // irreversible transformations, then we can reuse the motion event for this
         // dispatch as long as we are careful to revert any changes we make.
         // Otherwise we need to make a copy.
         final MotionEvent transformedEvent;
         if (newPointerIdBits == oldPointerIdBits) {
             if (child == null || child.hasIdentityMatrix()) {
                 if (child == null) {
                     handled = super.dispatchTouchEvent(event);
                 } else {
                     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 {
             transformedEvent = event.split(newPointerIdBits);
         }

         // Perform any necessary transformations and dispatch.
         if (child == null) {
             //如何没有孩子 调用父类的 dispatchTouchEvent 的方法 ,即View.dispatchTouchEvent()
             // 因此会执行ViewGroup的onTouch() ->> onTouchEvent() ->> performClick（） ->> onClick()，
             // 即自己处理该事件，事件不会往下传递（具体请参考View事件的分发机制中的View.dispatchTouchEvent（））
             // 此处需与上面区别：子View的dispatchTouchEvent（）
             // 等同于handled = onTouchEvent() 自己消费事件
             handled = super.dispatchTouchEvent(transformedEvent);
         } else {
             final float offsetX = mScrollX - child.mLeft;
             final float offsetY = mScrollY - child.mTop;
             transformedEvent.offsetLocation(offsetX, offsetY);
             if (! child.hasIdentityMatrix()) {
                 transformedEvent.transform(child.getInverseMatrix());
             }
             // 如果有child，再调用child的分发方法
             // 实现了事件从ViewGroup到子View的传递（具体请看下面的View事件分发机制）
             handled = child.dispatchTouchEvent(transformedEvent);
         }

         // Done.
         transformedEvent.recycle();
         return handled;
     }

````
4.View <br>
(1)dispatchTouchEvent

````
    public boolean dispatchTouchEvent(MotionEvent event) {
        // If the event should be handled by accessibility focus first.
        if (event.isTargetAccessibilityFocus()) {
            // We don't have focus or no virtual descendant has it, do not handle the event.
            if (!isAccessibilityFocusedViewOrHost()) {
                return false;
            }
            // We have focus and got the event, then use normal event dispatch.
            event.setTargetAccessibilityFocus(false);
        }

        boolean result = false;

        if (mInputEventConsistencyVerifier != null) {
            //消费事件
            mInputEventConsistencyVerifier.onTouchEvent(event, 0);
        }

        final int actionMasked = event.getActionMasked();
        if (actionMasked == MotionEvent.ACTION_DOWN) {
            // Defensive cleanup for new gesture
            stopNestedScroll();
        }

        if (onFilterTouchEventForSecurity(event)) {
            if ((mViewFlags & ENABLED_MASK) == ENABLED && handleScrollBarDragging(event)) {
                result = true;
            }
            // 实质上就是调用onTouchEvent用其返回值,mOnTouchListener 不为空 在这里调用了onTouch，它比click的方法调用的要早
            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;
            }
        }

        if (!result && mInputEventConsistencyVerifier != null) {
            mInputEventConsistencyVerifier.onUnhandledEvent(event, 0);
        }

        // Clean up after nested scrolls if this is the end of a gesture;
        // also cancel it if we tried an ACTION_DOWN but we didn't want the rest
        // of the gesture.
        if (actionMasked == MotionEvent.ACTION_UP ||
                actionMasked == MotionEvent.ACTION_CANCEL ||
                (actionMasked == MotionEvent.ACTION_DOWN && !result)) {
            stopNestedScroll();
        }

        return result;
    }

````
(2)onTouchEvent
````
// 当action为 MotionEvent.ACTION_DOWN 调用 performClick
if (!post(mPerformClick)) {
        performClick();
｝

````
(3)performClick

````
    public boolean performClick() {
        final boolean result;
        final ListenerInfo li = mListenerInfo;
        if (li != null && li.mOnClickListener != null) {
            playSoundEffect(SoundEffectConstants.CLICK);
            //调用onClick方法
            li.mOnClickListener.onClick(this);
            result = true;
        } else {
            result = false;
        }

        sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);

        notifyEnterOrExitForAutoFillIfNeeded(true);

        return result;
    }

````


#### 资料
1.[事件分发源码分析](https://www.jianshu.com/p/1be2e02d862f)