android点击事件的分发过程

Posted 2020-07-27 blueberry_mu

转载请注明出处 http://blog.csdn.net/a992036795/article/details/51698023

本文将讲述android点击事件的分发过程

我的上一篇文章讲述了android点击事件的来源，本文接着讲述当点击事件传输到Activity之后 分发的过程是什么样的。
上一篇文章链接： http://blog.csdn.net/a992036795/article/details/51690303

通过上一篇文章我们知道，事件最终会通过activity分发到PhoneWindow再到DecorView最后到他的子View。

那我们就从Activity的dispatchTouchEvent方法看起吧。
Activity#dispatchTouchEvent

 public boolean dispatchTouchEvent(MotionEvent ev) {
        if (ev.getAction() == MotionEvent.ACTION_DOWN) {
            onUserInteraction();
        }
        //调用 phoneWindow的 superDiapatchTouchEvent
        if (getWindow().superDispatchTouchEvent(ev)) {
            return true;
        }
        // 如果phoneWindow#superDiapatchTouchEvent为false ,
      //  则会调用Activity的 onTouchEvent
        return onTouchEvent(ev);
    }

从这段代码可以看出：activity把事件交给了 phoneWindow,向下传递。
如果下层没有处理这个事件，那么activity将调用自己的onTouchEvent来处理这个事件。

我们接看PhoneWindow的superDispatchTouchEvent
PhoneWindow#superDispatchTouchEvent

@Override
    public boolean superDispatchTouchEvent(MotionEvent event) {
        //传递给DecorView
        return mDecor.superDispatchTouchEvent(event);
    }

它将事件传递给了DecorView。
DecorView的superDispatchTouchEvent

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

它这里调用了super.dispatchTouchEvent(event)，实际就是调用了ViewGoup的
dispatchTouchEvent方法。
ViewGroup#dispatchTouchEvent

 @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
       ...

            if (actionMasked == MotionEvent.ACTION_DOWN) {
         cancelAndClearTouchTargets(ev);
                // 1、清除 了disallowIntercept  标记
                resetTouchState();
            }

            // Check for interception.
            final boolean intercepted;
         // 2 、判断是否拦截，这个if语句actionMasked == MotionEvent.ACTION_DOWN|| mFirstTouchTarget != null
         // 在ACTION_DOWN 或者 mFirstTouchTarget!=null的时候进入
         // 通过下文分析会得出:如果不拦截事件,将事件交由子View处理的
//mFirstTouchTarget 不会被赋值，也就是mFirstTouchTarget!=null 不成立。
//那么就会有一条结论：当ViewGroup拦截事件后，那么在这个事件序列中，
//将不会进入onInterceptTouchEvent(ev)判断，而是直接交由ViewGroup自身处理。
        //原因是如果拦截了，下个事件不可能是ACTION_DOWN，并且mFirstTouchTarget==null ,所以上述结论成立！

            if (actionMasked == MotionEvent.ACTION_DOWN
                    || mFirstTouchTarget != null) {
                final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
                //3、这个标示可以通过requestDisallowInterceptTouchEvent
                //进行设置，这个标志将影响事件的拦截，即如果这个设了这个标志，
                //ViewGroup将不拦截事件，但这个对ACTION_DOWN无效，
                //原因在于ACTION_DOWN时 会清楚标志，看1号注释
                if (!disallowIntercept) {
                    intercepted = onInterceptTouchEvent(ev);
                    ev.setAction(action); // restore action in case it was changed
                } else {
                    intercepted = false;
                }
            } else {

                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、如果不拦截将事件往下传递
            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);
                        // Find a child that can receive the event.
                        // Scan children from front to back.
                        final ArrayList<View> preorderedList = buildOrderedChildList();
                        final boolean customOrder = preorderedList == null
                                && isChildrenDrawingOrderEnabled();
                        final View[] children = mChildren;
                        // 5、遍历子View
                        for (int i = childrenCount - 1; i >= 0; i--) {
                            final int childIndex = customOrder
                                    ? getChildDrawingOrder(childrenCount, i) : i;
                            final View child = (preorderedList == null)
                                    ? children[childIndex] : preorderedList.get(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);
                            // 6、这个方法将事件分发给子View (即调用子View的 disatchTouchEvent犯法)
                            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();
                                // 7、对mFirstTouchEvent进行赋值
                                newTouchTarget = addTouchTarget(child, idBitsToAssign);
                                alreadyDispatchedToNewTouchTarget = true;
                                break;
                            }


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

            //8、如果父控件没有子View 或者子View的 disPatchTouchEvent返回fasle ,
            //即没有子View处理事件的话，将会走这个if分支
            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 {
                    // 9、如果子View正在处理事件，而此时ViewGroup的onIntercepted返回true,
                    //此时ViewGroup就会偷取事件。
                    //这个分支会回收target,将重新使得mFirstTouchEvent为null,
                    //并且子View会受到一个Cancel事件
                        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;
    }

这个方法代码比较长，内容也比较多。我们先看第一个注释的代码：

  private void resetTouchState() {
        clearTouchTargets();
        resetCancelNextUpFlag(this);
        //清楚标志位
        mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;
        mNestedScrollAxes = SCROLL_AXIS_NONE;
    }

看以看到如果是ACTION_DOWN事件的话，它会清楚FLAG_DISALLOW_INTERCEPT这个标志

接着看第二个注释的地方：

  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 {

                intercepted = true;
            }

这块代码，注释中已经说得差不多了。2条结论：
1、如果ViewGroup决定拦截事件，那么将不会再进入这个分支判断，后续的事件将都交由它处理。
2、可以使用 requestDisallowInterceptTouchEvent，使得ViewGroup不拦截事件，但为ACTION_DOWN事件无效。

接着会遍历所有的子View 并调用dispatchTransformedTouchEvent进行事件分发，我们来看这个方法的代码：

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

         // 处理cancle 事件
        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) {
            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());
            }
        //传递给子View
            handled = child.dispatchTouchEvent(transformedEvent);
        }

        // Done.
        transformedEvent.recycle();
        //返回结果
        return handled;
    }

这个方法，将会进行事件分发，如果传入的child不为null，则会传递给子View,调用子View的dispatchTouchEvent。

如果child为null 则会掉用 super.dispatchTouchEvent。当然ViewGroup的 父类是View 所以会执行view 的dispatchTouchEvent，这时就会调用ViewGroup的onTouchEvent了。

View#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)) {
            //noinspection SimplifiableIfStatement
            ListenerInfo li = mListenerInfo;
            //如果 mOnTouchListener.onTouch()返回 true,则不会调用
            //onTouchEvent，这里mOnTouchListener的优先级比较高
            if (li != null && li.mOnTouchListener != null
                    && (mViewFlags & ENABLED_MASK) == ENABLED
                    && li.mOnTouchListener.onTouch(this, event)) {
                result = true;
            }
        // 执行 onTouchEvent
            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;
    }

这样事件就分发到子View的onTouchEvent或者 自身的onTouchEvent了。

我们回过头，在看一下ViewGroup#dispatchTouchEvent这个方法中，注释7~9，看看它是怎么传递事件到自身 onTouchEvent的，和如果给mFirstTouchEvent赋值的。

我们先来看注释7、addTouchTarget方法是怎么赋值的。

   private TouchTarget addTouchTarget(View child, int pointerIdBits) {
        TouchTarget target = TouchTarget.obtain(child, pointerIdBits);
        target.next = mFirstTouchTarget;
        mFirstTouchTarget = target;
        return target;
    }

在看第8条注释，如果mFirstTouchEvent==null 说明没有子View处理事件，这时将向上冒泡，那我们来看看它怎么处理的。

 // Dispatch to touch targets.
            if (mFirstTouchTarget == null) {
                // No touch targets so treat this as an ordinary view.
                //调用这个方法，传入的child ==null
                handled = dispatchTransformedTouchEvent(ev, canceled, null,
                        TouchTarget.ALL_POINTER_IDS);

这是将调用dispatchTransformedTouchEvent 并传入的child==null,那么将会执行
dispatchTransformedTouchEvent 方法中的
handled = super.dispatchTouchEvent(event);
这个上文已经分析过了。

 if (child == null) {
                handled = super.dispatchTouchEvent(event);
            } else {
                handled = child.dispatchTouchEvent(event);
            }

在看第 9条注释：
这个是发生在，子View可能正在处理事件（mFirstTouchEvent!=null）,此时ViewGroup决定拦截事件，这是ViewGroup就会偷取子View的事件，向子View发送一个cancel事件，然后将子View从TouchTarget中移除，将导致mFirstTouchEvent重新为 null, 使得接下来的事件交由 ViewGroup自身处理
相关代码：

 final boolean cancelChild = resetCancelNextUpFlag(target.child)
                                || intercepted;
                                //传递一个 cancel事件给 子View
                        if (dispatchTransformedTouchEvent(ev, cancelChild,
                                target.child, target.pointerIdBits)) {
                            handled = true;
                        }
                        if (cancelChild) {
                            if (predecessor == null) {
                                mFirstTouchTarget = next;
                            } else {
                                predecessor.next = next;
                            }
                            //回收target
                            target.recycle();
                            target = next;
                            continue;

那么事件的分发到这里，就基本讲完了，其中很多细节目前还不是很懂，需要以后继续学习，下面我上传流程图：