前言

每次听说事件分发就觉得好难、肯定不好学，其实事件分发也就那么回事。将本文看下去不说你能对事件分发有多么了解、多么深入，但是在应用开发中简单的使用是绝对没有问题的，下面咱就不叨叨，开始咱们的学习。

Android Touch事件的分发是 Android 工程师必备技能之一。关于事件分发主要有几个方向可以展开深入分析：

• 1.Touch事件是如何从驱动层传递给 Framework 层的 InputManagerService；
• 2.WMS是如何通过 ViewRootImpl 将事件传递到目标窗口；
• 3.Touch事件到达 DecorView 后，是如何一步步传递到内部的子 View 中的。

名词了解

• AMS:统一调度所有应用程序的Activity
• WMS:控制所有Window的显示与隐藏以及要显示的位置

什么是事件

事件：Touch，既触碰，就是用户触碰手机界面的交互事件。事件主要包括：按下、滑动、抬起与取消。这些事件被封装成MotionEvent对象。该对象中的主要事件如下表所示：

事件流

按下、滑动、抬起、取消这几种事件组成了一个事件流。事件流以按下为开始，中间可能有若干次滑动，以抬起或取消作为结束。

什么是事件分发

事件分发：就是将一次完整的点击所包含的点击事件传递到某个具体的View或ViewGroup，让该View或该ViewGroup处理(消费)它。分发是从上往下依次传递的，其中可能经过的对象有最上层Activity，中间层ViewGroup，最下层View。例如在屏幕中有一个Button控件，点击它时该次点击事件就会从Activity传到Button所在的ViewGroup，最后传到该Button控件去处理它。即事件分发就是从上往下依次遍历，直到找到能够处理消费这次点击事件的View或ViewGroup。

在Android对事件分发的处理过程中，主要是对Down事件作分发，进而找到能够处理Down事件的组件。对于事件流中后续的事件(如Move、Up等)，则直接分发给能够处理按下事件的组件。故本文讨论的内容则是主要针对按下事件的。

思路梳理

在深入分析事件分发源码之前，需要先弄清楚2个概念。

ViewGroup

ViewGroup 是一组 View 的组合，在其内部有可能包含多个子 View，当手指触摸屏幕上时，手指所在的区域既能在ViewGroup显示范围内，也可能在其内部 View 控件上。因此它内部的事件分发的重心是处理当前 ViewGroup 和子 View 之间的逻辑关系：

• 1.当前 ViewGroup 是否需要拦截Touch事件；
• 2.是否需要将Touch事件继续分发给子 View；
• 3.如何将Touch事件分发给子 View。

View

View 是一个单纯的控件，不能再被细分，内部也并不会存在子 View，所以它的事件分发的重点在于当前 View 如何去处理 Touch 事件，并根据相应的手势逻辑进行一些列的效果展示(比如滑动，放大，点击，长按等)。

• 1.是否存在 TouchListener；
• 2.是否自己接收处理 touch 事件(主要逻辑在 onTouchEvent 方法中)。

涉及事件分发的方法

方法的简单用途解析

我们可以发现这三个方法的返回值都为boolean类型，其实它们就是通过返回值来决定下一步的传递处理方向。

1、dispatchTouchEvent() ——用来分发事件所用

该方法会将Touch事件自上而下依次分发到子元素中，直到被终止或者到达View层，该方法也是采用一种隧道方式来分发。在其中会调用onInterceptTouchEvent()和onTouchEvent()，一般不会重写。

• 返回false则不拦截继续往下分发;
• 返回true则拦截住该事件不在向下层元素分发;

在dispatchTouchEvent()方法中默认返回false。

2、onInterceptTouchEvent() ——用来拦截事件所用

• 返回false不拦截事件，Touch事件就会往下传递给其子View。
• 返回true，该事件将会被拦截，并且被当前ViewGroup处理，调用ViewGroup的onTouchEvent()方法。

3、onTouchEvent() ——用来处理事件

• 返回true则表示该View能处理该事件，事件将终止向上传递(传递给其父View)。
• 返回false表示不能处理，则把事件传递给其父View的onTouchEvent()方法来处理。

拥有上述方法的类

注意： 需要特别注意一点就是ViewGroup中额外拥有onInterceptTouchEvent()方法，其他两个方法为这三种类所共同拥有。

事件分发流程

单个事件触发后，事件分发流程：Activity①>ViewGroup②>View③，如下图：

即要想充分理解Android分发机制，本质上是要理解：

• Activity对点击事件的分发机制
• ViewGroup对点击事件的分发机制
• View对点击事件的分发机制

从U型图中可以发现，由父组件不断向子组件分发，若子组件能够处理，则立刻返回。若子组件都不处理，那传递到底层的子组件，再返回回来。整个View之间的事件分发，实质上就是一个大的递归函数。

实例

下面咱们写一个简单实例来更好的理解这个大U型图，效果图:

创建实例

创建MyViewGroup继承ViewGroup

重写dispatchTouchEvent()、onInterceptTouchEvent()、onTouchEvent()方法

public class MyViewGroup extends RelativeLayout {
    public MyViewGroup(Context context) {
        super(context);
    }

    public MyViewGroup(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        MLog.logEvent("MyViewGroup.dispatchTouchEvent:",ev);
        return super.dispatchTouchEvent(ev);
    }
    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        MLog.logEvent("MyViewGroup.onInterceptTouchEvent:",ev);
        return false;
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        MLog.logEvent("MyViewGroup.onTouchEvent自行处理:",event);
        return super.onTouchEvent(event);
    }
}

创建MyView继承View

重写dispatchTouchEvent()、onTouchEvent()方法

public class MyView extends View {
    public MyView(Context context) {
        super(context);
    }

    public MyView(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
    }
    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        MLog.logEvent("MyView.dispatchTouchEvent:",ev);
        return super.dispatchTouchEvent(ev);
    }
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        MLog.logEvent("MyView.onTouchEvent:",event);
        return super.onTouchEvent(event);
    }
}

创建TouchActivity继承Activity

重写dispatchTouchEvent()、onTouchEvent()方法

public class TouchActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_touch);
    }

    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        MLog.logEvent("TouchActivity.dispatchTouchEvent:",ev);
        return super.dispatchTouchEvent(ev);
    }
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        MLog.logEvent("TouchActivity.onTouchEvent:",event);
        return super.onTouchEvent(event);
    }
}

创建布局文件

添加控件MyViewGroup和MyView

<?xml version="1.0" encoding="utf-8"?>
<com.scc.demo.view.MyViewGroup xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/mtrg_touch"
    android:layout_width="match_parent"
    android:layout_height="300dp"
    android:background="@color/color_FF773D">
    <com.scc.demo.view.MyView
        android:id="@+id/mtv_onclick"
        android:layout_width="120dp"
        android:layout_height="60dp"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="40dp"
        android:background="@color/color_188FFF"/>
</com.scc.demo.view.MyViewGroup>

MLog.logEvent()

方便查看对应事件

public static void logEvent(String msg, MotionEvent event) {
        String motionEvent = "";
        switch (event.getAction()){
            case MotionEvent.ACTION_DOWN://在屏幕按下时(所有事件的开始)
                motionEvent="DOWN";
                break;
            case MotionEvent.ACTION_UP://在屏幕抬起时(与DOWN对应)
                motionEvent="UP";
                break;
            case MotionEvent.ACTION_MOVE://在屏幕上滑动时
                motionEvent="MOVE";
                break;
            case MotionEvent.ACTION_CANCEL://滑动超出控件边界时
                motionEvent="CANCEL";
                break;
        }
        Log.e("SccEvent", msg + motionEvent);
    }

点击页面，看效果

点击Activity(白色区域)

运行结果

E/SccEvent: TouchActivity.dispatchTouchEvent:DOWN
E/SccEvent: TouchActivity.onTouchEvent:DOWN
E/SccEvent: TouchActivity.dispatchTouchEvent:MOVE
E/SccEvent: TouchActivity.onTouchEvent:MOVE
E/SccEvent: TouchActivity.dispatchTouchEvent:MOVE
E/SccEvent: TouchActivity.onTouchEvent:MOVE
E/SccEvent: TouchActivity.dispatchTouchEvent:UP
E/SccEvent: TouchActivity.onTouchEvent:UP

点击ViewGroup(黄色区域)

运行结果

E/SccEvent: TouchActivity.dispatchTouchEvent:DOWN
E/SccEvent: MyViewGroup.dispatchTouchEvent:DOWN
E/SccEvent: MyViewGroup.onInterceptTouchEvent:DOWN
E/SccEvent: MyViewGroup.onTouchEvent:DOWN
E/SccEvent: TouchActivity.onTouchEvent:DOWN
E/SccEvent: TouchActivity.dispatchTouchEvent:MOVE
E/SccEvent: TouchActivity.onTouchEvent:MOVE
E/SccEvent: TouchActivity.dispatchTouchEvent:MOVE
E/SccEvent: TouchActivity.onTouchEvent:MOVE
E/SccEvent: TouchActivity.dispatchTouchEvent:UP
E/SccEvent: TouchActivity.onTouchEvent:UP

点击View(蓝色区域)

运行结果

E/SccEvent: TouchActivity.dispatchTouchEvent:DOWN
E/SccEvent: MyViewGroup.dispatchTouchEvent:DOWN
E/SccEvent: MyViewGroup.onInterceptTouchEvent:DOWN
E/SccEvent: MyView.dispatchTouchEvent:DOWN
E/SccEvent: MyView.onTouchEvent:DOWN
E/SccEvent: MyViewGroup.onTouchEvent:DOWN
E/SccEvent: TouchActivity.onTouchEvent:DOWN
E/SccEvent: TouchActivity.dispatchTouchEvent:MOVE
E/SccEvent: TouchActivity.onTouchEvent:MOVE
E/SccEvent: TouchActivity.dispatchTouchEvent:MOVE
E/SccEvent: TouchActivity.onTouchEvent:MOVE
E/SccEvent: TouchActivity.dispatchTouchEvent:UP
E/SccEvent: TouchActivity.onTouchEvent:UP

结果分析

重叠区域越多触发事件越多。这就用到了事件分发。

点击蓝色区域，走完了一个大U分发，没有人拦截和处理。

看看上面的日志你会发现按下事件走了那么多方法，为什么滑动和抬起仅调用Activity中的方法？

原因就是：MOVE、UP 等事件的分发交给谁，取决于它们的起始事件 Down 是由谁捕获的。可参阅文章后面的为什么 DOWN 事件特殊

本次将所有Touch事件打印，后续仅打印按下事件。

事件分发和处理

Activity处理和分发

处理

1.将MyViewGroup.dispatchTouchEvent()返回修改为false

  @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        MLog.logEvent("MyViewGroup.dispatchTouchEvent:",ev);
        return false;
    }

运行结果

E/SccEvent: TouchActivity.dispatchTouchEvent:DOWN
E/SccEvent: MyViewGroup.dispatchTouchEvent:DOWN
E/SccEvent: TouchActivity.onTouchEvent:DOWN
E/SccEvent: TouchActivity.SccEvent就在这里玩

2.MyViewGroup仅拦截不处理，也会交给Activity.onTouchEvent处理

3.向下分发的事件ViewGroup和View都不处理，最后还是交给Activity.onTouchEvent处理(如上面点击蓝色区域结果分析)

分发

Actvitiy是事件分发的顶层，dispatchTouchEvent方法返回true不做分发，事件结束。返回false或者super.dispatchTouchEvent(ev)则向下分发事件。向下分发就没必要处理(重写)dispatchTouchEvent()

ViewGroup拦截处理和分发

拦截处理

确保Activity做好分发后(即不对dispatchTouchEvent做修改)，修改MyViewGroup.onInterceptTouchEvent()和MyViewGroup.onTouchEvent()方法，ViewGroup的重点在于事件拦截(onInterceptTouchEvent),所以咱重写拦截事件和处理事件的两个方法即可。

    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        MLog.logEvent("MyViewGroup.dispatchTouchEvent:",ev);
        return super.dispatchTouchEvent(ev);
    }
    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        MLog.logEvent("MyViewGroup.onInterceptTouchEvent:",ev);
        return true;
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        MLog.logEvent("MyViewGroup.onTouchEvent:",event);
        MLog.logEvent("MyViewGroup.SccEvent就在这里玩",event.getAction());
        return true;
    }

运行结果

E/SccEvent: TouchActivity.dispatchTouchEvent:DOWN
E/SccEvent: MyViewGroup.dispatchTouchEvent:DOWN
E/SccEvent: MyViewGroup.onInterceptTouchEvent:DOWN
E/SccEvent: MyViewGroup.onTouchEvent:DOWN
E/SccEvent: MyViewGroup.SccEvent就在这里玩

结果分析

在MyViewGroup.onTouchEvent()方法将事件处理了，MyViewGroup告诉TouchActivity已经处理掉了。这个时候MyView想不想处理都不重要了，因为事件已经让MyViewGroup拐跑了。

如果这个时候返回super.onTouchEvent(event),则默认未处理，后面会交给TouchActivity.onTouchEvent()来处理。看效果

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        MLog.logEvent("MyViewGroup.onTouchEvent:",event);
        MLog.logEvent("MyViewGroup.SccEvent就在这里玩",event.getAction());
        return super.onTouchEvent(event);
    }

运行结果

E/SccEvent: TouchActivity.dispatchTouchEvent:DOWN
E/SccEvent: MyViewGroup.dispatchTouchEvent:DOWN
E/SccEvent: MyViewGroup.onInterceptTouchEvent:DOWN
E/SccEvent: MyViewGroup.onTouchEvent:DOWN
E/SccEvent: MyViewGroup.SccEvent就在这里玩
TouchActivity.onTouchEvent:DOWN

那这就是个失败的拦截和处理。

分发

不对ViewGroup的dispatchTouchEvent()和onInterceptTouchEvent()做修改即可

View处理和分发

View处理

确保ViewGroup做好分发后，修改MyView.onTouchEvent()方法。

@Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        MLog.logEvent("MyView.dispatchTouchEvent:",ev);
        return super.dispatchTouchEvent(ev);
    }
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        MLog.logEvent("MyView.onTouchEvent:",event);
        MLog.logEvent("MyView.SccEvent就在这里玩",event.getAction());
        return true;
//        return super.onTouchEvent(event);
    }

运行结果

E/SccEvent: TouchActivity.dispatchTouchEvent:DOWN
E/SccEvent: MyViewGroup.dispatchTouchEvent:DOWN
E/SccEvent: MyViewGroup.onInterceptTouchEvent:DOWN
E/SccEvent: MyView.dispatchTouchEvent:DOWN
E/SccEvent: MyView.onTouchEvent:DOWN
E/SccEvent: MyView.SccEvent就在这里玩

结果分析

在MyView.onTouchEvent()将事件处理了，MyTouchView告诉MyViewGroup我消费掉了,MyViewGroup告诉TouchActivity消费掉了。

分发

View本身就是最小的View，没有子View给他做分发，所以MyView.dispatchTouchEvent() 方法可以不做改变，或者不重写。

onTouch()与onTouchEvent()的区别(View)

onTouchEvent()方法：

onTouchEvent是手机屏幕事件的处理方法，是获取的对屏幕的各种操作，比如向左向右滑动，点击返回按钮等等。当屏幕有touch事件时，此方法就会别调用。

onTouch方法：

onTouch()是OnTouchListener接口的方法，它是获取某一个控件的触摸事件，因此使用时，必须使用setOnTouchListener绑定到控件，然后才能鉴定该控件的触摸事件。

小结

onTouch()优先级比onTouchEvent()高，会先触发。

假如onTouch方法返回false，会接着触发onTouchEvent，反之onTouchEvent方法不会被调用。

onClick等事件的实现等等都基于onTouchEvent，假如onTouchEvent返回true，这些事件将不会被触发。

以上以ViewGroup分发为前提。

上面几种情况基本包含应用中出现的场景，合理利用你也可以正确的使用Touch事件分发。是不是很简单。

为什么 DOWN 事件特殊

所有 Touch 事件都是从 DOWN 事件开始的，这是 DOWN 事件比较特殊的原因之一。另一个原因是 DOWN 事件的处理结果会直接影响后续 MOVE、UP 事件的逻辑。也就是说后续的 MOVE、UP 等事件的分发交给谁，取决于它们的起始事件 Down 是由谁捕获的。

• 向上滑动：查看方法的简单用途解析进行巩固
• 向下滑动：查看源码分析进一步学习

源码分析

下面，咱们一起通过源码，全面解析事件分发机制，即按顺序讲解：

• Activity事件分发机制
• ViewGroup事件分发机制
• View事件分发机制

Activity事件分发机制

Android事件分发机制首先会将点击事件传递到Activity中，具体是执行dispatchTouchEvent()进行事件分发。

Activity.dispatchTouchEvent()源码

/**
  * 创建人：帅次
  * 创建时间：2021/7/5
  * 功能：Activity.dispatchTouchEvent()
  */
public boolean dispatchTouchEvent(MotionEvent ev) {
    if (ev.getAction() == MotionEvent.ACTION_DOWN) {
	//在这里仅用于ACTION_DOWN的判断
	onUserInteraction();
    }
    //返回true
    if (getWindow().superDispatchTouchEvent(ev)) {
 	//Activity.dispatchTouchEvent()就返回true，则方法结束。
  	//该点击事件停止往下传递&事件传递过程结束(让爷爷吃了嘿嘿)
  	return true;
    }
    return onTouchEvent(ev);
}

Activity.onUserInteraction()源码

/**
  * 创建人：帅次
  * 创建时间：2021/7/6
  * 功能：该方法是用户交互，每当向Activity分派按键、触摸或轨迹球事件时调用。
  */
public void onUserInteraction() {
}

Window.superDispatchTouchEvent()源码

/**
  * 创建人：帅次
  * 创建时间：2021/7/6
  * 功能：Window.superDispatchTouchEvent属于抽象方法。
  * 用于自定义窗口，如Dialog，传递触摸屏事件进一步向下视图层次结构。
  * 应用程序开发人员应该不需要实现或调用它。
  */
public abstract boolean superDispatchTouchEvent(MotionEvent event);

因为Window是抽象类，咱就继续挖，就找到了它的唯一实现类PhoneWindow。

PhoneWindow.superDispatchTouchEvent()源码

// This is the top-level view of the window, containing the window decor.
//这是窗口的顶层View的实例对象。 
private DecorView mDecor;
@Override
public boolean superDispatchTouchEvent(MotionEvent event) {
	//咱们继续往下看
	return mDecor.superDispatchTouchEvent(event);
}

DecorView.superDispatchTouchEvent()源码

public boolean superDispatchTouchEvent(MotionEvent event) {
	//super调用父类dispatchTouchEvent方法。那它的父类是谁呢？
	//DecorView extends FrameLayout、FrameLayout extends ViewGroup！
	//从上面看出DecorView 是ViewGroup的间接子类。
	//看到这里Activity.dispatchTouchEvent()也基本差不多了
	//如果ViewGroup.dispatchTouchEvent return true，
	//则Activity.dispatchTouchEvent()return true。
	//如果ViewGroup.dispatchTouchEvent return false，
	//则执行Activity.onTouchEvent(ev)。
	return super.dispatchTouchEvent(event);
}

Activity.onTouchEvent()源码

/**
  * 创建人：帅次
  * 创建时间：2021/7/6
  * 功能：当Touch事件未被其下的任何View消费时调用。
  */
public boolean onTouchEvent(MotionEvent event) {
    //Window.shouldCloseOnTouch来判断是否消费。
    //那咱就继续看看Window.shouldCloseOnTouch是干嘛的
    if (mWindow.shouldCloseOnTouch(this, event)) {
        finish();
        //已经消费了该事件,则返回true
        return true;
    }
    //还没有消费返回false，默认返回false
    return false;
}

Window.shouldCloseOnTouch()源码

//这里支持的最高版本maxTargetSdk = Build.VERSION_CODES.P(28)，咱使用SDK30就没办法处理了。
//主要是对于处理边界外点击事件的判断：是否是DOWN事件，event的坐标是否在边界内等
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 115609023)
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 true;
    }
//返回false：在边界内，即未消费(默认)
    return false;
}

Activity.onTouchEvent()到这里就基本结束了。后面源码完善在再补充。

Activity源码总结

当一个点击事件发生时，从Activity的事件分发开始(Activity.dispatchTouchEvent())，流程如下：

ViewGroup事件分发机制

从上面Activity的事件分发机制可知，在Activity.dispatchTouchEvent()实现了将事件从Activity->ViewGroup的传递，ViewGroup的事件分发机制从dispatchTouchEvent()开始。

在Activity.dispatchTouchEvent()中遗留了ViewGroup.dispatchTouchEvent()什么时候返回true/false在下面的源码分析中找出来。

ViewGroup.dispatchTouchEvent()源码

先从宏观角度，纵览整个 dispatch 的源码如下：

@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
    /**
     * 一、检查当前ViewGroup是否需要拦截事件
     * 1、如果事件为DOWN事件，则调用onInterceptTouchEvent进行拦截判断；
     * 2、mFirstTouchTarget！=null，代表已经有子View捕获了这个事件，
     子 View 的 dispatchTouchEvent 返回true就是代表捕获touch 件。
     */
    /**
     * 二、将事件分发给子View
     * 满足条件canceled和intercepted都为false，既不取消也不拦截
     * 1、actionMasked==MotionEvent.ACTION_DOWN
     表明事件主动分发的前提是事件为 DOWN 事件
     * 2、通过for循环，遍历当前ViewGroup下的所有子View；
     * 3、处判断事件坐标是否在子 View 坐标范围内，并且子 View 并没有处在动画状态；
     * 4、调用 dispatchTransformedTouchEvent 方法将事件分发给子 View，
     如果子 View 捕获事件成功，则将 View 赋值给 mFirstTouchTarget。
     */
    /**
     * 三、根据mFirstTouchTarget再次分发事件
     * 3.1、mFirstTouchTarget为null，说明在上述的事件分发中并没有子 View 对事件进行了捕获操作。
     直接调用 dispatchTransformedTouchEvent 方法，并传入child为 null
     最终会调用 super.dispatchTouchEvent 方法。实际上最终会调用自身的 onTouchEvent 方法，进行处理touch事件。
     结论：如果没有子 View 捕获处理 touch 事件，ViewGroup会通过自身的onTouchEvent方法进行处理。
     * 3.2、mFirstTouchTarget 不为 null，说明在上述的事件分发中有子 View 对 touch 事件进行了捕获，
     则直接将当前以及后续的事件交给 mFirstTouchTarget 指向的 View 进行处理。
     */
}

下面咱逐层分析： 

@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    // 是否按下操作 , 最终的对外返回结果 , 该方法的最终返回值 
    boolean handled = false;
    /*onFilterTouchEventForSecurity以应用安全策略过滤触摸事件。
    /return true分派事件，return false删除事件。*/
    if (onFilterTouchEventForSecurity(ev)) {
        final int action = ev.getAction();
        final int actionMasked = action & MotionEvent.ACTION_MASK;
        final boolean intercepted;
        /**
         * 一、检查当前ViewGroup是否需要拦截事件
         * 1、如果事件为DOWN事件，则调用onInterceptTouchEvent进行拦截判断；
         * 2、mFirstTouchTarget！=null，代表已经有子View捕获了这个事件，
         子 View 的 dispatchTouchEvent 返回true就是代表捕获touch 件。
         */
        if (actionMasked == MotionEvent.ACTION_DOWN
                || mFirstTouchTarget != null) {
            final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
            if (!disallowIntercept) {
                intercepted = onInterceptTouchEvent(ev);
                //恢复操作以防它被更改
                ev.setAction(action);
            } 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;
        }
        // Check for cancelation.
        final boolean canceled = resetCancelNextUpFlag(this)
                || actionMasked == MotionEvent.ACTION_CANCEL;

        // Update list of touch targets for pointer down, if needed.
        final boolean isMouseEvent = ev.getSource() == InputDevice.SOURCE_MOUSE;
        final boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0
                && !isMouseEvent;
        TouchTarget newTouchTarget = null;
        boolean alreadyDispatchedToNewTouchTarget = false;
        /**
         * 二、将事件分发给子View
         * 满足条件canceled和intercepted都为false，既不取消也不拦截
         */
        if (!canceled && !intercepted) {
            /*1、actionMasked==MotionEvent.ACTION_DOWN表明
            事件主动分发的前提是事件为 DOWN 事件*/
            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;

                // Clean up earlier touch targets for this pointer id in case they
                // have become out of sync.
                removePointersFromTouchTargets(idBitsToAssign);

                final int childrenCount = mChildrenCount;
                if (newTouchTarget == null && childrenCount != 0) {
                    final float x =
                            isMouseEvent ? ev.getXCursorPosition() : ev.getX(actionIndex);
                    final float y =
                            isMouseEvent ? ev.getYCursorPosition() : ev.getY(actionIndex);
                    // Find a child that can receive the event.
                    // Scan children from front to back.
                    final ArrayList<View> preorderedList = buildTouchDispatchChildList();
                    final boolean customOrder = preorderedList == null
                            && isChildrenDrawingOrderEnabled();
                    final View[] children = mChildren;
                    //2、通过for循环，遍历当前ViewGroup下的所有子View；
                    for (int i = childrenCount - 1; i >= 0; i--) {
                        final int childIndex = getAndVerifyPreorderedIndex(
                                childrenCount, i, customOrder);
                        final View child = getAndVerifyPreorderedView(
                                preorderedList, children, childIndex);
                        //3、处判断事件坐标是否在子 View 坐标范围内，并且子 View 并没有处在动画状态；
                        if (!child.canReceivePointerEvents()
                                || !isTransformedTouchPointInView(x, y, child, null)) {
                            continue;
                        }

                        newTouchTarget = getTouchTarget(child);
                        if (newTouchTarget != null) {
                            // Child is already receiving touch within its bounds.
                            // Give it the new pointer in addition to the ones it is handling.
                            newTouchTarget.pointerIdBits |= idBitsToAssign;
                            break;
                        }

                        resetCancelNextUpFlag(child);
                        /*4、调用 dispatchTransformedTouchEvent 方法将事件分发给子 View，
                         如果子 View 捕获事件成功，则将 View 赋值给 mFirstTouchTarget。*/
                        if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
                            // Child wants to receive touch within its bounds.
                            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();
                            newTouchTarget = addTouchTarget(child, idBitsToAssign);
                            alreadyDispatchedToNewTouchTarget = true;
                            break;
                        }


                    }
                    if (preorderedList != null) preorderedList.clear();
                }
            }
        }
        /**
         * 三、根据mFirstTouchTarget再次分发事件
         */
        //3.1mFirstTouchTarget为null，
        if (mFirstTouchTarget == null) {
            /*说明在上述的事件分发中并没有子 View 对事件进行了捕获操作。
            直接调用 dispatchTransformedTouchEvent 方法，并传入child为 null
            最终会调用 super.dispatchTouchEvent 方法。
            实际上最终会调用自身的 onTouchEvent 方法，进行处理touch事件。*/
            /*结论：如果没有子 View 捕获处理 touch 事件，
            ViewGroup会通过自身的onTouchEvent方法进行处理。*/
            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;
            while (target != null) {
                final TouchTarget next = target.next;
                if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
                    handled = true;
                } else {
                    final boolean cancelChild = resetCancelNextUpFlag(target.child)
                            || intercepted;

                    /*mFirstTouchTarget 不为 null，说明在上述的事件分发中有子 View 对 touch 事件进行了捕获，
                    则直接将当前以及后续的事件交给 mFirstTouchTarget 指向的 View 进行处理。
                     */
                    if (dispatchTransformedTouchEvent(ev, cancelChild,
                            target.child, target.pointerIdBits)) {
                        handled = true;
                    }
                }
                predecessor = target;
                target = next;
            }
        }
    }
    return handled;
}

ViewGroup.onInterceptTouchEvent()源码

/**
  * 创建人：帅次
  * 创建时间：2021/7/6
  * 前提ViewGroup.dispatchTouchEvent return super.dispatchTouchEvent(ev);
  * 功能：是否拦截事件 return true拦截，return false(默认)不拦截
  */
public boolean onInterceptTouchEvent(MotionEvent ev) {
    if (ev.isFromSource(InputDevice.SOURCE_MOUSE)
            && ev.getAction() == MotionEvent.ACTION_DOWN
            && ev.isButtonPressed(MotionEvent.BUTTON_PRIMARY)
            && isOnScrollbarThumb(ev.getX(), ev.getY())) {
        return true;
    }
    return false;
}

ViewGroup.onTouchEvent()源码

ViewGroup是没有onTouchEvent()这个方法的，因为ViewGroup是View的子类，所以ViewGroup可以直接调用View的onTouchEvent()方法。这里就不做详细介绍，下面在View事件分发机制中一起解答。

ViweGroup源码总结

Android事件分发传递到Acitivity后，总是先传递到ViewGroup、再传递到View。流程总结如下：(假设已经经过了Acitivity事件分发传递并传递到ViewGroup)

View的事件分发机制

从上面ViewGroup事件分发机制知道，View事件分发机制从dispatchTouchEvent()开始。

View.dispatchTouchEvent()源码

public boolean dispatchTouchEvent(MotionEvent event) {
    /*一、(mViewFlags & ENABLED_MASK) == ENABLED
     1、该条件是判断当前点击的控件是否enable
     2、由于很多View默认enable，故该条件恒定为true（除非手动设置为false）
     */

    /*二、mOnTouchListener != null
     1、mOnTouchListener变量在View.setOnTouchListener()里赋值
     2、即只要给控件注册了Touch事件，mOnTouchListener就一定被赋值（即不为空）
     */

     /*三、mOnTouchListener.onTouch(this, event)
     1、即回调控件注册Touch事件时的onTouch()；
     2、需手动复写设置，具体如下（以View为例）
     view.setOnTouchListener(new OnTouchListener() {
        @Override
        public boolean onTouch(View v, MotionEvent event) {
            MLog.logEvent("MyTouchTrueView.onTouch自行处理:",event);
            return true;
            // 1、若在onTouch()返回true，就会让上述三个条件全部成立，
            从而使得View.dispatchTouchEvent()直接返回true，事件分发结束
            // 2、若在onTouch()返回false，就会使得上述三个条件不全部成立，
            从而使得View.dispatchTouchEvent()中跳出if，执行onTouchEvent(event)
            // 3、onTouchEvent()源码分析 
        }
    });
     */
    if ( (mViewFlags & ENABLED_MASK) == ENABLED &&
            mOnTouchListener != null &&
            mOnTouchListener.onTouch(this, event)) {
        return true;
    }

    return onTouchEvent(event);
}

View.onTouchEvent()源码

public boolean onTouchEvent(MotionEvent event) {  
    ... // 仅展示关键代码
    // 若该控件可点击，则进入switch判断中
    if (((viewFlags & CLICKABLE) == CLICKABLE || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)) {  
        // 根据当前事件类型进行判断处理
        switch (event.getAction()) { 
            // 抬起View
            case MotionEvent.ACTION_UP:  
                    performClick(); 
                    break;  
            // 按下
            case MotionEvent.ACTION_DOWN:  
                postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());  
                break;  
            // 取消
            case MotionEvent.ACTION_CANCEL:  
                refreshDrawableState();  
                removeTapCallback();  
                break;
            // 滑动
            case MotionEvent.ACTION_MOVE:  
                final int x = (int) event.getX();  
                final int y = (int) event.getY();  
                int slop = mTouchSlop;  
                if ((x < 0 - slop) || (x >= getWidth() + slop) ||  
                        (y < 0 - slop) || (y >= getHeight() + slop)) {  
                    removeTapCallback();  
                    if ((mPrivateFlags & PRESSED) != 0) {  
                        removeLongPressCallback();  
                        mPrivateFlags &= ~PRESSED;  
                        refreshDrawableState();  
                    }  
                }  
                break;  
        }  

        // 若该控件可点击，就一定返回true
        return true;  
    }  
  // 若该控件不可点击，就一定返回false
  return false;  
}
  public boolean performClick() {  
      if (mOnClickListener != null) {
          // 只要通过setOnClickListener()为控件View注册1个点击事件
          // 那么就会给mOnClickListener变量赋值（即不为空）
          // 则会往下回调onClick() & performClick()返回true
          playSoundEffect(SoundEffectConstants.CLICK);  
          mOnClickListener.onClick(this);  
          return true;  
      }  
      return false;  
  }  

View源码总结

Android事件分发传递到Acitivity后，总是先传递到ViewGroup、再传递到View。流程总结如下：(假设已经经过了ViewGroup事件分发传递并传递到View)

总结

重点分析了 dispatchTouchEvent 的事件的流程机制，这一过程主要分 3 部分：

• 1、判断是否需要拦截 —> 主要是根据 onInterceptTouchEvent 方法的返回值来决定是否拦截；
• 2、在 DOWN 事件中将 touch 事件分发给子 View —> 这一过程如果有子 View 捕获消费了 touch 事件，会对 mFirstTouchTarget 进行赋值；
• 3、最后一步，DOWN、MOVE、UP 事件都会根据 mFirstTouchTarget 是否为 null，决定是自己处理 touch 事件，还是再次分发给子 View。

然后介绍了整个事件分发中的几个特殊的点。

• 1、DOWN 事件的特殊之处：事件的起点；决定后续事件由谁来消费处理；
• 2、mFirstTouchTarget 的作用：记录捕获消费 touch 事件的 View，是一个链表结构；
• 3、CANCEL 事件的触发场景：当父视图先不拦截，然后在 MOVE 事件中重新拦截，此时子 View 会接收到一个 CANCEL 事件。

以上就是本文的全部内容，希望对大家学习 Android 事件分发有所帮助和启发。