目的
安卓上面的 View 是树形结构的，View 可能会重叠在一起，当我们点击的地方有多个 View 都可以响应的时候，这个点击事件应该给谁呢？为了解决这一个问题，就有了事件分发机制。
（一）View的事件分发机制
MontionEvent 点击事件的分发过程由三个很重要的方法来共同完成：
dispatchTouchEvent、onInterceptTouchEvent 和 onTouchEvent
public boolean dispatchTouchEvent(MontionEvent ev)
用来进行事件的分发。如果事件能够传递给当前的 View，那么此方法一定会被调用，返回结果受当前 View 的 onTouchEvent 和下级 View 的dispatchTouchEvent 方法的影响，表示 是否消耗当前事件public boolean onInterceptTouchEvent(MontionEvent ev)
在上述方法内部调用，用来判断是否拦截某个事件，如果当前 View 拦截了某个事件，那么在同一个事件序列当中，此方法不会被再次调用，返回结果表示 是否拦截当前事件public boolean onTouchEvent(MontionEvent ev)
在 dispatchTouchEvent 方法中调用，用来处理点击事件，返回结果表示 是否消耗当前事件，如果不消耗，则在同一个事件序列中，当前 View 无法再次接收到事件
1. View 的事件分发机制
当点击事件产生后，事件首先会传递给当前 Activity，这会调用 Activity 的 dispatchTouchEvent 方法，具体的事件处理工作都交由 Activity 中的 PhoneWindow 来完成，然后 PhoneWindow 再把事件处理工作交给 DecorView，之后再由 DecorView 将事件处理工作交给最顶级的 ViewGroup，依次传递给子 View
分发拦截方法
2. 点击事件的传递规则
上述的三种方法的关系，如下 伪代码：
public boolean diapatchTouchEvent(MotionEvent event){
boolean consume = false;
//判断是否拦截
if(onIntercetTouchEvent(ev)){ //拦截
consume = onTouchEvent(ev);//消费事件
}else{
consume = child.dispatchTouchEvent(ev);//chileView开始事件分发
}
return consume; //返回事件拦截结果 默认为false
}
通过上述代码，我们大致了解点击事件的传递规则：
对于一个根 ViewGroup 来说，点击事件产生后，首先会传递给它，这时它的 dispatchTouchEvent 就会被调用，如果这个 ViewGroup 的 onInterceptTouchEvent 方法返回 true 就表示它要拦截当前事件，接着事件就交给这个 ViewGroup 处理，即它的 onTouchEvent 方法就会被调用；如果这个 ViewGroup 的 onInterceptTouchEvent 方法返回的 false 就表示它不拦截当前事件，这时当前事件就会继续传递给它的子元素，接着子元素的 disptchTouchEvent 方法就会被调用，如此反复直到事件被最终处理
（二）事件分发的源码解析
1. Activity 对点击事件的分发过程
当一个点击事件发生时，事件最先传到当前 Activity 的 dispatchTouchEvent 进行事件分发，之后事件传递给 Window，Window 是个抽象类，它的唯一实现类是 PhoneWindow，PhoneWindow 又将事件直接传递给了 DecorView，这个 DecorView 类是 PhoneWindow 类的一个内部类 DecorView 继承自 FrameLayout，是所有界面的父类，FrameLayout 是 ViewGroup 的子类，故 DecorView 的间接父类 = ViewGroup（顶级 View）
源码如下：
public boolean dispatchTouchEvent(MotionEvent ev) {
if (ev.getAction() == MotionEvent.ACTION_DOWN) {
onUserInteraction();
}
if (getWindow().superDispatchTouchEvent(ev)) {
return true;
}
return onTouchEvent(ev);
}
首先，事件开始交给 Activity 所附属的 Window 进行分发，如果返回 true，整个事件循环就结束了，返回 false 意味着事件没人处理，所有 View 的 onTouchEvent 都返回了 false，那么 Activity 的 onTouchEvent 就会被调用
示意图
2. ViewGroup 事件的分发过程
点击事件传递到 ViewGroup（顶级 View），ViewGroup 的事件分发机制也是从 dispatchTouchEvent 开始
源码如下：
public boolean dispatchTouchEvent(MotionEvent ev) {
... // 仅贴出关键代码
// 重点分析1：ViewGroup每次事件分发时，都需调用onInterceptTouchEvent()询问是否拦截事件
if (disallowIntercept || !onInterceptTouchEvent(ev)) {
// 判断值1：disallowIntercept = 是否禁用事件拦截的功能(默认是false)，可通过调用requestDisallowInterceptTouchEvent（）修改
// 判断值2： !onInterceptTouchEvent(ev) = 对onInterceptTouchEvent()返回值取反
// a. 若在onInterceptTouchEvent()中返回false（即不拦截事件），就会让第二个值为true，从而进入到条件判断的内部
// b. 若在onInterceptTouchEvent()中返回true（即拦截事件），就会让第二个值为false，从而跳出了这个条件判断
// c. 关于onInterceptTouchEvent() ->>分析1
ev.setAction(MotionEvent.ACTION_DOWN);
final int scrolledXInt = (int) scrolledXFloat;
final int scrolledYInt = (int) scrolledYFloat;
final View[] children = mChildren;
final int count = mChildrenCount;
// 重点分析2
// 通过for循环，遍历了当前ViewGroup下的所有子View
for (int i = count - 1; i >= 0; i--) {
final View child = children[i];
if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE
|| child.getAnimation() != null) {
child.getHitRect(frame);
// 判断当前遍历的View是不是正在点击的View，从而找到当前被点击的View
// 若是，则进入条件判断内部
if (frame.contains(scrolledXInt, scrolledYInt)) {
final float xc = scrolledXFloat - child.mLeft;
final float yc = scrolledYFloat - child.mTop;
ev.setLocation(xc, yc);
child.mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;
// 条件判断的内部调用了该View的dispatchTouchEvent()
// 即 实现了点击事件从ViewGroup到子View的传递（具体请看下面的View事件分发机制）
if (child.dispatchTouchEvent(ev)) {
mMotionTarget = child;
return true;
// 调用子View的dispatchTouchEvent后是有返回值的
// 若该控件可点击，那么点击时，dispatchTouchEvent的返回值必定是true，因此会导致条件判断成立
// 于是给ViewGroup的dispatchTouchEvent（）直接返回了true，即直接跳出
// 即把ViewGroup的点击事件拦截掉
}
}
}
}
}
}
boolean isUpOrCancel = (action == MotionEvent.ACTION_UP) ||
(action == MotionEvent.ACTION_CANCEL);
if (isUpOrCancel) {
mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;
}
final View target = mMotionTarget;
// 重点分析3
// 若点击的是空白处（即无任何View接收事件） / 拦截事件（手动复写onInterceptTouchEvent（），从而让其返回true）
if (target == null) {
ev.setLocation(xf, yf);
if ((mPrivateFlags & CANCEL_NEXT_UP_EVENT) != 0) {
ev.setAction(MotionEvent.ACTION_CANCEL);
mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;
}
return super.dispatchTouchEvent(ev);
// 调用ViewGroup父类的dispatchTouchEvent()，即View.dispatchTouchEvent()
// 因此会执行ViewGroup的onTouch() ->> onTouchEvent() ->> performClick（） ->> onClick()，即自己处理该事件，事件不会往下传递（具体请参考View事件的分发机制中的View.dispatchTouchEvent（））
// 此处需与上面区别：子View的dispatchTouchEvent（）
}
...
}
/**
* 分析1：ViewGroup.onInterceptTouchEvent()
* 作用：是否拦截事件
* 说明：
* a. 返回true = 拦截，即事件停止往下传递（需手动设置，即复写onInterceptTouchEvent（），从而让其返回true）
* b. 返回false = 不拦截（默认）
*/
public boolean onInterceptTouchEvent(MotionEvent ev) {
return false;
}
总是先传递到 ViewGroup、再传递到子 View
示意图
2. View 事件的分发机制
源码：
public boolean dispatchTouchEvent(MotionEvent event) {
if (mOnTouchListener != null && (mViewFlags & ENABLED_MASK) == ENABLED &&
mOnTouchListener.onTouch(this, event)) {
return true;
}
return onTouchEvent(event);
}
// 说明：只有以下3个条件都为真，dispatchTouchEvent()才返回true；否则执行onTouchEvent()
// 1. mOnTouchListener != null
// 2. (mViewFlags & ENABLED_MASK) == ENABLED
// 3. mOnTouchListener.onTouch(this, event)
// 下面对这3个条件逐个分析
/**
* 条件1：mOnTouchListener != null
* 说明：mOnTouchListener变量在View.setOnTouchListener（）方法里赋值
*/
public void setOnTouchListener(OnTouchListener l) {
mOnTouchListener = l;
// 即只要我们给控件注册了Touch事件，mOnTouchListener就一定被赋值（不为空）
}
/**
* 条件2：(mViewFlags & ENABLED_MASK) == ENABLED
* 说明：
* a. 该条件是判断当前点击的控件是否enable
* b. 由于很多View默认enable，故该条件恒定为true
*/
/**
* 条件3：mOnTouchListener.onTouch(this, event)
* 说明：即 回调控件注册Touch事件时的onTouch（）；需手动复写设置，具体如下（以按钮Button为例）
*/
button.setOnTouchListener(new OnTouchListener() {
@Override
public boolean onTouch(View v, MotionEvent event) {
return false;
}
});
// 若在onTouch（）返回true，就会让上述三个条件全部成立，从而使得View.dispatchTouchEvent（）直接返回true，事件分发结束
// 若在onTouch（）返回false，就会使得上述三个条件不全部成立，从而使得View.dispatchTouchEvent（）中跳出If，执行onTouchEvent(event)
onTouchEvent(event)的源码：
public boolean onTouchEvent(MotionEvent event) {
final int viewFlags = mViewFlags;
if ((viewFlags & ENABLED_MASK) == DISABLED) {
return (((viewFlags & CLICKABLE) == CLICKABLE ||
(viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE));
}
if (mTouchDelegate != null) {
if (mTouchDelegate.onTouchEvent(event)) {
return true;
}
}
// 若该控件可点击，则进入switch判断中
if (((viewFlags & CLICKABLE) == CLICKABLE ||
(viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)) {
switch (event.getAction()) {
// a. 若当前的事件 = 抬起View（主要分析）
case MotionEvent.ACTION_UP:
boolean prepressed = (mPrivateFlags & PREPRESSED) != 0;
...// 经过种种判断，此处省略
// 执行performClick() ->>分析1
performClick();
break;
// b. 若当前的事件 = 按下View
case MotionEvent.ACTION_DOWN:
if (mPendingCheckForTap == null) {
mPendingCheckForTap = new CheckForTap();
}
mPrivateFlags |= PREPRESSED;
mHasPerformedLongPress = false;
postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
break;
// c. 若当前的事件 = 结束事件（非人为原因）
case MotionEvent.ACTION_CANCEL:
mPrivateFlags &= ~PRESSED;
refreshDrawableState();
removeTapCallback();
break;
// d. 若当前的事件 = 滑动View
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)) {
// Outside button
removeTapCallback();
if ((mPrivateFlags & PRESSED) != 0) {
// Remove any future long press/tap checks
removeLongPressCallback();
// Need to switch from pressed to not pressed
mPrivateFlags &= ~PRESSED;
refreshDrawableState();
}
}
break;
}
// 若该控件可点击，就一定返回true
return true;
}
// 若该控件不可点击，就一定返回false
return false;
}
/**
* 分析1：performClick（）
*/
public boolean performClick() {
if (mOnClickListener != null) {
playSoundEffect(SoundEffectConstants.CLICK);
mOnClickListener.onClick(this);
return true;
// 只要我们通过setOnClickListener（）为控件View注册1个点击事件
// 那么就会给mOnClickListener变量赋值（即不为空）
// 则会往下回调onClick（） & performClick（）返回true
}
return false;
}
onTouch 的执行 先于 onClick
示意图
（三）代码举例分析
（1）工作日常演示
老板派发工作，给经理提出需求，经理给组长分发任务，组长再给程序员安排任务
Activity：老板
ManagerViewGroup：经理
LoaderViewGroup：组长
ProgrammerView：程序员
- 经理代码：
public class ManagerViewGroup extends LinearLayout {
private final String TAG = "Eren";
private Paint mPaint;
public ManagerViewGroup(Context context, AttributeSet attrs) {
super(context, attrs);
init();
}
private void init() {
mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
mPaint.setColor(Color.WHITE);
mPaint.setTextSize(70f);
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
canvas.drawText("经理", 30f, getHeight() - 80f, mPaint);
}
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
Log.e(TAG, "dispatchTouchEvent ---> 经理接到老板发的任务通知");
return super.dispatchTouchEvent(ev);
}
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
Log.e(TAG, "onInterceptTouchEvent ---> 经理拦截任务，查看任务通知");
return super.onInterceptTouchEvent(ev);
}
@Override
public boolean onTouchEvent(MotionEvent event) {
Log.e(TAG, "onTouchEvent --->经理把自己的任务做了");
return super.onTouchEvent(event);
}
}
- 组长代码：
public class LoaderViewGroup extends LinearLayout {
private final String TAG = "Eren";
private Paint mPaint;
public LoaderViewGroup(Context context, AttributeSet attrs) {
super(context, attrs);
init();
}
private void init() {
mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
mPaint.setColor(Color.WHITE);
mPaint.setTextSize(70f);
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
canvas.drawText("组长", 30f, getHeight() - 80f, mPaint);
}
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
Log.e(TAG, "dispatchTouchEvent ---> 组长接到经理发的任务通知");
return true;
}
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
Log.e(TAG, "onInterceptTouchEvent ---> 组长拦截任务，查看任务通知");
return super.onInterceptTouchEvent(ev);
}
@Override
public boolean onTouchEvent(MotionEvent event) {
Log.e(TAG, "onTouchEvent --->组长把自己的任务做了");
return super.onTouchEvent(event);
}
}
- 程序员代码：
public class ProgrammerView extends View {
private final String TAG = "Eren";
private Paint mPaint;
public ProgrammerView(Context context, AttributeSet attrs) {
super(context, attrs);
init();
}
private void init() {
mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
mPaint.setColor(Color.WHITE);
mPaint.setTextSize(70f);
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
canvas.drawText("程序员", 30f, getHeight() - 50f, mPaint);
}
@Override
public boolean dispatchTouchEvent(MotionEvent event) {
Log.e(TAG, "dispatchTouchEvent ---> 程序员接到组长发的任务通知");
return super.dispatchTouchEvent(event);
}
@Override
public boolean onTouchEvent(MotionEvent event) {
Log.e(TAG, "onTouchEvent ---> 程序员把自己的任务做完");
return super.onTouchEvent(event);
}
}
- 布局文件
运行效果
点击程序员，查看Log信息：
Log信息
这个任务所有人都没有进行拦截，最终任务又回到了BOSS那里（愤怒！）
由此可见
- 事件由上而下传递
传递顺序：
Activity -> Window -> ViewGroup -> View
- 由下而上消费
消费顺序：
Activity <- Window <- ViewGroup <- View
（2）更改需求
如果这个问题组长就能解决，并且程序员请假没有来，将组长代码中的 onInterceptTouchEvent 返回值改成 true，对事件进行拦截：
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
Log.e(TAG, "onInterceptTouchEvent ---> 组长拦截任务，查看任务通知");
return true;
}
再次点击程序员，查看Log信息：
Log信息
组长对任务进行了拦截，所以不会继续传递，任务完全由组长完成
（3）再次更改需求
程序员没有请假，并且要完成这个任务，将程序员代码中的 onTouchEvent 返回值改成 true，对事件进行消耗
@Override
public boolean onTouchEvent(MotionEvent event) {
Log.e(TAG, "onTouchEvent ---> 程序员把自己的任务做完");
return true;
}
再再次点击程序员，查看Log信息：
Log信息
程序员把工作做了，不会再交给上级处理
（4）突发情况
程序员的女朋友约程序员吃饭看电影，程序员接到上级通知，但是依然放弃手头工作陪女朋友（通常情况下是不可能的，因为，程序员根本没有女朋友 ￣へ￣）
public class MainActivity extends AppCompatActivity {
private final String TAG = "Eren";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//女朋友 onTouch 进行事件消费为 true
findViewById(R.id.programmer).setOnTouchListener(new View.OnTouchListener() {
@Override
public boolean onTouch(View view, MotionEvent motionEvent) {
Log.e(TAG, "onTouch ---> 女朋友有约");
return true;
}
});
}
}
点击程序员，查看Log信息：
Log信息
onTouch 方式是 View 的 OnTouchListener 接口中定义的方法，其优先级大于 onTouchEvent（女朋友最重要），手动复写在onTouch 中返回 true（事件消费掉），将不会再执行 onTouchEvent
总结
文章借鉴于：Android事件分发机制详解：史上最全面、最易懂
下一章，View 的工作原理