概念
- 用户的Touch事件被包装成MotionEvent. 分为:
- ACTION_DOWN: 表示用户开始触摸.
- ACTION_MOVE: 表示用户在移动(手指或者其他).
- ACTION_UP: 表示用户抬起了手指.
- ACTION_CANCEL: 表示手势被取消了.
- ACTION_OUTSIDE: 表示用户触碰超出了正常的UI边界.
- ACTION_POINTER_DOWN: 有一个非主要的手指按下了. 二指触摸时, 第二个手指按下了.
- ACTION_POINTER_UP: 一个非主要的手指抬起来了. 二指触摸时, 有一个指头抬起来了.(最后抬起的是ACTION_UP).
- 第一根按下的手指触发ACTION_DOWN事件，之后按下的手指触发ACTION_POINTER_DOWN事件，中间起来的手指触发ACTION_POINTER_UP事件，最后起来的手指触发ACTION_UP事件（即使它不是触发ACTION_DOWN事件的那根手指）。
- pointer id可以用于跟踪手指，从按下的那个时刻起pointer id生效，直至起来的那一刻失效，这之间维持不变。
- TouchTarget: 消费视图链, 将onTouchEvent�() 返回true的 view 绑在一起. 类似 Message 链
方法
- dispatchTouchEvent(): 用来传递触摸事件
- 返回 true: 消费此事件, 后续事件也分发到这
- 返回 false: 不消费此事件, 将事件回传到父控件的
onTouchEvent, 后续事件也分发到这
- onTouch(): onTouchListener 里被调用的方法, 重写 �touch 事件时使用, 重写后返回 true 会不再传递 = 消费
- onTouchEvent():
dispatchTouchEvent()里的方法, 处理各种DOWN, UP, MOVE 等 Action. 如果重写了onTouch()且返回true, 则不执行.- 返回 true: 自己处理事件, 代码会把这层的
dispatchTouchEvent也置为true, 后续事件也分发到这一层 - 返回 false: 将事件传递给父层的
onTouchEvent, 这一层不会再接收此事件列的后续事件
- 返回 true: 自己处理事件, 代码会把这层的
- onInteceptTouchEvent(): 只存在于 ViewGroup. 是否拦截掉事件
- 返回 true: 拦截事件, 执行自己的
onTouchEvent方法, 此事件序列的后续action直接交给这一层处理, 不会再调用该方法 - 返回 false: 不拦截事件, 传递到更深层的ViewGroup, 如果是 View 就传递给 ViewGroup 父类, 也就是 view, 去
dispatchTouchEvent
- 返回 true: 拦截事件, 执行自己的
事件传�递简述from
当手指触摸到屏幕, 系统就会调用相应的 View 的 onTouchEvent(), 并传入一系列 action.
当有多个层级的 View, 在父层级允许的情况下, 这个 action 会传递到最底层的 View, 所以 touch 事件默认最先调用的是最底层的 View 的 onTouchEvent. 如果 View 的 onTouchEvent 接收到某个 touch action 并做了处理, 最后有两种返回方式,
- return true 会告诉系统, 当前的 View 需要处理这次的 touch 事件, 以后系统发出的 ACTION_MOVE, ACTION_UP 还是需要继续监听并接收的. 而且这次的action已经被消费掉了, 父层是不可能触发
onTouchEvent().
所以, 每一个action 最多只能由一个 onTouchEvent 返回 true.
- 如果return false, 便会通知系统, 当前 view 不关心这一次的 touch 事件, 此时这个 action 会传向父级, 调用父级的
onTouchEvent(). 但是这一次 touch 事件发出的任何 action, 该 view 都不会再接收,onTouchEvent在这一次的 touch 事件中再也不会触发了, 也就是说一旦 view 返回false, 那么之后的 ACTION_MOVE, ACTION_UP 等 action 都不会再传入这个 View. 但是下一次 touch 事件的 action 还是会传进来.
前面说了, 底层的 view 能够接收这次事件有一个前提条件: 在父层级允许的情况下. 假设不改变父层级的 dispatch 方法, 系统在调用底层的 onTouchEvent 之前会先调用父View 的 onInteceptTouchEvent方法判断, 父层View是不是要截获本次touch事件之后的 action.
- 如果
onInteceptTouchEvent返回了 true, 那么本次touch事件之后的所有 action 不会再向深层 View 传递, 统统传给父层View 的onTouchEvent. 就是说父层已经截获了这次 touch 事件的后续所有 action. 这些 action 也不再询问onInteceptTouchEvent, 在这次的 touch 事件之后发出的 action,onInteceptTouchEvent不会再调用, 直到下一次touch事件的到来. - 如果
onInteceptTouchEvent返回了 false, 那么本次 action 将会传送给更深层的view, 并且之后的每一次 action 都会询问父层的onInteceptTouchEvent需不需要截获本次 touch 事件. 只有 ViewGroup 才有onInteceptTouchEvent, 因为一个普通的 view 肯定是位于最深层的view, touch事件能传到这里已经是最后一站了. 肯定会调用View 的 onTouchEvent.
对于底层的 view, 有一种方法可以阻止父层截获 touch 事件, 就是调用getParent.requestDisallowInterceptTouchEvent(true)方法.
事件传递详述
一. 当按下屏幕, 点击事件最先传到的是 Activity 的 dispatchTouchEvent()
```
public boolean dispatchTouchEvent(MotionEvent ev) {
if (ev.getAction() == MotionEvent.ACTION_DOWN) {
onUserInteraction();
}
if (getWindow().superDispatchTouchEvent(ev)) {
return true;
}
return onTouchEvent(ev);
}
```
可以看到 activity 调了 getWindow().superDispatchTouchEvent(ev). 也就是 PhoneWindow 的
```
@Override
public boolean superDispatchTouchEvent(MotionEvent event) {
return mDecor.superDispatchTouchEvent(event);
}
```
PhoneWindow 又调了 DecorView 的
```
public boolean superDispatchTouchEvent(MotionEvent event) {
return super.dispatchTouchEvent(event);
}
```
我们知道 DecorView 继承自 FrameLayout, FrameLayout 又继承 ViewGroup. 所以其实 activity 的 dispatchTouchEvent 就已经进入了 ViewGroup 的 dispatchTouchEvent.
点击事件从 activity 传递到了 ViewGroup.
二. 在 ViewGroup 的 dispatchTouchEvent 中: from
分成五步:
- 初始化. 传入的是 ACTION_DOWN, 则认为开始传入新的 touch 事件链, 清空原来记录的状态
- 检查是否拦截(标识 intercepted):
- 在 ACTION_DOWN 或 mFirstTouchTarget链存在的情况下, 如果这里的子view请求了拦截直接置 false. 如果子 view 也没有请求不拦截, 就根据
onInterceptTouchEvent返回值判断
- 在 ACTION_DOWN 或 mFirstTouchTarget链存在的情况下, 如果这里的子view请求了拦截直接置 false. 如果子 view 也没有请求不拦截, 就根据
- 对于非 ACTION_DOWN 或 没有 mFirstTouchTarget链�返回 true
- 检查是不是 ACTION_CANCEL(标识 canceled)
- touch事件分发.(intercepted 为 false, canceled 也为 false), 然后在 ACTION_DOWN 的前提下:
- �1. newTouchTarget 为空, 当前视图的子view里位于触摸范围内, 判断它们是不是在 mFirstTouchTarget链里, 在就取出这个 TouchTarget链 放进 newTouchTarget链 进入下一步, 不在就递归当前视图的子 view 的子 view 的 dispatchTouchEvent方法, 如果有就新建 newTouchTarget链 加进 mFirstTouchTarget链, 并置标识位 alreadyDispatchedToNewTouchTarget.
- newTouchTarget链 为空, mFirstTouchTarget链不为空(有消费, 但不是这个视图), �把 touch 点放到mFirstTouchTarget链里
- �设置 dispatchTouchEvent 的返回值 handled:
- mFirstTouchTarget链为空, 此时还为空就说明不存在消费, 就把自己当作与一个普通的view, 开始 onTouchEvent, handled 为 onTouchEvent 的返回值
- mFirstTouchTarget链不为空, 并且等于 newTouchTarget 而 alreadyDispatchedToNewTouchTarget 也为 true, ,说明正好是当前视图消费掉了, handled 返回true. 否则传递子视图 dispatchTouchEvent.
- 如果发生了canceled或UP, 更新�链
public boolean dispatchTouchEvent(MotionEvent ev) {
if (mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onTouchEvent(ev, 1);
}
// If the event targets the accessibility focused view and this is it, start
// normal event dispatch. Maybe a descendant is what will handle the click.
if (ev.isTargetAccessibilityFocus() && isAccessibilityFocusedViewOrHost()) {
ev.setTargetAccessibilityFocus(false);
}
boolean handled = false;
if (onFilterTouchEventForSecurity(ev)) {
final int action = ev.getAction();
final int actionMasked = action & MotionEvent.ACTION_MASK;
/**
* 第一步, 初始化
* 因为 ACTION_DOWN 是一系列事件的开端, 当是 ACTION_DOWN 时进行一些初始化操作
* 清除以往的touch状态, 开始新的手势
* 将 mFirstTouchTarget链 设置为 null
* 随后在 resetTouchState 中重置 Touch 的标识
*源码注释:
* 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
* 走到这段代码时的if把情况分成两种:
* 1. 当按下 ACTION_DOWN
* 2. 当 ACTION_DOWN 被消费后, 后续的 ACTION_MOVE, ACTION_UP, ACTION_CANCEL.(mFirstTouchTarget != null)
*源码注释
* Check for interception.
**/
final boolean intercepted;
if (actionMasked == MotionEvent.ACTION_DOWN
|| mFirstTouchTarget != null) {
//FLAG_DISALLOW_INTERCEPT 是否禁用了事件拦截默认false,
//子控件可以通过 requestDisallowInterceptTouchEvent 设置父控件不拦截事件
final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
if (!disallowIntercept) {
// 子控件 disallowIntercept, 就直接将事件传递给了 onInterceptTouchEvent, 看下面的分析1
intercepted = onInterceptTouchEvent(ev);
ev.setAction(action); // restore action in case it was changed
} else {
//子控件请求父不拦截
intercepted = false;
}
} else {
// 如果是 ACTION_MOVE, ACTION_CANCEL等, intercepted 置为true, 继续拦截事件
// 也就是概念里提到的,
// 如果 dispatchTouchEvent 消费了 ACTION_DOWN, 后续事件也会被 ViewGroup 拦截
//源码注释:
// 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);
}
/**
* 第三步 检查canceled
**/
// Check for cancelation.
final boolean canceled = resetCancelNextUpFlag(this)
|| actionMasked == MotionEvent.ACTION_CANCEL;
// 更新消费视图链, 如果有第二个手指触摸
// Update list of touch targets for pointer down, if needed.
final boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0;
TouchTarget newTouchTarget = null;
boolean alreadyDispatchedToNewTouchTarget = false;
/**
* 第四步 事件分发 (不是取消不是拦截时进行)
**/
if (!canceled && !intercepted) {
// If the event is targeting accessiiblity 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;
// 处理 ACTION_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;
//4.1
if (newTouchTarget == null && childrenCount != 0) {
//依靠Touch坐标寻找子View来接收touch事件
final float x = ev.getX(actionIndex);
final float y = ev.getY(actionIndex);
final ArrayList<View> preorderedList = buildTouchDispatchChildList();
final boolean customOrder = preorderedList == null
&& isChildrenDrawingOrderEnabled();
final View[] children = mChildren;
// for循环 遍历 ViewGroup 底下全部子 view, 判断哪个 View 接收 touch 事件
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);
// 如果 view 能在触摸范围内, 也在可接收触摸的视图链里面
if (newTouchTarget != null) {
// 找到了接收事件的子View, 跳出循环
// 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);
/**
* �将 touch 事件分给子 view 去做 (分发的核心)
* 说明1: if 中的 dispatchTransformedTouchEvent 内部 会递归调用 当前 view 的子 view 的 dispatchTouchEvent.
* 如果子 view 是 ViewGroup, 就继续 dispatchTouchEvent.
* 如果子 view 是 View, 则调用 onTouchEvent,
*
* 返回true, 说明当前 ViewGroup 消费了事件, 接下来处理 3 步:
* 1. 给 newTouchTarget 赋值
* 2. 置标识 alreadyDispatchedToNewTouchTarget为 true
* 3. break 跳出循环
*
* 说明2: addTouchTarget(). ViewGroup 有一个静态内部类 TouchTarget, 用于存储拦截�触摸的 view. newTouchTarget 和 mFirstTouchTarget 都是 TouchTarget.
* 注意: 这一步操作是在if(...ACTION_DOWN)的大判断里的, 如果是 ACTION_MOVE, ACTION_CANCEL, 则直接去判断 mFirstTouchTarget.
* 所以如果一个 view 不处理 ACTION_DOWN, 那么系统是不会将ACTION_MOVE, ACTION_CANCEL传过来的
* 总结:
* 对于 ACTION_DOWN 的处理体现在, 如果 dispatchTransformedTouchEvent(), 该方法返回boolean:
* true -> 事件被消费 -> mFirstTouchTarget != null;
* false -> 事件未被消费 -> mFirstTouchTarget == null;
**/
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);
}// for循环结束
if (preorderedList != null) preorderedList.clear();
}
//如果遍历后�没有子view接收事件, 并且 mFirstTouchTarget 不为空, 就把事件扔给最初的TouchTarget
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指向了最初的TouchTarget
newTouchTarget.pointerIdBits |= idBitsToAssign;
}
}
}
/**
* 第五步 对处理完的touch链进行判断
* 现在的 mFirstTouchTarget 有两种状态
**/
// Dispatch to touch targets.
if (mFirstTouchTarget == null) {
//1. mFirstTouchTarget 为 null, 就是说 touch 没被消费
//即 没有找到消费 touch 事件的子组件 或 touch事件被拦截
//那么就像普通不消费事件的 view 一样, 叫此 view 的上层 ViewGroup 的 onTouchEvent 处理事件.
//通过 dispatchTransformedTouchEvent, 并将第三个参数置为null 实现.
// No touch targets so treat this as an ordinary view.
handled = dispatchTransformedTouchEvent(ev, canceled, null,
TouchTarget.ALL_POINTER_IDS);
} else {
// 如果找到了消费事件的 view, 且后续事件可以传递给此 view
// 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;
//循环处理 被消费的 touch 链的各个 ACTION.
while (target != null) {
final TouchTarget next = target.next;
// 只有 ACTION_DOWN时才能设置的 alreadyDispatchedToNewTouchTarget == true.
//所以这里是对 ACTION_DOWN 做判断, 且当前消费视图链吻合, 就是已被处理, 则忽略
if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
handled = true;
} else {
//对于非 ACTION_DOWN 事件, 继续传递给目标子组件进行处理
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;
}
}
// 若触摸点发生了 up 或 cancel, 则更新 TouchTarget 链表
//源码注释:
// Update list of touch targets for pointer up or cancel, if needed.
if (canceled
|| actionMasked == MotionEvent.ACTION_UP
|| actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
resetTouchState();
} else if (split && actionMasked == MotionEvent.ACTION_POINTER_UP) {
final int actionIndex = ev.getActionIndex();
final int idBitsToRemove = 1 << ev.getPointerId(actionIndex);
removePointersFromTouchTargets(idBitsToRemove);
}
}
if (!handled && mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onUnhandledEvent(ev, 1);
}
return handled;
}
分析1 ViewGroup.onInterceptTouchEvent
public boolean onInterceptTouchEvent(MotionEvent ev) {
if (ev.isFromSource(InputDevice.SOURCE_MOUSE)
&& ev.getAction() == MotionEvent.ACTION_DOWN
&& ev.isButtonPressed(MotionEvent.BUTTON_PRIMARY)
&& isOnScrollbarThumb(ev.getX(), ev.getY())) {
return true;
}
return false;
}
如果自己不重写, 默认是false;
分析2 ViewGroup.dispatchTransformedTouchEvent
如果第三个参数 child 设为view, 就调用super.dispatchTouchEvent.
如果 child 为 null, 就调用child的dispatchTouchEvent.
private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
View child, int desiredPointerIdBits) {
final boolean handled;
...
// 删掉部分后就是根据是否传进了 child 判断分发给谁
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;
}
...
}
4. 在 view 中的 dispatchTouchEvent
从继承上, Button extends TextView extends View
当按下 Button 时, 会先调用 dispatchTouchEvent, Button 和 TextView 都没有重写, 默认在 View 里重写.
在 dispatchTouchEvent 中:
public boolean dispatchTouchEvent(MotionEvent event) {
if (mOnTouchListener != null && (mViewFlags & ENABLED_MASK) == ENABLED &&
mOnTouchListener.onTouch(this, event)) {
return true;
}
return onTouchEvent(event);
}
只有当:
1. 控件�创建了 mOnTouchListener
2. 控件 ENABLE
3. mOnTouchListener 的 onTouch 方法返回值为true
三步都具备时, 就不再进入 onTouchEvent(event) 方法.
那么, 要么 onTouch 返回true, 或者 onTouchEvent 返回true时, dispathTouchEvent 返回true
5. TODO View 的 onTouchEVent
- 大概的是如果这个view可点击, 一定返回true, 否则一定返回false.
注意点:
- 如果一个控件不是 ENABLE, 那么它在第 2 步就永远过不去, 如果还想监听它的 touch 事件, 就得自己重写它的 onTouchEvent 方法.
- 如果一个控件滑不起来(或只收到ACTION_DOWN, 收不到ACTION_MOVE等), 加 xml 中 clickable = "true", 或者 onTouch 方法返回 true
- 拦截不等于消费. 得有一方的 onTouchEvent 返回 true 才是消费
总结: from
- 如果在某个层级没有处理ACTION_DOWN事件，那么该层就再也收不到后续的Touch事件了直到下一次ACTION_DOWN事件
说明：- a.某个层级没有处理某个事件指的是它以及它的子View都没有处理该事件。
- b.这条规则不适用于Activity层（它是顶层），它们可以收到每一个Touch事件。
- c.如果没有处理ACTION_MOVE这类事件，不会有任何影响。
- 如果ACTION_DOWN事件发生在某个View的范围之内，则后续的ACTION_MOVE，ACTION_UP和ACTION_CANCEL等事件都将被发往该View，即使事件已经出界了
- 如果一个ACTION_DOWN事件被父View拦截了，则任何子View不会再收到任何Touch事件了如果一个非ACTION_DOWN事件被父View拦截了，则那些上次处理了ACTION_DOWN事件的子View会收到一个ACTION_CANCEL事件，之后不会再收到任何Touch事件了，即使父View不再拦截后续的Touch事件
- 如果父View决定处理Touch事件或者子View没有处理Touch事件，则父View按照普通View的处理方式处理Touch事件，否则它根本不处理Touch事件
- 如果父View在onInterceptTouchEvent中拦截了事件，则onInterceptTouchEvent中不会再收到Touch事件了，事件被直接交给它自己处理（按照普通View的处理方式）
- ACTION_DOWN 去探路, 找到消费事件的view, ACTION_MOVE 直接传给消费者了.
Q&A: from
- Q: onTouch 和 onTouchEvent 区别
- 都是在 View.dispatchTouchEvent, 但 onTouch 先于 onTouchEvent 执行.
- 如果 onTouch 返回true, onTouchEvent 得不到执行
- 如果一个控件是非enable, 走不到ontouch的判断, 就只能依靠 onTouchEvent 来监听
参考
