厚积薄发

0%

Touch事件分发

Posted on Edited on In

之前分析了界面显示流程，显示以后，界面将接收用户操作事件，本文将分析Touch事件分发机制。

1. 由Activity显示到界面流程分析中我们知道最后创建ViewRoot，ViewRoot的setView中注册了事件消息处理。

具体的注册流程和事件回调请看老罗消息处理机制分析

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
public void setView(View view, WindowManager.LayoutParams attrs,
		View panelParentView) {
	synchronized (this) {
		if (mView == null) {
			mView = view;
			mWindowAttributes.copyFrom(attrs);
			attrs = mWindowAttributes;

			mSoftInputMode = attrs.softInputMode;
			mWindowAttributesChanged = true;
			mAttachInfo.mRootView = view;
			mAttachInfo.mScalingRequired = mTranslator != null;
			mAttachInfo.mApplicationScale =
					mTranslator == null ? 1.0f : mTranslator.applicationScale;
			if (panelParentView != null) {
				mAttachInfo.mPanelParentWindowToken
						= panelParentView.getApplicationWindowToken();
			}

			requestLayout();
			mInputChannel = new InputChannel();
			try {
				res = sWindowSession.add(mWindow, mWindowAttributes,
						getHostVisibility(), mAttachInfo.mContentInsets,
						mInputChannel);
			} catch (RemoteException e) {

			} finally {
				if (restore) {
					attrs.restore();
				}
			}

			if (mInputQueueCallback != null) {

			} else {
				InputQueue.registerInputChannel(mInputChannel, mInputHandler,
						Looper.myQueue());
			}
		}
	}
}

InputQueue.registerInputChannel(mInputChannel, mInputHandler,Looper.myQueue())，注册接收mInputHandler。

2. new InputHandler()

1
2
3
4
5
6
7
8
9
10
11
private final InputHandler mInputHandler = new InputHandler() {
	public void handleKey(KeyEvent event, Runnable finishedCallback) {
		startInputEvent(finishedCallback);
		dispatchKey(event, true);
	}

	public void handleMotion(MotionEvent event, Runnable finishedCallback) {
		startInputEvent(finishedCallback);
		dispatchMotion(event, true);
	}
};

3. ViewRoot.dispatchMotion

1
2
3
4
5
6
7
8
9
10
11
12
13
14
private void dispatchMotion(MotionEvent event, boolean sendDone) {
	int source = event.getSource();
	if ((source & InputDevice.SOURCE_CLASS_POINTER) != 0) {
		dispatchPointer(event, sendDone);
	} else if ((source & InputDevice.SOURCE_CLASS_TRACKBALL) != 0) {
		dispatchTrackball(event, sendDone);
	} else {
		// TODO
		Log.v(TAG, "Dropping unsupported motion event (unimplemented): " + event);
		if (sendDone) {
			finishInputEvent();
		}
	}
}

4. ViewRoot.dispatchPointer

1
2
3
4
5
6
private void dispatchPointer(MotionEvent event, boolean sendDone) {
	Message msg = obtainMessage(DISPATCH_POINTER);
	msg.obj = event;
	msg.arg1 = sendDone ? 1 : 0;
	sendMessageAtTime(msg, event.getEventTime());
}

ViewRoot本身是Handler对象。

5. ViewRoot.handleMessage

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Override 
public void handleMessage(Message msg) {
	switch (msg.what) {
	case DISPATCH_POINTER: {
		MotionEvent event = (MotionEvent) msg.obj;
		try {
			deliverPointerEvent(event);
		} finally {
			event.recycle();
			if (msg.arg1 != 0) {
				finishInputEvent();
			}
			if (LOCAL_LOGV || WATCH_POINTER) Log.i(TAG, "Done dispatching!");
		}
	} break;
}

6. ViewRoot.deliverPointerEvent

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
private void deliverPointerEvent(MotionEvent event) {
	if (mTranslator != null) {
		mTranslator.translateEventInScreenToAppWindow(event);
	}
	
	boolean handled;
	if (mView != null && mAdded) {

		...
		
		handled = mView.dispatchTouchEvent(event);
		if (MEASURE_LATENCY) {
			lt.sample("B Dispatched TouchEvents ", System.nanoTime() - event.getEventTimeNano());
		}
		if (!handled && isDown) {
			int edgeSlop = mViewConfiguration.getScaledEdgeSlop();

			....

			if (edgeFlags != 0 && mView instanceof ViewGroup) {
				View nearest = FocusFinder.getInstance().findNearestTouchable(
						((ViewGroup) mView), x, y, direction, deltas);
				if (nearest != null) {
					event.offsetLocation(deltas[0], deltas[1]);
					event.setEdgeFlags(0);
					mView.dispatchTouchEvent(event);
				}
			}
		}
	}
}
这里mView在setView的方法中初始化，其实就是Window中的DecorView。

7. DecorView.dispatchTouchEvent

1
2
3
4
5
6
7
8
9
10
11
12
13
public boolean dispatchKeyEvent(KeyEvent event) {
	final int keyCode = event.getKeyCode();
	final boolean isDown = event.getAction() == KeyEvent.ACTION_DOWN;

	final Callback cb = getCallback();
	final boolean handled = cb != null && mFeatureId < 0 ? cb.dispatchKeyEvent(event)
			: super.dispatchKeyEvent(event);
	if (handled) {
		return true;
	}
	return isDown ? PhoneWindow.this.onKeyDown(mFeatureId, event.getKeyCode(), event)
			: PhoneWindow.this.onKeyUp(mFeatureId, event.getKeyCode(), event);
}

这里的callback就是在activity的attach方法中设置的，其实就是Activity。

8. Activity.dispatchTouchEvent

1
2
3
4
5
6
7
8
9
public boolean dispatchTouchEvent(MotionEvent ev) {
	if (ev.getAction() == MotionEvent.ACTION_DOWN) {
		onUserInteraction();
	}
	if (getWindow().superDispatchTouchEvent(ev)) {
		return true;
	}
	return onTouchEvent(ev);
}

9. PhoneWindow.superDispatchTouchEvent

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

10. DecorView.superDispatchTouchEvent

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

11. 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
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
	if (!onFilterTouchEventForSecurity(ev)) {
		return false;
	}

	final int action = ev.getAction();
	final float xf = ev.getX();
	final float yf = ev.getY();
	final float scrolledXFloat = xf + mScrollX;
	final float scrolledYFloat = yf + mScrollY;
	final Rect frame = mTempRect;

	boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;

	if (action == MotionEvent.ACTION_DOWN) {
		if (mMotionTarget != null) {
			// this is weird, we got a pen down, but we thought it was
			// already down!
			// XXX: We should probably send an ACTION_UP to the current
			// target.
			mMotionTarget = null;
		}
		// If we're disallowing intercept or if we're allowing and we didn't
		// intercept
		if (disallowIntercept || !onInterceptTouchEvent(ev)) {
			// reset this event's action (just to protect ourselves)
			ev.setAction(MotionEvent.ACTION_DOWN);
			// We know we want to dispatch the event down, find a child
			// who can handle it, start with the front-most child.
			final int scrolledXInt = (int) scrolledXFloat;
			final int scrolledYInt = (int) scrolledYFloat;
			final View[] children = mChildren;
			final int count = mChildrenCount;

			for (int i = count - 1; i >= 0; i--) {
				final View child = children[i];
				if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE
						|| child.getAnimation() != null) {
					child.getHitRect(frame);
					if (frame.contains(scrolledXInt, scrolledYInt)) {
						// offset the event to the view's coordinate system
						final float xc = scrolledXFloat - child.mLeft;
						final float yc = scrolledYFloat - child.mTop;
						ev.setLocation(xc, yc);
						child.mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;
						if (child.dispatchTouchEvent(ev))  {
							// Event handled, we have a target now.
							mMotionTarget = child;
							return true;
						}
						// The event didn't get handled, try the next view.
						// Don't reset the event's location, it's not
						// necessary here.
					}
				}
			}
		}
	}

	boolean isUpOrCancel = (action == MotionEvent.ACTION_UP) ||
			(action == MotionEvent.ACTION_CANCEL);

	if (isUpOrCancel) {
		// Note, we've already copied the previous state to our local
		// variable, so this takes effect on the next event
		mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;
	}

	// The event wasn't an ACTION_DOWN, dispatch it to our target if
	// we have one.
	final View target = mMotionTarget;
	if (target == null) {
		// We don't have a target, this means we're handling the
		// event as a regular view.
		ev.setLocation(xf, yf);
		if ((mPrivateFlags & CANCEL_NEXT_UP_EVENT) != 0) {
			ev.setAction(MotionEvent.ACTION_CANCEL);
			mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;
		}
		return super.dispatchTouchEvent(ev);
	}

	// if have a target, see if we're allowed to and want to intercept its
	// events
	if (!disallowIntercept && onInterceptTouchEvent(ev)) {
		final float xc = scrolledXFloat - (float) target.mLeft;
		final float yc = scrolledYFloat - (float) target.mTop;
		mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;
		ev.setAction(MotionEvent.ACTION_CANCEL);
		ev.setLocation(xc, yc);
		if (!target.dispatchTouchEvent(ev)) {
			// target didn't handle ACTION_CANCEL. not much we can do
			// but they should have.
		}
		// clear the target
		mMotionTarget = null;
		// Don't dispatch this event to our own view, because we already
		// saw it when intercepting; we just want to give the following
		// event to the normal onTouchEvent().
		return true;
	}

	if (isUpOrCancel) {
		mMotionTarget = null;
	}

	// finally offset the event to the target's coordinate system and
	// dispatch the event.
	final float xc = scrolledXFloat - (float) target.mLeft;
	final float yc = scrolledYFloat - (float) target.mTop;
	ev.setLocation(xc, yc);

	if ((target.mPrivateFlags & CANCEL_NEXT_UP_EVENT) != 0) {
		ev.setAction(MotionEvent.ACTION_CANCEL);
		target.mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;
		mMotionTarget = null;
	}

	return target.dispatchTouchEvent(ev);
}

1）首先判断disallowIntercept，只有ViewGroup才可以中断touch事件传递。
2）onInterceptTouchEvent开发者自定义是否中断事件传递，默认为false。
3）for循环遍历子View，然后调用子View的dispatchTouchEvent，如果有子View消费事件使用mMotionTarget记录当前的子View。
4）这里可以看出，只有Down的时候消费了事件才可以接收接下来的事件。
5）如果没有子View消费事件或者ViewGroup中断事件传递则调用super.dispatchTouchEvent(ev)，则是View.dispatchTouchEvent(ev)。

12. View.dispatchTouchEvent

1
2
3
4
5
6
7
8
9
10
11
public boolean dispatchTouchEvent(MotionEvent event) {
	if (!onFilterTouchEventForSecurity(event)) {
		return false;
	}

	if (mOnTouchListener != null && (mViewFlags & ENABLED_MASK) == ENABLED &&
			mOnTouchListener.onTouch(this, event)) {
		return true;
	}
	return onTouchEvent(event);
}

这里如果设置自定义的mOnTouchListener，然后消费事件则直接返回true，否则调用onTouchEvent

13 View.onTouchEvent

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
public boolean onTouchEvent(MotionEvent event) {
	final int viewFlags = mViewFlags;

	if ((viewFlags & ENABLED_MASK) == DISABLED) {
		// A disabled view that is clickable still consumes the touch
		// events, it just doesn't respond to them.
		return (((viewFlags & CLICKABLE) == CLICKABLE ||
				(viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE));
	}

	if (mTouchDelegate != null) {
		if (mTouchDelegate.onTouchEvent(event)) {
			return true;
		}
	}

	if (((viewFlags & CLICKABLE) == CLICKABLE ||
			(viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)) {
		switch (event.getAction()) {
			case MotionEvent.ACTION_UP:
				boolean prepressed = (mPrivateFlags & PREPRESSED) != 0;
				if ((mPrivateFlags & PRESSED) != 0 || prepressed) {
					// take focus if we don't have it already and we should in
					// touch mode.
					boolean focusTaken = false;
					if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {
						focusTaken = requestFocus();
					}

					if (!mHasPerformedLongPress) {
						// This is a tap, so remove the longpress check
						removeLongPressCallback();

						// Only perform take click actions if we were in the pressed state
						if (!focusTaken) {
							// Use a Runnable and post this rather than calling
							// performClick directly. This lets other visual state
							// of the view update before click actions start.
							if (mPerformClick == null) {
								mPerformClick = new PerformClick();
							}
							if (!post(mPerformClick)) {
								performClick();
							}
						}
					}

					if (mUnsetPressedState == null) {
						mUnsetPressedState = new UnsetPressedState();
					}

				}
				break;

			case MotionEvent.ACTION_DOWN:
			
				break;

			case MotionEvent.ACTION_CANCEL:

				break;

			case MotionEvent.ACTION_MOVE:

				break;
		}
		return true;
	}

	return false;
}

如果View是CLICKABLE，直接消费事件（Button就是CLICKABLE）

touch消息处理流程图