Android事件分发机制——Touch事件

// 处理触摸屏事件。可以重写这个函数来拦截所有的触摸屏事件，不让它们分发到window。为了应该被正常处理的触摸屏幕事件，一定要确保调用这个实现。
public boolean dispatchTouchEvent(MotionEvent ev) {
    if (ev.getAction() == MotionEvent.ACTION_DOWN) {  // 从ACTION_DOWN事件开始本次触摸事件
        onUserInteraction();
    }
    if (getWindow().superDispatchTouchEvent(ev)) {  // 会调用window中的根ViewGroup进行事件分发
        return true;   // 如果子View消费了这个事件，返回true.
    }
    return onTouchEvent(ev);    // 没有View处理本次事件，调用Activity的onTouchEvent。
}

// 当一个触摸屏事件没有被它下面的任意view处理的时候，调用这个函数。这个处理对于触摸事件超出window范围的时候很有用，这个时候没有view接收到事件。
public boolean onTouchEvent(MotionEvent event) {
    if (mWindow.shouldCloseOnTouch(this, event)) {
        finish();
        return true;
    }
    return false;
}

// 将屏幕触摸事件向下传递给目标view.
public boolean dispatchTouchEvent(MotionEvent event) {
    ......
    if (onFilterTouchEventForSecurity(event)) {
        // ListenerInfo类保存了设给这个view的各种listener，如OnClickListener,OnTouchListener等。
        ListenerInfo li = mListenerInfo;
        if (li != null && li.mOnTouchListener != null && (mViewFlags & ENABLED_MASK) == ENABLED
                       && li.mOnTouchListener.onTouch(this, event)) {
            // 当mOnTouchListener不为null，当前控件是enable的，且mOnTouchListener.onTouch返回true, 那么dispatchTouchEvent返回true.
            // 从这里可以看到onTouch执行要先于onTouchEvent及onClick
            return true;
        }
        // 上面的条件都不成立，才会执行onTouchEvent()
        if (onTouchEvent(event)) {       // 如果一个控件是可点击的，那么onTouchEvent必定返回true, 因此dispatchTouchEvent也返回true.
            return true;
        }
    }
    ......
    return false;
} 

// 实现这个方法处理屏幕触摸手势事件
// 如果这个方法被用于检测点击动作，那么推荐通过调用performClick来实现。这样做可以确保系统行为一致，包括服从点击声音喜好,调度OnClickListener调用，当辅助 // 功能启用的时候处理ACTION_CLICK ACTION_CLICK。
public boolean onTouchEvent(MotionEvent event) {
    final int viewFlags = mViewFlags;
    if ((viewFlags & ENABLED_MASK) == DISABLED) {
        if (event.getAction() == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {
            setPressed(false);    // 设置按下UI状态
        }
        // 一个可点击的但是disabled的view仍然消费touch事件，只是不作出回应。
        return (((viewFlags & CLICKABLE) == CLICKABLE || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE));
    }
    ......    
    if (((viewFlags & CLICKABLE) == CLICKABLE || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)) {
        switch (event.getAction()) {
            case MotionEvent.ACTION_UP:
                boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;
                if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) {
                    // 如果我们没有拥有它，我们应该获取焦点，而且应该在Touch模式下。
                    boolean focusTaken = false;
                    if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {
                        focusTaken = requestFocus();
                    }
    
                    if (prepressed) {
                        // 按钮在我们实际显示它按下之前被释放。现在使它显示按下状态(在调度click之前)，以确保用户看到它。
                        setPressed(true);
                    }

                    if (!mHasPerformedLongPress) {
                        // 这是一个阀门，所以移除长按的检查
                        removeLongPressCallback();
                        // 只有在按下状态中时才执行click动作。
                        if (!focusTaken) {
                            // 使用Runnable和post执行performClick,而不是直接执行。这样可以让这个view的其它可见状态在click操作开始前更新。
                            if (mPerformClick == null) {
                                mPerformClick = new PerformClick();
                            }
                            if (!post(mPerformClick)) {
                                performClick();              // 注意,在MotionEvent.ACTION_UP时执行click。
                            }
                        }
                    }
                    if (mUnsetPressedState == null) {
                        mUnsetPressedState = new UnsetPressedState();
                    }
                    if (prepressed) {
                        postDelayed(mUnsetPressedState, ViewConfiguration.getPressedStateDuration());
                    } else if (!post(mUnsetPressedState)) {
                        mUnsetPressedState.run();
                    }
                    removeTapCallback();
                }
                break;
    
            case MotionEvent.ACTION_DOWN:
                mHasPerformedLongPress = false;
                if (performButtonActionOnTouchDown(event)) {
                    break;
                }
    
                // 沿层次结构走，以确定我们是否在一个滚动的容器内。
                boolean isInScrollingContainer = isInScrollingContainer();
                // 对于在一个滚动容器内的views,延迟一会按下的反馈，以防这是一个滚动。
                if (isInScrollingContainer) {
                    mPrivateFlags |= PFLAG_PREPRESSED;
                    if (mPendingCheckForTap == null) {
                        mPendingCheckForTap = new CheckForTap();
                    }
                    postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
                } else {
                    // 如果不是在一个正在滚动的容器内，那么马上显示反馈。
                    setPressed(true);
                    checkForLongClick(0);
                }
                break;
    
            case MotionEvent.ACTION_CANCEL:
                setPressed(false);
                removeTapCallback();
                removeLongPressCallback();
                break;

            case MotionEvent.ACTION_MOVE:
                final int x = (int) event.getX();
                final int y = (int) event.getY();
                // 按钮之外的移动要容忍。
                if (!pointInView(x, y, mTouchSlop)) {
                    // Outside button
                    removeTapCallback();
                    if ((mPrivateFlags & PFLAG_PRESSED) != 0) {
                        // 移除后面长按/阀门的检查
                        removeLongPressCallback();
                        setPressed(false);
                    }
                }
            break;
        }
        return true; // 如果一个控件是可点击的，那么点击该控件时，onTouchEvent的返回值必定是true
    } 
    return false;
} 

// 如果定义了OnClickListener，则调用。执行所有与click关联的动作：报告可访问性事件，播放按键声音。
public boolean performClick() {
    sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);
    
    ListenerInfo li = mListenerInfo;
    if (li != null && li.mOnClickListener != null) {
        playSoundEffect(SoundEffectConstants.CLICK);
        li.mOnClickListener.onClick(this);
        return true;
    }
    return false;
}

public void setOnClickListener(OnClickListener l) {
    if (!isClickable()) {
        setClickable(true);  // 如果这个view不是clickable，将它设置为clickable。
    }
    getListenerInfo().mOnClickListener = l;
}

// 实现这个方法来拦截所有触摸屏移动事件。这可以让你在事件被分配给孩子的时候看到事件，并在任意时刻获取当前手势的所有权。
// 使用这个功能需要特别注意，因为它与View.onTouchEvent有着相当复杂的相互作用，并且使用它还需要以正确的方式实现这个方法。
// 事件将会以下面顺序被接收：
// (1) ViewGroup会在这里接收到DOWN事件，这个DOWN事件会被这个ViewGroup的一个子View处理掉，或者给这个ViewGroup自己的onTouchEvent函数进行处理。那就意味着ViewGroup应该实现onTouchEvent()函数并且返回true, 这样你就会继续看到手势的后续事件(而不是寻找父View来处理)。
// (2) 通过从ViewGroup自己的onTouchEvent()返回true, ViewGroup的onInterceptTouchEvent()中将不会再收到任何后续事件，即后续事件不用再经过onInterceptTouchEvent()了，所有触摸的处理都像正常情况一样发生在onTouchEvent里了。
// (3) 只要ViewGroup从这个函数返回false，接下来的每个事件(包括最后的UP)都会首先传递到这里，然后再传递给目标View的onTouchEvent()。
// (4) 如果ViewGroup从这个函数返回true，说明从子view拦截了事件，并将它们通过onTouchEvent()传递给这个ViewGroup。当前目标View将接收到相同事件，但是Action为ACTION_CANCEL，并且没有进一步消息在这里传递。

public boolean onInterceptTouchEvent(MotionEvent ev) {  
    return false;  
}

public boolean dispatchTouchEvent(MotionEvent ev) {
    if (mInputEventConsistencyVerifier != null) {
        mInputEventConsistencyVerifier.onTouchEvent(ev, 1);
    }
    
    boolean handled = false;
    if (onFilterTouchEventForSecurity(ev)) {
        final int action = ev.getAction();
        final int actionMasked = action & MotionEvent.ACTION_MASK;

        // 处理最初的down事件
        if (actionMasked == MotionEvent.ACTION_DOWN) {
            // 开始一个新的触摸手势时，丢掉所有之前的状态。framework可能由于app切换，ANR或者其它状态变化而放弃前一个手势的up或者cancel事件。
            cancelAndClearTouchTargets(ev);
            resetTouchState();
        }

        // 检查拦截
        final boolean intercepted;
        if (actionMasked == MotionEvent.ACTION_DOWN || mFirstTouchTarget != null) {
            final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;       // 是否禁用事件拦截功能，默认为false.
            if (!disallowIntercept) {
                intercepted = onInterceptTouchEvent(ev);// 根据onInterceptTouchEvent返回值决定是否拦截，返回false表示不拦截，返回true表示拦截。
                ev.setAction(action); // 重新保存action,以防它发生变化。
            } else {
                intercepted = false;
            }
        } else {
            // 没有触摸目标且action不是最初的DOWN事件，那么这个ViewGroup继续拦截触摸事件。
            intercepted = true;
        }

        // 检查取消
        final boolean canceled = resetCancelNextUpFlag(this) || actionMasked == MotionEvent.ACTION_CANCEL;

        // 如果需要，更新触摸目标列表给向下的指针。
        final boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0;
        TouchTarget newTouchTarget = null;
        boolean alreadyDispatchedToNewTouchTarget = false;
        if (!canceled && !intercepted) { // 如果不是CANCEL，而且不拦截事件，则往下走。intercepted的值在前面被赋值。intercepted为true，则事件不再往下传。
            if (actionMasked == MotionEvent.ACTION_DOWN || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
                            || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
                final int actionIndex = ev.getActionIndex();  // DOWN事件这个值通常为0
                final int idBitsToAssign = split ? 1 << ev.getPointerId(actionIndex) : TouchTarget.ALL_POINTER_IDS;
    
                // 为该指针id除早期的触摸目标，以防它们已经不同步了。
                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 View[] children = mChildren;
                    final boolean customOrder = isChildrenDrawingOrderEnabled();
                    for (int i = childrenCount - 1; i >= 0; i--) {
                        final int childIndex = customOrder ? getChildDrawingOrder(childrenCount, i) : i;
                        final View child = children[childIndex];
                        if (!canViewReceivePointerEvents(child) || !isTransformedTouchPointInView(x, y, child, null)) {
                            continue;
                        }
    
                        newTouchTarget = getTouchTarget(child);
                        if (newTouchTarget != null) {
                            // 子view已经在它的范围内接收触摸事件了。
                            // 给它新指针，除了它正在处理的指针。
                            newTouchTarget.pointerIdBits |= idBitsToAssign;
                            break;      // 找到了接收事件的target，跳出循环。
                        }
    
                        resetCancelNextUpFlag(child);
                        if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {   // dispatchTransformedTouchEvent函数中调用子view的dispatchTouchEvent。
                            // 子view在它的范围内接收触摸事件。
                            mLastTouchDownTime = ev.getDownTime();
                            mLastTouchDownIndex = childIndex;
                            mLastTouchDownX = ev.getX();
                            mLastTouchDownY = ev.getY();
                            newTouchTarget = addTouchTarget(child, idBitsToAssign);
                            alreadyDispatchedToNewTouchTarget = true;
                            break;
                        }
                    }
                }
    
                if (newTouchTarget == null && mFirstTouchTarget != null) {
                    // 没有找到一个子view来接收事件，将指针指向最近添加的目标。
                    newTouchTarget = mFirstTouchTarget;
                    while (newTouchTarget.next != null) {
                        newTouchTarget = newTouchTarget.next;
                    }
                    newTouchTarget.pointerIdBits |= idBitsToAssign;
                }
            }
        }
        // 分发给触摸目标
        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;
            }
        }
    
        // Update list of touch targets for pointer up or cancel, if needed.
        // 如果需要，为指针UP或者CANCEL更新触摸目标列表。
        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;
}

// 将手势事件转换成特定子view的坐标空间，过滤无关的指针ID，如有必要覆盖它的action。如果child为null,则取而代之的是假定手势事件会发送给该ViewGroup。
private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel, View child, int desiredPointerIdBits) {
    final boolean handled;
 
    // 取消手势动作是一种特殊情况。不需要执行任何转换或者过滤操作。重点关注的是action，而不是内容。
    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);     // 调用child的dispatchTouchEvent。
        }
        event.setAction(oldAction);
        return handled;
    }

    // 结算要传递的指针数量。
    final int oldPointerIdBits = event.getPointerIdBits();
    final int newPointerIdBits = oldPointerIdBits & desiredPointerIdBits;

    // 如果因为某种原因，我们在一个不符的状态中结束了，在这个状态中看起来我们可能会产生一个不带指针的手势事件，那么就放弃这个事件。
    if (newPointerIdBits == 0) {
        return false;
    }

    // 如果指针的数量是相等的，那么我们就不需要执行任何代价高的不可逆转的转换，那么只要我们小心恢复我们做的任何修改，我们就可以在这次分发中重用手势事件。
    // 否则，我们就需要复制一个手势事件。
    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);
    }

    // 执行任何需要的转换和分发。
    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); //若一个控件是可点击的，则点击该控件时，dispatchTouchEvent的返回值必定是true
    }
    // 完成
    transformedEvent.recycle();
    return handled;
}