Android事件分发机制

已于 2022-10-21 16:07:35 修改
阅读量789 收藏
点赞数
分类专栏： Android源码分析 文章标签： android
于 2016-07-19 22:33:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Love667767/article/details/51960159
版权

文章目录

一、概述

Android 事件分发机制是一块比较重要的知识，了解并熟悉整套事件分发机制有助于我们在开发过程中处理各种滑动冲突相关的问题，因此有必要掌握这部分内容。

SDK版本： 29

关联文章：

二、事件分发的基础知识

在分析事件分发流程之前，需要先了解一下相关的基础知识。

  1. MotionEvent 事件类型。
  2. 事件分发过程的关联函数。

2.1 MotionEvent 的类型

MotionEvent 类型含义
ACTION_DOWN手指首次落到屏幕上触发(一个事件周期内只会触发一次)
ACTION_UP手指离开屏幕时触发(一个事件周期内只会触发一次)
ACTION_MOVE手指在屏幕上滑动时触发(一个事件周期内会触发很多次)
ACTION_CANCEL事件被上层控件拦截时触发

说明： 从 ACTION_DOWN 事件开始到 ACTION_UP 事件结束为一个事件周期。

2.2 事件分发过程的关联函数

事件在 Activity、ViewGroup、View 三者之间进行传递。且按照 Activity --> ViewGroup --> View 方向进行传递。

事件传递的相关方法：

类型方法ActivityViewGroupView
事件分发dispatchTouchEvent有有有
事件拦截onInterceptTouchEvent无有无
事件消费onTouchEvent有无有

2.3 ViewGroup与View中dispatchTouchEvent方法的区别

ViewGroup.dispatchTouchEvent() 方法内是分发事件的逻辑。
View.dispatchTouchEvent() 方法内是消费事件的逻辑。

2.4 ViewGroup.mFirstTouchTarget 设计成链表？

深入理解事件分发 ViewGroup.mFirstTouchTarget的设计

结论：

  • 非多点触控：mFirstTouchTarget链表退化成单个TouchTarget对象。
  • 多点触控，目标相同：同样为单个TouchTarget对象，只是pointerIdBits保存了多个pointerId信息。
  • 多点触控，目标不同：mFirstTouchTarget成为链表。

为什么要把mFirstTouchTarget设计成链表？

mFirstTouchTarget设计成链表的作用，是用于记录多点触控情况下，多目标控件的派分逻辑。

记录目标的TouchTarget的pointerIdBits又起到什么作用？

pointerIdBits的作用，是配合mFirstTouchTarget，使多点触控时，同个目标可以对多个触控点进行合理的处理逻辑。

三、事件的分发流程

已知事件分发顺序： Activity --> ViewGroup --> View，所以下面我们也分三部分进行分析。

3.1 Activity 分发流程

// Activity.java
public boolean dispatchTouchEvent(MotionEvent ev) {
    if (ev.getAction() == MotionEvent.ACTION_DOWN) {
        onUserInteraction();
    }
    // 调用PhoneWindow.superDispatchTouchEvent()分发进行分发。
    if (getWindow().superDispatchTouchEvent(ev)) {
        return true;
    }
    // 如果Window中所有View都不消费该事件，则Activity自己消费，即执行Activity.onTouchEvent()方法。
    return onTouchEvent(ev);
}

// PhoneWindow.java
public boolean superDispatchTouchEvent(MotionEvent event) {
	// PhoneWindow中持有DecorView的对象mDecor，即视图根节点。
    return mDecor.superDispatchTouchEvent(event);
}
// DecorView.java (View的根节点)
public boolean superDispatchTouchEvent(MotionEvent event) {
    return super.dispatchTouchEvent(event);
}

// Activity.java
public boolean onTouchEvent(MotionEvent event) {
	// 类似于点击popWindow之外的区域，popWindow关闭的场景。
	if (mWindow.shouldCloseOnTouch(this, event)) {
	    finish();
	    return true;
	}
	return false;
}

// Window.java
public boolean shouldCloseOnTouch(Context context, MotionEvent event) {
    final boolean isOutside =
            event.getAction() == MotionEvent.ACTION_UP && isOutOfBounds(context, event)
            || event.getAction() == MotionEvent.ACTION_OUTSIDE;
    if (mCloseOnTouchOutside && peekDecorView() != null && isOutside) {
    	// 事件在边界外，消费事件。
        return true;
    }
    // 事件在边界内，不消费事件。
    return false; 
}

小结：

  • Activity 阶段结束后，事件传递给了 DecorView，即ViewGroup。
  • 此流程的传递过程受 ViewGroup.dispatchTouchEvent() 方法返回值的影响。
    在这里插入图片描述

3.2 ViewGroup 分发流程(分3步)

要点： ViewGroup.dispatchTouchEvent() 方法内是进行事件分发的逻辑，可以分为3部分。

  1. Step1：请求拦截处理的逻辑。
  2. Step2：事件接收控件的查找 & DOWN事件的分发，并进行Target赋值。
  3. Step3：执行事件分发逻辑。

下面先看下这三部分对应的代码位置，代码如下：

// ViewGroup.java
public boolean dispatchTouchEvent(MotionEvent ev) {
    // 省略代码
    boolean handled = false;
    if (onFilterTouchEventForSecurity(ev)) {
    	// 省略代码
    	
		// Setp1：请求拦截处理的逻辑
        final boolean intercepted;
        if (actionMasked == MotionEvent.ACTION_DOWN || mFirstTouchTarget != null) {
        	intercepted = onInterceptTouchEvent(ev);
            // 省略代码
        }
        // 省略代码

        //  Step2：当前控件不拦截子控件，则会去查找接收事件的子View。
        if (!canceled && !intercepted) {
            // 省略代码
            // 下面是几个核心方法
            final ArrayList<View> preorderedList = buildTouchDispatchChildList();
            if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
				// 省略代码
				newTouchTarget = addTouchTarget(child, idBitsToAssign);
           		alreadyDispatchedToNewTouchTarget = true;
			}
        }
		
		//  Step3：执行事件
        // Dispatch to touch targets.
        if (mFirstTouchTarget == null) {
            handled = dispatchTransformedTouchEvent(ev, canceled, null, TouchTarget.ALL_POINTER_IDS);
        } else {
        	// 省略代码
			dispatchTransformedTouchEvent(ev, cancelChild, target.child, target.pointerIdBits)
		}
        // 省略代码
    }
	
	// 如果事件被消费，则handled为true
    return handled;
}

Step1：事件拦截逻辑

基本流程：

  1. 在每次接收到 ACTION_DOWN 事件时，会清理上次的 TouchTarget 和请求不拦截标记(FLAG_DISALLOW_INTERCEPT)等数据，避免上次的数据影响本次逻辑。
  2. 执行事件拦击逻辑，具体执行拦截逻辑，分两种场景。
    1. 通过 getParent().requestDisallowInterceptTouchEvent() 实现子控件请求父控件不拦截事件(优先级高与onInterceptTouchEvent()方法)。
    2. 通过 onInterceptTouchEvent() 实现当前控件不拦截子控件事件。
// ViewGroup.dispatchTouchEvent()
public boolean dispatchTouchEvent(MotionEvent ev) {
    // 省略代码
    boolean handled = false;
    if (onFilterTouchEventForSecurity(ev)) {
        final int action = ev.getAction();
        final int actionMasked = action & MotionEvent.ACTION_MASK;
		
		// 1.每次ACTION_DOWN事件会清楚数据(如Target，FLAG_DISALLOW_INTERCEPT标记等)，避免上次数据影响本次的事件消费。
        // Handle an initial down.
        if (actionMasked == MotionEvent.ACTION_DOWN) {
            // 清除TouchTarget(消费事件的View)
            cancelAndClearTouchTargets(ev);
            // 会重置跟事件相关的有FLAG_DISALLOW_INTERCEPT标记，该标记表示子类请求父类不对事件进行拦截。
            resetTouchState();
        }
		
		//2. Step1：请求拦截处理的逻辑
        // Check for interception.
        final boolean intercepted;
        // DOWN事件、mFirstTouchTarget不为空(即有子View消费事件)两个场景。
        if (actionMasked == MotionEvent.ACTION_DOWN
                || mFirstTouchTarget != null) {
            // 2.1 子控件通过 getParent().requestDisallowInterceptTouchEvent()来请求父控件不拦截事件。
            final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
            if (!disallowIntercept) {
            	// 2.2 当前ViewGroup可以通过重写onInterceptTouchEvent方法对子控件进行事件拦截，默认不拦截。
                intercepted = onInterceptTouchEvent(ev);
                ev.setAction(action); // restore action in case it was changed
            } else {
                intercepted = false;
            }
        } else {
            // 非ACTION_DOWN事件 & 没有View接收事件
            intercepted = true;
        }

        // 省略代码
    }
	// 省略代码
    return handled;
}

Step2：事件接收控件的查找 & DOWN事件的分发

在分析查找逻辑之前先来看一下关联的几个方法。

  • ViewGroup.buildTouchDispatchChildList() ：将控件按照Z值从大到小保存在mPreSortedChildren集合中。
  • ViewGroup.getAndVerifyPreorderedIndex() & ViewGroup.getAndVerifyPreorderedView()：按照子View在Canvas上绘制的先后顺序从后往前获取View。
  • ViewGroup.isTransformedTouchPointInView() ：判断触摸点是否在子View内部。
  • ViewGroup.dispatchTransformedTouchEvent()：将事件传递给子View。

ViewGroup.buildTouchDispatchChildList() 方法：

将控件按照Z值从大到小保存在mPreSortedChildren集合中(通常 ViewGroup 中的子 View，Z 值一致)。
可以参考文章： Android控制View绘制顺序的关键方法——setChildrenDrawingOrderEnabled

// ViewGroup.java
public ArrayList<View> buildTouchDispatchChildList() {
    return buildOrderedChildList();
}

// 将控件按照Z值大小从大到小保存在mPreSortedChildren集合中。
ArrayList<View> buildOrderedChildList() {
    final int childrenCount = mChildrenCount;
    if (childrenCount <= 1 || !hasChildWithZ()) return null;

    if (mPreSortedChildren == null) {
        mPreSortedChildren = new ArrayList<>(childrenCount);
    } else {
        // callers should clear, so clear shouldn't be necessary, but for safety...
        mPreSortedChildren.clear();
        mPreSortedChildren.ensureCapacity(childrenCount);
    }

    final boolean customOrder = isChildrenDrawingOrderEnabled();
    for (int i = 0; i < childrenCount; i++) {
        // add next child (in child order) to end of list
        final int childIndex = getAndVerifyPreorderedIndex(childrenCount, i, customOrder);
        final View nextChild = mChildren[childIndex];
        final float currentZ = nextChild.getZ();

        // insert ahead of any Views with greater Z
        int insertIndex = i;
        // 将控件按照Z值从大到小保存在mPreSortedChildren集合中。
        while (insertIndex > 0 && mPreSortedChildren.get(insertIndex - 1).getZ() > currentZ) {
            insertIndex--;
        }
        mPreSortedChildren.add(insertIndex, nextChild);
    }
    return mPreSortedChildren;
}

ViewGroup.getAndVerifyPreorderedIndex() & ViewGroup.getAndVerifyPreorderedView() 方法：

获取Children[]中指定索引的View返回，这中间包括是否使用自定义的顺序 。

// ViewGroup.java
private int getAndVerifyPreorderedIndex(int childrenCount, int i, boolean customOrder) {
    final int childIndex;
    if (customOrder) {
    	// 如果按照自定义顺序，可以在View的getChildDrawingOrder方法中返回指定的drawingPosition。
        final int childIndex1 = getChildDrawingOrder(childrenCount, i);
        if (childIndex1 >= childrenCount) {
            throw new IndexOutOfBoundsException("...");
        }
        childIndex = childIndex1;
    } else {
        childIndex = i;
    }
    return childIndex;
}

protected int getChildDrawingOrder(int childCount, int drawingPosition) {
    return drawingPosition;
}

private static View getAndVerifyPreorderedView(ArrayList<View> preorderedList, View[] children,
        int childIndex) {
    final View child;
    if (preorderedList != null) {
        child = preorderedList.get(childIndex);
        if (child == null) {
            throw new RuntimeException("...");
        }
    } else {
        child = children[childIndex];
    }
    return child;
}

ViewGroup.isTransformedTouchPointInView() 方法：

判断当前的触摸点是否在该View的内部(触摸点不再View上，则该View不用处理事件)。

protected boolean isTransformedTouchPointInView(float x, float y, View child,
        PointF outLocalPoint) {
    final float[] point = getTempPoint();
    point[0] = x;
    point[1] = y;
    transformPointToViewLocal(point, child);
    // 判断当前的触摸点是否在该View的内部(触摸点不再View上，则该View不用处理事件)。
    final boolean isInView = child.pointInView(point[0], point[1]);
    if (isInView && outLocalPoint != null) {
        outLocalPoint.set(point[0], point[1]);
    }
    return isInView;
}

ViewGroup.dispatchTransformedTouchEvent() 方法我们在分析完 ViewGroup.dispatchTouchEvent() Step2部分的逻辑再分析该方法。

ViewGroup.dispatchTouchEvent() 方法：

基本流程：

  1. 判断当前事件是否是cancel事件，默认没有事件取消时是不会出现Cancel事件的 (当父控件在MOVE事件中拦截子控件的事件时，会触发子View的CANCEL事件)。
  2. 执行查找事件接收控件的逻辑。
    1. 搜索子View过程：将 ChildrenView 按照Z值大小进行排列 (Z值大的排前面，通常ViewGroup中的子View，其Z值一致)，如果Z值相同，则按照自定义的顺序进行查找，这部分在 ViewGroup.dispatchDraw() 中也有。
    2. 查找过程：优先Z值查找，其次按照自定义顺序查找。但是不管是按照Z值还是自定义的顺序，这些最终都与View在Canvas上的绘制的先后顺序有关。在响应触摸事件时，如果最上层控件可以响应事件，我们肯定不会希望包含它的父控件响应。
    3. 边界校验：找到View后，调用isTransformedTouchPointInView()方法判断当前触摸点是否在child控件内，true为触摸点在控件内。
    4. 事件分发给子View：当触摸点在View的内部时，将事件传递给子View继续分发，方法返回true时代表有控件消费了DOWN事件，因此需要将该View保存在TouchTarget上，代表事件消费的对象。
// ViewGroup.dispatchTouchEvent()
public boolean dispatchTouchEvent(MotionEvent ev) {
    // 省略代码

    boolean handled = false;
    if (onFilterTouchEventForSecurity(ev)) {
        final int action = ev.getAction();
        final int actionMasked = action & MotionEvent.ACTION_MASK;
		// 省略状态重置代码
		final boolean intercepted;
		
		// 省略Step1：请求拦截处理的逻辑
        
        // 1.如果没有事件取消，则canceld为false。
        // Check for cancelation.
        final boolean canceled = resetCancelNextUpFlag(this) || actionMasked == MotionEvent.ACTION_CANCEL;
        
        TouchTarget newTouchTarget = null;
        boolean alreadyDispatchedToNewTouchTarget = false;
        // 2.Step2：当前控件不拦截子控件，则会去查找接收事件的子View。
        // canceled因为没有事件的取消，所以为false，而intercepted上面也没有拦截，所以也为false。
        if (!canceled && !intercepted) {
            // 省略代码
            
            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;
				// 省略代码
				
                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.
                    // 2.1 查找可以接收事件的子View。
                    // 搜索子View过程：将ChildrenView按照Z值大小进行排列(Z值大的排前面)。
                    final ArrayList<View> preorderedList = buildTouchDispatchChildList();
                    // 如果preorderedList不存在(即Z都一样大，通常ViewGroup中的子View，其Z值一致)，则按照自定义的顺序查找子View。
                    final boolean customOrder = preorderedList == null
                            && isChildrenDrawingOrderEnabled();
                    final View[] children = mChildren;
                    // 倒序遍历(Children数组的View元素越靠后，越是叶子节点的View)
                    for (int i = childrenCount - 1; i >= 0; i--) {
                    	// 2.2 查找过程：优先Z值查找，其次按照自定义顺序查找。
                        final int childIndex = getAndVerifyPreorderedIndex(childrenCount, i, customOrder);
                        final View child = getAndVerifyPreorderedView(preorderedList, children, childIndex);

                        // 省略代码

						// 2.3 isTransformedTouchPointInView方法用于判断当前触摸点是否在child控件内，true为触摸点在控件内。
                        if (!child.canReceivePointerEvents()
                                || !isTransformedTouchPointInView(x, y, child, null)) {
                            ev.setTargetAccessibilityFocus(false);
                            // 如果触摸点没在child控件内，则继续遍历下一个，直到找到为止(或遍历完)。
                            continue;
                        }

                        newTouchTarget = getTouchTarget(child);
                        // 省略代码
                        
                        // 2.4 分发事件给子View，此处传入了接收事件的View(child)，返回true表示有子View消费事件。
                        if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
                            // 省略代码
							// 2.5 将消费事件的View包装成TouchTarget。
                            newTouchTarget = addTouchTarget(child, idBitsToAssign);
                            // 此处表示有新的Target接收了事件。
                            alreadyDispatchedToNewTouchTarget = true;
                            // 这里找到第一个View后就会退出查找逻辑。
                            break;
                        }
                        // 省略代码
                    }
                    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;
                }
            }
        }
		// 省略Step3：执行事件逻辑
    }
	// 省略代码
	// 如果事件被消费，则handled为true
    return handled;
}

ViewGroup.dispatchTransformedTouchEvent() 方法：

基本流程：

  1. 当前控件向子类分发事件时，不管是 ACTION_CANCEL 事件还是其它事件，都会根据child==null是成立分两种情况。
  2. 如果 child == null，即没有找到接收该事件的子View，则调用ViewGroup父类的dispatchTouchEven()t方法，即 View.dispatchTouchEvent()，该方法主要是消费事件的逻辑(不一定消费)。
  3. 如果 child != null，即找到接收该事件的子View，则调用子View的dispatchTouchEven()方法，如果子View是一个ViewGroup，则继续执行ViewGroup.dispatchTouchEven() 的事件分发逻辑，如果子View是一个View，则执行View.dispatchTouchEvent()逻辑。

说明： 接收事件不代表消费事件，仅代表有该事件往下进行传递。

// ViewGroup.java
private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
        View child, int desiredPointerIdBits) {
    final boolean handled;

    // 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();
    // 接收ACTION_CANCEL事件
    if (cancel || oldAction == MotionEvent.ACTION_CANCEL) {
    	// cancel=true时，强制传递ACTION_CANCEL事件给子View。
        event.setAction(MotionEvent.ACTION_CANCEL);
        if (child == null) {
        	// 没有子类接收事件，则自己尝试处理。
            handled = super.dispatchTouchEvent(event);
        } else {
        	// 有子类接收事件，则将事件继续分发给子类。
            handled = child.dispatchTouchEvent(event);
        }
        // cancel=true时，，还原真实的MotionEvent事件类型。
        event.setAction(oldAction);
        return handled;
    }
    // 省略代码

	// 处理其它非ACTION_CANCEL事件。
	final MotionEvent transformedEvent;
    // 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;
}

ViewGroup.addTouchTarget() 方法：

将接收事件的子View包装成 TouchTarget 对象。

// ViewGroup.java
private TouchTarget addTouchTarget(@NonNull View child, int pointerIdBits) {
    final TouchTarget target = TouchTarget.obtain(child, pointerIdBits);
    target.next = mFirstTouchTarget;
    mFirstTouchTarget = target;
    return target;
}

Step3：事件分发逻辑

基本流程：
1.当 mFirstTouchTarget == null 时 (即没有找到子View接收事件，或者事件被当前View拦截)，且传入child=null时，表示当前View尝试自己处理事件，即最终调用 View.dispatchTouchEvent() 方法。
2. 当 mFirstTouchTarget != null 时，如果是 DOWN 事件，则在Step2过程中(查找到接收事件的子View)就已经分发过事件了，且设置 alreadyDispatchedToNewTouchTarget=true，因此这里直接对handled进行赋值(handled=true)。
3. 如果是 MOVE/UP 事件，则会在Step3中执行(在Step2中不处理)，此时需要根据cancelChild 状态值来判断向子View中执行ACTION_CANCEL 事件还是 MOVE/UP 事件。

// ViewGroup.dispatchTouchEvent()
public boolean dispatchTouchEvent(MotionEvent ev) {
    // 省略代码
    
    boolean handled = false;
    if (onFilterTouchEventForSecurity(ev)) {
		final int action = ev.getAction();
        final int actionMasked = action & MotionEvent.ACTION_MASK;
		// 省略状态重置代码
		final boolean intercepted;
		
		// 省略Step1：请求拦截处理的逻辑

        TouchTarget newTouchTarget = null;
        // 省略Step2：当前控件不拦截子控件，则会去查找接收事件的子View。
        if (!canceled && !intercepted) {
            // 省略代码
        }
		
		// Step3：执行事件分发逻辑
        // Dispatch to touch targets.
        // 如果没有找到子View接收事件，或者事件被拦截了，则mFirstTouchTarget==null成立。
        if (mFirstTouchTarget == null) {
            // No touch targets so treat this as an ordinary view.
            // 1.分发事件时child传入null，代表尝试自己处理事件。
            handled = dispatchTransformedTouchEvent(ev, canceled, null,
                    TouchTarget.ALL_POINTER_IDS);
        } else {
            // Dispatch to touch targets, excluding the new touch target if we already
            // dispatched to it.  Cancel touch targets if necessary.
            TouchTarget predecessor = null;
            TouchTarget target = mFirstTouchTarget;
            // target != nul，即有子View接收事件。
            while (target != null) {
                final TouchTarget next = target.next;
                // 2.alreadyDispatchedToNewTouchTarget==true说明DOWN事件已经分发过一次，且找到了接收事件的View(逻辑在Step2：查找接收事件的子View)。此时mFirstTouchTarget肯定不为null(上面已经判断过了)，即target!=null。
                if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
                	// 将handled赋值为true，并最终回传给Activity.dispatchTouchEvent()。
                    handled = true;
                } else {
                	// 3.下面主要处理MOVE和UP事件。
                	// resetCancelNextUpFlag 方法返回当前View是否需要取消事件，并重置状态为false。
                    final boolean cancelChild = resetCancelNextUpFlag(target.child)
                            || intercepted;
                    // 分两种情况：
                    // Condition1：拦截MOVE事件或target.childView本身需要执行ACTION_CANCEL事件，此时cancelChild=true且target.child != null，则向子View分发ACTION_CANCEL事件。
                    // Condition2：没有拦截MOVE事件且target.child本身不需要执行ACTION_CANCEL事件，则向子View分发当前的ev事件。
                    if (dispatchTransformedTouchEvent(ev, cancelChild,
                            target.child, target.pointerIdBits)) {
                        handled = true;
                    }
                    // 回收包装子View的TouchTarget链表。
                    if (cancelChild) {
                        if (predecessor == null) {
                            mFirstTouchTarget = next;
                        } else {
                            predecessor.next = next;
                        }
                        target.recycle();
                        target = next;
                        continue;
                    }
                }
                predecessor = target;
                target = next;
            }
        }
        // 省略代码
    }
	// 省略代码
	// 如果事件被消费，则handled为true
    return handled;
}

小结：

在这里插入图片描述

3.3 View 分发流程

View.dispatchTouchEvent() 方法：

// View.java
public boolean dispatchTouchEvent(MotionEvent event) {
    // 代码省略
    boolean result = false;
	// 代码省略
    if (onFilterTouchEventForSecurity(event)) {
        if ((mViewFlags & ENABLED_MASK) == ENABLED && handleScrollBarDragging(event)) {
            result = true;
        }
        //noinspection SimplifiableIfStatement
        ListenerInfo li = mListenerInfo;
        // 1.这里执行onTouch事件，所以Touch事件是最先被执行的。
        if (li != null && li.mOnTouchListener != null
                && (mViewFlags & ENABLED_MASK) == ENABLED
                && li.mOnTouchListener.onTouch(this, event)) {
            result = true;
        }
		// 2.如果onTouch返回false，则执行View.onTouchEvent()方法(点击事件逻辑都在里面)。
        if (!result && onTouchEvent(event)) {
            result = true;
        }
    }
	// 代码省略

    return result;
}

View.onTouchEvent() 方法：

// View.java
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 (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
                        // 长按在DOWn事件中触发，因此在UP事件响应点击事件时要移除长按逻辑，避免点击和长按逻辑都被触发。
                        removeLongPressCallback();

                        if (!focusTaken) {
                            if (mPerformClick == null) {
                                mPerformClick = new PerformClick();
                            }
                            // UP事件中触发点击事件。
                            if (!post(mPerformClick)) {
                                performClickInternal();
                            }
                        }
                    }
					// 代码省略
                }
                break;

            case MotionEvent.ACTION_DOWN:
                // 代码省略
                if (isInScrollingContainer) {
                    // 代码省略
                } else {
                    // Not inside a scrolling container, so show the feedback right away
                    setPressed(true, x, y);
                    // 在DOWN事件中触发长按点击事件。
                    checkForLongClick(
                            ViewConfiguration.getLongPressTimeout(),
                            x,
                            y,
                            TOUCH_GESTURE_CLASSIFIED__CLASSIFICATION__LONG_PRESS);
                }
                break;

            case MotionEvent.ACTION_MOVE:
            	// 代码省略
            	// MOVE事件中也会触发长按事件(长按时手指不可避免会出现移动)。
                checkForLongClick(
                    0 /* send immediately */,
                    x,
                    y,
                    TOUCH_GESTURE_CLASSIFIED__CLASSIFICATION__DEEP_PRESS);
                break;
        }
		// 响应可点击的逻辑时，都会返回true。
        return true;
    }
    return false;
}

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

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

小结：
在这里插入图片描述

3.4 完整的事件分发流程

在这里插入图片描述

参考

Elson_6
关注
专栏目录
android 事件分发机制
lanhuzi9999的专栏
05-22 2万+
前段时间做项目的时候，碰见listview
了解Android中的事件分发机制
Good_tea_h的博客
10-12 864
事件分发的对象是点击事件（Touch事件），当用户触摸屏幕时，将产生点击事件。这些事件包括ACTION_DOWN（按下）、ACTION_MOVE（移动）、ACTION_UP（抬起）和ACTION_CANCEL（取消）等类型。同一个事件序列指从手指刚接触屏幕，到手指离开屏幕的那一刻结束，在这一过程产生的一系列事件，这个序列一般以down事件开始，中间含有多个move事件，最终以up事件结束。事件分发的本质，其实就是将点击事件（MotionEvent）传递到某个具体的View处理的整个过程。
Android事件分发机制详解：史上最全面、最易懂
lcs353732057的专栏
03-29 1513
前言 Android事件分发机制是每个Android开发者必须了解的基础知识网上有大量关于Android事件分发机制的文章，但存在一些问题：内容不全、思路不清晰、无源码分析、简单问题复杂化等等 今天，我将全面总结Android的事件分发机制，我能保证这是市面上的最全面、最清晰、最易懂的 本文秉着“结论先行、详细分析在后”的原则，即先让大家感性认识，再通过理性分析从而理解问题；所以
android 的事件分发机制
qq_30867605的博客
02-23 525
  说到事件分发，我们都应该有一些了解，再开发的多多少少都会碰到一些事件冲突（比如滑动冲突），利用事件分发机制就可以解决，对于事件分发机制我虽然看过很多文章，但自己不做总结，总有点一知半解所以有了这片文章。好了说正文。   当一个点击操作发生时，事件分发是从Activity 的dispatchTouchEvent方法开始的，看源码可知实现在Window的  superDispatchTouchE...
android事件分发机制
12-29
### Android事件分发机制详解 #### 一、触摸事件涉及的核心类 在Android系统中，触摸事件主要由两类核心对象负责处理：`ViewGroup` 和 `View`。 1. **ViewGroup**：作为容器，继承自 `View`，用于容纳多个 `View`...
Android事件分发机制的详解
08-29
Android事件分发机制详解 Android事件分发机制是Android系统中的一种机制，它负责将事件分发给不同的View，以达到处理用户交互的目的。这个机制是Android系统中最重要的机制之一，它直接关系到应用程序的用户体验...
【Android】事件分发机制
最新发布
2303_79296612的博客
10-19 780
从上表可以看到 Activity和 View都是没有事件拦截的，这是因为：Activity 作为原始的事件分发者，如果 Activity 拦截了事件会导致整个屏幕都无法响应事件，这肯定不是我们想要的效果。View作为事件传递的最末端，要么消费掉事件，要么不处理进行回传，根本没必要进行事件拦截。
Android 安卓事件分发
看美丽风晴
07-13 804
开发的过程中，会遇到很多很多的滑动冲突，当然，我们解决滑动冲突就会用到事件分发，由于网上的例子较多，你可能直接找一个工具类而不去考虑是怎么解决的，所以面试的时候一脸蒙蔽，在这里我也为大家讲解一下。 在这里给大家展示一个流程图，我在网上看到的，感觉画的不错。 可以看出事件分发是有三层事件处理，分别为Activity 、ViewGroup 、 View 事件处理的标志有 super、t...
Android 事件分发
子墨博客
01-20 6522
当你作为一名应届生去面试的时候,面试官可能就是简单的问你Android的四大组件,各种布局等基础知识,但你作为一名有工作经验的应聘者就不会那么简单了,今天就来讨论很多面试官喜欢问的Android的事件分发. Android为什么要有事件分发呢?因为它是按照层排列,他如何知道你点击的哪一层呢,就需要用到事件分发了. 说到事件分发可能就会想起那三个威武的方法:事件分发(dispatchTouchE
Android---事件分发机制原理讲述
老王博客
01-12 594
事件分发机制讲解
Android-事件分发
feifan784的博客
05-17 237
前言 在Andorid卡法体系中，事件分发是一个比较重要的知识体系，了解整套的分发机制，可以分析各种点击滑动的问题，可以更好的拓展控件的事件功能和自定义控件。 Android的事件分发图解 图解:(从上往下Activity -> ViewGroup -> View) 从Activity的dispatchTouchEvent开始，通过不同的返回类型，结果也不同 如果事件不被打断，事件流向一个类U型图 图解： 假设一个DOWN事件到来，从Activity的dispatchTouchEvent
android事件分发
JeffTech的专栏
04-29 3727
先参考一下老罗同志的关于key事件的分发流程。http://blog.csdn.net/luoshengyang/article/details/6882903#comments 这里主要是写一下事件从native层上到Java层后，即到了InputQueue后的分发流程，以keyEvent为例。 InputQueue.java中 private static voi
Android事件分发机制【最新、最全、最易懂、由浅入深】
丨康有为丨的博客
03-18 5935
Android事件分发流程 = Activity -> ViewGroup -> View即：1个点击事件发生后，事件先传到Activity、再传到ViewGroup、最终再传到ViewActivity对点击事件的分发机制ViewGroup对点击事件的分发机制View对点击事件的分发机制Activity事件分发机制、ViewGroup事件分发机制、View事件分发机制当一个点击事件发生时，从Activity的事件分发开始（），流程总结如下：三者介绍。
android之事件分发机制
liangtianmeng的专栏
03-02 271
android的事件分发机制相对来说是非常重要的一块内容，初学者在事件分发上面会踩很多坑，类似滑动冲突等，对事件自定义控件也有很大帮助，对这块内容的深入研究迫在眉睫。 一、关于View的一些知识点 1、首先讲一下View与ViewGroup的关系：View是所有控件的基类，控件可以直接继承自View，也可以继承ViewGroup。ViewGroup继承自View。 2、View的位置参数，l...
Android之事件分发机制
jsyjst的博客
07-30 885
文章中出现的源码均基于8.0 一、View的事件分发机制 1. 基本认识 1.1 事件分发的本质 将点击事件（MotionEvent）传递到某个具体的View处理的整个过程 1.2 事件分发的对象 点击事件（Touch事件）：当用户触摸屏幕时，将产生点击事件 事件类型： 类型 说明 MotionEvent.ACTION_DOWN 手指刚接触屏幕，一般为事件的开始 Motio...
深入解析Android事件分发机制
"本文将深入探讨Android事件分发机制，包括View和ViewGroup的事件处理以及OnTouch和OnClickListener的交互。 Android事件分发机制是Android UI交互的基础，它涉及到用户与屏幕上的控件交互时，事件如何从系统层传递...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值