Android事件分发机制一直都是Android开发者需要熟悉的内容，自己也断断续续的学过几次，但是一直都是学了忘，忘了再学。所以想自己整理一篇博客，也是为了以后需要的时候能最快的get到。话不多说，先上一张事件分发机制的图。这个也是我之前见过很多次也觉得很好记忆的一张图。
通过上面的图能看出，事件分发机制主要有三个对象（Activity、ViewGroup、View）以及三个方法（dispatchTouchEvent、onInterceptTouchEvent、onTouchEvent）。
- dispatchTouchEvent：这个方法的主要作用就是进行事件的分发，在上面三个类中都具有该方法，事件分发的流程也是从这个方法开始的。
- onInterceptTouchEvent：这个方法只在ViewGroup中有，通过方法名可知，该方法是控制是否拦截事件的，如果返回值是true，那么ViewGroup就拦截了事件不再往子View进行传递，并在自己的onTouchEvent中消费掉所有的事件（down、move、up），返回值是false的话就不拦截，向ViewGroup中的子View传递事件。该方法中默认只有return false这一句，也就是默认ViewGroup不拦截事件。View中没有这个方法也是因为View中是不含有子View的所以就不会需要拦截这个操作。
- onTouchEvent：该方法表示对事件进行处理，是在dispatchTouchEvent方法内部调用的，方法返回true就表示消费掉事件，返回false就表示不消费事件。那么事件就会向上传递，如上图右侧部分所示流程。
上面提到的三个方法负责了整个事件分发流程的传递和控制。可以使用伪代码表示上面三个方法的关系：
public boolean dispatchTouchEvent(MotionEvent event) {
boolean handled = false;
if(onInterceptTouchEvent(event)) {
handled = onTouchEvent(event);
} else {
handled = child.dispatchTouchEvent(event);
}
return handled;
}通过上面这一段代码，我们能看出来，ViewGroup进行事件分发的时候，首先通过onInterceptTouchEvent方法检查自己是否需要拦截事件，如果返回true就是拦截事件，那么就直接调用onTouchEvent方法消费掉事件，返回false就传递事件给子View进行处理。
上面的算是简单介绍一下事件分发机制的基础知识，下面详细说一下时间分发的代码流程和逻辑。首先我们知道这里的事件是指用户使用手指点击手机屏幕开始的一连串过程。我们知道Activity是Android显示UI的主要对象，我们所说的事件分发也都是讲的从Activity开始到某个View响应事件的过程。下面我就从代码入手去学习一下事件分发机制（本文的代码是android8.0.1）。
Activity
首先是Activity的dispatchTouchEvent方法，如下图所示，打开PhoneWindow类的方法，发现是调用了DecorView的dispatchTouchEvent方法，而DecorView又是ViewGroup的子类（注：DecorView是我们通过setContentView方法设置的布局的父布局），其还是调用了ViewGroup的dispatchTouchEvent方法。
public boolean dispatchTouchEvent(MotionEvent ev) {
if (ev.getAction() == MotionEvent.ACTION_DOWN) {
onUserInteraction();
}
if (getWindow().superDispatchTouchEvent(ev)) { //getWindow返回的是PhoneWindow类的实例
return true;
}
return onTouchEvent(ev);
}查看ViewGroup的dispatchTouchEvent方法，发现方法体很长，只能一点点来分析我们所关注的部分。进入该方法中，首先看到这里，这里的作用是判断时间是否是ACTION_DOWN事件，如果是的话就进行一些变量初始化工作，如把mFirstTouchTarget设置为null（mFirstTouchTarget变量是事件传递过程中很重要，通过后文可以知道消费ViewGroup的事件的子View就是mFirstTouchTarget对象）。
// Handle an initial down.
if (actionMasked == MotionEvent.ACTION_DOWN) {
// Throw away all previous state when starting a new touch gesture.
// The framework may have dropped the up or cancel event for the previous gesture
// due to an app switch, ANR, or some other state change.
cancelAndClearTouchTargets(ev);
resetTouchState();
}再往下就是判断是否需要拦截事件了，intercepted变量就表示是否要拦截事件。
// Check for interception.
final boolean intercepted;
if (actionMasked == MotionEvent.ACTION_DOWN
|| mFirstTouchTarget != null) { 1 //mFirstTouchTarget是在VG中的消耗点击事件的View
final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
if (!disallowIntercept) {
//FLAG_DISALLOW_INTERCEPT标志位的作用是禁止ViewGroup拦截除了DOWN之外的事件，一般通过子View的requestDisallowInterceptTouchEvent来设置
intercepted = onInterceptTouchEvent(ev); //该方法默认是返回false，可以继承ViewGroup类来重写该方法来改变返回值
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;
}
// If intercepted, start normal event dispatch. Also if there is already
// a view that is handling the gesture, do normal event dispatch.
if (intercepted || mFirstTouchTarget != null) {
ev.setTargetAccessibilityFocus(false);
}
// Check for cancelation.
final boolean canceled = resetCancelNextUpFlag(this)
|| actionMasked == MotionEvent.ACTION_CANCEL;上面代码片段比较长，稍微解释一下：
代码中1处有两个判断，可以解释如下：1、如果当前事件是DOWN事件或者ViewGroup中子View消费了事件，那么我们都要执行onInterceptTouchEvent方法来判断是否需要拦截，否则就直接拦截（intercepted = true）。例如：DOWN不是由子View消费的，那么mFirstTouchTarget就是null，那么之后的MOVE和UP事件就不用在分发给子View了，直接由这个ViewGroup处理。所以ViewGroup拦截了事件的话，后续的事件都会由Viewgroup来处理，不会再调用onInterceptTouchEvent方法。
TouchTarget newTouchTarget = null; //初始化
boolean alreadyDispatchedToNewTouchTarget = false; //初始化
//当事件不拦截的时候，就执行到子View中
if (!canceled && !intercepted) {
View childWithAccessibilityFocus = ev.isTargetAccessibilityFocus()
? findChildWithAccessibilityFocus() : null;
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);
//开始子View的分发
final int childrenCount = mChildrenCount;
//如果子View个数不为0就进行从上到下遍历子View进行事件传递
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.
final ArrayList<View> preorderedList = buildTouchDispatchChildList();
final boolean customOrder = preorderedList == null
&& isChildrenDrawingOrderEnabled();
final View[] children = mChildren;
//从最上层的子View开始往内层遍历
for (int i = childrenCount - 1; i >= 0; i--) {
final int childIndex = getAndVerifyPreorderedIndex(
childrenCount, i, customOrder);
final View child = getAndVerifyPreorderedView(
preorderedList, children, childIndex);
// If there is a view that has accessibility focus we want it
// to get the event first and if not handled we will perform a
// normal dispatch. We may do a double iteration but this is
// safer given the timeframe.
if (childWithAccessibilityFocus != null) {
if (childWithAccessibilityFocus != child) {
continue;
}
childWithAccessibilityFocus = null;
i = childrenCount - 1;
}
//判断点击事件是否在子View的坐标范围内，并且子View没有在坐标系中移动（执行动画）
if (!canViewReceivePointerEvents(child)
|| !isTransformedTouchPointInView(x, y, child, null)) {
ev.setTargetAccessibilityFocus(false);
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);
//dispatchTransformedTouchEvent该方法是来对子View进行事件分发的，返回true表示被子View消耗
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();
//走到这里表示已经找到了消费事件的View，并进行赋值。
newTouchTarget = addTouchTarget(child, idBitsToAssign);
alreadyDispatchedToNewTouchTarget = true;
break;
}
// The accessibility focus didn't handle the event, so clear
// the flag and do a normal dispatch to all children.
ev.setTargetAccessibilityFocus(false);
}
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;
}
}接下来继续看代码，上图代码中第一个if语句判断的就是ViewGroup不拦截事件，并且不是取消事件，那么就向子View传递。而第二个if判断当前事件是否是DOWN。上面代码中在关键代码处添加了注释。下面针对上面比较重要的几个方法，单拉出来说明一下。
private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
View child, int desiredPointerIdBits) {
final boolean handled;
......
if (child == null || child.hasIdentityMatrix()) {
if (child == null) {
//子View为空就使用父View的dispatchTouchEvent
handled = super.dispatchTouchEvent(event);
} else {
final float offsetX = mScrollX - child.mLeft;
final float offsetY = mScrollY - child.mTop;
event.offsetLocation(offsetX, offsetY);
//否则就交个子View处理
handled = child.dispatchTouchEvent(event);
event.offsetLocation(-offsetX, -offsetY);
}
return handled;
}
......
}dispatchTransformedTouchEvent方法，上面只抽取了关键代码，该方法判断传递进来的View是否为null，如果为空就表示没有子View被找到来接收时间分发，此时就调用父类（View类）的dispatchTouchEvent方法，这时就把ViewGroup当做普通View来处理，也就是自己消费事件。当传递进来的的child不为null时，就会调用子View的dispatchTouchEvent方法把事件分发给子View，这里也就完成了ViewGroup到子View的事件传递，事件处理完毕之后会返回一个布尔值，该值表示子View是否消耗了事件。如果返回值为true就表示子View消费了事件，否则就没有消费事件，事件继续传递。
private TouchTarget addTouchTarget(@NonNull View child, int pointerIdBits) {
final TouchTarget target = TouchTarget.obtain(child, pointerIdBits);
target.next = mFirstTouchTarget;
mFirstTouchTarget = target;
return target;
}上面还有一个方法addTouchTarget，执行到该方法说明ViewGroup找到了消费事件的子View，这时就把变量mFirstTouchTarget和newTouchTarget指向该子View，同时break遍历循环。
上面的流程主要是ViewGroup在寻找分发事件的View，可能是自己，也可能是子View，或者是它的父View。也分发了DOWN事件给某个View，除了DOWN之外的UP、MOVE等事件接着也有分发出去啊。接着往下看代码。
// 如果遍历完了子View，点击事件还没有被消耗，那么就将点击事件给父View(即自己)去处理
// 可能有两种情况：一、ViewGroup下面没有子View。二、子View没有消耗点击事件。这两种情况下，ViewGroup会自己处理点击事件
// Dispatch to touch targets.
if (mFirstTouchTarget == null) {
// No touch targets so treat this as an ordinary view.
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) {
//如果子View消耗了ACTION_DOWN事件，那么alreadyDispatchedToNewTouchTarget和newTouchTarget已经有值了
handled = true;
} else { //这里把ACTION_MOVE、ACTION_UP等别的事件发放给子View处理
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;
}
}上面代码中第一个if判断mFirstTouchTarget如果为null，那么就说明没有找到分发事件的子View，所以就ViewGroup就自己消费事件，所以dispatchTransformedTouchEvent方法中child传递的null，这个方法上面已经讲过了。如果mFirstTouchTarget不为空，那么就说明找到了消费事件的View，这时只需要再分发UP和MOVE等事件给该View就可以了。
综上所述：如果事件传递到了ViewGroup中，ViewGroup拦截了事件或者其子View都不消费事件，那么事件就交给ViewGroup自己处理，可能自己消费或者分发会给它的父View。如果有子View消费了DOWN事件，那么也把后续的事件分发给该子View。
上面主要都是ViewGroup的事件分发的代码和逻辑，下面对View的代码进行梳理一下。在ViewGroup的事件分发代码中，我们看到有两个地方会分发事件到View来。
- ViewGroup分发事件给子View的时候，调用dispatchTransformedTouchEvent方法，会调用子View的dispatchTouchEvent方法；
- ViewGroup没有找到消费事件的子View（有两种情况：1、ViewGroup中没有子View；2、ViewGroup中的子View都不消费事件），那么就会调用ViewGroup父类的dispatchTouchEvent方法，而ViewGroup的父类就是View，此时ViewGroup就相当于一个普通的View。
public boolean dispatchTouchEvent(MotionEvent event) {
......
boolean result = false;
......
//onFilterTouchEventForSecurity是用来判断点击事件来到时，窗口有没有被遮挡住，如果被遮挡住则直接返回false，不消耗事件。
if (onFilterTouchEventForSecurity(event)) {
if ((mViewFlags & ENABLED_MASK) == ENABLED && handleScrollBarDragging(event)) {
result = true;
}
//noinspection SimplifiableIfStatement
ListenerInfo li = mListenerInfo;
if (li != null && li.mOnTouchListener != null
&& (mViewFlags & ENABLED_MASK) == ENABLED
&& li.mOnTouchListener.onTouch(this, event)) {
result = true;
}
//OnTouchListener的优先级高于onTouchEvent()
//如果所设置的OnTouchListener得onTouch返回true，则直接消耗点击事件，不再执行onTouchEvent()方法
if (!result && onTouchEvent(event)) {
result = true;
}
}
.......
return result;
}首先还是看看dispatchTouchEvent方法，上面是关键代码段。上面判断View是否设置了onTouchListener，如果设置了就调用onTouch方法，onTouch方法返回true的话，就表示消费了事件，这时result就为true，也就不会执行到onTouchEvent方法了。反之，如果View没有设置onTouchListener或者onTouch方法返回false，都会执行到onTouchEvent方法。而通常情况下，onTouch方法都是在绑定监听器的时候复写的。
public boolean onTouchEvent(MotionEvent event) {
......
if (((viewFlags & CLICKABLE) == CLICKABLE ||(viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE) ||
(viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE) {
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
removeLongPressCallback();
// Only perform take click actions if we were in the pressed state
if (!focusTaken) {
// Use a Runnable and post this rather than calling
// performClick directly. This lets other visual state
// of the view update before click actions start.
if (mPerformClick == null) {
mPerformClick = new PerformClick();
}
if (!post(mPerformClick)) {
performClick();
}
}
}
...
break;
...
}
return true;
}
......
}在onTouchEvent方法中，首先是判断当前View是否可以点击或者长按，如果满足一个条件，就进行事件的处理。同时主要到最后的返回值是true，也就表示在这里事件被消费了。在UP事件中，会调用方法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;
}
sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);
notifyEnterOrExitForAutoFillIfNeeded(true);
return result;
}在performClick方法中首先判断是否设置了onClickListener，如果设置了就调用onClick方法。通过上面的整理，我们可以得到如下结论：onTouch优先于onTouchEvent执行，而onTouchEvent又优先于onClick执行。
通过整个分析下来，我们回头看文章开始的图片，会觉得整个流程又清晰了许多。
