Andorid 中TouchEvent理解(二） TouchEvent分发机制(onTouchEvent()回调返回值区别)

逻辑较为复杂，分两步来分析，相对好一些。

1）Down事件确定TouchEvent处理的View（mFirstTouchTarget）
2）将MOVE，UP事件传递到第一步中确定的时间处理View（mFirstTouchTarget）下面分别分析这两步怎么做的。

分析背景，当前一个LinerLayout中加入一个自定义的chlidView。

第一步：Down事件确定mFirstTouchTarget

上一篇分析到DecorView调用ViewGroup的dispatchTouchEvent() 。对于触摸事件来说第一件Event必然是Down事件，分析这个流程就是第一步了，看一下源码对这个流程的处理。

1）初始化ViewGroup的传递状态，这里即是一个完整事件传递的起始位置。

// 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();
}

这段代码判断当前为ACTION_DOWN执行的方法，

cancelAndClearTouchTargets(ev)：将mFirstTouchTarget赋值为null，这个就是要找寻的处理事件的View，初始化为null。

resetTouchState()：强制清除mGroupFlags中的FLAG_DISALLOW_INTERCEPT，这个Flag，这个flag影响到拦截函数onInterceptTouchEvent()的调用。

2）是否拦截事件，onTouchEvent在这里调用

final boolean intercepted;
if (actionMasked == MotionEvent.ACTION_DOWN
|| mFirstTouchTarget != null) {
final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;

4000
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;
}

这里即使用了上一步的FLAG_DISALLOW_INTERCEPT这个flag做了判断是否要调用拦截函数，根据这里的判断条件，执行拦截函数返回false不拦截，intercept为false。

3）找到Down事件的落点位置的ChlidView并传递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 = 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;
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;
}

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);
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;
}
}

这段代码校多，在这段代码中有循环遍历ChlidView的代码，简单来讲就是

a.使用isTransformedTouchPointInView()来找到落点的位置在哪一个View的范围内，在如下的代码中传递到ChlidView，

dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)

这个函数的作用简单来讲如果child为null，将使用View的dispatchTouchEvent()，将自己作为View来使用，即递归的边界，调用onTouchEvent()。现在找到了这个ChildView不为null，传递到这个View调用dispatchTouchEvent(),接着目标View使用onTouchEvent():这里可以返回true和false，接下来就是这两个返回值的区别了。
先分析true的情况下：赋值当前的mFirstTouchTarget为找到的chlidView.

newTouchTarget = addTouchTarget(child, idBitsToAssign);
alreadyDispatchedToNewTouchTarget = true;

addTouchTarger()完成了赋值，同时标志位alreadyDispatchedToNewTouchTarget 也置为true。

false情况下

mFirstTouchTarget继续为null，alreadyDispatchedToNewTouchTarget 继续为false

第二步：根据mFirstTouchTarget传递ACTION_MOVE,ACTION_UP

// 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;
}
}

在上一步中，Down事件传递了下去，不管Chlid的TouchEvent的返回值是如何，都完成了整个传递的流程的，但是，如果是MOVE事件的话，第一步的代码是不会走的，跳过之后来到这里（上面这一段代码），Down事件的时候被alreadyDispatchedToNewTouchTarget 这个标记为过滤掉了，因此这段代码中只处理MOVE和UP。

第一步中已经知道onTouchEvent的返回值true时，mFirstTouchTarget为目标View，onTouchEvent的返回值false时，mFirstTouchTarget为null，

代码中有判断mFirstTouchTarget！=null的时候才执行dispatchTransformedTouchEvent，这就是当ChildView的Ontouch返回false时，只能收到一个Down事件的原因。

onTouchEvent()返回为false时，通俗的讲：找到了Down落点的位置View但是这个View不处理，那么就是没找到，自己来处理，自己的OnTouchEvent()再不处理，就又回到了调用这个View的上一级View处理，和此处递归逻辑一致，只是到了上一层。最上是Activity的OntouchEvent()回调，这里返回值没有任何效果，不处理也得处理了。