Android View事件分发机制

1、OnTouch、onTouchEvent不同点以及调用顺序

当我们需要给一个button点击事件时我们只需要.setOnClickListener();就好了

当我们需要给一个button设置touch时间时，我们只需要.setOnTouchListener();

button.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        log.d("TAG", "onclick execute");
    }
});
button.setOnTouchListener(new View.OnTouchListener() {
    @Override
    public boolean onTouch(View v, MotionEvent event) {
        log.d("TAG", "onTouch execute" + event.getAction());
        return false;
    }
});

 我们可以看出，OnTouch是优于OnClick执行的，并且执行了两次。这其中分别是ACTION_DOWN和ACTION_UP(还可能有多次，因为还有ACTION_MOVE)。总结时间传递的顺序是从onTouch->onClick

如果我们在onTouch方法return false；改为 return true；结果就会是：

 click事件不执行了！从上得知是从OnTouch之后执行的onClick，我们来看看dispatchTouchEvent()源码，之所以看这个方法是因为触摸任何一个空间，就一定会调用这个方法，这个方法在View类中:

    public boolean dispatchTouchEvent(MotionEvent 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;
    }

抛开其他因素情况下，我们只看这部分代码。第一个条件相信大家看英文单词就能明白。

第二个条件：mOnTouchListener != null; 这个值在那边设置呢？在View类中:

    public void setOnTouchListener(OnTouchListener l) {
        getListenerInfo().mOnTouchListener = l;
    }

就是说我们给button设置onTouchListener就是使用这个方法。

第三个条件：(mViewFlags & ENABLED_MASK) == ENABLED 是判断当前控件是否是enabled，按钮默认是enabled。

第四个条件：mOnTouchListener.onTouch(this, event)，就是我们在设置Touch事件中onTouch方法中的返回值。

接下来我们看后面的if判断[!result && onTouchEvent(event)]，上面的经过4个条件后，如果为true，因为是与操作(&&)就不会执行onTouchEvent(event)了。否则就会执行onTouchEvent。我们继续跟踪onTouchEvent(event)，由于篇幅过长且我们之前分析过在ACTION_DOWN后，所以我这边就删减了ACTION_CANCEL和ACTION_MOVE。

public boolean onTouchEvent(MotionEvent event) {
        final float x = event.getX();
        final float y = event.getY();
        final int viewFlags = mViewFlags;
        final int action = event.getAction();

        final boolean clickable = ((viewFlags & CLICKABLE) == CLICKABLE
                || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
                || (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE;

        if ((viewFlags & ENABLED_MASK) == DISABLED) {
            if (action == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {
                setPressed(false);
            }
            mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
            // A disabled view that is clickable still consumes the touch
            // events, it just doesn't respond to them.
            return clickable;
        }
        if (mTouchDelegate != null) {
            if (mTouchDelegate.onTouchEvent(event)) {
                return true;
            }
        }

        if (clickable || (viewFlags & TOOLTIP) == TOOLTIP) {
            switch (action) {
                case MotionEvent.ACTION_UP:
                    mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
                    if ((viewFlags & TOOLTIP) == TOOLTIP) {
                        handleTooltipUp();
                    }
                    if (!clickable) {
                        removeTapCallback();
                        removeLongPressCallback();
                        mInContextButtonPress = false;
                        mHasPerformedLongPress = false;
                        mIgnoreNextUpEvent = false;
                        break;
                    }
                    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)) {
                                    performClickInternal();
                                }
                            }
                        }

                        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:
                    if (event.getSource() == InputDevice.SOURCE_TOUCHSCREEN) {
                        mPrivateFlags3 |= PFLAG3_FINGER_DOWN;
                    }
                    mHasPerformedLongPress = false;

                    if (!clickable) {
                        checkForLongClick(
                                ViewConfiguration.getLongPressTimeout(),
                                x,
                                y,
                                TOUCH_GESTURE_CLASSIFIED__CLASSIFICATION__LONG_PRESS);
                        break;
                    }

                    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(
                                ViewConfiguration.getLongPressTimeout(),
                                x,
                                y,
                                TOUCH_GESTURE_CLASSIFIED__CLASSIFICATION__LONG_PRESS);
                    }
                    break;
              
            }

            return true;
        }

        return false;
    }

代码篇幅还是过长了，我们捡重点讲。我们直接看第25行的判断，如果他是可被点击的或者可以被长按的话，进入switch判断。在switch中当我们抬起手，也就是ACTION_UP时，经过种种判断之后，会执行到performClickInternal()方法。我们进入方法瞧一瞧：

private boolean performClickInternal() {
    // Must notify autofill manager before performing the click actions to avoid scenarios where
    // the app has a click listener that changes the state of views the autofill service might
    // be interested on.
    notifyAutofillManagerOnClick();

    return performClick();
}

 在这边我们看到主要执行了performClick();

    public boolean performClick() {
        ......
        final ListenerInfo li = mListenerInfo;
        if (li != null && li.mOnClickListener != null) {
            playSoundEffect(SoundEffectConstants.CLICK);
            li.mOnClickListener.onClick(this);
            result = true;
        } else {
            result = false;
        }

        ......

        return result;
    }

在这边我们就豁然开朗了，执行了mOnClickListener.onClick();其中mOnclickListener其实是我们button.setOnClickListener()设置的，我们来找找源码。

    public void setOnClickListener(@Nullable OnClickListener l) {
        if (!isClickable()) {
            setClickable(true);
        }
        getListenerInfo().mOnClickListener = l;
    }

这样我们整个就清楚了。不过还有一个很重要的问题需要说，被遗漏了。touch的传递，给一个控件注册了touch事件，它会触发ACTION_DOWN，ACTION_MOVE，ACTION_UP 等事件。如果dispatchTouchEvent返回false的话后续就不回执行了。

也就是上面dispatchTouchEvent中这个判断，我这边重新发下判断及之后的代码

if (!result && onTouchEvent(event)) {
    result = true;
}
return result;

如果说在该方法中返回了false，整个dispatchTouchEvent的result就会是false，返回false，后续的传递就会没了。这边因为篇幅关系就简单说说，在ViewGroup里dispatchTransformedTouchEvent()中进行了处理。这就是为什么我们在OnTouch中返回了false，有些情况下只走了ACTION_DOWN。是因为onTouchEvent返回了false，会返回false的原因是因为某些控件默认是不可点击，因此进入不了if返回false。

篇幅受长，后续问题下期讲。