最详细的 Android View 的事件分发原理

最新推荐文章于 2024-03-18 17:39:00 发布

OpenHarmony_小贾

最新推荐文章于 2024-03-18 17:39:00 发布

阅读量283

点赞数

分类专栏： Android 移动开发架构文章标签： android 移动开发面试 APP架构架构

本文链接：https://blog.csdn.net/maniuT/article/details/132562567

版权

移动开发同时被 3 个专栏收录

516 篇文章 2 订阅

订阅专栏

Android

226 篇文章 8 订阅

订阅专栏

架构

47 篇文章 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 学习笔录

Android 性能优化篇：https://qr18.cn/FVlo89
Android 车载篇：https://qr18.cn/F05ZCM
Android 逆向安全学习笔记：https://qr18.cn/CQ5TcL
Android Framework底层原理篇：https://qr18.cn/AQpN4J
Android 音视频篇：https://qr18.cn/Ei3VPD
Jetpack全家桶篇（内含Compose）：https://qr18.cn/A0gajp
Kotlin 篇：https://qr18.cn/CdjtAF
Gradle 篇：https://qr18.cn/DzrmMB
OkHttp 源码解析笔记：https://qr18.cn/Cw0pBD
Flutter 篇：https://qr18.cn/DIvKma
Android 八大知识体：https://qr18.cn/CyxarU
Android 核心笔记：https://qr21.cn/CaZQLo
Android 往年面试题锦：https://qr18.cn/CKV8OZ
2023年最新Android 面试题集：https://qr18.cn/CgxrRy
Android 车载开发岗位面试习题：https://qr18.cn/FTlyCJ
音视频面试题锦：https://qr18.cn/AcV6Ap

OpenHarmony_小贾

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
最详细的 Android View 的事件分发原理

Android 的 View 的事件分发一直是老生常谈的问题，市面上的所有文章资料都在通过 dispatchTouchEvent、onInterceptTouchEvent 和 onTouchEvent 讲事件分发的原理，对于一些细节没有涉及，本文带你一窥源码，搞清楚 View 是如何选择事件处理的。后续的步骤也会涉及这个变量。这个步骤主要是处理非 DOWN 事件的（除了事件序列的起始事件），因为起始事件回去创建新的触摸目标，而后续的事件可以直接交给 TouchTarget 来进行，避免再次查找提高效率。
复制链接

扫一扫