关于Android事件派发流程的理解

以前看了很多人介绍的Android事件派发流程，但最近使用那些来写代码的时候出现了不少错误。所以回顾一下整个流程，简单介绍从手触摸屏幕开始到事件在View树派发。从源码上分析ViewGroup.dispatchTouchEvent。

事件从触摸到View简述

Android的事件产生是从我们触摸屏幕开始，在经过Input子系统，最后达到我们的应用程序(或者经过WindowManagerService到达应用程序)。

而其中Input子系统在Java层对应着InputManagerService，其主要在native层，由InputReader读取EventHub的元数据，将这些数据加工成InputEvent，最后发到InputDispatcher，而InputDispatcher则负责将时间发到应用程序，Input子系统流程可以参见这篇文章Android Framework——之Input子系统。

对于应用层的时间流程，主要是下面的流程图所示：



其中最后一步就是我们经常说的View事件派发流程。另外上面DecorView是经过了两次，第一次是调用DecorView的dispatchTouchEvent，它的源码是:

@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
final Callback cb = getCallback();
return cb != null && !isDestroyed() && mFeatureId < 0 ? cb.dispatchTouchEvent(ev)
: super.dispatchTouchEvent(ev);
}

Callback就是Window.Callback，Activity实现了这个接口。在Activity的attach函数中，会调用window的setCallback，将Activity设置给Window。所以这里getCallback返回的就是Activity，最终会调用Activity的dispatchTouchEvent。下面看一下Activity的dispatchTouchEvent函数:

public boolean dispatchTouchEvent(MotionEvent ev) {
if (ev.getAction() == MotionEvent.ACTION_DOWN) {
onUserInteraction();
}
if (getWindow().superDispatchTouchEvent(ev)) {
return true;
}
return onTouchEvent(ev);
}

在ACTION_DOWN的时候会调用onUserInteraction方法，然后调用Window（实际上是PhoneWindow)的superDispatchTouchEvent，如果Window的superDispatchTouchEvent消耗了事件，则直接返回，不会调用Activity的onTouchEvent方法。

@Override
public boolean superDispatchTouchEvent(MotionEvent event) {
return mDecor.superDispatchTouchEvent(event);
}

而DecorView的superDispatchTouchEvent为:

public boolean superDispatchTouchEvent(MotionEvent event) {
return super.dispatchTouchEvent(event);
}

最终还是调用DecorView的父类的dispatchTouchEvent，DecorView的父类是FrameLayout，它没实现该方法，最终会调用ViewGroup的dispatchTouchEvent方法。从这里开始就进入了view树的时间派发流程了。

View树的事件派发流程

这里从源码上分析事件派发的一些特性。事件派发最开始会进入到ViewGroup的dispatchTouchEvent(DecorVIew父类)，下面是ViewGroup的dispatchTouchEvent伪代码的分析，直接在对应的代码部分加了注释：

“`

@Override

public boolean dispatchTouchEvent(MotionEvent ev) {

//一开始做一些调试验证，另外如果事件的目标是focused view,并且当前view就是一个focused view,

//有可能view的子View就会处理这次事件，所以将targetAccessibilityFocus设置为false。

…

boolean handled = false;

if (onFilterTouchEventForSecurity(ev)) {　//检查event是否是安全的

final int action = ev.getAction();

final int actionMasked = action & MotionEvent.ACTION_MASK;

// 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.
//清除之前的事件状态。比如说在app切换，ANR或其他状态改变时，系统框架将会去掉up或cancel事件。在这里会将mFirstTouchTarget清空，mFirstTouchTarget是保存了会接受事件的View处理对象。
cancelAndClearTouchTargets(ev);
resetTouchState();　//这里会将mGroupFlags的FLAG_DISALLOW_INTERCEPT标识清除，
//1. 每次事件流开始的时候都会先清除FLAG_DISALLOW_INTERCEPT，所以子view的requestDisallowInterceptTouchEvent只有当次事件流有效。
}

// 判断是否需要拦截事件，去判断是否拦截事件的条件是此次事件是DOWN事件，或者有子类会处理这次事件(mFirstTouchTarget不为null)，并且FLAG_DISALLOW_INTERCEPT没被设置。
final boolean intercepted;
if (actionMasked == MotionEvent.ACTION_DOWN
|| mFirstTouchTarget != null) {
final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
if (!disallowIntercept) {
//2. 只有有TouchTarget并且没有被disallow，或者是ACTION_DOWN时才会调用onInterceptTouchEvent。
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;
}

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

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

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 = buildOrderedChildList();
final boolean customOrder = preorderedList == null
&& isChildrenDrawingOrderEnabled();
final View[] children = mChildren;
for (int i = childrenCount - 1; i >= 0; i--) {
final int childIndex = customOrder
? getChildDrawingOrder(childrenCount, i) : i;
final View child = (preorderedList == null)
? children[childIndex] : preorderedList.get(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;
}
//判断当前的child是否可以接收事件，并且事件是否在当前的view范围
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);
//3.dispatchTransformedTouchEvent会将Event转化为child坐标空间(getX的变化)，然后去除无关的points id，如果有必要更改事件，最后调用child.dispatchTouchEvent。 dispatchTransformedTouchEvent把事件派发给child，如果child成功处理了，则会将child添加到mFirstTouchTarget
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();
//addTouchTarget会创建新的TouchTarget，并将其加入到mFirstTouchTarget
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;
}
}
}

//4. 派发事件
// Dispatch to touch targets.
if (mFirstTouchTarget == null) { //mFirstTouchTarget为空表示没有子View会处理这次事件，则交给当前的ViewGroup处理。
// 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) {//遍历mFirstTouchTarget链表，一个一个地处理TouchTarget。
final TouchTarget next = target.next;
if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {//新添加的不会立刻处理，ACTION_DOWN已经在前面派发了
handled = true;
} else {
final boolean cancelChild = resetCancelNextUpFlag(target.child)
|| intercepted;
//dispatchTransformedTouchEvent会将Event转化为child坐标空间(getX的变化)，然后去除无关的points id，如果有必要更改事件，最后调用child.dispatchTouchEvent
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;
}
}

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

...
//用于测试的代码

return handled;
}

“`

事件派发流程主要集中在这几个方法的调用:

- dispatchTouchEvent 这是事件派发每个View的时候，第一个被调用的方法，如果是ViewGroup，dispatchTouchEvent会先去调用onInterceptTouchEvent是否应该拦截事件，不拦截的话会先从子View中判断是否有处理该次事件的（在ACTION_DOWN中采用mFirstTouchTarget链接保存会处理事件的TouchTarget），如果没有的话则调用当前View的onTouchEvent。

- onInterceptTouchEvent 判断是否应该拦截事件，ViewGroup默认实现是返回false，子View可以调用getParent.requestDisallowInterceptTouchEvent()来阻止父View拦截。否则只要有子View可能消费事件，该方法都会被调用。

- onTouchEvent这个方法是在没有子View将会消耗事件时才会被调用，onClickListener，onTouchListener,onLongClickListener都是在这个方法中处理的。如果返回true表示消费这次事件。

对于事件派发流程，我觉得有几个地方需要注意的：

1. 应该把ViewGroup以及它所包含的子View都看作是这个ViewGroup的一部分，对于一个ViewGroup是否会处理一次事件，应该是包含了它的子View是否也处理。

2. 如果整个ViewGroup以及它的子类没有一个View处理ACTION_DOWN事件，那么下一次就不会调用这个ViewGroup的dispatchTouchEvent。但是如果ACTION_DOWN返回了true，那么下一次事件还是会继续派发到ViewGroup，即使中间某个ACTION_MOVE返回了false。

3. onInterceptTouchEvent是在子View可能会处理该次事件，并且没有被设置FLAG_DISALLOW_INTERCEPT才会被调用。正常情况下，它在ACTION_DOWN的时候一定会被调用的，因为在ACTION_DOWN的时候会先调用resetTouchState()。

这个是最近略微改了一下很久之前写的一个模仿QQ邮箱滑动退出写的一个东西:https://github.com/xxxzhi/SlideListener，改的过程发现之前看的东西理解地不够好…

源码是解释很多现象的最根本的原因，阅读源码能够更好地理解事件派发流程，理解地更加深刻。