Android 事件分发机制（1）-源码分析

沙滩捡贝壳的小孩

已于 2023-03-16 22:36:55 修改

阅读量579

点赞数

分类专栏： android基础源码解析文章标签： android android studio

于 2020-05-22 01:15:35 首次发布

本文链接：https://blog.youkuaiyun.com/z936689039/article/details/106271230

版权

android基础同时被 2 个专栏收录

22 篇文章

订阅专栏

源码解析

10 篇文章

订阅专栏

1.准备知识

要弄明白事件分发，首先得知道这么几个知识点，

1.1 activity，window，DetorView,ViewGroup这几个之间的关系

大概关系如图：

其中DecorView本身是继承至FrameLayout的，如图：

它本来就是一个ViewGroup来的，window本身是一个抽象类，PhoneWinodw是唯一实现类，如图：

1.2事件分发的对象是谁

分发对象是MotionEvent，它是当用户点击屏幕里View或者ViewGroup的时候，将会产生一个事件对象，这个事件对象就是MotionEvent对象，这个对象记录了事件的类型，触摸的位置，以及触摸的时间等。MotionEvent里面定义了事件的类型，其实很容易理解，因为用户可以在屏幕触摸，滑动，离开屏幕动作，分别对应MotionEvent.ACTION_DOWN，MotionEvent.ACTION_MOVE，MotionEvent.ACTION_UP；详细解释：

MotionEvent.ACTION_DOWN：用户触摸View&ViewGroup。
MotionEvent.ACTION_MOVE：用户手指移动View&ViewGroup。
MotionEvent.ACTION_UP：用户手指离开屏幕。
MotionEvent.ACTION_CANCEL：事件退出了，不是用户导致的。

1.3 本质是什么

本质就是将点击事件传递到View的过程

1.4 事件分发在哪些对象之间传递和顺序

activity->PhoneWindow->ViewGroup->View

1.5 事件分发由哪些方法来完成

其中activity中没有onInterceptTouchEvent

2.源码分析(android 29)

首先从activity开始

ctrl方法点进去是跳到这里来，然后我们在点ctrl

发现其实还是调用window.dispatchTouchEvent

然后继续点ctrl，发现跳转到DecorView这了

也就是说activity的dispatchTouchEvent，默认当调用为super的时候，则指向了ViewGroup的dispatchTouchEvent

总结：

然后分析ViewGroup的事件分发过程，代码有点多，我们发现，但是问题不大，哎，搜那个onInterceptTouchEvent

然后来分析下源码，DOWN 事件就不用说了，那 mFirstTouchTarget 是什么呢？
从后面的逻辑代码可以看出来，当事件由 ViewGroup 的子元素成功处理时，它即被赋值为子元素，
换种说话就是，当ACTION_MOVE和ACTION_UP事件到来时，如果没有子元素处理事件（mFirstTouchTarget==null），则ViewGroup的onInterceptTouchEvent不会再被调用，而且同一序列中的其它事件都会默认交给它处理（ intercepted=true），都由 ViewGroup 自行处理。

我们看到其中还有一个 FLAG_DISALLOW_INTERCEPT 的标记位，这个是子元素中的 ViewGroup 通过调用 requestDisallowInterceptTouchEvent(boolean) 来设置的，一旦子元素有调用这个方法，那么此 ViewGroup 将无法拦截除 DOWN 以外的其他事件。
为什么说是除 DOWN 以外呢？因为前面我们说了，FLAG_DISALLOW_INTERCEPT 在 DOWN事件的时候也会被重置，因此，对于 DOWN 事件，ViewGroup 总是通过 onInterceptTouchEvent 来判断是否拦截。

ViewGroup的拦截事件之后的处理逻辑
然后我们可以看到，当拦截并且不是 ACTION_CANCEL 时，如果之前没有事件交给子元素去处理的话，则直接调用 dispatchTransformedTouchEvent，而传的第三个参数为 null，则该方法相当于直接调用 dispatchTouchEvent。

final boolean canceled = resetCancelNextUpFlag(this)
        || actionMasked == MotionEvent.ACTION_CANCEL;
if (!canceled && !intercepted) {
    ....
}
if (mFirstTouchTarget == null) {
    handled = dispatchTransformedTouchEvent(ev, canceled, null, TouchTarget.ALL_POINTER_IDS);
} else {
    ...
}
private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel, View child, ...) {
      //这里的条件相当于直接调用 ViewGroup的 dispatchTouchEvent
    if (child == null) {
        return super.dispatchTouchEvent(event);
    }
}

接着我们来看 mFirstTouchTarget != null 时的逻辑：

boolean alreadyDispatchedToNewTouchTarget = false;
if (mFirstTouchTarget == null) {
    ...
} 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;
            //传递 ACTION_CANCEL给处理了事件的子元素  和DOWN事件重置时执行的逻辑一致
            if (dispatchTransformedTouchEvent(ev, cancelChild,target.child,...)) {
                handled = true;
            }
            ...
        }
        target = next;
    }
}

即为传递 ACTION_CANCEL 给处理了事件的子元素，和DOWN事件重置时执行的逻辑一致

ViewGroup不拦截的处理逻辑

我们先来如果没有子元素时，可以看到下面的代码相当于没有。

if (!canceled && !intercepted) {
    if (actionMasked == MotionEvent.ACTION_DOWN
            || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
            || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
        final int childrenCount = mChildrenCount;
        if (newTouchTarget == null && childrenCount != 0) {
            ...
        }
    }
}

然后当有子元素时：

View childWithAccessibilityFocus = ev.isTargetAccessibilityFocus()
        ? findChildWithAccessibilityFocus() : null;
if (newTouchTarget == null && childrenCount != 0) {
    final float x = ev.getX(actionIndex);
    final float y = ev.getY(actionIndex);
    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 (!child.canReceivePointerEvents()
                || !isTransformedTouchPointInView(x, y, child, null)) {
            ev.setTargetAccessibilityFocus(false);
            continue;
        }

        resetCancelNextUpFlag(child);
        //分发事件给子元素
        if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
            mLastTouchDownTime = ev.getDownTime();
            if (preorderedList != null) {
                for (int j = 0; j < childrenCount; j++) {
                    if (children[childIndex] == mChildren[j]) {
                        mLastTouchDownIndex = j;
                        break;
                    }
                }
            } else {
                mLastTouchDownIndex = childIndex;
            }
            break;
        }
        newTouchTarget = addTouchTarget(child, idBitsToAssign);
        ev.setTargetAccessibilityFocus(false);
    }
    if (preorderedList != null) preorderedList.clear();
}
private TouchTarget addTouchTarget(@NonNull View child, int pointerIdBits) {
    final TouchTarget target = TouchTarget.obtain(child, pointerIdBits);
    target.next = mFirstTouchTarget;
    mFirstTouchTarget = target;
    return target;
}

倒序遍历子元素，判断事件的坐标是否在子元素内，
然后调用 dispatchTransformedTouchEvent，里面的逻辑即为调用 child.dispatchTouchEvent(transformedEvent)，把事件分发给子元素。
如果某个子元素处理了事件，则记录当前子元素的在子元素列表中的索引为 mLastTouchDownIndex。
然后在 addTouchTarget 中赋值 mFirstTouchTarget 为此子元素。
dispatchTransformedTouchEvent 中的 transformedEvent 即为动画等做的位置变换。

private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel, View child, ...) {
    if (child == null) {
    } 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);
    }
    transformedEvent.recycle();
    return handled;
}

通过上面的分析，我们可以看到最后的逻辑相当于：

if (XXX) {
    handled = super.dispatchTouchEvent(event);
} else {
    handled = child.dispatchTouchEvent(event);
}

可能继续调用 ViewGroup的 super.dispatchTouchEvent 或者调用 View 的 dispatchTouchEvent 方法。而 super.dispatchTouchEvent 即为调用 View 的 dispatchTouchEvent。

然后我们再去看ViewGroup的onInterceptTouchEvent方法

可以看出默认是返回false的

总结：

PS：其他小知识点

1.当ACTION_MOVE和ACTION_UP事件到来时，如果没有子元素处理事件（mFirstTouchTarget==null），则ViewGroup的onInterceptTouchEvent不会再被调用，而且同一序列中的其它事件都会默认交给它处理（ intercepted=true），都由 ViewGroup 自行处理。
2.一旦子元素有调用这个requestDisallowInterceptTouchEvent(true) 方法，那么此 ViewGroup 将无法拦截除 DOWN 以外的其他事件。

示意图

核心方法总结

接下来我们就来看看 View 的 dispatchTouchEvent 方法的处理逻辑。

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

这里我们可以看到，首先会判断当前是否设置了 OnTouchListener，设置了的话还得判断状态是否是 ENABLED，是的话就会调用我们设置的 OnTouchListener 的 onTouch 方法，
如果我们返回 true 了，则 dispatchTouchEvent 返回 true。
如果返回 false, 则调用 onTouchEvent 方法，dispatchTouchEvent 返回值即为 onTouchEvent 的返回值。

继续看 onTouchEvent 的处理逻辑。View 的 onTouchEvent
判断View的状态

final int viewFlags = mViewFlags;
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;
    return clickable;
}

如果是 DISABLED 状态，则返回当前是否可以点击。

View 的 LONG_CLICKABLE 属性默认是 false，而 CLICKABLE 属性的值和 View 是否可以点击有关，
比如Button是可以点击的，所以 CLICKABLE 为 true；
而 TextView 默认是不可点击的，所以 CLICKABLE 为 false。

通过 setOnClickListener 和 setOnLongClickListener 可以改变对应的属性，可以从它们的源码可以看出：

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

View是否设置了代理
然后判断View是否设置了代理 mTouchDelegate，设置了则会调用其 onTouchEvent 方法，然后对事件进行消费

if (mTouchDelegate != null) {
    if (mTouchDelegate.onTouchEvent(event)) {
        return true;
    }
}

然后就是对应事件的处理了。

处理对应的事件
到这里了，就说明事件即被当前View消耗了，只是对不同的事件做不同的处理，我们主要关注 ACTION_UP事件，里面主要就是调用了 performClickInternal()。

public boolean onTouchEvent(MotionEvent event) {
    if (clickable || (viewFlags & TOOLTIP) == TOOLTIP) {
        switch (action) {
            case MotionEvent.ACTION_UP:
                boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;
                if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) {
                    if (!mHasPerformedLongPress && !mIgnoreNextUpEvent) {
                        ...
                        // This is a tap, so remove the longpress check
                        removeLongPressCallback();
                        if (!focusTaken) {
                            if (mPerformClick == null) {
                                mPerformClick = new PerformClick();
                            }
                            if (!post(mPerformClick)) {
                                performClickInternal();
                            }
                        }
                    }
                    ...
                }
                mIgnoreNextUpEvent = false;
                break;
            case MotionEvent.ACTION_DOWN:
                ...
                break;
            case MotionEvent.ACTION_CANCEL:
                ...
                removeTapCallback();
                removeLongPressCallback();
                break;
            case MotionEvent.ACTION_MOVE:
                ...
                break;
        }
        return true;
    }
    return false;
}

View 的 performClickInternal
这里就是看我们是否设置了 OnClickListener ，设置了及返回 true，否则返回 false.

private boolean performClickInternal() {
    return performClick();
}
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;
    }
    return result;
}

所以我们如果自定义想设置点击事件的话，也可以直接重写 performClick。

总结：