Android输入输出系统之TouchEvent流程

一个是InputReader，一个是InputDispatcher。方法是dispatchTouch。

入口点是InputReader 的loopOnce方法.

InputReader里面有个线程叫做InputReaderThread，threadLoop

[code="java"]InputReaderThread::InputReaderThread(const sp& reader) :
        Thread(/*canCallJava*/ true), mReader(reader) {
}

InputReaderThread::~InputReaderThread() {
}

bool InputReaderThread::threadLoop() {
    mReader->loopOnce();
    return true;
}

1. void InputDispatcher::dispatchOnce() {
2. nsecs_t keyRepeatTimeout = mPolicy->getKeyRepeatTimeout();
3. nsecs_t keyRepeatDelay = mPolicy->getKeyRepeatDelay();
4. nsecs_t nextWakeupTime = LONG_LONG_MAX;
5. { // acquire lock
6. AutoMutex _l(mLock);
7. dispatchOnceInnerLocked(keyRepeatTimeout, keyRepeatDelay, & nextWakeupTime);
8. if (runCommandsLockedInterruptible()) {
9. nextWakeupTime = LONG_LONG_MIN;  // force next poll to wake up immediately
10. }
11. } // release lock
12. // Wait for callback or timeout or wake.  (make sure we round up, not down)
13. nsecs_t currentTime = now();
14. int32_t timeoutMillis;
15. if (nextWakeupTime > currentTime) {
16. uint64_t timeout = uint64_t(nextWakeupTime - currentTime);
17. timeout = (timeout + 999999LL) / 1000000LL;
18. timeoutMillis = timeout > INT_MAX ? -1 : int32_t(timeout);
19. } else {
20. timeoutMillis = 0;
21. }
22. mLooper->pollOnce(timeoutMillis);
23. }

1. case EventEntry::TYPE_MOTION: {
2. MotionEntry* typedEntry = static_cast<MotionEntry*>(mPendingEvent);
3. if (dropReason == DROP_REASON_NOT_DROPPED && isAppSwitchDue) {
4. dropReason = DROP_REASON_APP_SWITCH;
5. }
6. done = dispatchMotionLocked(currentTime, typedEntry,
7. &dropReason, nextWakeupTime);
8. break;

1. bool InputDispatcher::dispatchMotionLocked(
2. nsecs_t currentTime, MotionEntry* entry, DropReason* dropReason, nsecs_t* nextWakeupTime) {
3. // Preprocessing.
4. if (! entry->dispatchInProgress) {
5. entry->dispatchInProgress = true;
6. resetTargetsLocked();
7. logOutboundMotionDetailsLocked("dispatchMotion - ", entry);
8. }
9. // Clean up if dropping the event.
10. if (*dropReason != DROP_REASON_NOT_DROPPED) {
11. resetTargetsLocked();
12. setInjectionResultLocked(entry, *dropReason == DROP_REASON_POLICY
13. ? INPUT_EVENT_INJECTION_SUCCEEDED : INPUT_EVENT_INJECTION_FAILED);
14. return true;
15. }
16. bool isPointerEvent = entry->source & AINPUT_SOURCE_CLASS_POINTER;
17. // Identify targets.
18. if (! mCurrentInputTargetsValid) {
19. int32_t injectionResult;
20. if (isPointerEvent) {
21. // Pointer event.  (eg. touchscreen)
22. injectionResult = findTouchedWindowTargetsLocked(currentTime,
23. entry, nextWakeupTime);
24. } else {
25. // Non touch event.  (eg. trackball)
26. injectionResult = findFocusedWindowTargetsLocked(currentTime,
27. entry, nextWakeupTime);
28. }
29. if (injectionResult == INPUT_EVENT_INJECTION_PENDING) {
30. return false;
31. }
32. setInjectionResultLocked(entry, injectionResult);
33. if (injectionResult != INPUT_EVENT_INJECTION_SUCCEEDED) {
34. return true;
35. }
36. addMonitoringTargetsLocked();
37. commitTargetsLocked();
38. }
39. // Dispatch the motion.
40. dispatchEventToCurrentInputTargetsLocked(currentTime, entry, false);
41. return true;
42. }

1. startDispatchCycleLocked 中的方法
2. status = connection->inputPublisher.publishMotionEvent(motionEntry->deviceId,
3. motionEntry->source, action, flags, motionEntry->edgeFlags, motionEntry->metaState,
4. xOffset, yOffset,
5. motionEntry->xPrecision, motionEntry->yPrecision,
6. motionEntry->downTime, firstMotionSample->eventTime,
7. motionEntry->pointerCount, motionEntry->pointerIds,
8. firstMotionSample->pointerCoords);

1. ViewRoot有个InputHandler

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

InputHandler注册给了系统

1. InputQueue.registerInputChannel(mInputChannel, mInputHandler,
2. Looper.myQueue());

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

调用了dispatchPointer

ViewRoot本身就是Handler直接sendMessageAtTime

然后就进入了View的焦点系统。

下面就说一下Activity的焦点是怎么回事。

1. InputDisapatcher.cpp中调用了如下方法
2. dispatchEventToCurrentInputTargetsLocked(currentTime, motionEntry,
3. true /*resumeWithAppendedMotionSample*/);

然后

1. dispatchEventToCurrentInputTargetsLocked

调用了如下方法

1. int32_t InputDispatcher::findFocusedWindowTargetsLocked(nsecs_t currentTime,
2. const EventEntry* entry, nsecs_t* nextWakeupTime) {
3. mCurrentInputTargets.clear();
4. int32_t injectionResult;
5. // If there is no currently focused window and no focused application
6. // then drop the event.
7. if (! mFocusedWindow) {
8. if (mFocusedApplication) {
9. #if DEBUG_FOCUS
10. LOGD("Waiting because there is no focused window but there is a "
11. "focused application that may eventually add a window: %s.",
12. getApplicationWindowLabelLocked(mFocusedApplication, NULL).string());
13. #endif
14. injectionResult = handleTargetsNotReadyLocked(currentTime, entry,
15. mFocusedApplication, NULL, nextWakeupTime);
16. goto Unresponsive;
17. }
18. LOGI("Dropping event because there is no focused window or focused application.");
19. injectionResult = INPUT_EVENT_INJECTION_FAILED;
20. goto Failed;
21. }
22. // Check permissions.
23. if (! checkInjectionPermission(mFocusedWindow, entry->injectionState)) {
24. injectionResult = INPUT_EVENT_INJECTION_PERMISSION_DENIED;
25. goto Failed;
26. }
27. // If the currently focused window is paused then keep waiting.
28. if (mFocusedWindow->paused) {
29. #if DEBUG_FOCUS
30. LOGD("Waiting because focused window is paused.");
31. #endif
32. injectionResult = handleTargetsNotReadyLocked(currentTime, entry,
33. mFocusedApplication, mFocusedWindow, nextWakeupTime);
34. goto Unresponsive;
35. }
36. // If the currently focused window is still working on previous events then keep waiting.
37. if (! isWindowFinishedWithPreviousInputLocked(mFocusedWindow)) {
38. #if DEBUG_FOCUS
39. LOGD("Waiting because focused window still processing previous input.");
40. #endif
41. injectionResult = handleTargetsNotReadyLocked(currentTime, entry,
42. mFocusedApplication, mFocusedWindow, nextWakeupTime);
43. goto Unresponsive;
44. }
45. // Success!  Output targets.
46. injectionResult = INPUT_EVENT_INJECTION_SUCCEEDED;
47. addWindowTargetLocked(mFocusedWindow, InputTarget::FLAG_FOREGROUND, BitSet32(0));
48. // Done.
49. Failed:
50. Unresponsive:
51. nsecs_t timeSpentWaitingForApplication = getTimeSpentWaitingForApplicationLocked(currentTime);
52. updateDispatchStatisticsLocked(currentTime, entry,
53. injectionResult, timeSpentWaitingForApplication);
54. #if DEBUG_FOCUS
55. LOGD("findFocusedWindow finished: injectionResult=%d, "
56. "timeSpendWaitingForApplication=%0.1fms",
57. injectionResult, timeSpentWaitingForApplication / 1000000.0);
58. #endif
59. return injectionResult;
60. }

move事件的处理和Down事件的处理很不相同。

新建立的Window在处理焦点的时候，按下事件没有起来之前，保持了原来的焦点窗口。除非ACTION_UP事件收到以后

1. /* Updates the cached window information provided to the input dispatcher. */
2. public void updateInputWindowsLw() {
3. // Populate the input window list with information about all of the windows that
4. // could potentially receive input.
5. // As an optimization, we could try to prune the list of windows but this turns
6. // out to be difficult because only the native code knows for sure which window
7. // currently has touch focus.
8. final ArrayList<WindowState> windows = mWindows;
9. final int N = windows.size();
10. for (int i = N - 1; i >= 0; i--) {
11. final WindowState child = windows.get(i);
12. if (child.mInputChannel == null || child.mRemoved) {
13. // Skip this window because it cannot possibly receive input.
14. continue;
15. }
16. final int flags = child.mAttrs.flags;
17. final int type = child.mAttrs.type;
18. final boolean hasFocus = (child == mInputFocus);
19. final boolean isVisible = child.isVisibleLw();
20. final boolean hasWallpaper = (child == mWallpaperTarget)
21. && (type != WindowManager.LayoutParams.TYPE_KEYGUARD);
22. // Add a window to our list of input windows.
23. final InputWindow inputWindow = mTempInputWindows.add();
24. inputWindow.inputChannel = child.mInputChannel;
25. inputWindow.name = child.toString();
26. inputWindow.layoutParamsFlags = flags;
27. inputWindow.layoutParamsType = type;
28. inputWindow.dispatchingTimeoutNanos = child.getInputDispatchingTimeoutNanos();
29. inputWindow.visible = isVisible;
30. inputWindow.canReceiveKeys = child.canReceiveKeys();
31. inputWindow.hasFocus = hasFocus;
32. inputWindow.hasWallpaper = hasWallpaper;
33. inputWindow.paused = child.mAppToken != null ? child.mAppToken.paused : false;
34. inputWindow.layer = child.mLayer;
35. inputWindow.ownerPid = child.mSession.mPid;
36. inputWindow.ownerUid = child.mSession.mUid;
37. final Rect frame = child.mFrame;
38. inputWindow.frameLeft = frame.left;
39. inputWindow.frameTop = frame.top;
40. inputWindow.frameRight = frame.right;
41. inputWindow.frameBottom = frame.bottom;
42. final Rect visibleFrame = child.mVisibleFrame;
43. inputWindow.visibleFrameLeft = visibleFrame.left;
44. inputWindow.visibleFrameTop = visibleFrame.top;
45. inputWindow.visibleFrameRight = visibleFrame.right;
46. inputWindow.visibleFrameBottom = visibleFrame.bottom;
47. switch (child.mTouchableInsets) {
48. default:
49. case ViewTreeObserver.InternalInsetsInfo.TOUCHABLE_INSETS_FRAME:
50. inputWindow.touchableAreaLeft = frame.left;
51. inputWindow.touchableAreaTop = frame.top;
52. inputWindow.touchableAreaRight = frame.right;
53. inputWindow.touchableAreaBottom = frame.bottom;
54. break;
55. case ViewTreeObserver.InternalInsetsInfo.TOUCHABLE_INSETS_CONTENT: {
56. Rect inset = child.mGivenContentInsets;
57. inputWindow.touchableAreaLeft = frame.left + inset.left;
58. inputWindow.touchableAreaTop = frame.top + inset.top;
59. inputWindow.touchableAreaRight = frame.right - inset.right;
60. inputWindow.touchableAreaBottom = frame.bottom - inset.bottom;
61. break;
62. }
63. case ViewTreeObserver.InternalInsetsInfo.TOUCHABLE_INSETS_VISIBLE: {
64. Rect inset = child.mGivenVisibleInsets;
65. inputWindow.touchableAreaLeft = frame.left + inset.left;
66. inputWindow.touchableAreaTop = frame.top + inset.top;
67. inputWindow.touchableAreaRight = frame.right - inset.right;
68. inputWindow.touchableAreaBottom = frame.bottom - inset.bottom;
69. break;
70. }
71. }
72. }
73. // Send windows to native code.
74. mInputManager.setInputWindows(mTempInputWindows.toNullTerminatedArray());
75. // Clear the list in preparation for the next round.
76. // Also avoids keeping InputChannel objects referenced unnecessarily.
77. mTempInputWindows.clear();
78. }

真正的Input的控制是通过以下方式

/**
     * Z-ordered (bottom-most first) list of all Window objects.
     */
    final ArrayList<WindowState> mWindows = new ArrayList<WindowState>();

1. /**
2. * Z-ordered (bottom-most first) list of all Window objects.
3. */
4. final ArrayList<WindowState> mWindows = new ArrayList<WindowState>();

另外的touch的target并不是通过input focus 获得的。而是通过visible来获得

1. int32_t InputDispatcher::findTouchedWindowTargetsLocked(nsecs_t currentTime,
2. const MotionEntry* entry, nsecs_t* nextWakeupTime) {
3. enum InjectionPermission {
4. INJECTION_PERMISSION_UNKNOWN,
5. INJECTION_PERMISSION_GRANTED,
6. INJECTION_PERMISSION_DENIED
7. };
8. mCurrentInputTargets.clear();
9. nsecs_t startTime = now();
10. // For security reasons, we defer updating the touch state until we are sure that
11. // event injection will be allowed.
12. //
13. // FIXME In the original code, screenWasOff could never be set to true.
14. //       The reason is that the POLICY_FLAG_WOKE_HERE
15. //       and POLICY_FLAG_BRIGHT_HERE flags were set only when preprocessing raw
16. //       EV_KEY, EV_REL and EV_ABS events.  As it happens, the touch event was
17. //       actually enqueued using the policyFlags that appeared in the final EV_SYN
18. //       events upon which no preprocessing took place.  So policyFlags was always 0.
19. //       In the new native input dispatcher we're a bit more careful about event
20. //       preprocessing so the touches we receive can actually have non-zero policyFlags.
21. //       Unfortunately we obtain undesirable behavior.
22. //
23. //       Here's what happens:
24. //
25. //       When the device dims in anticipation of going to sleep, touches
26. //       in windows which have FLAG_TOUCHABLE_WHEN_WAKING cause
27. //       the device to brighten and reset the user activity timer.
28. //       Touches on other windows (such as the launcher window)
29. //       are dropped.  Then after a moment, the device goes to sleep.  Oops.
30. //
31. //       Also notice how screenWasOff was being initialized using POLICY_FLAG_BRIGHT_HERE
32. //       instead of POLICY_FLAG_WOKE_HERE...
33. //
34. bool screenWasOff = false; // original policy: policyFlags & POLICY_FLAG_BRIGHT_HERE;
35. int32_t action = entry->action;
36. int32_t maskedAction = action & AMOTION_EVENT_ACTION_MASK;
37. // Update the touch state as needed based on the properties of the touch event.
38. int32_t injectionResult = INPUT_EVENT_INJECTION_PENDING;
39. InjectionPermission injectionPermission = INJECTION_PERMISSION_UNKNOWN;
40. if (maskedAction == AMOTION_EVENT_ACTION_DOWN) {
41. mTempTouchState.reset();
42. mTempTouchState.down = true;
43. } else {
44. mTempTouchState.copyFrom(mTouchState);
45. }
46. bool isSplit = mTempTouchState.split && mTempTouchState.down;
47. if (maskedAction == AMOTION_EVENT_ACTION_DOWN
48. || (isSplit && maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN)) {
49. /* Case 1: New splittable pointer going down. */
50. int32_t pointerIndex = getMotionEventActionPointerIndex(action);
51. int32_t x = int32_t(entry->firstSample.pointerCoords[pointerIndex].x);
52. int32_t y = int32_t(entry->firstSample.pointerCoords[pointerIndex].y);
53. const InputWindow* newTouchedWindow = NULL;
54. const InputWindow* topErrorWindow = NULL;
55. // Traverse windows from front to back to find touched window and outside targets.
56. size_t numWindows = mWindows.size();
57. for (size_t i = 0; i < numWindows; i++) {
58. const InputWindow* window = & mWindows.editItemAt(i);
59. int32_t flags = window->layoutParamsFlags;
60. if (flags & InputWindow::FLAG_SYSTEM_ERROR) {
61. if (! topErrorWindow) {
62. topErrorWindow = window;
63. }
64. }
65. if (window->visible) {
66. if (! (flags & InputWindow::FLAG_NOT_TOUCHABLE)) {
67. bool isTouchModal = (flags & (InputWindow::FLAG_NOT_FOCUSABLE
68. | InputWindow::FLAG_NOT_TOUCH_MODAL)) == 0;
69. if (isTouchModal || window->touchableAreaContainsPoint(x, y)) {
70. if (! screenWasOff || flags & InputWindow::FLAG_TOUCHABLE_WHEN_WAKING) {
71. newTouchedWindow = window;
72. }
73. break; // found touched window, exit window loop
74. }
75. }
76. if (maskedAction == AMOTION_EVENT_ACTION_DOWN
77. && (flags & InputWindow::FLAG_WATCH_OUTSIDE_TOUCH)) {
78. int32_t outsideTargetFlags = InputTarget::FLAG_OUTSIDE;
79. if (isWindowObscuredAtPointLocked(window, x, y)) {
80. outsideTargetFlags |= InputTarget::FLAG_WINDOW_IS_OBSCURED;
81. }
82. mTempTouchState.addOrUpdateWindow(window, outsideTargetFlags, BitSet32(0));
83. }
84. }
85. }
86. // If there is an error window but it is not taking focus (typically because
87. // it is invisible) then wait for it.  Any other focused window may in
88. // fact be in ANR state.
89. if (topErrorWindow && newTouchedWindow != topErrorWindow) {
90. #if DEBUG_FOCUS
91. LOGD("Waiting because system error window is pending.");
92. #endif
93. injectionResult = handleTargetsNotReadyLocked(currentTime, entry,
94. NULL, NULL, nextWakeupTime);
95. injectionPermission = INJECTION_PERMISSION_UNKNOWN;
96. goto Unresponsive;
97. }
98. // Figure out whether splitting will be allowed for this window.
99. if (newTouchedWindow
100. && (newTouchedWindow->layoutParamsFlags & InputWindow::FLAG_SPLIT_TOUCH)) {
101. // New window supports splitting.
102. isSplit = true;
103. } else if (isSplit) {
104. // New window does not support splitting but we have already split events.
105. // Assign the pointer to the first foreground window we find.
106. // (May be NULL which is why we put this code block before the next check.)
107. newTouchedWindow = mTempTouchState.getFirstForegroundWindow();
108. }
109. // If we did not find a touched window then fail.
110. if (! newTouchedWindow) {
111. if (mFocusedApplication) {
112. #if DEBUG_FOCUS
113. LOGD("Waiting because there is no touched window but there is a "
114. "focused application that may eventually add a new window: %s.",
115. getApplicationWindowLabelLocked(mFocusedApplication, NULL).string());
116. #endif
117. injectionResult = handleTargetsNotReadyLocked(currentTime, entry,
118. mFocusedApplication, NULL, nextWakeupTime);
119. goto Unresponsive;
120. }
121. LOGI("Dropping event because there is no touched window or focused application.");
122. injectionResult = INPUT_EVENT_INJECTION_FAILED;
123. goto Failed;
124. }
125. // Set target flags.
126. int32_t targetFlags = InputTarget::FLAG_FOREGROUND;
127. if (isSplit) {
128. targetFlags |= InputTarget::FLAG_SPLIT;
129. }
130. if (isWindowObscuredAtPointLocked(newTouchedWindow, x, y)) {
131. targetFlags |= InputTarget::FLAG_WINDOW_IS_OBSCURED;
132. }
133. // Update the temporary touch state.
134. BitSet32 pointerIds;
135. if (isSplit) {
136. uint32_t pointerId = entry->pointerIds[pointerIndex];
137. pointerIds.markBit(pointerId);
138. }
139. mTempTouchState.addOrUpdateWindow(newTouchedWindow, targetFlags, pointerIds);
140. } else {
141. /* Case 2: Pointer move, up, cancel or non-splittable pointer down. */
142. // If the pointer is not currently down, then ignore the event.
143. if (! mTempTouchState.down) {
144. LOGI("Dropping event because the pointer is not down.");
145. injectionResult = INPUT_EVENT_INJECTION_FAILED;
146. goto Failed;
147. }
148. }
149. // Check permission to inject into all touched foreground windows and ensure there
150. // is at least one touched foreground window.
151. {
152. bool haveForegroundWindow = false;
153. for (size_t i = 0; i < mTempTouchState.windows.size(); i++) {
154. const TouchedWindow& touchedWindow = mTempTouchState.windows[i];
155. if (touchedWindow.targetFlags & InputTarget::FLAG_FOREGROUND) {
156. haveForegroundWindow = true;
157. if (! checkInjectionPermission(touchedWindow.window, entry->injectionState)) {
158. injectionResult = INPUT_EVENT_INJECTION_PERMISSION_DENIED;
159. injectionPermission = INJECTION_PERMISSION_DENIED;
160. goto Failed;
161. }
162. }
163. }
164. if (! haveForegroundWindow) {
165. #if DEBUG_INPUT_DISPATCHER_POLICY
166. LOGD("Dropping event because there is no touched foreground window to receive it.");
167. #endif
168. injectionResult = INPUT_EVENT_INJECTION_FAILED;
169. goto Failed;
170. }
171. // Permission granted to injection into all touched foreground windows.
172. injectionPermission = INJECTION_PERMISSION_GRANTED;
173. }
174. // Ensure all touched foreground windows are ready for new input.
175. for (size_t i = 0; i < mTempTouchState.windows.size(); i++) {
176. const TouchedWindow& touchedWindow = mTempTouchState.windows[i];
177. if (touchedWindow.targetFlags & InputTarget::FLAG_FOREGROUND) {
178. // If the touched window is paused then keep waiting.
179. if (touchedWindow.window->paused) {
180. #if DEBUG_INPUT_DISPATCHER_POLICY
181. LOGD("Waiting because touched window is paused.");
182. #endif
183. injectionResult = handleTargetsNotReadyLocked(currentTime, entry,
184. NULL, touchedWindow.window, nextWakeupTime);
185. goto Unresponsive;
186. }
187. // If the touched window is still working on previous events then keep waiting.
188. if (! isWindowFinishedWithPreviousInputLocked(touchedWindow.window)) {
189. #if DEBUG_FOCUS
190. LOGD("Waiting because touched window still processing previous input.");
191. #endif
192. injectionResult = handleTargetsNotReadyLocked(currentTime, entry,
193. NULL, touchedWindow.window, nextWakeupTime);
194. goto Unresponsive;
195. }
196. }
197. }
198. // If this is the first pointer going down and the touched window has a wallpaper
199. // then also add the touched wallpaper windows so they are locked in for the duration
200. // of the touch gesture.
201. if (maskedAction == AMOTION_EVENT_ACTION_DOWN) {
202. const InputWindow* foregroundWindow = mTempTouchState.getFirstForegroundWindow();
203. if (foregroundWindow->hasWallpaper) {
204. for (size_t i = 0; i < mWindows.size(); i++) {
205. const InputWindow* window = & mWindows[i];
206. if (window->layoutParamsType == InputWindow::TYPE_WALLPAPER) {
207. mTempTouchState.addOrUpdateWindow(window,
208. InputTarget::FLAG_WINDOW_IS_OBSCURED, BitSet32(0));
209. }
210. }
211. }
212. }
213. // Success!  Output targets.
214. injectionResult = INPUT_EVENT_INJECTION_SUCCEEDED;
215. for (size_t i = 0; i < mTempTouchState.windows.size(); i++) {
216. const TouchedWindow& touchedWindow = mTempTouchState.windows.itemAt(i);
217. addWindowTargetLocked(touchedWindow.window, touchedWindow.targetFlags,
218. touchedWindow.pointerIds);
219. }
220. // Drop the outside touch window since we will not care about them in the next iteration.
221. mTempTouchState.removeOutsideTouchWindows();
222. Failed:
223. // Check injection permission once and for all.
224. if (injectionPermission == INJECTION_PERMISSION_UNKNOWN) {
225. if (checkInjectionPermission(NULL, entry->injectionState)) {
226. injectionPermission = INJECTION_PERMISSION_GRANTED;
227. } else {
228. injectionPermission = INJECTION_PERMISSION_DENIED;
229. }
230. }
231. // Update final pieces of touch state if the injector had permission.
232. if (injectionPermission == INJECTION_PERMISSION_GRANTED) {
233. if (maskedAction == AMOTION_EVENT_ACTION_UP
234. || maskedAction == AMOTION_EVENT_ACTION_CANCEL) {
235. // All pointers up or canceled.
236. mTempTouchState.reset();
237. } else if (maskedAction == AMOTION_EVENT_ACTION_DOWN) {
238. // First pointer went down.
239. if (mTouchState.down) {
240. #if DEBUG_FOCUS
241. LOGD("Pointer down received while already down.");
242. #endif
243. }
244. } else if (maskedAction == AMOTION_EVENT_ACTION_POINTER_UP) {
245. // One pointer went up.
246. if (isSplit) {
247. int32_t pointerIndex = getMotionEventActionPointerIndex(action);
248. uint32_t pointerId = entry->pointerIds[pointerIndex];
249. for (size_t i = 0; i < mTempTouchState.windows.size(); ) {
250. TouchedWindow& touchedWindow = mTempTouchState.windows.editItemAt(i);
251. if (touchedWindow.targetFlags & InputTarget::FLAG_SPLIT) {
252. touchedWindow.pointerIds.clearBit(pointerId);
253. if (touchedWindow.pointerIds.isEmpty()) {
254. mTempTouchState.windows.removeAt(i);
255. continue;
256. }
257. }
258. i += 1;
259. }
260. }
261. }
262. // Save changes to touch state.
263. mTouchState.copyFrom(mTempTouchState);
264. } else {
265. #if DEBUG_FOCUS
266. LOGD("Not updating touch focus because injection was denied.");
267. #endif
268. }
269. Unresponsive:
270. // Reset temporary touch state to ensure we release unnecessary references to input channels.
271. mTempTouchState.reset();
272. nsecs_t timeSpentWaitingForApplication = getTimeSpentWaitingForApplicationLocked(currentTime);
273. updateDispatchStatisticsLocked(currentTime, entry,
274. injectionResult, timeSpentWaitingForApplication);
275. #if DEBUG_FOCUS
276. LOGD("findTouchedWindow finished: injectionResult=%d, injectionPermission=%d, "
277. "timeSpentWaitingForApplication=%0.1fms",
278. injectionResult, injectionPermission, timeSpentWaitingForApplication / 1000000.0);
279. #endif
280. return injectionResult;
281. }

最关键的几行代码，说明了Windows是如何找到触屏的输入焦点的：

1. if (window->visible) {
2. if (! (flags & InputWindow::FLAG_NOT_TOUCHABLE)) {
3. bool isTouchModal = (flags & (InputWindow::FLAG_NOT_FOCUSABLE
4. | InputWindow::FLAG_NOT_TOUCH_MODAL)) == 0;
5. if (isTouchModal || window->touchableAreaContainsPoint(x, y)) {
6. if (! screenWasOff || flags & InputWindow::FLAG_TOUCHABLE_WHEN_WAKING) {
7. newTouchedWindow = window;
8. }
9. break; // found touched window, exit window loop
10. }
11. }
12. if (maskedAction == AMOTION_EVENT_ACTION_DOWN
13. && (flags & InputWindow::FLAG_WATCH_OUTSIDE_TOUCH)) {
14. int32_t outsideTargetFlags = InputTarget::FLAG_OUTSIDE;
15. if (isWindowObscuredAtPointLocked(window, x, y)) {
16. outsideTargetFlags |= InputTarget::FLAG_WINDOW_IS_OBSCURED;
17. }
18. mTempTouchState.addOrUpdateWindow(window, outsideTargetFlags, BitSet32(0));
19. }
20. }

1. // Focus tracking for touch.
2. struct TouchedWindow {
3. const InputWindow* window;
4. int32_t targetFlags;
5. BitSet32 pointerIds;
6. sp<InputChannel> channel;
7. };
8. struct TouchState {
9. bool down;
10. bool split;
11. Vector<TouchedWindow> windows;
12. TouchState();
13. ~TouchState();
14. void reset();
15. void copyFrom(const TouchState& other);
16. void addOrUpdateWindow(const InputWindow* window, int32_t targetFlags, BitSet32 pointerIds);
17. void removeOutsideTouchWindows();
18. const InputWindow* getFirstForegroundWindow();
19. };
20. 另外如何定义按键和其他触屏焦点的：
21. /* Updates the cached window information provided to the input dispatcher. */
22. public void updateInputWindowsLw() {
23. // Populate the input window list with information about all of the windows that
24. // could potentially receive input.
25. // As an optimization, we could try to prune the list of windows but this turns
26. // out to be difficult because only the native code knows for sure which window
27. // currently has touch focus.
28. final ArrayList<WindowState> windows = mWindows;
29. final int N = windows.size();
30. for (int i = N - 1; i >= 0; i--) {
31. final WindowState child = windows.get(i);
32. if (child.mInputChannel == null || child.mRemoved) {
33. // Skip this window because it cannot possibly receive input.
34. continue;
35. }
36. final int flags = child.mAttrs.flags;
37. final int type = child.mAttrs.type;
38. <span style="color: #ff6600;"> final boolean hasFocus = (child == mInputFocus);</span>
39. //本行代码确定，一次性的focusWindow只有一个。
40. final boolean isVisible = child.isVisibleLw();
41. final boolean hasWallpaper = (child == mWallpaperTarget)
42. && (type != WindowManager.LayoutParams.TYPE_KEYGUARD);