本文是自己参照网上文章或视频，尝试梳理下ViewGroup的事件分发流程，来让自己对整个流程能进一步理解（至今还是不太理解，感觉好难）。
ViewGroup.dispatchTouchEvent()源码主要分为三步。
public boolean dispatchTouchEvent(MotionEvent ev) {
...
/**第一部分：判断是否要拦截事件
*1、当事件e为ACTION_DOWN时，会清空touchTargets即mFirstTouchTarget = null，
*并重置位mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT ;
*2、当事件e为ACTION_DOWN时，一定能执行onInterceptTouchEvent（）；
*3、当事件e不为ACTION_DOWN时，
* 如果ACTION_DOWN被当前viewgroup消费了，则mFirstTouchTarget != null条件不满足，则intercepted = true；
* 如果ACTION_DOWN被子view消费了，则通过disallowIntercept条件来判断当前viewgroup是否要对事件e进行拦截
*/
// 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();
}
// Check for interception.
final boolean intercepted;
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;
}
} else {
// There are no touch targets and this action is not an initial down
// so this view group continues to intercept touches.
intercepted = true;
}
//第二部分：ACTION_DOWN事件没有被拦截和取消， 将事件向子view分发
//注意ACTION_MOVE事件不会走这里的逻辑
if (!canceled && !intercepted) {
//事件为ACTION_DOWN时才进行事件分发（另外两种情况不太清楚）
if (actionMasked == MotionEvent.ACTION_DOWN
|| (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
|| actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
...
if (newTouchTarget == null && childrenCount != 0) {
...
final View[] children = mChildren;
for (int i = childrenCount - 1; i >= 0; i--) {
final int childIndex = getAndVerifyPreorderedIndex(
childrenCount, i, customOrder);
final View child = getAndVerifyPreorderedView(
preorderedList, children, childIndex);
if (!child.canReceivePointerEvents()
|| !isTransformedTouchPointInView(x, y, child, null)) {
continue;
}
newTouchTarget = getTouchTarget(child);
//newTouchTarget 不为null，代表事件被子view消费了
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的dispatchTouchEvent()
//即子view往子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赋值， 并alreadyDispatchedToNewTouchTarget设为true
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;
}
}
}
}
//第三部分：
//viewgroup拦截了事件e则自己处理事件，没有拦截则
/ 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) {
handled = true;
} else {
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;
}
}
...
return handled;
}背景知识
源码中有一些变量需要提前了解：
1、mFirstTouchTarget 表示触摸目标链表数据结构中第一个数据。
viewgroup的触摸事件（down或pointer_down事件）分发过程中，当多个事件被多个子view消费了（多指操作），viewgroup用一个链表结构来存储这些目标子view。mFirstTouchTarget指向该链表头，表示链表的第一个数据。每次有新的目标子view时，会往链表头部插入子view，然后让mFirstTouchTarget指向链表头。
// First touch target in the linked list of touch targets.
private TouchTarget mFirstTouchTarget;mFirstTouchTarget是一个TouchTarget对象，通过注释的说明："触摸目标的链接列表中的第一个触摸目标"，可以得出：mFirstTouchTarget是"触摸目标"链表的头部。
引申出一个问题：什么叫做"触摸目标"：
"触摸目标"可以理解为触控点按下时，处理该触控点对应事件的目标控件。
简单来说，在ViewGroup.dispatchTouchEvent()遇到非拦截事件，且事件类型为ACTION_DOWN或ACTION_POINTER_DOWN，则会触发一个遍历子控件以查找"触摸目标"的流程。（非拦截事件：如果事件被拦截则不会走第二部分，即事件不会被分发）
//事件分发的第二部分逻辑
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;
}
private TouchTarget addTouchTarget(@NonNull View child, int pointerIdBits) {
final TouchTarget target = TouchTarget.obtain(child, pointerIdBits);
target.next = mFirstTouchTarget;
mFirstTouchTarget = target;
return target;
}当触摸事件类型为DOWN时，会清空链表数据，并设置mFirstTouchTarget=null来初始化状态。
//事件分发第一部分代码
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();
}
/**
* Clears all touch targets.
*/
private void clearTouchTargets() {
TouchTarget target = mFirstTouchTarget;
if (target != null) {
do {
TouchTarget next = target.next;
target.recycle();
target = next;
} while (target != null);
mFirstTouchTarget = null;
}
}
2、TouchTarget 触摸目标对象
private static final class TouchTarget {
// The touched child view.
public View child;
// The combined bit mask of pointer ids for all pointers captured by the target.
public int pointerIdBits;
// The next target in the target list.
public TouchTarget next;
}-
View
child：
被点击的子控件，即消耗事件的目标控件。 -
int
pointerIdBits：
"目标捕获的所有指针的指针ID的组合位掩码"，光看注释难以理解，其实这里涉及到安卓所偏爱的位运算。
为了区分多点触控时不同的触控点，每一个触控点都会携带一个pointerId。
而pointerIdBits即是所有被目标控件消耗的触控点的pointerId的组合。即pointerIdBits包含一个或以上的pointerId数据。
这个pointerIdBits的运算相关实现，将会在下面提到idBitsToAssign的时候说明。
- 简单来说，就是如果记录
pointerId为0，2，5时，pointerIdBits即为0010 0101，即：
0对应0000 0001， 2对应0000 0100， 5对应0010 0000，然后通过或运算合并为0010 0101。
- TouchTarget
next：
记录下一个TouchTarget对象，由此组成链表。
- 注意到
TouchTarget包含obtain和recycle两个方法，用于缓存复用，这个同样在Message中实现，需要缓存复用的时候可以参考借鉴该方式，这也是安卓中常见的操作。
分析可得， TouchTarget的作用，是记录一个View及其对应分发的触控点列表pointerIdBits，且可以通过next与其他实例形成链表。
进一步分析，TouchTarget是对消耗事件（ACTION_DOWN或ACTION_POINTER_DOWN）的View以链表方式保存，且记录各个View对应的触控点列表，以实现后续的事件派分处理。
同时可以推理出：
- 非多点触控：
mFirstTouchTarget链表退化成单个TouchTarget对象。- 多点触控，目标相同：同样为单个
TouchTarget对象，只是pointerIdBits保存了多个pointerId信息。- 多点触控，目标不同：
mFirstTouchTarget成为链表。
具体参考文章
深入理解事件分发 ViewGroup.mFirstTouchTarget的设计
触碰事件监听中按下动作：ACTION_DOWN 和ACTION_POINTER_DOWN区别
第一步：判断是否要拦截事件
1、down事件初始化处理
// 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();
}
// Check for interception.
final boolean intercepted;
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;
}
} else {
// There are no touch targets and this action is not an initial down
// so this view group continues to intercept touches.
intercepted = true;
}当事件类型为DOWN时，做了三件事情：
1、cancelAndClearTouchTargets()方法内部会循环调用dispatchTransformedTouchEvent(event, true, target.child, target.pointerIdBits)方法来向viewgroup中使用mFirstTouchTarget指向的链表数据（触摸目标链表）分发ACTION_CANCEL事件，从而让触摸目标取消当前已有事件执行，并对同一序列的后续事件不再处理。
2、调用clearTouchTargets()来清空并回收mFirstTouchTarget指向的链表数据（触摸目标链表）。mFirstTouchTarget设置为null。
3、mGroupFlags标志位设置为~FLAG_DISALLOW_INTERCEPT。表示子view允许viewgroup拦截事件。
2、判断是否拦截触摸事件
情况1：触摸事件为action_down， 则actionMasked == MotionEvent.ACTION_DOWN条件满足，进入if体。down事件会提前做初始化操作， 所以disallowIntercept=false，所以会调用onInterceptTouchEvent(ev)来让viewgroup决定是否要拦截down事件。返回true，代表拦截。
情况2：触摸事件(用ev代替)非action_down，则判断mFirstTouchTarget != null。这里要分两种情况：
如果ev之前的事件被viewgroup拦截了，则mFirstTouchTarget==null， 则走到的是else体，即intercepted = true代表viewgroup拦截ev事件。
如果ev之前的事件没有被viewgroup拦截，则mFirstTouchTarget！=null（代表子view消费了ev之前的事件），进入if体。接着要判断disallowIntercept，这个值代表子view是否允许viewgroup拦截事件ev。disallowIntercept=true代表不允许viewgroup拦截。这里又分两种情况：
如果disallowIntercept=false，则执行onInterceptTouchEvent(ev)来让viewgroup决定是否要拦截down事件。返回true，代表拦截，intercepted = true；返回false，代表不拦截，intercepted = false。
如果disallowIntercept=true，则子view直接不允许viewgroup拦截down事件。intercepted = false。
所以总结一下：
1、down事件每次都会让viewgroup执行onInterceptTouchEvent()决定是否要拦截down事件；
2、onInterceptTouchEvent()中关于down事件处理返回true，则down事件被viewgroup拦截了， 则后续同一序列所有事件不再执行onInterceptTouchEvent()。默认被拦截了intercepted = true；这会导致触摸子view没有响应；
3、onInterceptTouchEvent()中关于down事件处理返回false，则down事件没有被viewgroup拦截，则后续同一序列所有事件将参照disallowIntercept的值来决定是否调用onInterceptTouchEvent(ev)，disallowIntercept=true则不拦截事件，事件仍由子view处理；disallowIntercept=false则看onInterceptTouchEvent关于ev事件是如何实现的。
第二步：分发ACTION_DOWN或ACTION_POINTER_DOWN事件
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) {
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;
for (int i = childrenCount - 1; i >= 0; i--) {
final int childIndex = getAndVerifyPreorderedIndex(
childrenCount, i, customOrder);
final View child = getAndVerifyPreorderedView(
preorderedList, children, childIndex);
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);
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;
}
// 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;
}
}
}第二部分是事件分发的逻辑。这部分逻辑只针对事件ACTION_DOWN和ACTION_POINTER_DOWN。ACTION_POINTER_DOWN指的是多指操作场景。其他事件不走这里的逻辑。
首先做分发事件的初始化操作。newTouchTarget表示的是消费该事件的触摸目标，alreadyDispatchedToNewTouchTarget代表事件是否已经分发给新的触摸目标了。
TouchTarget newTouchTarget = null;
boolean alreadyDispatchedToNewTouchTarget = false;其次判断事件没有被取消或没有被viewgroup拦截，
if (!canceled && !intercepted) 当事件为ACTION_DOWN或ACTION_POINTER_DOWN时，开始分发事件
if (actionMasked == MotionEvent.ACTION_DOWN
|| (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
|| actionMasked == MotionEvent.ACTION_HOVER_MOVE)接着会遍历viewgroup中所有的子view， 直到找到消费事件的触摸目标。
final View[] children = mChildren;
for (int i = childrenCount - 1; i >= 0; i--) {
...
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;
}
...
if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
...
newTouchTarget = addTouchTarget(child, idBitsToAssign);
alreadyDispatchedToNewTouchTarget = true;
break;
}
...
}首先会判断子view是否能接受点击事件，和点击位置是否在子view的有效范围内，如果为false，则直接跳出循环查找下一个子view;
在上面条件满足的情况下，调用getTouchTarget(child)来判断该子view是否已经在mFirstTouchTarget， 在的话说明该子view之前消费过同一序列的事件（多指操作的场景下存在这种现象），则直接返回该子view。并且把该子view作为事件消费的触摸目标。然后直接跳出循环。
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;
}
private TouchTarget getTouchTarget(@NonNull View child) {
for (TouchTarget target = mFirstTouchTarget; target != null; target = target.next) {
if (target.child == child) {
return target;
}
}
return null;
}newTouchTarget=null的话，说明该子view之前没有消费过事件， 则判断该子view是否消费当前事件，调用的是dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)， 返回true，则把该子view通过头插法添加到mFirstTouchTarget指向的链表中。并设置相关属性后跳出循环。
newTouchTarget = addTouchTarget(child, idBitsToAssign);
alreadyDispatchedToNewTouchTarget = true;
break;最后，判断下分发事件循环逻辑中是否找到一个子view消费事件。
如果没有找到的话，newTouchTarget == null。这里要分两种情况：
如果是单指操作，则newTouchTarget == null && mFirstTouchTarget == null， 则事件分发操作就执行完了；
如果是多指操作， 则第一指点击后找到了目标子view，mFirstTouchTarget != null；第二指点击后没有找到目标子view，则第二指点击时满足newTouchTarget == null && mFirstTouchTarget != null。则会使newTouchTarget指向mFirstTouchTarget链表最后的元素，也是最早消费同一序列事件的子view（一般即为消耗ACTION_DOWN的控件），并把当次ACTION_POINTER_DOWN事件的PointID记录到该元素。这相当于点击了mFirstTouchTarget链表中最后一个不为null的触摸目标。
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.
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;
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;
}
}1、viewgroup拦截了整个事件序列
如果mFirstTouchTarget=null，则说明要么down事件被拦截了，要么down事件没有被拦截，但是在viewgroup分发事件时没有合适的子view消费事件。
mFirstTouchTarget == null代表没有子view消费事件，或viewgroup自己拦截了事件。则viewgroup自己处理事件ev。调用的是dispatchTransformedTouchEvent()，传入的child参数为null。可以看到该函数内部针对child=null情况，调用的是super.dispatchTouchEvent(event)。
可以看出， viewgroup调用了其父类View的dispatchTouchEvent()。之前分析过View的dispatchTouchEvent方法，知道其本质是处理事件的。
所以， 这里事件由viewgroup自己尝试处理。并返回自己是否能消费事件，如果可以消费则返回true，否则返回false表示自己处理不了交给上一级处理。
handled = dispatchTransformedTouchEvent(ev, canceled, null,
TouchTarget.ALL_POINTER_IDS);
private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
View child, int desiredPointerIdBits) {
final boolean handled;
...
// Perform any necessary transformations and dispatch.
if (child == null) {
handled = super.dispatchTouchEvent(transformedEvent);
}
...
return handled;
}2、viewgroup分发给子view处理了,处理down和POINTER_DOWN事件
如果mFirstTouchTarget != null，则代表事件分发给子view处理了。
然后使用了一个while循环来挨个遍历mFirstTouchTarget链表的数据（多指操作mFirstTouchTarget指向的链表有多个值需要循环多次，单指操作的话mFirstTouchTarget只有一个对象所以会只循环一次）。
条件alreadyDispatchedToNewTouchTarget && target == newTouchTarget，只有第二步的ACTION_DOWN或ACTION_POINTER_DOWN事件才能满足这两个条件。每次进入onDispatchTouchEvent()方法，在第二步事件分发之前都会把这两个变量复位。
TouchTarget newTouchTarget = null;
boolean alreadyDispatchedToNewTouchTarget = false;由于第二步分发down事件给子view时，已经调用过了dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)方法，其内部会调用handled = child.dispatchTouchEvent(event)来处理事件。所以事件其实在第二步就已经交给子view去处理了。第三步这里就直接返回true即可！！
注意：其实只有事件为ACTION_DOWN或ACTION_POINTER_DOWN时才会走这里的逻辑， 因为只有这两种情况才会设置alreadyDispatchedToNewTouchTarget=true和newTouchTarget值。
if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
handled = true;
}3、viewgroup分发给子view处理了,处理其他事件
接下来就是处理其他事件的逻辑了，比如move、up事件。
首先会根据intercept标志位来标识是否要取消子view上的事件。
final boolean cancelChild = resetCancelNextUpFlag(target.child)
|| intercepted;然后调用dispatchTransformedTouchEvent()方法，传入子view和cancelChild标志位。这里要注意了，重点来了：
情况1：当cancelChild为false时，则条件“cancel || oldAction == MotionEvent.ACTION_CANCEL”不满足，接着往下走，调用child.dispatchTouchEvent(transformedEvent)来处理move或up等事件；
情况2：当cancelChild为true时，条件“cancel || oldAction == MotionEvent.ACTION_CANCEL”满足，先使用oldAction保存当前的事件ev，然后设置ev事件为ACTION_CANCEL新值，然后viewgroup或子view来处理ACTION_CANCEL事件。当处理这个事件时，代表目前已有的事件都会被丢弃，并且将不再接受到任何点击。你应该像up事件一样对待这个事件，但不执行任何操作。
然后利用之前保存的oldAction把ev事件设置回之前的值，然后返回处理ACTION_CANCLE的结果，退出函数。
接着逻辑返回到onDispatchTouchEvent的第三步，继续分析cancelChild为true的情况。然后会从mFirstTouchTarget指向的链表中回收这个target。所以同一序列的后续事件在该target上不会再响应了。所以这个子view不再能收到同一序列的后续事件了！！！
4、ACTION_UP事件处理
剩余的部分，是对ACTION_UP类型事件进行清理：
-
ACTION_UP：说明这是最后一个触控点抬起，通过resetTouchState()完全清理派分目标和状态。 -
ACTION_POINTER_UP：移除触控点对应的TouchTarget内的pointerIdBits记录，当移除后pointerIdBits = 0（即没有其他触控点记录），则把该TouchTarget从mFirstTouchTarget中移除。
总结一下第三步：
如果viewgroup拦截了down事件，则事件都由viewgroup自己处理；处理不了交给其上一级viewgroup处理；
如果viewgroup没有拦截down事件，但是没有子view能处理down事件，则事件都viewgroup自己处理；处理不了交给其上一级viewgroup处理；
如果viewgroup没有拦截down事件，并且存在子view能消费down事件，
当事件为down或point_down时，直接返回true;
当事件非down或point_down时，根据第一步是否拦截了该事件做了不同处理。
如果不拦截，则子view来处理该事件，如果处理不了则交给viewgroup的上一级处理；
如果拦截， 则子view执行ACTION_CANCEL事件操作。该子view不再接受同一序列后续的所有事件。
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;
}private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
View child, int desiredPointerIdBits) {
final boolean handled;
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;
}
// 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;
}事件分发常见疑问
1、down事件被子view消费了，后续事件如move被viewgroup拦截了。这个是不是一个事件序列被两个view处理了？？
答：是的。down事件被子view消费了，同一序列的move等事件被viewgroup拦截了并处理，则会在子view上执行action_cancle事件。然后把子view从mFirstTouchTarget链表中删除（子view上已有的事件都被丢弃，并且子view不再接受同一序列后续的事件），所以之后的MOVE事件不会再分发到子view上了。如果是单指操作的话，mFirstTouchTarget此时为null，所以第三步直接被viewgroup处理后续的move事件和up事件。
6313
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
