TouchEvent分发机制

触摸事件的传递顺序

触摸屏幕首先调用Activity的dispatchTouchEvent()，可以重写这个方法来拦截本该传递给Window的TouchEvent。

   /** * 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)) {        // 如果Window处理了触摸事件        return true;    }    // Window没有处理触摸事件，那就由Activity处理    return onTouchEvent(ev);}

Activity的onTouchEvent()默认返回false

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

所以交给Window处理是这句代码

getWindow().superDispatchTouchEvent(ev)

getWindow()方法返回Window类，查找代码发现具体实现是PhoneWindow，PhoneWindow的superDispatchTouchEvent()方法：

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

这个mDecor是一个DecorView

    // This is the top-level view of the window, containing the window decor.    private DecorView mDecor;

DecorView是PhoneWindow的内部类，继承于FrameLayout

private final class DecorView extends FrameLayout implements RootViewSurfaceTaker {}

他的superDispatchTouchEvent()方法

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

调用的是父类的方法，也就是ViewGroup中的dispatchTouchEvent()

ViewGroup的dispatchTouchEvent()

以下代码省去了部分次要代码

    @Overridepublic boolean dispatchTouchEvent(MotionEvent ev) {    boolean handled = false;    // onFilterTouchEventForSecurity()方法实现是当窗口部分被遮挡且设置了FILTER_TOUCHES_WHEN_OBSCURED标志时则返回false，即过滤掉这个TouchEvent，不执行if内语句，最后返回false    if (onFilterTouchEventForSecurity(ev)) {       ...     }    return handled;}

然后看if语句内的实现：
- ACTION_DOWN初始化点击状态

final int action = ev.getAction(); // Action本身包含action信息和pointer信息，actionMasked就是过滤掉pointer信息，只留下action信息 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);     // 这个方法把FLAG_DISALLOW_INTERCEPT清除掉了，所以子控件无法拦截父布局的ACTION_DOWN     resetTouchState();}

• 判断是否拦截：

// Check for interception. 检测拦截 final boolean intercepted; if (actionMasked == MotionEvent.ACTION_DOWN        // TouchTarget以链表形式存储，mFirstTouchTarget是链表的第一个。mFirstTouchTarget非空的情况是子View处理了事件才会赋值。所以如果ViewGruop拦截了事件，则ACTION_MOVE和ACTION_UP都不会进到这个if语句里，onInterceptTouchEvent方法不会再调用到了。         || mFirstTouchTarget != null) {         // 查看是否设置了ViewGroup不能拦截，对于ACTION_DOWWN总是不能拦截的，所以总是可以调用到onInterceptTouchEvent方法     final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;     if (!disallowIntercept) {         // 如果可以拦截，那就调用onInterceptTouchEvent()方法，该方法默认返回false         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; }

根据对以上代码的分析，可以得出以下结论：
1. 如果是ACTION_MOVE和ACTION_UP事件，而且没有子View接收事件的话，intercepted直接为true，不触发onInterceptTouchEvent()。即ViewGroup决定自己接收事件后，就不会再调用到onInterceptTouchEvent()。
2. 如果是ACTION_DOWN事件，则必定触发onInterceptTouchEvent()。
3. 如果是ACTION_MOVE和ACTION_UP事件，而且有子View接收事件，则会根据DISALLOW_INTECEPT标志决定是否调用onInterceptTouchEvent()。
- 分发事件

// 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.// 是否设置了手势分配到多个子Viewfinal boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0;TouchTarget newTouchTarget = null;boolean alreadyDispatchedToNewTouchTarget = false;if (!canceled && !intercepted) {    ...}// 分发TouchEvent，没有child处理的话就自己处理if (mFirstTouchTarget == null) {    // 没有目标view，所以把自己当做view    handled = dispatchTransformedTouchEvent(ev, canceled, null,            TouchTarget.ALL_POINTER_IDS);} else {    // 分发到新的目标上，排除掉已经分发的。如果必要的话取消掉目标    TouchTarget predecessor = null;    TouchTarget target = mFirstTouchTarget;    // 循环每个目标分发TouchEvent    while (target != null) {        final TouchTarget next = target.next;        if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {            // 如果已经分发到新target，而且当前target等于新target，handled就是true，移动到下一个目标            handled = true;        } else {            // 如果没有分发到新target，或者当前target不是新target，就根据child是否设置了NEXT_UP_FLAG或者ViewGroup拦截了这个TouchEvent来决定是否发送ACTION_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) {    // 如果是取消或者是ACTION_UP，则重置TouchTarget、清除CANEL_NEXT_UP标志、清除FLAG_DISALLOW_INTERCEPT标志       resetTouchState();} else if (split && actionMasked == MotionEvent.ACTION_POINTER_UP) {    final int actionIndex = ev.getActionIndex();    final int idBitsToRemove = 1 << ev.getPointerId(actionIndex);    removePointersFromTouchTargets(idBitsToRemove);}

如果不是取消动作，也没有拦截的话：

    // 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;    // 单独对ACTION_DOWN进行处理    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);        // 遍历子View        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;            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 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;                }                // 判断子View能否接收TouchEvent                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);                // 调用子view的dispatchTouchEvent()，根据返回结果决定要不要给mFirstTouchTarget赋值。如果子view没有处理，mFirstTouchTarget就为空，就会给ViewGroup处理。                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();                    // 给mFirstTouchTarget赋值，赋值完毕退出循环                    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;        }    }

ViewGroup的onInterceptTouchEvent()：

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

默认实现是拦截鼠标左键按下在ScrollBar滚动条事件。
在一个点击事件序列中，ViewGroup的onInterceptTouchEvent()有几个特点：
1. ACTION_DOWN事件必定会传给onInterceptTouchEvent()
2. ACTION_DOWN事件要不就是让子View去处理，要不就是ViewGroup自身的onTouchEvent()去处理。所以需要在子View或者ViewGroup本身的onTouchEvent()的ACTION_DOWN时返回true才能接收到后续事件，而不是往上一级找人来处理。
3. 而onTouchEvent()返回为true之后，后续事件就不会调用到onInterceptTouchEvent()了，直接走到onTouchEvent()
4. 如果onInterceptTouchEvent()返回为false，则后续事件都会先传递到这里，然后再传递给目标的onTouchEvent()
5. 如果onInterceptTouchEvent()返回为true，则目标view会接收到同样的事件，只不过Action改成了ACTION_CANCEL，然后事件传递到ViewGroup的onTouchEvent()，也不会再调用onInterceptTouchEvent()了。

dispatchTransformedTouchEvent():把TouchEvent转换成特定子View的坐标内，过滤掉不相关的pointer id，必要时复写action。如果子View是空的，那MotionEvent会发送给这个ViewGroup

   /** * 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;    // 首先处理CANCEL事件，如果child为空，则调用View类的dispatchTouchEvent，如果child非空，则调用其dispatchTouchEvent方法，返回处理结果    // 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;    }    // 对pointer进行处理，如果没有pointer则返回false    // 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;    }    // 如果pointer处理前后数目相等，而且我们也不进行任何不可逆的转换，则可以在本次dispatch中一直重用motion event，只要小心注意恢复做出的改变即可。不然我们就要做一个拷贝了    // 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) {        //  新的pointer个数与原有的相同        if (child == null || child.hasIdentityMatrix()) {            if (child == null) { // 调用自己作为View的dispatchTouchEvent方法                handled = super.dispatchTouchEvent(event);            } else { // 根据child的位置和自己的内容滑动距离来算出在child中的坐标，传给child后再恢复初始坐标                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;        }        // child非空而且没有identityMatrix，则拷贝这个event        transformedEvent = MotionEvent.obtain(event);    } else {        // 新的pointer个数与原有的不同，那就分割到只剩指定的pointer        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中的dispatchTouchEvent方法：

返回结果是触摸事件是否被OnTouchListener或者onTouchEvent()处理了

    /** * 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);    }    // TouchEvent处理结果    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        // 对于ACTION_DOWN，停止NestedScroll        stopNestedScroll();    }    // 跟ViewGroup一样的遮蔽判断    if (onFilterTouchEventForSecurity(event)) {        if ((mViewFlags & ENABLED_MASK) == ENABLED && handleScrollBarDragging(event)) {            // 如果当前View是enabled，而且该操作是拖动ScrollBar，设置事件处理成功            result = true;        }        //noinspection SimplifiableIfStatement        ListenerInfo li = mListenerInfo;        if (li != null && li.mOnTouchListener != null                && (mViewFlags & ENABLED_MASK) == ENABLED                && li.mOnTouchListener.onTouch(this, event)) {                // 如果当前View是enabled，而且有设置OnTouchListener，则调用OnTouchListener的onTouch方法            result = true;        }        // 如果这个事件没有被作为拖动ScrollBar消耗掉，也没有被OnTouchListener的onTOuch方法消耗掉，那就调用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.    // 如果是ACTION_UP或ACTION_CANCEL，则在停止内嵌滑动，或者说如果这是ACTION_DOWN，但是上面的三种方式都没有消耗掉这个事件，也停止内嵌滑动    if (actionMasked == MotionEvent.ACTION_UP ||            actionMasked == MotionEvent.ACTION_CANCEL ||            (actionMasked == MotionEvent.ACTION_DOWN && !result)) {        stopNestedScroll();    }    // 返回事件处理结果    return result;}

View的onTouchEvent方法：

如果view是可点击的，就返回true，否则返回false。

    /** * 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) {        // 如果当前View是DISABLED的，直接返回结果        if (action == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {            // ACTION_UP情况下设为非pressed            setPressed(false);        }        // disabled的View如果是可点击、可长按或者是ContextClickable的话，也会消耗TouchEvent，只是没有任何反应而已        // 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);    }    // 如果设置了修改点击范围的TouchDelegate，则把事件传递过去    if (mTouchDelegate != null) {        if (mTouchDelegate.onTouchEvent(event)) {            return true;        }    }    // 当前View是ENABLED，TouchEvent也没有被代理消耗掉    if (((viewFlags & CLICKABLE) == CLICKABLE ||            (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE) ||            (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE) {        // ENABLED，而且满足CLICKABLE或者LONG_CLICKABLE或者CONTEXT_CLICKABLE。如果都不满足直接返回false未处理        switch (action) {            case MotionEvent.ACTION_UP:                // prepressed状态是ACTION_DOWN后的一段极短时间的状态，过完才算pressed状态                boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;                if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) {                    // 处于prepressed或者pressed状态                    // take focus if we don't have it already and we should in                    // touch mode.                    boolean focusTaken = false;                    if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {                        // 如果当前是focusable而且focusableInTouchMode而且没有focused，就获取focus                        focusTaken = requestFocus();                    }                    if (prepressed) {                        // 预点击状态下就走到这个ACTION_UP分支，还是显示点击状态效果让用户可见                        // 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) {                        // 没有长按，只是个tap，移除长按回调                        // 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();                            }                            // 在Runnable中调用performClick或者添加到队列中失败时自行调用performClick方法，performClick中会调用到OnCLickListener                            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;}