【面试必备】最详细的 Android View 的事件分发原理

作者: JCYDSHANKS | 来源:发表于2023-02-09 11:49 被阅读0次

事件分发原理

序言

Android 的 View 的事件分发一直是老生常谈的问题，市面上的所有文章资料都在通过 dispatchTouchEvent、onInterceptTouchEvent 和 onTouchEvent 讲事件分发的原理，对于一些细节没有涉及，本文带你一窥源码，搞清楚 View 是如何选择事件处理的。

MotionEvent

MotionEvent 定义了用于报告移动(鼠标、笔、手指、轨迹球)事件的对象。运动事件可以保存绝对或相对运动和其他数据，这取决于设备的类型。

用户触摸一次屏幕将会产生 MotionEvent 事件，并将事件传递给合适的 View 。MotionEvent 会包含一些触摸行为的相关信息，例如事件的类型、触摸的X和Y坐标、接触区域的大小和方向的信息等等。有些设备可以同时报告多条移动轨迹。多点触控屏幕为每个手指发出一个运动轨迹。单个的手指或其他产生运动轨迹的对象称为指针。

通常情况下，用户的触摸事件类型包括：按下（ACTION_DOWN）、移动（ACTION_MOVE）、抬起(ACTION_UP)、取消(ACTION_CANCEL)。

用户的一次触摸通常以 ACTION_DOWN 事件开始，在屏幕上移动时产生多个 ACTION_MOVE 事件，最后抬起手指触发 ACTION_UP 或 ACTION_CANCEL 事件。

View 和 ViewGroup

在讲解事件分发机制之前，要区分 View 和 ViewGroup ，尽管 ViewGroup 继承自 View ，但是它们代表了不容的概念。
Android 的视图结构是树结构，View 代表的是叶子节点，而 ViewGroup 则表示可以拥有子节点的非叶子节点。它们的事件分发逻辑是有区别的。

简述事件分发

下文的分析可能比较复杂，这里总结一下事件分发涉及核心方法的流程：

View 的事件分发流程

当触摸事件来临时，会触发 View 的 dispatchTouchEvent(event) 将事件进行分发。如果 View 设置了 onTouchListener ，会优先回调 onTouch(view, event) ，onTouch 方法的返回值表示是否处理事件。

如果 onTouch 不处理事件，会进入 View 自己的 onTouchEvent ，在没有覆盖的情况下，该方法内部会识别该事件是点击、长按或其他类型，点击会调用 performClick() ，perfromClick 方法会调用 onClickListener 的 onClick(View) 。

onTouchEvent 方法用户可以自己来实现，从而实现 View 的拖拽等能力。

如果 onTouchEvent 方法也返回 false ，说明当前 View 不消耗这个事件，dispatchTouchEvent 返回 false 。

ViewGroup 的事件分发流程

当触摸事件来临时，会触发 ViewGroup 的 dispatchTouchEvent 将事件进行分发。

ViewGroup 会优先处理事件的分发逻辑，经过窗口的检查后，首先会通过通过 Flag 检查是否需要拦截，并调用 onInterceptTouchEvent(event) 确定真正是否进行拦截的结果。然后进行取消的 Flag 检查。

在不拦截不取消的情况下，通过 View 的渲染顺序和 Z 轴顺序会生成一个有序的 View 列表，根据列表顺序获取符合事件坐标位置的 View ，然后通过 dispatchTransformedTouchEvent(view, ...) 来分发给这个 View ，dispatchTransformedTouchEvent 方法内部调用 view.dispatchTouchEvent(event) ，如果 view 为空的情况，直接调用 super.dispatchTouchEvent(event) ，也就是调用 ViewGroup 的父类 View 的 dispatchTouchEvent 方法。

如果子 View 不消耗事件（dispatchTouchEvent 方法返回了 false），ViewGroup 会调用 dispatchTransformedTouchEvent(view = null, ...) 的形式，调用到自己的 super.dispatchTouchEvent(event) ，也就是将自己视为最后 View 来检查是否消耗。

View dispatchTouchEvent

View 的 dispatchTouchEvent 方法会将触摸屏运动事件传递到目标视图，如果是目标，则传递给这个视图。并返回当前 View 是否要处理这个事件的结果（需要处理 true，反之 false）。接下来逐步分析 dispatchTouchEvent 方法中关键的逻辑：

1. 检查事件序列逻辑自洽

protected final InputEventConsistencyVerifier mInputEventConsistencyVerifier = InputEventConsistencyVerifier.isInstrumentationEnabled() ? new InputEventConsistencyVerifier(this, 0) : null;

public boolean dispatchTouchEvent(MotionEvent event) {
    // ...
    if (mInputEventConsistencyVerifier != null) {
        mInputEventConsistencyVerifier.onTouchEvent(event, 0);
    }
    // ...
}

mInputEventConsistencyVerifier 是用于调试目的的一个类，用来检查事件序列是否逻辑自洽，例如连续两个 down 事件就不符合同一个事件序列的逻辑规则。

2. ACTION_DOWN 触发新手势防御性清理

public boolean dispatchTouchEvent(MotionEvent event) {
    // 1. 检查事件序列逻辑自洽

    boolean result = false;

    // action 
    final int actionMasked = event.getActionMasked();
    if (actionMasked == MotionEvent.ACTION_DOWN) {
        // 为新手势进行防御性清理， 停止嵌套滑动
        stopNestedScroll();
    }
    // ...
}

在这一个步骤前，先定义了一个变量 result ，用来记录内部逻辑是否处理了这个事件，并在最后返回结果。后续的步骤也会涉及这个变量。
经过事件序列检查后，检查是否是 Down 事件，如果是，则需要为新手势进行防御性清理，停止嵌套滑动。

3. 窗口遮挡策略检查

public boolean dispatchTouchEvent(MotionEvent event) {
    // 1. 检查事件序列逻辑自洽
    // 2. ACTION_DOWN 触发新手势防御性清理
    if (onFilterTouchEventForSecurity(event)) {
        // ...
    }
    // ...
}

在经过 Down 事件的处理后，会通过 onFilterTouchEventForSecurity 方法过滤事件，这个方法的作用是检查窗口是否被遮挡。当然用户也可以通过覆盖 onFilterTouchEventForSecurity 的方式，自定义过滤策略。

4. 处理事件

public boolean dispatchTouchEvent(MotionEvent event) {
    // 1. 检查事件序列逻辑自洽
    // 2. ACTION_DOWN 触发新手势防御性清理
    if (onFilterTouchEventForSecurity(event)) { // 3. 窗口遮挡策略检查
        ListenerInfo li = mListenerInfo; // 取出当前 View 的监听信息
        if (li != null && li.mOnTouchListener != null // mOnTouchListener 不为空
            && (mViewFlags & ENABLED_MASK) == ENABLED // 掩码，与setFlags一起使用，表示该视图是否启用的比特位  
            && li.mOnTouchListener.onTouch(this, event)  // onTouch 方法处理事件 在向视图发送触摸事件时调用。这让 listener 有机会在目标视图之前做出响应。
        ) {
            result = true;
        }
        // 如果这个时候result 还不是 true，调用 onTouchEvent

        // 实现 onTouchEvent 方法来处理触摸屏运动事件。如果使用此方法检测单击行为，建议通过实现并调用performClick()来执行这些操作。
        // 这将确保系统行为的一致性，包括: 1.服从点击声音偏好设置; 2. 调度OnClickListener调用; 3. 当无障碍功能启用时处理ACTION_CLICK
        if (!result && onTouchEvent(event)) {
            result = true;
        }
    }
    // ...
}

经过了窗口遮挡检查，就开始处理事件了，这里省略了鼠标拖拽滚动条的逻辑（不是很重要）。
首先，取出 mListenerInfo 属性保存的监听信息，检查它的 mOnTouchListener 变量不为空、并且当前 View 是否处于启用状态（Flag == ENABLED），并且 mOnTouchListener 的 onTouch 方法返回了 true ，说明当前 View 的 onTouch 处理了事件，事件到此为止，分发结束。

onTouch 优先调用的作用是在向 View 发送触摸事件时调用。这让 mOnTouchListener 有机会在交给目标视图处理之前做出响应。

如果 onTouch 方法返回了 false ，没有消耗事件，那么将调用当前 View 的 onTouchEvent 方法来处理事件。

onTouchEvent(MotionEvent) 是 View 用来开始处理触摸运动事件的方法，如果使用此方法检测单击行为，建议通过实现并调用performClick()来执行这些操作。这样能够保证一些系统行为的一致性，包括：

调用 onClickListener
无障碍处理 ACTION_CLICK 事件
触发系统点击音效

View 的 onTouchEvent 方法中处理了单击、长按、UI 的按压状态等逻辑，内部通过调用 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();
    }

5. 通知事件验证器忽略次事件序列

如果执行到这一步此还没有处理事件，说明当前 View 不消耗这个事件序列，通知 mInputEventConsistencyVerifier 给定事件未处理，应该忽略事件跟踪的其余部分。

public boolean dispatchTouchEvent(MotionEvent event) {
    // 1. 检查事件序列逻辑自洽
    // 2. ACTION_DOWN 触发新手势防御性清理
    if (onFilterTouchEventForSecurity(event)) { // 3. 窗口遮挡策略检查
        // 4. 处理事件
    }
    // 到这里仍不处理，调试器不为空，交给调试器记录不处理的事件
    if (!result && mInputEventConsistencyVerifier != null) {
        mInputEventConsistencyVerifier.onUnhandledEvent(event, 0);
    }
    // ...
}

6. 结束手势到清理工作

如果这个手势是一个结束手势（包括 UP 事件、CANCEL 事件、或是 DOWN 事件时，当前 View 不处理事件的情况），停止嵌套滚动。

public boolean dispatchTouchEvent(MotionEvent event) {
    // 1. 检查事件序列逻辑自洽
    // 2. ACTION_DOWN 触发新手势防御性清理
    if (onFilterTouchEventForSecurity(event)) { // 3. 窗口遮挡策略检查
        // 4. 处理事件
    }
    // 5. 通知事件验证器忽略次事件序列
    
    if (actionMasked == MotionEvent.ACTION_UP ||
            actionMasked == MotionEvent.ACTION_CANCEL ||
            (actionMasked == MotionEvent.ACTION_DOWN && !result)) {
        stopNestedScroll();
    }
    return result;
}

到这一步，View 的事件分发就结束了。

ViewGroup dispatchTouchEvent

ViewGroup 的 dispatchTouchEvent 逻辑与 View 有所不同。

1. 检查事件序列逻辑自洽

@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    // 检查事件序列逻辑自洽
    if (mInputEventConsistencyVerifier != null) {
        mInputEventConsistencyVerifier.onTouchEvent(ev, 1);
    }
}

与 View 相同。

2. 窗口遮挡策略检查

ViewGroup 的第二步直接进行了过滤策略方法的调用，不存在滚动的能力，所以忽略了 View 的第二步和最后停止嵌套滚动的逻辑。

public boolean dispatchTouchEvent(MotionEvent event) {
    // 1. 检查事件序列逻辑自洽
    boolean handled = false;

    if (onFilterTouchEventForSecurity(event)) {
        // ...
    }
    // ...
}

3. 最初的 DOWN 事件触发清理逻辑

public boolean dispatchTouchEvent(MotionEvent event) {
    // 1. 检查事件序列逻辑自洽
    boolean handled = false;

    if (onFilterTouchEventForSecurity(event)) { // 2. 窗口遮挡策略检查
        final int action = ev.getAction();
        final int actionMasked = action & MotionEvent.ACTION_MASK;

        // Handle an initial down. 处理第一个 down 事件
        if (actionMasked == MotionEvent.ACTION_DOWN) {
            // 当开始一个新的触摸手势时，抛弃之前所有的状态。
            // 由于应用程序切换、ANR或其他一些状态变化，框架可能已经放弃了前一个手势的up或cancel事件。
            cancelAndClearTouchTargets(ev); // 取消并清除
            resetTouchState();
        }
    }
    // ...
}

经过筛选后，如果事件是 DOWN 事件，需要抛弃之前的状态，这里也可能由于应用程序切换、ANR或其他一些状态变化，框架可能已经放弃了前一个手势的 UP 或 CANCEL 事件。

4. 拦截检查

public boolean dispatchTouchEvent(MotionEvent event) {
    // 1. 检查事件序列逻辑自洽
    boolean handled = false;

    if (onFilterTouchEventForSecurity(event)) { // 2. 窗口遮挡策略检查
        // 3. 最初的 DOWN 事件触发清理逻辑

        final boolean intercepted;
        if (actionMasked == MotionEvent.ACTION_DOWN || mFirstTouchTarget != null) {
            final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0; 
            if (!disallowIntercept) { // 如果允许拦截，走 onInterceptTouchEvent
                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; // 首个事件没有触摸目标，这个动作不是一个初始的down所以这个视图组继续拦截触摸。
        }
    }
    // ...
}

检查拦截的第一步是判断如果是 DOWN 事件或当前第一次点击目标不为空，表示不是第一个事件，此时会检查是否允许拦截，如果允许，调用 onInterceptTouchEvent(MotionEvent) ，根据 onInterceptTouchEvent 方法返回的结果表示是否拦截，设置到临时变量 intercepted 上；其他情况表示不允许拦截事件。

5. 获取事件取消等状态

public boolean dispatchTouchEvent(MotionEvent event) {
    // 1. 检查事件序列逻辑自洽
    boolean handled = false;

    if (onFilterTouchEventForSecurity(event)) { // 2. 窗口遮挡策略检查
        // 3. 最初的 DOWN 事件触发清理逻辑
        // 4. 拦截检查 
        
        // Check for cancelation. 检查是否取消
        final boolean canceled = resetCancelNextUpFlag(this) || actionMasked == MotionEvent.ACTION_CANCEL;

        // 是否来自鼠标的事件
        final boolean isMouseEvent = ev.getSource() == InputDevice.SOURCE_MOUSE;
        // FLAG_SPLIT_MOTION_EVENTS 当设置这个属性时，这个ViewGroup会在合适的时候将 MotionEvents 拆分给多个子视图。
        final boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0 && !isMouseEvent; 
        // 新的触摸目标
        TouchTarget newTouchTarget = null; 
        // 已分发给新的触摸目标
        boolean alreadyDispatchedToNewTouchTarget = false;

    }
    // ...
}

在这一个步骤中，首先事件查询是否被取消，然后定义了一些后续逻辑中会用到的临时变量。

6. 分发 DOWN 事件

public boolean dispatchTouchEvent(MotionEvent event) {
    // 1. 检查事件序列逻辑自洽
    boolean handled = false;

    if (onFilterTouchEventForSecurity(event)) { // 2. 窗口遮挡策略检查
        // 3. 最初的 DOWN 事件触发清理逻辑
        // 4. 拦截检查 
        // 5. 获取事件取消等状态

        // 在确保没有被取消或拦截的情况下，向下分发事件 （这里忽略一些鼠标等输入设备和无障碍相关的逻辑）
        if (!canceled && !intercepted) {
            if (actionMasked == MotionEvent.ACTION_DOWN) {  
                final int actionIndex = ev.getActionIndex(); // always 0 for down
                final int idBitsToAssign = split ? 1 << ev.getPointerId(actionIndex) : TouchTarget.ALL_POINTER_IDS;
                final int childrenCount = mChildrenCount; // 获取子 View 数量
                if (newTouchTarget == null && childrenCount != 0) { // 存在触摸目标，且存在子 View 
                    // TODO 
                }
            }
        }
    }
    // ...
}

在确保没有被取消或拦截的情况下，准备开始向子 View 分发事件，这里忽略一些鼠标等输入设备和无障碍相关的逻辑。

1. 获取有序的子 View 列表

if (!canceled && !intercepted) {
    if (actionMasked == MotionEvent.ACTION_DOWN) {  
        // ...
        if (newTouchTarget == null && childrenCount != 0) { // 存在触摸目标，且存在子 View 
            // 当前坐标 / 当前事件的坐标
            final float x = isMouseEvent ? ev.getXCursorPosition() : ev.getX(actionIndex);
            final float y = isMouseEvent ? ev.getYCursorPosition() : ev.getY(actionIndex);
            final ArrayList<View> preorderedList = buildTouchDispatchChildList();
            // isChildrenDrawingOrderEnabled 如果子 View 的绘制顺序由getChildDrawingOrder(int, int)定义，返回true，否则返回false
            final boolean customOrder = preorderedList == null && isChildrenDrawingOrderEnabled();

            // ... 
        }
    }
    // ... 
}

这一步主要是 buildTouchDispatchChildList 方法，它提供了按照视图显示层级顺序的 View 列表。（先按Z排序，然后按子元素的绘制顺序(如果适用)排序。）；该列表必须在使用后清除，以避免泄漏子视图。

2. 遍历子 View

if (!canceled && !intercepted) {
    if (actionMasked == MotionEvent.ACTION_DOWN) {  
        // ...
        if (newTouchTarget == null && childrenCount != 0) { // 存在触摸目标，且存在子 View 
            // 1. 获取有序的子 View 列表

            final View[] children = mChildren;
            // 开始遍历
            for (int i = childrenCount - 1; i >= 0; i--) {
                // 【todo】这里遍历逻辑
            }

            // ... 
        }
    }
    // ... 
}

【todo】位置执行的遍历逻辑可以拆分成四个步骤：

遍历子 View 的逻辑比较复杂，首先通过 getAndVerifyPreorderedIndex 方法获取子 View 在已根据规则排好顺序的 preorderedList 中的索引，然后再去 preorderedList 中找到这个 View。

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

检查事件的坐标是否处于子 View 的范围内，如果不在，直接进行下一次循环；或是子 View 能否接受事件。

// 【坐标点过滤】触摸点不在子 View 范围内 or 子 View 不接收事件，直接进行下一次循环
if (!child.canReceivePointerEvents() || !isTransformedTouchPointInView(x, y, child, null)) {
    ev.setTargetAccessibilityFocus(false);
    continue;
}

已存在触摸目标，更新触摸目标的指针，跳出循环。

newTouchTarget = getTouchTarget(child);
if (newTouchTarget != null) {
    newTouchTarget.pointerIdBits |= idBitsToAssign;
    break;
}

执行到这一步说明坐标检查通过，且没有已存在触摸目标，通过 dispatchTransformedTouchEvent 分发事件给子 View ，如果分发成功了，会更新最后一次的触摸目标信息。

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();
    // addTouchTarget 将指定子对象的触摸目标添加到 TouchTarget 列表的头。假设目标子元素还不存在。
    newTouchTarget = addTouchTarget(child, idBitsToAssign);
    alreadyDispatchedToNewTouchTarget = true;
    break;
}

3. 清除有序的子 View 列表

前面提到了 buildTouchDispatchChildList 方法返回了 View 列表要在使用后清除，避免造成泄漏：

if (!canceled && !intercepted) {
    if (actionMasked == MotionEvent.ACTION_DOWN) {  
        // ...
        if (newTouchTarget == null && childrenCount != 0) { // 存在触摸目标，且存在子 View 
            // 1. 获取有序的子 View 列表
            // 2. 遍历子 View
            if (preorderedList != null) preorderedList.clear();
            
        }
    }
    // ... 
}

4. 没有找到子 View 处理事件，将触摸目标更新成最近添加的触摸目标


if (!canceled && !intercepted) {
    if (actionMasked == MotionEvent.ACTION_DOWN) {  
        // ...
        if (newTouchTarget == null && childrenCount != 0) { // 存在触摸目标，且存在子 View 
            // 1. 获取有序的子 View 列表
            // 2. 遍历子 View
            // 3. 清除有序的子 View 列表
        }

        if (newTouchTarget == null && mFirstTouchTarget != null) {
            newTouchTarget = mFirstTouchTarget;
            while (newTouchTarget.next != null) {
                newTouchTarget = newTouchTarget.next;
            }
            newTouchTarget.pointerIdBits |= idBitsToAssign;
        }
    }
    // ... 
}

这一步，也就是说，没有找到子 View 可以处理事件，将事件交给最近添加的触摸目标。

7. 分发非 DOWN 事件

这个步骤主要是处理非 DOWN 事件的（除了事件序列的起始事件），因为起始事件回去创建新的触摸目标，而后续的事件可以直接交给 TouchTarget 来进行，避免再次查找提高效率。

public boolean dispatchTouchEvent(MotionEvent event) {
    // 1. 检查事件序列逻辑自洽
    boolean handled = false;

    if (onFilterTouchEventForSecurity(event)) { // 2. 窗口遮挡策略检查
        // 3. 最初的 DOWN 事件触发清理逻辑
        // 4. 拦截检查 
        // 5. 获取事件取消等状态
        // 6. 处理 DOWN 事件的分发
        
        // 处理非 DOWN 事件
        if (mFirstTouchTarget == null) {
            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;
            }
        }
    }
    // ...
}

8. 处理 UP 事件或取消

public boolean dispatchTouchEvent(MotionEvent event) {
    // 1. 检查事件序列逻辑自洽
    boolean handled = false;

    if (onFilterTouchEventForSecurity(event)) { // 2. 窗口遮挡策略检查
        // 3. 最初的 DOWN 事件触发清理逻辑
        // 4. 拦截检查 
        // 5. 获取事件取消等状态
        // 6. 处理 DOWN 事件的分发
        // 7. 分发非 DOWN 事件

        if (canceled
                || actionMasked == MotionEvent.ACTION_UP
                || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
            resetTouchState();
        }
    }
    // ...
}

如果取消了或者事件是 ACTION_UP 、ACTION_HOVER_MOVE ，重置触摸状态。

9. 通知事件验证器忽略次事件序列

public boolean dispatchTouchEvent(MotionEvent event) {
    // 1. 检查事件序列逻辑自洽
    boolean handled = false;

    if (onFilterTouchEventForSecurity(event)) { // 2. 窗口遮挡策略检查
        // 3. 最初的 DOWN 事件触发清理逻辑
        // 4. 拦截检查 
        // 5. 获取事件取消等状态
        // 6. 处理 DOWN 事件的分发
        // 7. 分发非 DOWN 事件
        // 8. 处理 UP 事件或取消
    }

    if (!handled && mInputEventConsistencyVerifier != null) {
        mInputEventConsistencyVerifier.onUnhandledEvent(ev, 1);
    }
    return handled;
}

最后一步如果没有通过过滤策略检查，通知 mInputEventConsistencyVerifier 忽略这些事件。

ViewGroup 分发逻辑 dispatchTransformedTouchEvent

在 ViewGroup 的分发逻辑中，传递给子 View 进行分发的方法是 dispatchTransformedTouchEvent(...)，该方法将 MotionEvent 转换到特定子 View 的坐标空间，过滤不相关的指针id，并在必要时覆盖其操作。如果 child 为 null，则假定 MotionEvent 将被发送到此 ViewGroup 。

private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
        View child, int desiredPointerIdBits) {
    // ...
    if (child == null) {
        handled = super.dispatchTouchEvent(transformedEvent);
    } else {
        handled = child.dispatchTouchEvent(transformedEvent);
    }
    // ... 
    return handled
}

【面试必备】最详细的 Android View 的事件分发原理

事件分发原理

序言

MotionEvent

View 和 ViewGroup

简述事件分发

View 的事件分发流程

ViewGroup 的事件分发流程

View dispatchTouchEvent

1. 检查事件序列逻辑自洽

2. ACTION_DOWN 触发新手势防御性清理

3. 窗口遮挡策略检查

4. 处理事件

5. 通知事件验证器忽略次事件序列

6. 结束手势到清理工作

ViewGroup dispatchTouchEvent

1. 检查事件序列逻辑自洽

2. 窗口遮挡策略检查

3. 最初的 DOWN 事件触发清理逻辑

4. 拦截检查

5. 获取事件取消等状态

6. 分发 DOWN 事件

1. 获取有序的子 View 列表

2. 遍历子 View

3. 清除有序的子 View 列表

4. 没有找到子 View 处理事件，将触摸目标更新成最近添加的触摸目标

7. 分发非 DOWN 事件

8. 处理 UP 事件或取消

9. 通知事件验证器忽略次事件序列

ViewGroup 分发逻辑 dispatchTransformedTouchEvent

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读