美文网首页
Android View从源码的角度分析Touch事件传递流程

Android View从源码的角度分析Touch事件传递流程

作者: 走在路上的日子 | 来源:发表于2018-07-30 10:27 被阅读0次

    都知道在Android中的事件主要包括三部分内容:分发事件dispatchTouchEvent、拦截事件onInterceptTouchEvent、消费事件onTouchEvent。这几乎是所有开发者都要面临的问题,无论是解决一些事件冲突问题,还是自定义View,都会或多或少涉及到。由于其独特的重要性,大多数面试的时候也基本会有所涉及,所以很好的掌握View的Touch事件传递显得尤其重要。

    1、Activity的dispatchTouchEvent

    首先来看Activity的dispatchTouchEvent方法:

        /**
         * Called to process touch screen events.  You can override this to
         * intercept all touch screen events before they are dispatched to the
         * window.  Be sure to call this implementation for touch screen events
         * that should be handled normally.
         *
         * @param ev The touch screen event.
         *
         * @return boolean Return true if this event was consumed.
         */
        public boolean dispatchTouchEvent(MotionEvent ev) {
            if (ev.getAction() == MotionEvent.ACTION_DOWN) {
                onUserInteraction();
            }
            if (getWindow().superDispatchTouchEvent(ev)) {
                return true;
            }
            return onTouchEvent(ev);
        }
    
    

    如果事件为按下状态,则先调用onUserInteraction方法:

          /**
         * Called whenever a key, touch, or trackball event is dispatched to the
         * activity.  Implement this method if you wish to know that the user has
         * interacted with the device in some way while your activity is running.
         * This callback and {@link #onUserLeaveHint} are intended to help
         * activities manage status bar notifications intelligently; specifically,
         * for helping activities determine the proper time to cancel a notfication.
         *
         * <p>All calls to your activity's {@link #onUserLeaveHint} callback will
         * be accompanied by calls to {@link #onUserInteraction}.  This
         * ensures that your activity will be told of relevant user activity such
         * as pulling down the notification pane and touching an item there.
         *
         * <p>Note that this callback will be invoked for the touch down action
         * that begins a touch gesture, but may not be invoked for the touch-moved
         * and touch-up actions that follow.
         *
         * @see #onUserLeaveHint()
         */
        public void onUserInteraction() {
        }
    
    

    该方法为空,从注释可以知道,当此activity在栈顶时,触屏点击按home、back、menu键等都会触发此方法,一般会用于屏保。

    接着调用了getWindow().superDispatchTouchEvent(ev),即PhoneWindow类(Window的具体实现类)的superDispatchTouchEvent方法:

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

    简单调用了mDecor.superDispatchTouchEvent(event),即DecorView的superDispatchTouchEvent方法:

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

    我们知道DecorView继承自FrameLayout,FrameLayout又继承了ViewGroup,所以这里就是调用了ViewGroup的dispatchTouchEvent方法。

    所以执行getWindow().superDispatchTouchEvent(ev)实际上是执行了ViewGroup.dispatchTouchEvent(event),这样事件就从 Activity 传递到了 ViewGroup。这里后续会接着分析。

    这里需要注意的是:

    当getWindow().superDispatchTouchEvent(ev)返回true时,即Activity的子View拦截了TouchEvent事件,那么接下来就不会再传递给Activity的onTouchEvent 方法,同时Activity的dispatchTouchEvent方法返回true;

    反之返回false时,这个事件就交给Activity的onTouchEvent 方法来处理。

        /**
         * Called when a touch screen event was not handled by any of the views
         * under it.  This is most useful to process touch events that happen
         * outside of your window bounds, where there is no view to receive it.
         *
         * @param event The touch screen event being processed.
         *
         * @return Return true if you have consumed the event, false if you haven't.
         * The default implementation always returns false.
         */
        public boolean onTouchEvent(MotionEvent event) {
            if (mWindow.shouldCloseOnTouch(this, event)) {
                finish();
                return true;
            }
     
            return false;
        }
    
    

    可以看到Activity的onTouchEvent 方法返回了false,也就意味着当getWindow().superDispatchTouchEvent(ev)返回false时,Activity的dispatchTouchEvent方法默认返回false。

    2、ViewGroup的dispatchTouchEvent

    如果要很好掌握Touch事件处理,这部分要重点学习,而且不同Android版本的实现不一致,本文仍然使用最新的Android 7.1源码,相比之前的源码加入了更多的复杂逻辑操作,但是最基本的流程保持一致。

    接下来直接分析ViewGroup的dispatchTouchEvent方法,这个方法代码比较多,就分开几段来做分析,首先来看下面这段源码:

         @Override
        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) {
                    // Throw away all previous state when starting a new touch gesture.
                    // The framework may have dropped the up or cancel event for the previous gesture
                    // due to an app switch, ANR, or some other state change.
                    cancelAndClearTouchTargets(ev);
                    resetTouchState();
                }
                ...
            }
            ...
        }
    
    

    其中第一个if语句主要用于调试可直接忽略,后面的变量handled用于表示是否有view消费了该事件,接着调用了父类View的onFilterTouchEventForSecurity方法来判断是否被其他窗口遮盖,方法具体如下:

         /**
         * Filter the touch event to apply security policies.
         *
         * @param event The motion event to be filtered.
         * @return True if the event should be dispatched, false if the event should be dropped.
         *
         * @see #getFilterTouchesWhenObscured
         */
        public boolean onFilterTouchEventForSecurity(MotionEvent event) {
            //noinspection RedundantIfStatement
            if ((mViewFlags & FILTER_TOUCHES_WHEN_OBSCURED) != 0
                    && (event.getFlags() & MotionEvent.FLAG_WINDOW_IS_OBSCURED) != 0) {
                // Window is obscured, drop this touch.
                return false;
            }
            return true;
        }
    
    

    如果被其他窗口遮挡,该方法返回false,表示需要过滤触摸事件,就会跳过dispatchTouchEvent方法中的if语句代码,直接退出dispatchTouchEvent方法并返回false,表示没有View消费Touch事件;如果没有被其他窗口遮挡,该方法返回true,进而继续执行if语句里面的代码。

    每一个事件都是由一个触摸按下事件,一个触摸抬起事件和N个触摸滑动事件组成的,触摸按下事件就是这里的ACTION_DOWN,其为一系列事件的开端。所以在ACTION_DOWN时进行一些初始化操作,分别调用了cancelAndClearTouchTargets方法和resetTouchState方法,用来清楚掉之前消费Touch事件的View信息,并重置触摸状态。

    首先来看cancelAndClearTouchTargets方法:

        /**
         * Cancels and clears all touch targets.
         */
        private void cancelAndClearTouchTargets(MotionEvent event) {
            if (mFirstTouchTarget != null) {
                boolean syntheticEvent = false;
                if (event == null) {
                    final long now = SystemClock.uptimeMillis();
                    event = MotionEvent.obtain(now, now,
                            MotionEvent.ACTION_CANCEL, 0.0f, 0.0f, 0);
                    event.setSource(InputDevice.SOURCE_TOUCHSCREEN);
                    syntheticEvent = true;
                }
     
                for (TouchTarget target = mFirstTouchTarget; target != null; target = target.next) {
                    resetCancelNextUpFlag(target.child);
                    dispatchTransformedTouchEvent(event, true, target.child, target.pointerIdBits);
                }
                clearTouchTargets();
     
                if (syntheticEvent) {
                    event.recycle();
                }
            }
        }
    
    

    首先判断目标View,如果存在则进行统一清除操作。如果event为空,则将动作设为ACTION_CANCEL,接着用一个for循环不断向下传递触摸事件,然后再清除所有触摸目标,最后在回收拷贝的对象。

    接着再来看resetTouchState方法:

        /**
         * Resets all touch state in preparation for a new cycle.
         */
        private void resetTouchState() {
            clearTouchTargets();
            resetCancelNextUpFlag(this);
            mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;
            mNestedScrollAxes = SCROLL_AXIS_NONE;
        }
    
    

    该方法非常简单,就是重置了一些Touch标志位。

    然后继续回到dispatchTouchEvent方法,看第二个代码块:

                // Check for interception.
                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;
    
    

    变量intercepted用来标记是否要拦截该Touch事件,true表示拦截,false表示不拦截。

    接着一个if判断语句,如果为ACTION_DOWN事件,此时还没有找到消费Touch事件的View,所以mFirstTouchTarget为空;如果为ACTION_MOVE和ACTION_UP事件,当前面的ACTION_DOWN事件找到了消费Touch事件的View则mFirstTouchTarget不为空。这两种情况都可以执行if里面的代码块。

    变量disallowIntercept 用来标记是否允许拦截,默认为false,但是可以通过 requestDisallowInterceptTouchEvent方法来重置该变量的值。

    如果允许拦截,则调用onInterceptTouchEvent方法,即我们熟知的拦截事件。该方法代码如下:

         /**
         * Implement this method to intercept all touch screen motion events.  This
         * allows you to watch events as they are dispatched to your children, and
         * take ownership of the current gesture at any point.
         *
         * <p>Using this function takes some care, as it has a fairly complicated
         * interaction with {@link View#onTouchEvent(MotionEvent)
         * View.onTouchEvent(MotionEvent)}, and using it requires implementing
         * that method as well as this one in the correct way.  Events will be
         * received in the following order:
         *
         * <ol>
         * <li> You will receive the down event here.
         * <li> The down event will be handled either by a child of this view
         * group, or given to your own onTouchEvent() method to handle; this means
         * you should implement onTouchEvent() to return true, so you will
         * continue to see the rest of the gesture (instead of looking for
         * a parent view to handle it).  Also, by returning true from
         * onTouchEvent(), you will not receive any following
         * events in onInterceptTouchEvent() and all touch processing must
         * happen in onTouchEvent() like normal.
         * <li> For as long as you return false from this function, each following
         * event (up to and including the final up) will be delivered first here
         * and then to the target's onTouchEvent().
         * <li> If you return true from here, you will not receive any
         * following events: the target view will receive the same event but
         * with the action {@link MotionEvent#ACTION_CANCEL}, and all further
         * events will be delivered to your onTouchEvent() method and no longer
         * appear here.
         * </ol>
         *
         * @param ev The motion event being dispatched down the hierarchy.
         * @return Return true to steal motion events from the children and have
         * them dispatched to this ViewGroup through onTouchEvent().
         * The current target will receive an ACTION_CANCEL event, and no further
         * messages will be delivered here.
         */
        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;
        }
    
    

    该方法是ViewGroup中特有的方法,用于表示是否拦截触摸事件。返回为true的话则表示拦截事件,事件不在向子View中分发,若返回false的话,则表示不拦截事件,将继续分发事件。

    正常都是返回默认的false,但是一般我们在自定义ViewGroup中会重写该方法,用于拦截事件的分发。当我们在父ViewGroup重写该方法返回为true执行事件拦截的逻辑的时候,可以在子View中通过调用requestDisallowInterceptTouchEvent方法,重新设置父ViewGroup的onInterceptTouchEvent方法为false,不拦截对事件的分发逻辑。

    这里也是我们在开发中接触碰到的问题,所以需要好好理解一下,下面为requestDisallowInterceptTouchEvent方法的源码:

        @Override
        public void requestDisallowInterceptTouchEvent(boolean disallowIntercept) {
     
            if (disallowIntercept == ((mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0)) {
                // We're already in this state, assume our ancestors are too
                return;
            }
     
            if (disallowIntercept) {
                mGroupFlags |= FLAG_DISALLOW_INTERCEPT;
            } else {
                mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;
            }
     
            // Pass it up to our parent
            if (mParent != null) {
                mParent.requestDisallowInterceptTouchEvent(disallowIntercept);
            }
        }
    
    

    拦截事件判断完成后,会接着调用resetCancelNextUpFlag方法来检查当前事件是否被取消。

        /**
         * Resets the cancel next up flag.
         * Returns true if the flag was previously set.
         */
        private static boolean resetCancelNextUpFlag(@NonNull View view) {
            if ((view.mPrivateFlags & PFLAG_CANCEL_NEXT_UP_EVENT) != 0) {
                view.mPrivateFlags &= ~PFLAG_CANCEL_NEXT_UP_EVENT;
                return true;
            }
            return false;
        }
    
    

    继续回到dispatchTouchEvent方法,看第三个代码块:

                 // 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;
                if (!canceled && !intercepted) {
     
                    // If the event is targeting accessiiblity 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 = 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 = 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 (!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();
                                    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;
                        }
                    }
                }
    
    

    该段代码首先是一个if判断语句,如果事件没有被取消,也没有被拦截,就分发该事件。只有ACTION_DOWN事件才会执行第二个if语句里面的代码,对于ACTION_MOVE和ACTION_UP事件则直接传给消费了ACTION_DOWN事件的目标View。

    接着获取该ViewGroup中子View的个数,得到该事件发生的位置,获取子View的list集合preorderedList,再通过for循环倒序遍历当前ViewGroup的所有子视图。

    有一点值得注意的是,这里采用了倒序遍历,这是由于preorderedList中的顺序是按照addView或XML布局文件中的顺序来的。如点击的地方有两个子View都包含点击事件的坐标,那么后被添加到布局中的那个子view会先响应事件,即点击的时候最上层的那个组件先去响应该事件。

    在for循环中第一个if语句调用了canViewReceivePointerEvents(child)和isTransformedTouchPointInView(x, y, child, null)方法。

        /**
         * Returns true if a child view can receive pointer events.
         * @hide
         */
        private static boolean canViewReceivePointerEvents(@NonNull View child) {
            return (child.mViewFlags & VISIBILITY_MASK) == VISIBLE
                    || child.getAnimation() != null;
        }
    
    

    该方法用于判断当前视图的状态,只有其正在显示或正在执行动画,才可以接受触摸事件。

        /**
         * Returns true if a child view contains the specified point when transformed
         * into its coordinate space.
         * Child must not be null.
         * @hide
         */
        protected boolean isTransformedTouchPointInView(float x, float y, View child,
                PointF outLocalPoint) {
            final float[] point = getTempPoint();
            point[0] = x;
            point[1] = y;
            transformPointToViewLocal(point, child);
            final boolean isInView = child.pointInView(point[0], point[1]);
            if (isInView && outLocalPoint != null) {
                outLocalPoint.set(point[0], point[1]);
            }
            return isInView;
        }
    
    

    判断视图有scrollTo或scrollBy造成的滚动偏移也需要计算在内,并判断触摸点是否在当前子视图内。

    从这两个方法可知,如果当前子View可以消费该ACTION_DOWN事件,并且该ACTION_DOWN事件发生的位置在当前子View的范围内,则继续执行将ACTION_DOWN事件分发给它;否则continue判断下一个子View可否接受该ACTION_DOWN事件。

    然后代码通过调用getTouchTarget方法去查找当前子View是否在mFirstTouchTarget.next这条target链中的某一个targe中,如果在则返回这个target,否则返回null。紧接着用if判断找到接收Touch事件的子View,即newTouchTarget,既然已经找到则执行break跳出for循环。

    如果该子View还没有消费掉该ACTION_DOWN事件,就直接调用dispatchTransformedTouchEvent方法将该ACTION_DOWN事件传递给该子View。

        /**
         * Transforms a motion event into the coordinate space of a particular child view,
         * filters out irrelevant pointer ids, and overrides its action if necessary.
         * If child is null, assumes the MotionEvent will be sent to this ViewGroup instead.
         */
        private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
                View child, int desiredPointerIdBits) {
            final boolean handled;
     
            // Canceling motions is a special case.  We don't need to perform any transformations
            // or filtering.  The important part is the action, not the contents.
            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());
                }
     
                handled = child.dispatchTouchEvent(transformedEvent);
            }
     
            // Done.
            transformedEvent.recycle();
            return handled;
        }
    
    

    该方法是一个非常重要的方法,其主要包括三块内容,结构雷同。而且会发现该方法中代码为一个递归调用,若其子View是ViewGroup则重复执行ViewGroup的dispatchTouchEvent方法,若其子View是View则执行View的dispatchTouchEvent方法。

    从最开始到这里,我们大概分析了一下事件分发流程,通过调用Activity的dispatchTouchEvent方法,事件会首先被派发到最顶级的DecorView也就是ViewGroup,再由ViewGroup递归传递到View的dispatchTouchEvent方法。对于View的dispatchTouchEvent方法,我们后面再做分析。

    如果dispatchTransformedTouchEvent方法返回true,则表示子View消费掉该事件。那么就回到dispatchTouchEvent方法继续执行if语句里的代码块,将子View加入到mFirstTouchTarget链表的表头,并且将该表头赋值给newTouchTarget,同时 alreadyDispatchedToNewTouchTarget置为true,说明有子View消费掉了该down事件。

    for循环执行完毕后,如果newTouchTarget为null,且 mFirstTouchTarget不为null,即没找到子View来消耗该事件,但为了保存Touch事件的链表不为空,则把newTouchTarget赋值为最早加进mFirstTouchTarget链表的target。

    再看dispatchTouchEvent方法的第四个代码块:

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

    如果没有找到消费Touch事件的子View,则直接把当前的ViewGroup当作普通的View看待,把事件传递给自己,即前面分析的dispatchTransformedTouchEvent方法中child为null的情况;如果之前的ACTION_DOWN事件被子View消费掉了,就会直接找到该子View对应的Target,将ACTION_MOVE和ACTION_UP事件传递给它们。

    这里需要注意的是,如果intercepted为true,也就是ACTION_MOVE和ACTION_UP事件被拦截了,则cancelChild为true,则会分发一次ACTION_CANCLE事件。

    再看dispatchTouchEvent方法的第五个代码块:

        @Override
        public boolean dispatchTouchEvent(MotionEvent ev) {
            ...
            if (onFilterTouchEventForSecurity(ev)) {
                ...
                // 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;
        }
    
    

    如果当前事件是ACTION_CANCLE或ACTION_UP,会调用resetTouchState方法清空Touch状态。

    至此,ViewGroup的dispatchTouchEvent方法分析完毕。

    3、View的dispatchTouchEvent

    在分析ViewGroup的dispatchTouchEvent方法时,里面多处调用了dispatchTransformedTouchEvent方法,最终将事件从ViewGroup传递到 View,那么事件在后续如何传递的,接下来继续分析。

        /**
         * Pass the touch screen motion event down to the target view, or this
         * view if it is the target.
         *
         * @param event The motion event to be dispatched.
         * @return True if the event was handled by the view, false otherwise.
         */
        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;
                }
                //noinspection SimplifiableIfStatement
                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;
        }
    
    

    相比较ViewGroup的dispatchTouchEvent方法,View的dispatchTouchEvent方法要简便得多。当View没有被其他窗口遮挡时,判断mOnTouchListener是否为空,即判断该View有没有绑定OnTouchListener监听器。

    从源码里面可以找到,mOnTouchListener是通过setOnTouchListener方法来进行绑定的:

          /**
         * Register a callback to be invoked when a touch event is sent to this view.
         * @param l the touch listener to attach to this view
         */
        public void setOnTouchListener(OnTouchListener l) {
            getListenerInfo().mOnTouchListener = l;
        }
    
    

    OnTouchListener监听器如下:

        /**
         * Interface definition for a callback to be invoked when a touch event is
         * dispatched to this view. The callback will be invoked before the touch
         * event is given to the view.
         */
        public interface OnTouchListener {
            /**
             * Called when a touch event is dispatched to a view. This allows listeners to
             * get a chance to respond before the target view.
             *
             * @param v The view the touch event has been dispatched to.
             * @param event The MotionEvent object containing full information about
             *        the event.
             * @return True if the listener has consumed the event, false otherwise.
             */
            boolean onTouch(View v, MotionEvent event);
        }
    
    

    当前View一旦执行了setOnTouchListener方法,该View的mOnTouchListener就不为空,就会调用OnTouchListener监听器的OnTouch方法。从返回值可以看到,如果重写的OnTouch方法返回true的话,那么result的值就为true,意味着该事件被消费掉了,就不会继续执行后面的onTouchEvent方法了;否则继续执行onTouchEvent方法。

    4、View的onTouchEvent

    onTouchEvent方法源码如下:

        /**
         * Implement this method to handle touch screen motion events.
         * <p>
         * If this method is used to detect click actions, it is recommended that
         * the actions be performed by implementing and calling
         * {@link #performClick()}. This will ensure consistent system behavior,
         * including:
         * <ul>
         * <li>obeying click sound preferences
         * <li>dispatching OnClickListener calls
         * <li>handling {@link AccessibilityNodeInfo#ACTION_CLICK ACTION_CLICK} when
         * accessibility features are enabled
         * </ul>
         *
         * @param event The motion event.
         * @return True if the event was handled, false otherwise.
         */
        public boolean onTouchEvent(MotionEvent event) {
            final float x = event.getX();
            final float y = event.getY();
            final int viewFlags = mViewFlags;
            final int action = event.getAction();
     
            if ((viewFlags & ENABLED_MASK) == DISABLED) {
                if (action == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {
                    setPressed(false);
                }
                // A disabled view that is clickable still consumes the touch
                // events, it just doesn't respond to them.
                return (((viewFlags & CLICKABLE) == CLICKABLE
                        || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
                        || (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE);
            }
            if (mTouchDelegate != null) {
                if (mTouchDelegate.onTouchEvent(event)) {
                    return true;
                }
            }
     
            if (((viewFlags & CLICKABLE) == CLICKABLE ||
                    (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE) ||
                    (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE) {
                switch (action) {
                    case MotionEvent.ACTION_UP:
                        boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;
                        if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) {
                            // take focus if we don't have it already and we should in
                            // touch mode.
                            boolean focusTaken = false;
                            if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {
                                focusTaken = requestFocus();
                            }
     
                            if (prepressed) {
                                // The button is being released before we actually
                                // showed it as pressed.  Make it show the pressed
                                // state now (before scheduling the click) to ensure
                                // the user sees it.
                                setPressed(true, x, y);
                           }
     
                            if (!mHasPerformedLongPress && !mIgnoreNextUpEvent) {
                                // This is a tap, so remove the longpress check
                                removeLongPressCallback();
     
                                // Only perform take click actions if we were in the pressed state
                                if (!focusTaken) {
                                    // Use a Runnable and post this rather than calling
                                    // performClick directly. This lets other visual state
                                    // of the view update before click actions start.
                                    if (mPerformClick == null) {
                                        mPerformClick = new PerformClick();
                                    }
                                    if (!post(mPerformClick)) {
                                        performClick();
                                    }
                                }
                            }
     
                            if (mUnsetPressedState == null) {
                                mUnsetPressedState = new UnsetPressedState();
                            }
     
                            if (prepressed) {
                                postDelayed(mUnsetPressedState,
                                        ViewConfiguration.getPressedStateDuration());
                            } else if (!post(mUnsetPressedState)) {
                                // If the post failed, unpress right now
                                mUnsetPressedState.run();
                            }
     
                            removeTapCallback();
                        }
                        mIgnoreNextUpEvent = false;
                        break;
     
                    case MotionEvent.ACTION_DOWN:
                        mHasPerformedLongPress = false;
     
                        if (performButtonActionOnTouchDown(event)) {
                            break;
                        }
     
                        // Walk up the hierarchy to determine if we're inside a scrolling container.
                        boolean isInScrollingContainer = isInScrollingContainer();
     
                        // For views inside a scrolling container, delay the pressed feedback for
                        // a short period in case this is a scroll.
                        if (isInScrollingContainer) {
                            mPrivateFlags |= PFLAG_PREPRESSED;
                            if (mPendingCheckForTap == null) {
                                mPendingCheckForTap = new CheckForTap();
                            }
                            mPendingCheckForTap.x = event.getX();
                            mPendingCheckForTap.y = event.getY();
                            postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
                        } else {
                            // Not inside a scrolling container, so show the feedback right away
                            setPressed(true, x, y);
                            checkForLongClick(0, x, y);
                        }
                        break;
     
                    case MotionEvent.ACTION_CANCEL:
                        setPressed(false);
                        removeTapCallback();
                        removeLongPressCallback();
                        mInContextButtonPress = false;
                        mHasPerformedLongPress = false;
                        mIgnoreNextUpEvent = false;
                        break;
     
                    case MotionEvent.ACTION_MOVE:
                        drawableHotspotChanged(x, y);
     
                        // Be lenient about moving outside of buttons
                        if (!pointInView(x, y, mTouchSlop)) {
                            // Outside button
                            removeTapCallback();
                            if ((mPrivateFlags & PFLAG_PRESSED) != 0) {
                                // Remove any future long press/tap checks
                                removeLongPressCallback();
     
                                setPressed(false);
                            }
                        }
                        break;
                }
     
                return true;
            }
     
            return false;
        }
    
    

    该方法代码比较多,但是思路非常清晰。可以从第一个if语句看到,即使View为 disable 状态,其依然可以消耗事件。从后面的if语句可以看到,当 View 的 LongClick 或 Clickable 属性,只要有一个为 true则能消耗事件,执行onClick和onLongClick方法。

    其中onClick是在ACTION_UP事件中执行的,onLongClick是在ACTION_DOWN事件中执行的,分别对应performClick和checkForLongClick方法。

        /**
         * Call this view's OnClickListener, if it is defined.  Performs all normal
         * actions associated with clicking: reporting accessibility event, playing
         * a sound, etc.
         *
         * @return True there was an assigned OnClickListener that was called, false
         *         otherwise is returned.
         */
        public boolean performClick() {
            final boolean result;
            final ListenerInfo li = mListenerInfo;
            if (li != null && li.mOnClickListener != null) {
                playSoundEffect(SoundEffectConstants.CLICK);
                li.mOnClickListener.onClick(this);
                result = true;
            } else {
                result = false;
            }
     
            sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);
            return result;
        }
    
    

    上面代码判断mOnClickListener是否为空,即判断该View有没有绑定OnClickListener监听器。如果通过调用setOnClickListener方法绑定了OnClickListener监听器,则调用onClick方法。

        /**
         * Register a callback to be invoked when this view is clicked. If this view is not
         * clickable, it becomes clickable.
         *
         * @param l The callback that will run
         *
         * @see #setClickable(boolean)
         */
        public void setOnClickListener(@Nullable OnClickListener l) {
            if (!isClickable()) {
                setClickable(true);
            }
            getListenerInfo().mOnClickListener = l;
        }
    
    

    接着来看checkForLongClick方法的源码:

        private void checkForLongClick(int delayOffset, float x, float y) {
            if ((mViewFlags & LONG_CLICKABLE) == LONG_CLICKABLE) {
                mHasPerformedLongPress = false;
     
                if (mPendingCheckForLongPress == null) {
                    mPendingCheckForLongPress = new CheckForLongPress();
                }
                mPendingCheckForLongPress.setAnchor(x, y);
                mPendingCheckForLongPress.rememberWindowAttachCount();
                postDelayed(mPendingCheckForLongPress,
                        ViewConfiguration.getLongPressTimeout() - delayOffset);
            }
        }
    
    

    由于长按事件比较复杂,需要根据ACTION_DOWN事件开始计时,所以这里新建了一个CheckForLongPress对象,其实际为一个Runnable对象:

        private final class CheckForLongPress implements Runnable {
            private int mOriginalWindowAttachCount;
            private float mX;
            private float mY;
     
            @Override
            public void run() {
                if (isPressed() && (mParent != null)
                        && mOriginalWindowAttachCount == mWindowAttachCount) {
                    if (performLongClick(mX, mY)) {
                        mHasPerformedLongPress = true;
                    }
                }
            }
     
            public void setAnchor(float x, float y) {
                mX = x;
                mY = y;
            }
     
            public void rememberWindowAttachCount() {
                mOriginalWindowAttachCount = mWindowAttachCount;
            }
        }
    
    

    run方法中调用了performLongClick 方法,继续追踪:

        /**
         * Calls this view's OnLongClickListener, if it is defined. Invokes the
         * context menu if the OnLongClickListener did not consume the event,
         * anchoring it to an (x,y) coordinate.
         *
         * @param x x coordinate of the anchoring touch event, or {@link Float#NaN}
         *          to disable anchoring
         * @param y y coordinate of the anchoring touch event, or {@link Float#NaN}
         *          to disable anchoring
         * @return {@code true} if one of the above receivers consumed the event,
         *         {@code false} otherwise
         */
        public boolean performLongClick(float x, float y) {
            mLongClickX = x;
            mLongClickY = y;
            final boolean handled = performLongClick();
            mLongClickX = Float.NaN;
            mLongClickY = Float.NaN;
            return handled;
        }
    
    

    继续调用了重载的performLongClick 方法:

        /**
         * Calls this view's OnLongClickListener, if it is defined. Invokes the
         * context menu if the OnLongClickListener did not consume the event.
         *
         * @return {@code true} if one of the above receivers consumed the event,
         *         {@code false} otherwise
         */
        public boolean performLongClick() {
            return performLongClickInternal(mLongClickX, mLongClickY);
        }
    
    

    直接调用了performLongClickInternal方法:

        /**
         * Calls this view's OnLongClickListener, if it is defined. Invokes the
         * context menu if the OnLongClickListener did not consume the event,
         * optionally anchoring it to an (x,y) coordinate.
         *
         * @param x x coordinate of the anchoring touch event, or {@link Float#NaN}
         *          to disable anchoring
         * @param y y coordinate of the anchoring touch event, or {@link Float#NaN}
         *          to disable anchoring
         * @return {@code true} if one of the above receivers consumed the event,
         *         {@code false} otherwise
         */
        private boolean performLongClickInternal(float x, float y) {
            sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_LONG_CLICKED);
     
            boolean handled = false;
            final ListenerInfo li = mListenerInfo;
            if (li != null && li.mOnLongClickListener != null) {
                handled = li.mOnLongClickListener.onLongClick(View.this);
            }
            if (!handled) {
                final boolean isAnchored = !Float.isNaN(x) && !Float.isNaN(y);
                handled = isAnchored ? showContextMenu(x, y) : showContextMenu();
            }
            if (handled) {
                performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
            }
            return handled;
        }
    
    

    上面代码判断mOnLongClickListener是否为空,即判断该View有没有绑定OnLongClickListener监听器。如果通过调用setOnLongClickListener方法绑定了OnLongClickListener监听器,则调用onLongClick方法。

        /**
         * Register a callback to be invoked when this view is clicked and held. If this view is not
         * long clickable, it becomes long clickable.
         *
         * @param l The callback that will run
         *
         * @see #setLongClickable(boolean)
         */
        public void setOnLongClickListener(@Nullable OnLongClickListener l) {
            if (!isLongClickable()) {
                setLongClickable(true);
            }
            getListenerInfo().mOnLongClickListener = l;
        }
    
    

    从以上的代码分析知道,如果在ACTION_DOWN事件中已经执行了onLongClick的话,则mHasPerformedLongPress变量会被置为true,这样在ACTION_UP事件中,就会把onClick的回调remove掉,就不会再执行onClick了。

    至此,Touch事件的传递流程分析完毕。

    总结

    按照上面一步一步分析,流程确实比较复杂,只是便于理解具体如何传递的,最后再把其中的关键流程总结一下。主要有以下几点:

    image

    事件从Activity.dispatchTouchEveent()开始传递,只要没有拦截,就会从最上层(ViewGroup)开始一直往下传递,子View通过onTouchEvent()消费事件。如果事件从上往下一直传递到最底层的子View,但是该View并没有消费该事件,那么该事件就会反序往上传递,即从该View传递给自己的ViewGroup,然后再传给更上层的ViewGroup直至传递给Activity.onTouchEvent()。

    事件从ViewGroup传递给子View时,其中ViewGroup可以通过onInterceptTouchEvent()方法对事件进行拦截,停止其往下传递,如果拦截(即返回true)后该事件会直接走到该ViewGroup中的onTouchEvent()方法,不会再往下传递给子View。如果从DOWN开始,之后的MOVE、UP都会直接在该ViewGroup.onTouchEvent()中进行处理。

    image

    如果子View之前在处理某个事件,但是后续被ViewGroup拦截,那么子View会接收到ACTION_CANCEL。如果View没有消费ACTION_DOWN事件,之后其他的ACTION_MOVE和ACTION_UP等事件都不会传递过来。

    OnTouchListener优先于onTouchEvent()对事件进行消费,onLongClick优先于oClick对事件进行消费。

    image

    这一块的内容详细分析确实比较麻烦,但是整体疏通以后看起来大体还算比较简单的。如果有疑问,欢迎留言一起相互探讨共同进步。

    原文链接:手把手教你读懂源码,View的Touch事件传递流程详细剖析

    View系列文章:
    Android View从源码的角度分析加载流程
    Android View从源码的角度分析绘制流程
    Android View从源码的角度分析事件的注册和接收

    相关文章

      网友评论

          本文标题:Android View从源码的角度分析Touch事件传递流程

          本文链接:https://www.haomeiwen.com/subject/shvxvftx.html