【安卓开发艺术探索】第3章 触摸事件传递 笔记

为了更有条理，我将分两个方面介绍触摸事件的传递：触摸事件的传递机制和事件传递的总入口。

触摸事件传递机制

View中：

我们先看View，View里有个dispatchTouchEvent方法，顾名思义，这里将是一般意义上的第一个接收到事件的方法，简单而言这个方法会按顺序调用onTouchListener.onTouch，如果此方法成功消化了事件，就不再继续，否则继续调用onTouchEvent，这个方法的默认实现会做一些点击的检查比如performClick，checkForLongClick方法，没错，像onClickListener.onClick都是在默认的onTouchEvent中做处理的。onTouchEvent的返回结果也将表明这个view是否能消化此事件，如果不能，那么后续的事件也不会发给它。
来看下上面说的这些过程的代码，删掉了与此关系不大的代码：

    public boolean dispatchTouchEvent(MotionEvent event) {

        boolean result = false;

        if (onFilterTouchEventForSecurity(event)) {

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

        return result;
    }

从后两个if语句就能得到我上面所说的论述了。至此，不难得出一个事件能否被消化会根据如下顺序决定（在默认dispatchTouchEvent逻辑下）：

• onTouchListener.onTouch
• onTouchEvent
• 默认实现的onTouchEvent的返回值又会取决于：
  
  • clickable
  • long_clickable
  • context_clickable

所以咯，如果你想表示能处理这个事件，即返回true，方式有很多很多了，重写onTouchEvent，甚至重写dispatchTouchEvent，当然这里的重写，并不是指完全不用父亲的方法，而只是不用父亲的方法的返回值，比如：

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        super.onTouchEvent(event);
        return result;
    }

另外，请注意对于ACTION_DOWN事件，整个调用链上的onTouchEvent都会被调用，当你还不确定是否要消化这次事件的时候，请不要在ACTION_DOWN的事件中做任何业务处理，否则效果就是无论你是否消化，每次点击都会触发你的业务代码。

---

小插曲

我在测试多点触摸时，在onTouchEvent中打印MotionEvent的信息，发现每次当多于2个指头的时候，就会触发ACTION_CANCEL事件，上网查了一波没有结果，国外网站回答说一般是父亲夺取了事件处理权会触发ACTION_CANCEL（其实你最好别这么认为，因为每次事件序列是否拦截对于“一般的父亲”只有一次机会决定，MotionEvent源码对此注释是，你可以将此认为是不需要做对应处理的ACTION_UP事件）。
经过我再三思考，忽然想到，擦三个手指滑动时不就和系统截屏快捷键冲突了吗？突然想到，擦，会不会是系统拦截了，于是打开设置，关闭三指截屏功能的时候看到这么一句话：会影响所有三指和三指以上的触摸操作。晕。。关了以后发现终于正常了，10点触摸也没问题。。

---

ViewGroup中：

ViewGroup里重写了dispatchTouchEvent，这完全可以理解，毕竟它要负责把事件真正传递给孩子，如果没有孩子能处理，那么再看看自己能不能处理。
我们能简单地理解dispatchTouchEvent的逻辑是：

• 如果是ACTION_DOWN，复位状态。检查intercept情况，如果没有孩子调用过requestDisallowInterceptTouchEvent的话，会通过调用onInterceptTouchEvent（ViewGroup特有方法）来判断是否要拦截，默认不拦截。如果最后结果是要拦截，那么孩子就无缘接收此次事件流了（是的，叫它事件流是因为后续的ACTION_MOVE和UP你都没法收到了）。如果不拦截，继续执行。
• 遍历childView（遍历顺序可以通过drawingOrder更改，默认从后到前），寻找合适的View（什么叫合适的View，条件比较复杂，比如可见性，比如触摸点在孩子之中等等）。找到了合适的View后，会调用dispatchTransformedTouchEvent（为什么是TransformedTouchEvent？注释里有解释，其中包括把坐标转换到了childView的本地坐标）。而在这个方法中一般会调用childView.dispatchTouchEvent。于是这个事件就经过转换，发给了下一级的View。以此类推。

另外，ViewGroup的onTouchEvent没有重写，使用上面View默认的。
问题来了：

1. 如何实现将一次事件流发给固定的目标呢？
2. 如果是自己拦截，那么谁去调用自己的onTouchEvent呢？

解释：ViewGroup通过TouchTarget类构造了一个单链表，它保存的是目标View和对应的pointerId等信息。mFirstTouchTarget是根节点，在找到合适的childView的时候，会调用addTouchTarget把新的TouchTarget插到表头，即mFirstTouchTarget指向最新的TouchTarget，而对于一般情况这个过程只发生在ACTION_DOWN的时候。所以一般情况下这个链表其实只有一个元素。

在dispatchTouchEvent的最后部分（除了ACTION_DOWN事件下也运行），会检查mFirstTouchTarget：

如果是空的，则会调用dispatchTransformedTouchEvent，但是有一个参数View child传递了null，在dispatchTransformedTouchEvent对null的处理就是去调用super.dispatchTouchEvent，也就是自己继承的View的dispatchTouchEvent重复上面讲的部分，也会调用到ViewGroup自己的onTouchEvent咯。

如果不是空的，则对单链表进行遍历，调用dispatchTransformedTouchEvnet传递的自然是当前TouchTarget的view。于是自然而然就会不断指向一个固定的View传递event调用dispatchTouchEvent了。
贴一下删减过的源码：

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

            if (actionMasked == MotionEvent.ACTION_DOWN) {
                //这里会清空TouchTarget
                cancelAndClearTouchTargets(ev);
                resetTouchState();
            }

            //检查是不是要拦截
            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 {
                intercepted = true;
            }

            TouchTarget newTouchTarget = null;
            boolean alreadyDispatchedToNewTouchTarget = false;
            if (!canceled && !intercepted) {

                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;
                    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 = buildOrderedChildList();
                        final boolean customOrder = preorderedList == null
                                && isChildrenDrawingOrderEnabled();
                        final View[] children = mChildren;
                        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);

                            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)) {
                                //已找到
                                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();
                                //把新的touchTarget插入到表头，即mFirstTouchTarget是新的touchTarget
                                newTouchTarget = addTouchTarget(child, idBitsToAssign);
                                alreadyDispatchedToNewTouchTarget = true;
                                break;
                            }

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

            //一般情况下，根据touchTarget情况进行分发。
            if (mFirstTouchTarget == null) {
                //注意第三个参数，没有找到合适的view时。
                handled = dispatchTransformedTouchEvent(ev, canceled, null,
                        TouchTarget.ALL_POINTER_IDS);
            } else {
                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;
                }
            }
        }

        return handled;
    }

贴一下dispatchTransformedTouchEvent:

    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);
            //这里只是举个例子，这个方法中有很多类似下面这样的代码，如果child为null，
            //就调用super的dispatchTouchEvent方法。
            if (child == null) {
                handled = super.dispatchTouchEvent(event);
            } else {
                handled = child.dispatchTouchEvent(event);
            }
            event.setAction(oldAction);
            return handled;
        }
        ....


        transformedEvent.recycle();
        return handled;
    }

这样就应该都清楚啦。可以自己写一个能切换ViewGroup拦截事件和childView处理事件的测试app试试自己是否掌握。

触摸事件的总入口

View之间的传递机制都了解了，下面我们再稍微深入一下，就和第4章的笔记一样，测、布、绘是从ViewRootImpl的performTraversals开始执行的一样，这此触摸事件的入口，也是来自ViewRootImpl，简单说是一个它的内部类的方法收到事件之后，开始调用mView.dispatchTouchEvent，而这个mView毫无疑问就是DecorView。简单看下代码：

        private int processPointerEvent(QueuedInputEvent q) {
            final MotionEvent event = (MotionEvent)q.mEvent;

            mAttachInfo.mUnbufferedDispatchRequested = false;
            //注意这句，dispatchPointerEvent是View的一个方法
            boolean handled = mView.dispatchPointerEvent(event);
            if (mAttachInfo.mUnbufferedDispatchRequested && !mUnbufferedInputDispatch) {
                mUnbufferedInputDispatch = true;
                if (mConsumeBatchedInputScheduled) {
                    scheduleConsumeBatchedInputImmediately();
                }
            }
            return handled ? FINISH_HANDLED : FORWARD;
        }

贴一下dispatchPointerEvent的源码：

    public final boolean dispatchPointerEvent(MotionEvent event) {
        if (event.isTouchEvent()) {
            return dispatchTouchEvent(event);
        } else {
            return dispatchGenericMotionEvent(event);
        }
    }

好了，不必多说了，开始进入dispatchTouchEvent了（DecorView还简单重写了这个方法，不过依然回调了父类的方法）。这样就真正进入了上面讲的的View之间的事件传递过程了。