View 的事件分发机制
这里的View的事件分发是指对于屏幕的Touch事件的分发。
首先，当在屏幕上进行操作的时候，会触发一系列的touch事件（Down，Move，UP，Cancel），系统会将其封成 MotionEvent，然后向下分发给各个View，寻找事件的处理者。
过程：首先，触摸事件产生后，首先是在Activity中将事件传递到顶层ViewGroup（DecorView），然后事件会从顶层的ViewGroup逐渐向下传递（在这个过程中判断是否拦截，若拦截则不再向下传递而是直接开始处理），然后又从底层View再向上传递（在这个过程中开始处理事件，若是处理的话，即返回true，则不再向上传递，而是结束该单个事件）。
整体类似于U型结构传递，如下图。
先看事件的传递过程：
图示解析：
这是完整的View 的事件传递的过程，首先，触发的事件会在Activity中调用dispatchTouchEvent进行分发。也就是说，Activity是事件的顶层分发者，但由于它不是View，所以要继续向下看它分发的对象。
//Activity.java
public boolean dispatchTouchEvent(MotionEvent ev) {
if (ev.getAction() == MotionEvent.ACTION_DOWN) {
onUserInteraction();
}
if (getWindow().superDispatchTouchEvent(ev)) {
return true;
}
return onTouchEvent(ev);
}
从Activity的dispatchTouchEvent源码可以看出，当事件序列为开始事件Down的时候，会调用onUserInteracton()，这个方法是个空实现。这个方法与事件的分发没有什么关系，将会在文章最后再提一下它的作用。然后继续看，Activity实际调用了getWindow().superDispatchTouchEvent()进行事件的分发。
//Activity.java
private Window mWindow;
public Window getWindow() {
return mWindow;
}
返回值是Window，而该Window是一个抽象方法，唯一实现类是PhoneWindow.java
//PhoneWindow.java
private DecorView mDecor;
@Override
public boolean superDispatchTouchEvent(MotionEvent event) {
return mDecor.superDispatchTouchEvent(event);
}
事件还是在继续传递，这里传到了DecorView。
public class DecorView extends FrameLayout implements RootViewSurfaceTaker, WindowCallbacks {
public boolean superDispatchTouchEvent(MotionEvent event) {
return super.dispatchTouchEvent(event);
}
}
从DecorView可以看出，它是FrameLayout的子类，也就是ViewGroup的子类，可以说事件分发到这里才算是分发到View中。那么根据这里也可以看出一个Activity的实际布局了。
这里，DecorView中放置的是一个LinearLayout，然后里面放置的是ActionBar布局和ContentView布局，其中我们的布局文件就是被添加在ContentView中。上图只是简单的包含关系
也就是说，DecorView 是一个Activity的顶层View，你所添加的界面都是放置在DecorView中的。所以当触发一个Touch事件序列的时候，Activity就会进行一系列的传递，将事件传递到顶层View中，然后再交由顶层的View来进行事件的分发。那么顶层的View是DecorView，而DecorView是FrameLayout的子类，并且FrameLayout也没有重写分发事件的一系列方法，也就是说，这里的顶层view的分发事件的过程是与ViewGroup的分发事件的过程是一致的。
而且可以看到，在DecorView的superDispatchTouchEvent中调用的也是ViewGroup的dispatchTouchEvent方法。
ViewGroup.java
public boolean dispatchTouchEvent(MotionEvent ev) {
...
boolean handled = false;
if (onFilterTouchEventForSecurity(ev)) {
final int action = ev.getAction();
final int actionMasked = action & MotionEvent.ACTION_MASK;
//如果是按下事件的话，将会对事件进行重置，设置TouchTarget为空
//TouchTarget是存储消费事件的View的一个链表
if (actionMasked == MotionEvent.ACTION_DOWN) {
cancelAndClearTouchTargets(ev);
resetTouchState();
}
//判断当前对象是否拦截事件，拦截条件：Down事件或者FirstTouchTarget非空
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 {
intercepted = true;
}
...
}
}
上面是ViewGroup中的dispatchTouchEvent的靠前的一部分。首先做了两件事：对于Down事件，重置TouchTarget；对于Down事件或者mFirstTouchTaret不为空的时候，调用onInterceptTouchEvent进行判断是否需要拦截该事件。这里可以看到是否调用onInterceptTouchEvent还要受disallowIntercept 的影响，这个是子View调用来修改的，将会在文章的最后进行分析。
至于mFirstTouchTarget，它本身可以看做一个链表，用于存储子View是否消耗事件。
也是说，当分发事件时，子View拦截事件了，那么mFirstTouchTarget就会被赋值为该子View。那么上面这个判断也就可以看出来调用拦截的条件了：
1，Down事件，对于任何Down事件都将会拦截
2，子View没有可处理的该事件的存在，这第二个条件通常是对应系列事件的后续事件的。
那么可以知道，当子View存在可拦截事件的存在的时候，父View就不会再调用自身的onInterceptTouchEvent，也就是说父View不再拦截事件。
要注意的是，onInterceptTouchEvent是VIewGroup中才有的，因为View是不可能有子View的，也就是说不需要拦截事件，所以也就没有onInterceptTouchEvent方法。
继续往下看dispatchTouchEvent方法。
public boolean dispatchTouchEvent(MotionEvent ev) {
...
if (onFilterTouchEventForSecurity(ev)) {
...
// 当父View不拦截该事件，并且这个事件不是Cancel事件的时候，将会分发事件给子View
if (!canceled && !intercepted) {
...
if (actionMasked == MotionEvent.ACTION_DOWN
|| (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
|| actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
final int childrenCount = mChildrenCount;
//若是有处理的子view，则不会进入该步（非第一次事件）
if (newTouchTarget == null && childrenCount != 0) {
...
// 循环遍历每个子View
for (int i = childrenCount - 1; i >= 0; i--) {
final int childIndex = getAndVerifyPreorderedIndex(childrenCount, i, customOrder);
final View child = getAndVerifyPreorderedView(preorderedList, children, childIndex);
//Event已经指定了处理这个事件的View并且不是当前View，则跳过
if (childWithAccessibilityFocus != null) {
if (childWithAccessibilityFocus != child) {
continue;
}
childWithAccessibilityFocus = null;
i = childrenCount - 1;
}
//判断当前View是否满足处理Touch事件的条件，否则跳过
//1，view状态为visible并且没有animation动画
//2，点击的事件的坐标发生在View里面
if (!canViewReceivePointerEvents(child)
|| !isTransformedTouchPointInView(x, y, child, null)) {
ev.setTargetAccessibilityFocus(false);
continue;
}
//从mFirstTouchTarget链表中寻找，若是找到，则不再继续向下分发
newTouchTarget = getTouchTarget(child);
if (newTouchTarget != null) {
newTouchTarget.pointerIdBits |= idBitsToAssign;
break;
}
resetCancelNextUpFlag(child);
//若是上面都没有满足的条件，则开始将事件分发给子View
//若是子View愿意处理事件，则将当前View加入到touchTarget中并结束循环
if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
...
newTouchTarget = addTouchTarget(child, idBitsToAssign);
alreadyDispatchedToNewTouchTarget = true;
break;
}
ev.setTargetAccessibilityFocus(false);
}
// 分发for循环结束
}
....
}
}
}
}
上面这一段主要是向子view分发事件的过程，也就是说，当前View不处理事件的时候，开始向子View分发事件，并且不是所有的子View都会分发，而是需要子view满足一定的条件。即事件发生在View内部，并且是visible并且没有动画播放的子View。
这里涉及到了几个方法，判断子view满足条件的方法和分发事件的方法。
canViewReceivePointerEvents(child)和isTransformedTouchPointInView(x, y, child, null))和dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)
private static boolean canViewReceivePointerEvents(@NonNull View child) {
return (child.mViewFlags & VISIBILITY_MASK) == VISIBLE
|| child.getAnimation() != null;
}
protected boolean isTransformedTouchPointInView(float x, float y, View child,PointF outLocalPoint) {
final float[] point = getTempPoint();
point[0] = x;
point[1] = y;
transformPointToViewLocal(point, child);
final boolean isInView = child.pointInView(point[0], point[1]);
if (isInView && outLocalPoint != null) {
outLocalPoint.set(point[0], point[1]);
}
return isInView;
}
public void transformPointToViewLocal(float[] point, View child) {
point[0] += mScrollX - child.mLeft;
point[1] += mScrollY - child.mTop;
if (!child.hasIdentityMatrix()) {
child.getInverseMatrix().mapPoints(point);
}
}
上面是用于判断子view是否满足visiable和noAnim，并且点击是否发生在view内部的实现。
上面dispatchTouchEvent还没走完，但是这里涉及到了分发事件给子View，那么就先看一下分发给子View的过程dispatchTransformedTouchEvent是怎么样的，然后再回来继续看dispatchTouchEvent。
private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
View child, int desiredPointerIdBits) {
final boolean handled;
final int oldAction = event.getAction();
//对于cancel事件，则直接将Event分发下去
if (cancel || oldAction == MotionEvent.ACTION_CANCEL) {
event.setAction(MotionEvent.ACTION_CANCEL);
if (child == null) {
// 没有子View的情况，直接调用父类View类的dispatchTouchEvent
handled = super.dispatchTouchEvent(event);
} else {
//有子View则分发给子View
handled = child.dispatchTouchEvent(event);
}
event.setAction(oldAction);
return handled;
}
// 下面是对事件的一些操作，只看主体的话与上面一样，先区分是否有子View
// 有的话则直接分发给子View，没有的话调用父类View的dispatchTouchEvent
if (newPointerIdBits == oldPointerIdBits) {
if (child == null || child.hasIdentityMatrix()) {
if (child == null) {
handled = super.dispatchTouchEvent(event);
} else {
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 {
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;
}
可以看到，事件分发给子View的过程就是调用子View 的dispatchTouchEvent方法，没有子View则调用父类的方法。
那么接下来还是要继续看dispatchTouchEvent的剩余部分的实现。
public boolean dispatchTouchEvent(MotionEvent ev) {
...
if (onFilterTouchEventForSecurity(ev)) {
...
if (!canceled && !intercepted) { ... }
...
// 分发事件结束后，开始处理事件
if (mFirstTouchTarget == null) {
// firstTouchTarget是在子View要消耗事件的时候插入进去的
// 也就是说这个链表中存放的是可以消费这个事件的子View
// 比如A中的子View是B，B中的子View是C，当前方法发生在A中，而实际消费
//事件的是C，那么A中链表中存放的就是B，B中的存放C，C的链表为空
// 这里传递的第三个参数是null，根据上面的分析，会调用View的dispatchTouchEvent
handled = dispatchTransformedTouchEvent(ev, canceled, null,
TouchTarget.ALL_POINTER_IDS);
} else {
// 当前的TouchTarget不为空，也就是子View中有消耗事件的存在
TouchTarget predecessor = null;
TouchTarget target = mFirstTouchTarget;
while (target != null) {
final TouchTarget next = target.next;
if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
// 这里代表已经分发过事件了，也就是进入了上面的if (!canceled && !intercepted) { ... }
// 方法，并在其中对子View进行循环分发
// 这种情况一般是发生在Down事件，Down事件是对于每一个View都分发一次
// 而后续的Move、Up事件就不会再进入上面的分发判断，而是直接进入下面else块
handled = true;
} else {
final boolean cancelChild = resetCancelNextUpFlag(target.child)
|| intercepted;
// 将事件分发给可消费事件的子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;
}
}
predecessor = target;
target = next;
}
}
...
}
if (!handled && mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onUnhandledEvent(ev, 1);
}
return handled;
}
上面就是ViewGroup的具体的实现细节了，可以看到，当事件发生的时候，ViewGroup将Down事件给满足条件的每个子view都分发了一次，然后在TouchTarget链表中记录可以消耗事件的子View，然后接下来的剩余事件就不会再每个子View都分发一次了，而是根据TouchTarget中记录的可以消耗事件的子view来进行具体的分发。
上面是ViewGroup的分发实现，那么接下来看View的分发实现，毕竟ViewGroup分发的最后，也是最终调用View的dispatchTouchEvent
// View.java
public boolean dispatchTouchEvent(MotionEvent event) {
// If the event should be handled by accessibility focus first.
if (event.isTargetAccessibilityFocus()) {
// We don't have focus or no virtual descendant has it, do not handle the event.
if (!isAccessibilityFocusedViewOrHost()) {
return false;
}
// We have focus and got the event, then use normal event dispatch.
event.setTargetAccessibilityFocus(false);
}
boolean result = false;
if (mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onTouchEvent(event, 0);
}
final int actionMasked = event.getActionMasked();
if (actionMasked == MotionEvent.ACTION_DOWN) {
// Defensive cleanup for new gesture
stopNestedScroll();
}
// 事件分发从这里开始
if (onFilterTouchEventForSecurity(event)) {
// 事件用于处理滚动条滚动
if ((mViewFlags & ENABLED_MASK) == ENABLED && handleScrollBarDragging(event)) {
result = true;
}
// 当前View是Enable的并且
// 设置了onTouchListener并返回了true
ListenerInfo li = mListenerInfo;
if (li != null && li.mOnTouchListener != null
&& (mViewFlags & ENABLED_MASK) == ENABLED
&& li.mOnTouchListener.onTouch(this, event)) {
result = true;
}
// onTouchListener返回false才会执行本身的onTouchEvent事件
if (!result && onTouchEvent(event)) {
result = true;
}
}
if (!result && mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onUnhandledEvent(event, 0);
}
if (actionMasked == MotionEvent.ACTION_UP ||
actionMasked == MotionEvent.ACTION_CANCEL ||
(actionMasked == MotionEvent.ACTION_DOWN && !result)) {
stopNestedScroll();
}
return result;
}
View的dispatchTouchEvent比较简单，就是设置调用了onTouchEvent方法而已。但是在调用之前又进行了一些判断用于消费事件，如滚动条滚动，设置了onTouchListener并返回true，则事件到此消费掉，不再调用onTouchEvent方法。
若是都没有消耗的话，就会进入onTouchEvent事件来进行事件的消费。
public boolean onTouchEvent(MotionEvent event) {
final float x = event.getX();
final float y = event.getY();
final int viewFlags = mViewFlags;
final int action = event.getAction();
// 这里获取view是否是可点击的
final boolean clickable = ((viewFlags & CLICKABLE) == CLICKABLE
|| (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
|| (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE;
// 若是disable状态下的View，直接返回clickable
// 也就是说虽然是disable，但若是能够click的话，仍然能够消耗事件，只是没有具体响应而已
if ((viewFlags & ENABLED_MASK) == DISABLED) {
if (action == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {
setPressed(false);
}
mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
return clickable;
}
if (mTouchDelegate != null) {
if (mTouchDelegate.onTouchEvent(event)) {
return true;
}
}
// 若View是可点击的，则会对于click事件进行处理
if (clickable || (viewFlags & TOOLTIP) == TOOLTIP) {
// 这里根据事件的类型进行了分类处理
switch (action) {
// up事件
case MotionEvent.ACTION_UP:
mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
if ((viewFlags & TOOLTIP) == TOOLTIP) {
handleTooltipUp();
}
// 若是在分发过程中，View被设置为了不可点击事件，则恢复一些点击相关状态，然后结束
if (!clickable) {
removeTapCallback();
removeLongPressCallback();
mInContextButtonPress = false;
mHasPerformedLongPress = false;
mIgnoreNextUpEvent = false;
break;
}
boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;
if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) {
// 获取focus焦点
boolean focusTaken = false;
if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {
focusTaken = requestFocus();
}
// 若是该View已经为释放状态，则重置为press状态
if (prepressed) {
setPressed(true, x, y);
}
if (!mHasPerformedLongPress && !mIgnoreNextUpEvent) {
// 非长按事件，移除长按回调
removeLongPressCallback();
// focusTaken为false，则分为几种情况
//1， 当前View不可获取focus
// 2，当前View在touch状态下不可获取focus
// 3，已经获取了focus
// 上面三种情况只要有一个满足就会使focusTaken为false，而若是都满足的话
// 则requestFocus通常能获取到焦点返回true的
// 这里也就是说，当点击这个View的时候，这个View没获取到焦点，则获取焦点但不执行点击事件
// 只有已经获取到焦点了或者本身就不能获取焦点，才会执行click事件
if (!focusTaken) {
if (mPerformClick == null) {
mPerformClick = new PerformClick();
}
// 使用Handler方式来post这个click事件
// 若是失败则直接调用这个click事件
if (!post(mPerformClick)) {
performClickInternal();
}
}
}
if (mUnsetPressedState == null) {
mUnsetPressedState = new UnsetPressedState();
}
// 设置View为非press状态
if (prepressed) {
postDelayed(mUnsetPressedState,
ViewConfiguration.getPressedStateDuration());
} else if (!post(mUnsetPressedState)) {
// If the post failed, unpress right now
mUnsetPressedState.run();
}
// 单击事件结束，移除click回调
removeTapCallback();
}
mIgnoreNextUpEvent = false;
break;
// Down事件
case MotionEvent.ACTION_DOWN:
if (event.getSource() == InputDevice.SOURCE_TOUCHSCREEN) {
mPrivateFlags3 |= PFLAG3_FINGER_DOWN;
}
mHasPerformedLongPress = false;
if (!clickable) {
checkForLongClick(0, x, y);
break;
}
if (performButtonActionOnTouchDown(event)) {
break;
}
boolean isInScrollingContainer = isInScrollingContainer();
// 若是可滚动的
if (isInScrollingContainer) {
mPrivateFlags |= PFLAG_PREPRESSED;
if (mPendingCheckForTap == null) {
mPendingCheckForTap = new CheckForTap();
}
mPendingCheckForTap.x = event.getX();
mPendingCheckForTap.y = event.getY();
postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
} else {
//检查长按事件
setPressed(true, x, y);
checkForLongClick(0, x, y);
}
break;
// Cancel事件则取消所有状态
case MotionEvent.ACTION_CANCEL:
if (clickable) {
setPressed(false);
}
removeTapCallback();
removeLongPressCallback();
mInContextButtonPress = false;
mHasPerformedLongPress = false;
mIgnoreNextUpEvent = false;
mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
break;
// Move
case MotionEvent.ACTION_MOVE:
if (clickable) {
drawableHotspotChanged(x, y);
}
// 若是Move出View边界，则移除相应回调，如取消单击或者长按等
if (!pointInView(x, y, mTouchSlop)) {
removeTapCallback();
removeLongPressCallback();
if ((mPrivateFlags & PFLAG_PRESSED) != 0) {
setPressed(false);
}
mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
}
break;
}
// 若是可点击状态返回true，如设置了单击事件，长按事件等
return true;
}
// 没有设置点击的相应事件监听
return false;
}
从View的onTouchEvent的分析可以看出，若是该View是可被点击的，则会返回true代表已经消耗了该事件，否则返回false，表示不消耗事件，然后就会再被传递回父View中的。
这里对于获取焦点可能会有点疑问，而就注释中所说的方式，执行点击事件的条件有两个：1，不可获取焦点的VIew，2，已经获取焦点的View
至于可获取焦点但是未获得焦点的View，点击的时候只会获取焦点，而不会触发点击事件。
再看下面两个方法
public void setOnClickListener(@Nullable OnClickListener l) {
if (!isClickable()) {
setClickable(true);
}
getListenerInfo().mOnClickListener = l;
}
public void setOnLongClickListener(@Nullable OnLongClickListener l) {
if (!isLongClickable()) {
setLongClickable(true);
}
getListenerInfo().mOnLongClickListener = l;
}
可以看出，在我们设置click监听和longClick监听的时候，会设置当前View为可点击的。也就是说，在一般没有重写事件分发的方法外，若是给其设置了点击或者长按监听，在onTouchEvent方法中就会返回true消耗事件。
到这里从ViewGroup到View的分发过程都已经清楚了。首先在事件序列中对于Down事件进行全部分发，然后记录需要消耗事件的View，后面的View就不再全部分发，而是只分发给需要处理消耗事件的View。
举例：
前提：布局图如下，其中A、B代表ViewGroup，C、D代表View。
示例1：正常点击C的事件序列为：
Activity#dispatchTouchEvent#DOWN
A#dispatchTouchEvent#DOWN
A#onInterceptTouchEvent#DOWN
B#dispatchTouchEvent#DOWN
B#onInterceptTouchEvent#DOWN
C#dispatchTouchEvent#DOWN
C#onTouchEvent#DOWN
B#onTouchEvent#DOWN
A#onTouchEvent#DOWN
Activity#onTouchEvent#DOWN
Activity#dispatchTouchEvent#UP
Activity#onTouchEvent#UP
事件并不经历D，因为D虽然也是A的子View，但是由于事件发生的位置不在D中，所以事件不分发给D。
另外由于ABC都不处理事件，因此后续的Up等事件就不会再向下分发了，而是直接交给Activity自己处理了。
示例2：若是C处理事件的话，即设置了setOnClickListener，则事件序列为：
Activity#dispatchTouchEvent#DOWN
A#dispatchTouchEvent#DOWN
A#onInterceptTouchEvent#DOWN
B#dispatchTouchEvent#DOWN
B#onInterceptTouchEvent#DOWN
C#dispatchTouchEvent#DOWN
C#onTouchEvent#DOWN
Activity#dispatchTouchEvent#UP
A#dispatchTouchEvent#UP
A#onInterceptTouchEvent#UP
B#dispatchTouchEvent#UP
B#onInterceptTouchEvent#UP
C#dispatchTouchEvent#UP
C#onTouchEvent#UP
C#onClick#UP
示例3：若是A不拦截Down和UP事件，而是要拦截Move事件（C设置了点击事件），事件序列为
重写A的onInterceptTouchEvent事件
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
Log.i(TAG, "onInterceptTouchEvent: " + printEvent(ev));
if (ev.getAction() == MotionEvent.ACTION_MOVE) {
return true;
} else {
return super.onInterceptTouchEvent(ev);
}
}
Activity#dispatchTouchEvent#DOWN
A#dispatchTouchEvent#DOWN
A#onInterceptTouchEvent#DOWN
B#dispatchTouchEvent#DOWN
B#onInterceptTouchEvent#DOWN
C#dispatchTouchEvent#DOWN
C#onTouchEvent#DOWN
Activity#dispatchTouchEvent#MOVE
A#dispatchTouchEvent#MOVE
A#onInterceptTouchEvent#MOVE
B#dispatchTouchEvent#CANCEL
B#onInterceptTouchEvent#CANCEL
C#dsipatchTouchEvent#CANCEL
C#onTouchEvent#CANCEL
Activity#dispatchTouchEvent#MOVE
A#dispatchTouchEvent#MOVE
A#onTouchEvent#MOVE
Activity#onTouchEvent#MOVE
Activity#dispatchTouchEvent#UP
A#dispatchTouchEvent#UP
A#onTouchEvent#UP
Activity#onTouchEvent#UP
可以看到，Down还是按照正常事件的分发。但是Move事件分发到A时被A拦截了，于是将Down事件转换成Cancel事件传递下去，并且后面的事件不再向下传递。
总结：
- 当事件发生的时候，首先传递到Activity，然后传递到PhoneWindow，然后传递到DecorView。
- 首先分发Down事件，从父View逐渐传递到子View进行分发。
- 然后子View开始处理事件，不处理的话则再逐渐将事件返回给父View进行处理
- 若是都不处理则最终返回到Activity的处理方法onTouchEvent
- 当Down事件完成分发处理后，就会根据TouchTarget形成一条链，接下来的事件就会根据这个链进行分发，而不是像Down事件一样全部分发一次。
附：
/**
* Called whenever a key, touch, or trackball event is dispatched to the
* activity. Implement this method if you wish to know that the user has
* interacted with the device in some way while your activity is running.
* This callback and {@link #onUserLeaveHint} are intended to help
* activities manage status bar notifications intelligently; specifically,
* for helping activities determine the proper time to cancel a notfication.
*
* <p>All calls to your activity's {@link #onUserLeaveHint} callback will
* be accompanied by calls to {@link #onUserInteraction}. This
* ensures that your activity will be told of relevant user activity such
* as pulling down the notification pane and touching an item there.
*
* <p>Note that this callback will be invoked for the touch down action
* that begins a touch gesture, but may not be invoked for the touch-moved
* and touch-up actions that follow.
*
* @see #onUserLeaveHint()
*/
public void onUserInteraction() {}
/**
* Called as part of the activity lifecycle when an activity is about to go
* into the background as the result of user choice. For example, when the
* user presses the Home key, {@link #onUserLeaveHint} will be called, but
* when an incoming phone call causes the in-call Activity to be automatically
* brought to the foreground, {@link #onUserLeaveHint} will not be called on
* the activity being interrupted. In cases when it is invoked, this method
* is called right before the activity's {@link #onPause} callback.
*
* <p>This callback and {@link #onUserInteraction} are intended to help
* activities manage status bar notifications intelligently; specifically,
* for helping activities determine the proper time to cancel a notification.
*
* @see #onUserInteraction()
*/
protected void onUserLeaveHint() {}
以上两个方法在Activity中定义，都是空方法，用于感知用户在当前Activity活跃的时候的操作状态。
其中onUserInteraction会在用户点击的时候被触发，该方法在事件分发或者点击key按键的时候会调用。
而onUserLeaveHint则是在用户将当前Activity切换到后台的时候调用，例如用于点击了Home键的时候。但是对于来电话了等非用户操作因素导致的活动置于后台的情况，该方法则不会被调用，并且该方法会在onPause方法之前被调用。
对于普通点击，onUserInteraction会被调用一次，而按下返回键销毁当前Activity的时候会被调用两次。按下home键的时候会先调用onUserInteraction再调用onUserLeaveHint。按下电源键则两个方法都不会被触发。
1749
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
