一、 Android View的层次结构
Activity —— PhoneWindow——DecorView——contentView（我们的布局文件）
二、事件分发流程
事件的层级调用
触摸事件从Activity开始传递，经过PhoneWindow，DecorView，DecorView实际上就是ViewGroup,然后通过ViewGroup的dispatchTouchEvent层层分发下去。
ViewGroup：先要走分发流程，再走处理流程
View： 只能走处理流程
ViewGroup的dispatchTouchEvent处理事件的分发流程
View的dispatchTouchEvent处理事件，通过调用onTouch、onTouchEvent等。
public class DecorView extends FrameLayout implements RootViewSurfaceTaker, WindowCallbacks {
public boolean superDispatchTouchEvent(MotionEvent event) {
return super.dispatchTouchEvent(event);
}
}
事件的大致分发过程
触摸事件从Activity开始，自上而下遍历。ViewGroup遍历其子View，寻找能够消费该事件的子View。
若子View是ViewGroup，则调用ViewGroup的dispatchTouchEvent继续往下分发；
若子View是View，则调用View的dispatchTouchEvent处理事件。
如果该View消费了事件，则事件结束；如果该View未消费事件，则往上传递，由它的父View处理该事件，如果父View不消费该事件...
最后如果都不消费，回到Activity自己处理。
应该注意的是，在遍历子View的过程中，同一层中，一般是先取出最上面的View（xml布局中，同一层放在最下面的控件），如果取出的View消费了事件，那么则不会询问后面的View了，也就是说后面的View不会调用dispatchTouchEvent方法处理事件。
事件分发流程详细分析——跟着源码走
（ps：以下分析不涉及到多指触控）
1、Down事件是怎么分发的
看一下ViewGroup的 dispatchTouchEvent方法
// 方法的返回值， true表示消费，false表示未消费
boolean handled = false;
往下看重要的代码（不重要的先省略～），看到这里第一个有用的if判断，这里判断如果是down事件，我们按下的动作，会清除重置一些状态，先记住这个地方mFirstTouchTarget、mGroupFlags这两个参数会重置。
// 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();
}Down事件继续往下走~
intercepted意思是 是否拦截该事件，若为true，则事件不会分发给子View，在事件是down事件时，进来会先重置状态，所以一般情况下会进来if(!disallowIntercept)这个判断， onInterceptTouchEvent()不重写的话，一般是不会拦截的，它的返回值为false。
mFirstTouchTarget（触摸目标）是一个链表结构，当有view消费了down事件时，它会记录赋值（ps：至于为什么是链表结构，这个跟多指触控有关～），这里为null。
每次进来这个方法，记住这两个参数的初始赋值噢（下面代码最后两行） TouchTarget newTouchTarget = null; boolean alreadyDispatchedToNewTouchTarget = false;
// Check for interception 表示是否拦截
final boolean intercepted;
if (actionMasked == MotionEvent.ACTION_DOWN
|| mFirstTouchTarget != null) {
// 一般默认情况下， mGroupFlags & FLAG_DISALLOW_INTERCEPT != 0 disallowIntercept 为true
// 子View可以通过 getParent().requestDisallowInterceptTouchEvent,
// 通过修改mGroupFlags来修改父亲disallowIntercept的值
final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
if (!disallowIntercept) { // 一般会进来
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;
}
// ...
// Check for cancelation.
// canceled这个参数一般为false
final boolean canceled = resetCancelNextUpFlag(this)
|| actionMasked == MotionEvent.ACTION_CANCEL;
// Update list of touch targets for pointer down, if needed.
// ...
// 两个需要注意的参数
TouchTarget newTouchTarget = null;
boolean alreadyDispatchedToNewTouchTarget = false;记住以上的一些参数，下面分发的重点来了～
此时假设没有拦截事件，会进入if (!canceled && !intercepted){ ...}代码块，再接着判断了一下down事件，开始对其所有子view进行排序，然后逐个遍历，找到满足条件的子View（可点击，在触摸范围内），执行dispatchTransformedTouchEvent方法（ps：这个方法后面拎出来看细细分析），此时注意其中传到第二个参数cancel和第三个参数child，决定了里面会执行child.dispatchTouchEvent方法（ps：child有可能是ViewGroup也可能是View，若是ViewGroup，则又是走一次这个分发流程，若是View，就是处理该事件），若dispatchTransformedTouchEvent返回true，则代表其子孙View消费处理了事件，通过addTouchTarget方法为mFirstTouchTarget赋值（ps：这里mFirstTouchTarge != null 成立啦），结束遍历，其他子view就不管了；若每次dispatchTransformedTouchEvent返回false，表示没有子view消费事件，那遍历结束之后，mFirstTouchTarget还是null。
注意，在addTouchTarget方法执行为mFirstTouchTarget赋值之后，下一行alreadyDispatchedToNewTouchTarget也赋值为true，唯一变为true的地方
// canceled为false，intercepted为false的时候，进入这个if
if (!canceled && !intercepted) {
// If the event is targeting accessibility focus we give it to the
// view that has accessibility focus and if it does not handle it
// we clear the flag and dispatch the event to all children as usual.
// We are looking up the accessibility focused host to avoid keeping
// state since these events are very rare.
View childWithAccessibilityFocus = ev.isTargetAccessibilityFocus()
? findChildWithAccessibilityFocus() : null;
// down事件， 进入这个if
if (actionMasked == MotionEvent.ACTION_DOWN
|| (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
|| actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
// ...
final int childrenCount = mChildrenCount;
// 前面一开始newTouchTarget == null， childrenCount 子View数 进入这个if
// 这里面做什么？ 子View排序，遍历， 寻找能够处理该事件的子View
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;
// 遍历子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 (!child.canReceivePointerEvents()
|| !isTransformedTouchPointInView(x, y, child, null)) {
ev.setTargetAccessibilityFocus(false);
continue;
}
// 前面的两个if通过了，子View来到这里， getTouchTarget返回null
// 为何？里面是遍历mFirstTouchTarget，而mFirstTouchTarget为null
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 ，重点参数 cancel false，child
// 这两个参数，决定了里面会执行子view的dispatchTouchEvent方法
// 若返回true，代表有子view处理了事件，为mFirstTouchTarget赋值，结束遍历
// 返回false ，继续遍历
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();
// mFirstTouchTarget的赋值处
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;
}
}
}来到下一段代码的分析
// Dispatch to touch targets.
if (mFirstTouchTarget == null) {
// No touch targets so treat this as an ordinary view.
// 这里其实是自己处理点击事件了，里面调用super.dispatchTouchEvent(event);
// ViewGroup继承自View
handled = dispatchTransformedTouchEvent(ev, canceled, null,
TouchTarget.ALL_POINTER_IDS);
} else { // mFirstTouchTarget！= null
// 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;
// down事件进来， mFirstTouchTarget！=null时，到这里alreadyDispatchedToNewTouchTarget为true
// target == newTouchTarget亦成立， handled = true 事件消费
if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
handled = true;
} else {
// cancelChild 重要到一个参数，前面的条件可以忽略， intercepted拦截值可以决定cancelChild的值
final boolean cancelChild = resetCancelNextUpFlag(target.child)
|| intercepted;
// 又是执行dispatchTransformedTouchEvent， 这里是MOVE、UP事件是否会变成CANCEL事件的关键
// 主要看第二个参数是否为ture了
// DOWN事件走不到这个分支来
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;
}
}
// Update list of touch targets for pointer up or cancel, if needed.
// ...
return handled;到了这里，正常down事件怎么走的流程，就已经结束了，对整个事件分发代码也了解了。再次简单总结一下
若拦截了down事件
intercepted == true，则 【1】——【2】——【7】——【10】
若没有拦截down事件
intercepted == false， 分两种情况
down事件被子VIew消费，则 【1】——【2】——【3】——【6】——【8】——【9】——【10】
down事件没被子View消费，则【1】——【2】——【3】——【5】——【7】——【10】
可以看到，拦截down事件，或者不拦截但子View不消费down事件，最后都是走【7】步骤，自己来处理这个事件
public boolean dispatchTouchEvent(MotionEvent ev) {
boolean handled = false;
//【1】down事件清空状态 mFirstTouchTarget == null
if (actionMasked == MotionEvent.ACTION_DOWN) {
// 清空状态
}
final boolean intercepted; // 拦截标识
//【2】处理intercepted的值
//...
final boolean canceled = ... // 一般为false
// 两个需要注意的参数
TouchTarget newTouchTarget = null;
boolean alreadyDispatchedToNewTouchTarget = false;
// 【3】没有拦截， 进这里
if (!canceled && !intercepted) {
// 遍历子View
for (...){
// 【4】子view处理消费了事件，if处理完就跳出来了
if (dispatchTransformedTouchEvent(...)){
//...
// 处理结果
// mFirstTouchTarget != null
// newTouchTarget = null
// alreadyDispatchedToNewTouchTarget = true
break;
}
// 【5】子子孙孙没有消费就继续遍历到死喽 ，mFirstTouchTarget还是null
// ...
}
}
// 【6】若前面有子View消费事件了，newTouchTarget赋值
if (newTouchTarget == null && mFirstTouchTarget != null) {
newTouchTarget = mFirstTouchTarget；
// ...
}
// 【7】FirstTouchTarget == null还成立 ，自己处理这个事件，
// down事件走这个分支，有两种情况
// 第一种是前面拦截了intercepted为true， 直接走这里，根据这个参数，表示自己处理这个事件
// 第二张是前面遍历完所有子子孙孙，没人消费这个事件，所以mFirstTouchTarget == null
if (mFirstTouchTarget == null) {
handled = dispatchTransformedTouchEvent(ev, canceled, null,
TouchTarget.ALL_POINTER_IDS);
} else { // 【8】down事件已经被消费了
TouchTarget target = mFirstTouchTarget;
while (target != null) { // 单点触控只执行一次哦
// down事件来说 ， 这里两个条件都成立
// 【9】handled = true
if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
handled = true; //
} else {
// ..
}
}
}
...
//【10】返回
return handled;
}
2、看看dispatchTransformedTouchEvent这个方法——分发或处理事件的地方
dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
View child, int desiredPointerIdBits)这个方法大致逻辑就是， 当 cancel为true时，将事件（MOVE、UP）变成CANCEL事件往下传，然后再通过event.setAction(oldAction)还原，当cancel为false时，就是将当前事件往下传；
若传进来的child是null，就调用super.dispatchTouchEvent，这个方法是在ViewGroup里面，ViewGroup继承自View，其实就是View的dispatchTouchEvent—— onTouch——onTouchEvent这个处理流程了，自己去处理这个事件；若传进来的child不是null，那么就继续分发或处理。（ps：down事件进行分发时是不会变为cancel事件的，可以将dispatchTouchEvent方法从上往下代入down事件走一遍看看）
final int oldAction = event.getAction(); // 保存事件
if (cancel || oldAction == MotionEvent.ACTION_CANCEL) {
event.setAction(MotionEvent.ACTION_CANCEL);
if (child == null) {
handled = super.dispatchTouchEvent(event);
} else {
handled = child.dispatchTouchEvent(event);
}
event.setAction(oldAction); // 还原事件
return handled;
}
//...后面还有后面的就不贴了，就还是通过 handled = super.dispatchTouchEvent(event)或者handled = child.dispatchTouchEvent(event)去处理或传递事件
3、Move事件
move事件会传递给处理down事件的View， 如果down事件没有处理，那么move事件也处理不了， 这个结论对吗？...先分析再说
假设down事件被子View消费了 ，这时候发生了Move事件。此时，mFirstTouchTarget != null ，会走这个分支
if (actionMasked == MotionEvent.ACTION_DOWN
|| mFirstTouchTarget != null) {
final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
if (!disallowIntercept) {
intercepted = onInterceptTouchEvent(ev);
ev.setAction(action); // restore action in case it was changed
} else {
intercepted = false;
}
} 这时候看我们是否拦截Move事件，先看看正常不拦截intercepted = false的情况，Move事件，里面的判断不成立，没有遍历寻找子View这个流程了
/// ...
TouchTarget newTouchTarget = null;
boolean alreadyDispatchedToNewTouchTarget = false;
if (!canceled && !intercepted) { // 进来了
// ...
if (actionMasked == MotionEvent.ACTION_DOWN
|| (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
|| actionMasked == MotionEvent.ACTION_HOVER_MOVE)
{
//... 没进来 因为是Move事件
}
}往下看， 不拦截Move事件，走【2】—— 【3】——【4】，熟悉的dispatchTransformedTouchEvent， 结束。
if (mFirstTouchTarget == null) { // 【1】
// No touch targets so treat this as an ordinary view.
handled = dispatchTransformedTouchEvent(ev, canceled, null,
TouchTarget.ALL_POINTER_IDS);
} else { // 【2】
// 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;
// alreadyDispatchedToNewTouchTarget flase
if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
handled = true;
} else { // 【3】
// 不拦截的情况 cancelChild 为false
final boolean cancelChild = resetCancelNextUpFlag(target.child)
|| intercepted;
if (dispatchTransformedTouchEvent(ev, cancelChild,
target.child, target.pointerIdBits)) { // 【4】
handled = true;
}
if (cancelChild) { // 【5】
if (predecessor == null) {
mFirstTouchTarget = next;
} else {
predecessor.next = next;
}
target.recycle();
target = next;
continue;
}
}
predecessor = target;
target = next;
}
}那如果我一来就拦截，ntercepted = true的情况呢？第一个Move事件进来（ps：Move是触发多次的，需要结合多次来看）
if (!canceled && !intercepted)都不成立， 所以直接来到 if (mFirstTouchTarget == null) { }else{ }这一处，接下来是重点了，一句一句看
final boolean cancelChild = resetCancelNextUpFlag(target.child)
|| intercepted;此时，cancelChild为true，执行
if (dispatchTransformedTouchEvent(ev, cancelChild,
target.child, target.pointerIdBits)) {
handled = true;
}前面分析过这个方法，cancelChild为ture时，会将事件转变为cancel事件，如果有子View，那么子View收不到这个move事件，而是收到了一个Cancel事件，再接下来，cancelChild为true，会执行这一句mFirstTouchTarget = next;（前面【2】处代码predecessor == null），next为null，也就是mFirstTouchTarget == null
if (cancelChild) { // 【4】
if (predecessor == null) {
mFirstTouchTarget = next;
} else {
predecessor.next = next;
}
target.recycle();
target = next;
continue;
}dispatchTouchEvent代码流程走完了。。。 但是，Move事件可不是只会触发一次，它是连续触发的，Move事件第二次进来会发生什么？ 这个时候mFirstTouchTarget == null，不一样了。
if (mFirstTouchTarget == null) { // 【1】
// No touch targets so treat this as an ordinary view.
handled = dispatchTransformedTouchEvent(ev, canceled, null,
TouchTarget.ALL_POINTER_IDS);
} 执行这一句， 自己处理了Move事件。。后续的Move事件都被它抢走了。
所以，就算是down事件被某一个view消费了，它后续也不一定能收到move序列事件，是有可能被它的父亲抢了去的
这个点，解决滑动冲突时会利用到
三、 滑动冲突 ？ 下一篇见
可以先瞧瞧上一篇？
Android 关于View事件分发（onTouch、onTouchEvent、onClick、onLongClick的关系及原理）（一）_半摆的博客-CSDN博客
225
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
