安卓事件分发学习之dispatchTouchEvent方法
背景
前几天开始了对Android里事件分发相关源码的阅读，事件分发由三个对象Activity、ViewGroup、View依次向下传递，其间由三个方法dispatchTouchEvent()、onInterceptTouchEvent()(此方法只在ViewGroup里有)和onTouchEvent贯穿之中。
昨天晚上读完了第一个方法dispatchTouchEvent()，今天做此记录
Activity
Activty中的源码如下
public boolean dispatchTouchEvent(MotionEvent ev) {
if (ev.getAction() == MotionEvent.ACTION_DOWN) {
onUserInteraction(); // 空方法
}
if (getWindow().superDispatchTouchEvent(ev)) {
/*
PhoneWindow类中实现：
@Override
public boolean superDispatchTouchEvent(MotionEvent event) {
return mDecor.superDispatchTouchEvent(event);
}
DecorView里的实现：
public boolean superDispatchTouchEvent(MotionEvent event) {
return super.dispatchTouchEvent(event);
}
调用的是父类FrameLayout的方法
*/
return true;
}
return onTouchEvent(ev);
}上来是调用了Window类的superDispatchTouchEvent()，然后是走到了DecorView的superDispatchTouchEvent()，DecorView则调用了父类FrameLayout的dispatchTouchEvent()方法，而FrameLayout没有覆写之，所以走的是ViewGroup的dispatchTouchEvent()。
而且ViewGroup的dispatchTouchEvent()返回false，才会调用Activity自己的onTouchEvent()
ViewGroup
源码如下，比较长，做了精简
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
.. // event连续性判断和无障碍处理
boolean handled = false;
if (onFilterTouchEventForSecurity(ev)) { // 事件安全性过滤，正常都是true
final int action = ev.getAction();
final int actionMasked = action & MotionEvent.ACTION_MASK;
// Handle an initial down.
if (actionMasked == MotionEvent.ACTION_DOWN) {
// ACTION_DOWN的时候清空touchTarget链表，因为按下事件是事件序列的开头
cancelAndClearTouchTargets(ev);
resetTouchState(); // 这个方法里，mFirstTouchTarget被赋值为null
}
// Check for interception.
final boolean intercepted;
if (actionMasked == MotionEvent.ACTION_DOWN
|| mFirstTouchTarget != null) {
// ACTION_DOWN或者此次事件流里之前的事件有子view处理
final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
if (!disallowIntercept) { // 正常是走这儿
intercepted = onInterceptTouchEvent(ev); // 调用ViewGroup.onInterceptTouchEvent()方法
ev.setAction(action); // restore action in case it was changed
} else {
intercepted = false;
}
} else {
// 没有点到这个ViewGroup的子view(说白了就是空白位置)，那这次事件流的剩余事件全部被ViewGroup拦截
intercepted = true;
}
.. //无障碍处理
// Check for cancelation.
final boolean canceled = resetCancelNextUpFlag(this) // 当前ViewGroup的cancel_next_up标志位清零
|| actionMasked == MotionEvent.ACTION_CANCEL;
// 当前view是否被暂时移除，或者收到ACTION_CANCEL事件
// Update list of touch targets for pointer down, if needed.
final boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0;
// 标志位判断，split为true的话表示down事件分割给多个子view，一般为false
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) {
// 只处理了Action_Down，因为这是事件的起点
final int actionIndex = ev.getActionIndex(); // always 0 for down
final int idBitsToAssign = split ? 1 << ev.getPointerId(actionIndex)
: TouchTarget.ALL_POINTER_IDS; // 一般取后者
.. // 清理上一次事件流的id
final int childrenCount = mChildrenCount;
if (newTouchTarget == null && childrenCount != 0) {
// 第一个判断是废话...
final float x = ev.getX(actionIndex); // x坐标
final float y = ev.getY(actionIndex); // y坐标
// Find a child that can receive the event.
// Scan children from front to back.
final ArrayList preorderedList = buildTouchDispatchChildList();
final boolean customOrder = preorderedList == null // preorderedList绝不为null，但顺序也一般和mChildren顺序一致
&& isChildrenDrawingOrderEnabled(); // 后一个判断分支一般为false
final View[] children = mChildren;
for (int i = childrenCount - 1; i >= 0; i--) {
// 从后往前遍历
final int childIndex = getAndVerifyPreorderedIndex(
childrenCount, i, customOrder);
// 可以当成childIndex = i
final View child = getAndVerifyPreorderedView(
preorderedList, children, childIndex);
// 可以当成child = children[childIndex];
.. // 无障碍处理
// 触点合法性判断
if (!canViewReceivePointerEvents(child) // child是visible或者是在执行动画，canViewReceivePointerEvents()返回true
|| !isTransformedTouchPointInView(x, y, child, null)) { // 点击坐标是不是在当前子view内
.. // 无障碍处理
continue;
}
newTouchTarget = getTouchTarget(child);
// 寻找之前确定过的处理这次事件流的子view的target
if (newTouchTarget != null) { // 新的ACTION_DOWN事件的话，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); // 子view的cancel_next_up标志位清理
if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
// 调用子view的dispatchTouchEvent()，若返回为true，则记录newTouchTarget，表示已经有子view处理事件了，退出循环
// Child wants to receive touch within its bounds.
mLastTouchDownTime = ev.getDownTime();
if (preorderedList != null) {
// preoderedList不可能是null
// childIndex points into presorted list, find original index
for (int j = 0; j < childrenCount; j++) {
if (children[childIndex] == mChildren[j]) {
mLastTouchDownIndex = j; // 由于外面的遍历是从后往前，这次记录touchDown索引，就要从前往后遍历寻找
// 为毛不直接mLastTouchDownIndex = childrenCount - i？
break;
}
}
} else {
mLastTouchDownIndex = childIndex;
}
mLastTouchDownX = ev.getX();
mLastTouchDownY = ev.getY();
newTouchTarget = addTouchTarget(child, idBitsToAssign);
// 将当前子view的touchTarget，此时mFirstTouchTarget被赋值，不再为null
alreadyDispatchedToNewTouchTarget = true;
break;
}
.. // 无障碍处理
}
if (preorderedList != null) preorderedList.clear();
}
// 没有子view处理这次事件，但是有子view处理这次事件流，但这个判断似乎永远不可能成立，因为这里只有ACTION_DOWN才能进来，但ACTION_DOWN的时候如果newTouchEventnull，mFirstTouchEvent也一定为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; // 把id位设置给上一个事件流里最后一个事件的target
}
}
}
// 分发给touchTarget
if (mFirstTouchTarget == null) {
// 没有子view处理这次事件流，就调用自己的(父类View)的dispatchTouchEvent()，分发给自己
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) { // 这个循环似乎只会循环一次，因为mFirstTouchTarget是按下事件的target，它的后继似乎是null
final TouchTarget next = target.next;
if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
// 如果已经有子view处理事件并且找到了，方法结果是true
handled = true;
} else { // 如果事件被拦截，会走这里
// 还没有找到相应的子view，就依次调用每个touchTarget的子view或viewGroup父类(View)的dispatchTouchEvent()
// 一旦有一个的dispatchTouchEvent()返回true，整体就返回true
// 顺便如果事件被拦截，就销毁target链表
final boolean cancelChild = resetCancelNextUpFlag(target.child)
|| intercepted;
// 主要由intercepted决定cancelChild是不是true
if (dispatchTransformedTouchEvent(ev, cancelChild,
target.child, target.pointerIdBits)) { // 如果cancelChild为true，也就是事件被拦截，似乎所有事件都被当成了Action_Cancel处理分发，故而此时子view只会收到cancel事件
handled = true;
}
if (cancelChild) { // 非down的事件被拦截
if (predecessor == null) { // predecessor为null
mFirstTouchTarget = next; // 之前的mFirstTouchTarget的后继为null，现在mFirstTouchTarget自己变成了null，所以之后的事件，只能走上面的分发给viewGroup自己了
} else {
predecessor.next = next;
}
target.recycle();
target = next;
continue;
}
}
predecessor = target;
target = next;
}
}
// 更新标志位
..
}
// 检查event的连续性
..
return handled;
} 代码不短，只看跟触摸事件有关而且常见的。首先如果是down事件，就情况touchTarget链表，因为down事件是触摸事件流的起点，在resetTouchState()方法里面，也将mFirstTouchTarget置为null
mFirstTouchTarget表示处理down事件的子view的target，不为null，则表示有子view处理这个事件流，为null，就交给ViewGroup自己处理
说明一下，处理down事件也就是处理这个事件流，不处理down事件就被认为不处理这个事件流，不过即便处理down事件，子view也不见得能接收所有事件，因为ViewGroup可以拦截后续事件
而后进行判断，如果是down事件或者有子view处理这个事件流，就调用ViewGroup.onInterceptTouchEvent()方法判断ViewGroup是否拦截事件
不拦截还则罢了，拦截的话，如果拦截的是down事件，mFirstTouchTarget为null，整个事件流归ViewGroup处理；拦截的不是down事件，比如move事件，此时mFirstTouchTarget不是null，当前事件归子view管，但子view接收到的却变成了cancel事件，这次事件流之后的事件全归了ViewGroup
然后在不是cancel事件也没有拦截的情况下，只处理down事件，根据坐标找到被点击的子view后，先尝试找到之前确定过的，处理这次事件流的子view的target(但在down事件的情况下，这里似乎一般都是null)，然后调用子view的dispatchTouchEvent()方法确定子view是不是要处理down，是的话，找到目标，调用addTouchTarget()方法给mFirstTouchTarget赋值，并把返回值赋给newTouchTarget，此刻，两者才不是null
所以在down的时候，newTouchTarget和mFirstTouchTarget要空都空，要不空都不是空
找到目标后，进行分发。
这里分发的就不一定是down事件了，如果mFirstTouchTarget是null，就只能分发给ViewGroup自己；如果不是null，就分发给mFirstTouchTarget对应的子view
如果ViewGroup拦截了down之后的事件，会导致cancelChild为true，但处理当前事件时，mFirstTouchTarget不是null，所以还是会分发给target.child，只不过这次分发的成了cancel事件。然后由于predecessor是null，导致mFirstTouchTarget被赋值成了后继(null)，所以待到下一个事件来的时候，直接走了上一段说的判断分支，也就是mFirstTouchTarget是null的情况，不会调用自己的onInterceptTouchEvent()(两个条件down事件和mFirstTouchTarget为null都不成立)，然后分发给自己，而不是子view
关于TouchTarget，可以参见我的文章安卓事件分发学习之TouchTarget源码阅读
这整个过程里，调用了一个关键方法dispatchTransformedTouchEvent()
ViewGroup#dispatchTransformedTouchEvent
源码如下
private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
View child, int desiredPointerIdBits) {
final boolean handled;
// 单独处理ACTION_CANCEL事件
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;
}
// Calculate the number of pointers to deliver.
final int oldPointerIdBits = event.getPointerIdBits();
final int newPointerIdBits = oldPointerIdBits & desiredPointerIdBits;
// 一般情况下，old和new是一样的，而且都是ALL_POINTER_IDS
// If for some reason we ended up in an inconsistent state where it looks like we
// might produce a motion event with no pointers in it, then drop the event.
if (newPointerIdBits == 0) {
// 此判断一般不成立
return false;
}
final MotionEvent transformedEvent;
if (newPointerIdBits == oldPointerIdBits) {
// 走这里
if (child == null || child.hasIdentityMatrix()) {
// 一般情况下后一个判断为false
if (child == null) {
// 子view为null，调用父类View的dispatchEvent()方法
handled = super.dispatchTouchEvent(event);
} else {
// 子view不为null，调整事件在view中的相对位置后再调用子view的dispatchTouchEvent()方法
// 但一般这儿走不到，分发给子view是走后面的逻辑
final float offsetX = mScrollX - child.mLeft;
final float offsetY = mScrollY - child.mTop;
event.offsetLocation(offsetX, offsetY);
handled = child.dispatchTouchEvent(event);
event.offsetLocation(-offsetX, -offsetY);
}
return handled;
}
transformedEvent = MotionEvent.obtain(event);
} else {
transformedEvent = event.split(newPointerIdBits);
}
// Perform any necessary transformations and dispatch.
if (child == null) {
handled = super.dispatchTouchEvent(transformedEvent);
} else {
// 在这里分发给子view
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;
}这里代码简单一些，分发给ViewGroup自己就是调用父类View的dispatchTouchEvent()
View#dispatchTouchEvent
代码如下
public boolean dispatchTouchEvent(MotionEvent event) {
// 无障碍处理
..
boolean result = false;
.. // 检查事件完整性
final int actionMasked = event.getActionMasked();
if (actionMasked == MotionEvent.ACTION_DOWN) {
// Defensive cleanup for new gesture
// ACTION_DOWN的话，停止滚动
stopNestedScroll();
}
if (onFilterTouchEventForSecurity(event)) {
if ((mViewFlags & ENABLED_MASK) == ENABLED && handleScrollBarDragging(event)) {
// handleScrollBarDragging()用来处理鼠标拖动滚动条，直接是false，所以可以忽略这个判断分支
result = true;
}
//noinspection SimplifiableIfStatement
ListenerInfo li = mListenerInfo;
if (li != null && li.mOnTouchListener != null
&& (mViewFlags & ENABLED_MASK) == ENABLED
&& li.mOnTouchListener.onTouch(this, event)) {
// 先调用我们给View设置的onTouchListener方法的onTouch()
result = true;
}
// result = false才会调用View.onTouchEvent
// 所以自定义的onTouchListener返回true，view的onTouchEvent就成了摆设
if (!result && onTouchEvent(event)) {
result = true;
}
}
if (!result && mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onUnhandledEvent(event, 0);
}
// Clean up after nested scrolls if this is the end of a gesture;
// also cancel it if we tried an ACTION_DOWN but we didn't want the rest
// of the gesture.
// 在ACTION_UP或ACTION_CANCEL时再次停止滚动(ACTION_MOVE时可能在滚动)
if (actionMasked == MotionEvent.ACTION_UP ||
actionMasked == MotionEvent.ACTION_CANCEL ||
(actionMasked == MotionEvent.ACTION_DOWN && !result)) {
stopNestedScroll();
}
return result;
}代码也不复杂，可以得出结论onTouchListener的onTouch()比onTouchEvent()优先级要高
结语
在安卓事件分发学习之onInterceptTouchEvent方法中，我会记录下一个方法--onInterceptTouchEvent的源码阅读