关于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方法。

1
2
3
4
@Override
public boolean superDispatchTouchEvent(MotionEvent event) {
return mDecor.superDispatchTouchEvent(event);
}

而DecorView的superDispatchTouchEvent为:

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

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

View树的事件派发流程

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
@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,改的过程发现之前看的东西理解地不够好…

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