blob: 2011551c38eda469e3d418c87e4912765d257417 [file] [log] [blame]
Michael Wrightd02c5b62014-02-10 15:10:22 -08001/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "InputDispatcher"
18#define ATRACE_TAG ATRACE_TAG_INPUT
19
John Recke0710582019-09-26 13:46:12 -070020#define LOG_NDEBUG 1
Michael Wrightd02c5b62014-02-10 15:10:22 -080021
22// Log detailed debug messages about each inbound event notification to the dispatcher.
23#define DEBUG_INBOUND_EVENT_DETAILS 0
24
25// Log detailed debug messages about each outbound event processed by the dispatcher.
26#define DEBUG_OUTBOUND_EVENT_DETAILS 0
27
28// Log debug messages about the dispatch cycle.
29#define DEBUG_DISPATCH_CYCLE 0
30
31// Log debug messages about registrations.
32#define DEBUG_REGISTRATION 0
33
34// Log debug messages about input event injection.
35#define DEBUG_INJECTION 0
36
37// Log debug messages about input focus tracking.
Siarhei Vishniakou86587282019-09-09 18:20:15 +010038static constexpr bool DEBUG_FOCUS = false;
Michael Wrightd02c5b62014-02-10 15:10:22 -080039
40// Log debug messages about the app switch latency optimization.
41#define DEBUG_APP_SWITCH 0
42
43// Log debug messages about hover events.
44#define DEBUG_HOVER 0
45
46#include "InputDispatcher.h"
47
Garfield Tane84e6f92019-08-29 17:28:41 -070048#include "Connection.h"
49
Michael Wrightd02c5b62014-02-10 15:10:22 -080050#include <errno.h>
Siarhei Vishniakou443ad902019-03-06 17:25:41 -080051#include <inttypes.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080052#include <limits.h>
Siarhei Vishniakoude4bf152019-08-16 11:12:52 -050053#include <statslog.h>
Mark Salyzyna5e161b2016-09-29 08:08:05 -070054#include <stddef.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080055#include <time.h>
Mark Salyzyna5e161b2016-09-29 08:08:05 -070056#include <unistd.h>
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -070057#include <queue>
58#include <sstream>
Mark Salyzyna5e161b2016-09-29 08:08:05 -070059
Michael Wright2b3c3302018-03-02 17:19:13 +000060#include <android-base/chrono_utils.h>
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -080061#include <android-base/stringprintf.h>
Robert Carr4e670e52018-08-15 13:26:12 -070062#include <binder/Binder.h>
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -080063#include <input/InputDevice.h>
Garfield Tan0fc2fa72019-08-29 17:22:15 -070064#include <log/log.h>
Gang Wang342c9272020-01-13 13:15:04 -050065#include <openssl/hmac.h>
66#include <openssl/rand.h>
Garfield Tan0fc2fa72019-08-29 17:22:15 -070067#include <powermanager/PowerManager.h>
68#include <utils/Trace.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080069
70#define INDENT " "
71#define INDENT2 " "
72#define INDENT3 " "
73#define INDENT4 " "
74
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -080075using android::base::StringPrintf;
76
Garfield Tane84e6f92019-08-29 17:28:41 -070077namespace android::inputdispatcher {
Michael Wrightd02c5b62014-02-10 15:10:22 -080078
79// Default input dispatching timeout if there is no focused application or paused window
80// from which to determine an appropriate dispatching timeout.
Michael Wright2b3c3302018-03-02 17:19:13 +000081constexpr nsecs_t DEFAULT_INPUT_DISPATCHING_TIMEOUT = 5000 * 1000000LL; // 5 sec
Michael Wrightd02c5b62014-02-10 15:10:22 -080082
83// Amount of time to allow for all pending events to be processed when an app switch
84// key is on the way. This is used to preempt input dispatch and drop input events
85// when an application takes too long to respond and the user has pressed an app switch key.
Michael Wright2b3c3302018-03-02 17:19:13 +000086constexpr nsecs_t APP_SWITCH_TIMEOUT = 500 * 1000000LL; // 0.5sec
Michael Wrightd02c5b62014-02-10 15:10:22 -080087
88// Amount of time to allow for an event to be dispatched (measured since its eventTime)
89// before considering it stale and dropping it.
Michael Wright2b3c3302018-03-02 17:19:13 +000090constexpr nsecs_t STALE_EVENT_TIMEOUT = 10000 * 1000000LL; // 10sec
Michael Wrightd02c5b62014-02-10 15:10:22 -080091
92// Amount of time to allow touch events to be streamed out to a connection before requiring
93// that the first event be finished. This value extends the ANR timeout by the specified
94// amount. For example, if streaming is allowed to get ahead by one second relative to the
95// queue of waiting unfinished events, then ANRs will similarly be delayed by one second.
Michael Wright2b3c3302018-03-02 17:19:13 +000096constexpr nsecs_t STREAM_AHEAD_EVENT_TIMEOUT = 500 * 1000000LL; // 0.5sec
Michael Wrightd02c5b62014-02-10 15:10:22 -080097
98// Log a warning when an event takes longer than this to process, even if an ANR does not occur.
Michael Wright2b3c3302018-03-02 17:19:13 +000099constexpr nsecs_t SLOW_EVENT_PROCESSING_WARNING_TIMEOUT = 2000 * 1000000LL; // 2sec
100
101// Log a warning when an interception call takes longer than this to process.
102constexpr std::chrono::milliseconds SLOW_INTERCEPTION_THRESHOLD = 50ms;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800103
104// Number of recent events to keep for debugging purposes.
Michael Wright2b3c3302018-03-02 17:19:13 +0000105constexpr size_t RECENT_QUEUE_MAX_SIZE = 10;
106
Michael Wrightd02c5b62014-02-10 15:10:22 -0800107static inline nsecs_t now() {
108 return systemTime(SYSTEM_TIME_MONOTONIC);
109}
110
111static inline const char* toString(bool value) {
112 return value ? "true" : "false";
113}
114
115static inline int32_t getMotionEventActionPointerIndex(int32_t action) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700116 return (action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >>
117 AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800118}
119
120static bool isValidKeyAction(int32_t action) {
121 switch (action) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700122 case AKEY_EVENT_ACTION_DOWN:
123 case AKEY_EVENT_ACTION_UP:
124 return true;
125 default:
126 return false;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800127 }
128}
129
130static bool validateKeyEvent(int32_t action) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700131 if (!isValidKeyAction(action)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800132 ALOGE("Key event has invalid action code 0x%x", action);
133 return false;
134 }
135 return true;
136}
137
Michael Wright7b159c92015-05-14 14:48:03 +0100138static bool isValidMotionAction(int32_t action, int32_t actionButton, int32_t pointerCount) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800139 switch (action & AMOTION_EVENT_ACTION_MASK) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700140 case AMOTION_EVENT_ACTION_DOWN:
141 case AMOTION_EVENT_ACTION_UP:
142 case AMOTION_EVENT_ACTION_CANCEL:
143 case AMOTION_EVENT_ACTION_MOVE:
144 case AMOTION_EVENT_ACTION_OUTSIDE:
145 case AMOTION_EVENT_ACTION_HOVER_ENTER:
146 case AMOTION_EVENT_ACTION_HOVER_MOVE:
147 case AMOTION_EVENT_ACTION_HOVER_EXIT:
148 case AMOTION_EVENT_ACTION_SCROLL:
149 return true;
150 case AMOTION_EVENT_ACTION_POINTER_DOWN:
151 case AMOTION_EVENT_ACTION_POINTER_UP: {
152 int32_t index = getMotionEventActionPointerIndex(action);
153 return index >= 0 && index < pointerCount;
154 }
155 case AMOTION_EVENT_ACTION_BUTTON_PRESS:
156 case AMOTION_EVENT_ACTION_BUTTON_RELEASE:
157 return actionButton != 0;
158 default:
159 return false;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800160 }
161}
162
Michael Wright7b159c92015-05-14 14:48:03 +0100163static bool validateMotionEvent(int32_t action, int32_t actionButton, size_t pointerCount,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700164 const PointerProperties* pointerProperties) {
165 if (!isValidMotionAction(action, actionButton, pointerCount)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800166 ALOGE("Motion event has invalid action code 0x%x", action);
167 return false;
168 }
169 if (pointerCount < 1 || pointerCount > MAX_POINTERS) {
Narayan Kamath37764c72014-03-27 14:21:09 +0000170 ALOGE("Motion event has invalid pointer count %zu; value must be between 1 and %d.",
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700171 pointerCount, MAX_POINTERS);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800172 return false;
173 }
174 BitSet32 pointerIdBits;
175 for (size_t i = 0; i < pointerCount; i++) {
176 int32_t id = pointerProperties[i].id;
177 if (id < 0 || id > MAX_POINTER_ID) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700178 ALOGE("Motion event has invalid pointer id %d; value must be between 0 and %d", id,
179 MAX_POINTER_ID);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800180 return false;
181 }
182 if (pointerIdBits.hasBit(id)) {
183 ALOGE("Motion event has duplicate pointer id %d", id);
184 return false;
185 }
186 pointerIdBits.markBit(id);
187 }
188 return true;
189}
190
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -0800191static void dumpRegion(std::string& dump, const Region& region) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800192 if (region.isEmpty()) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -0800193 dump += "<empty>";
Michael Wrightd02c5b62014-02-10 15:10:22 -0800194 return;
195 }
196
197 bool first = true;
198 Region::const_iterator cur = region.begin();
199 Region::const_iterator const tail = region.end();
200 while (cur != tail) {
201 if (first) {
202 first = false;
203 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -0800204 dump += "|";
Michael Wrightd02c5b62014-02-10 15:10:22 -0800205 }
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -0800206 dump += StringPrintf("[%d,%d][%d,%d]", cur->left, cur->top, cur->right, cur->bottom);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800207 cur++;
208 }
209}
210
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -0700211/**
212 * Find the entry in std::unordered_map by key, and return it.
213 * If the entry is not found, return a default constructed entry.
214 *
215 * Useful when the entries are vectors, since an empty vector will be returned
216 * if the entry is not found.
217 * Also useful when the entries are sp<>. If an entry is not found, nullptr is returned.
218 */
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -0700219template <typename K, typename V>
220static V getValueByKey(const std::unordered_map<K, V>& map, K key) {
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -0700221 auto it = map.find(key);
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -0700222 return it != map.end() ? it->second : V{};
Tiger Huang721e26f2018-07-24 22:26:19 +0800223}
224
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -0700225/**
226 * Find the entry in std::unordered_map by value, and remove it.
227 * If more than one entry has the same value, then all matching
228 * key-value pairs will be removed.
229 *
230 * Return true if at least one value has been removed.
231 */
232template <typename K, typename V>
233static bool removeByValue(std::unordered_map<K, V>& map, const V& value) {
234 bool removed = false;
235 for (auto it = map.begin(); it != map.end();) {
236 if (it->second == value) {
237 it = map.erase(it);
238 removed = true;
239 } else {
240 it++;
241 }
242 }
243 return removed;
244}
Michael Wrightd02c5b62014-02-10 15:10:22 -0800245
chaviwaf87b3e2019-10-01 16:59:28 -0700246static bool haveSameToken(const sp<InputWindowHandle>& first, const sp<InputWindowHandle>& second) {
247 if (first == second) {
248 return true;
249 }
250
251 if (first == nullptr || second == nullptr) {
252 return false;
253 }
254
255 return first->getToken() == second->getToken();
256}
257
Siarhei Vishniakouadfd4fa2019-12-20 11:02:58 -0800258static bool isStaleEvent(nsecs_t currentTime, const EventEntry& entry) {
259 return currentTime - entry.eventTime >= STALE_EVENT_TIMEOUT;
260}
261
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000262static std::unique_ptr<DispatchEntry> createDispatchEntry(const InputTarget& inputTarget,
263 EventEntry* eventEntry,
264 int32_t inputTargetFlags) {
265 if (inputTarget.useDefaultPointerInfo()) {
266 const PointerInfo& pointerInfo = inputTarget.getDefaultPointerInfo();
267 return std::make_unique<DispatchEntry>(eventEntry, // increments ref
268 inputTargetFlags, pointerInfo.xOffset,
269 pointerInfo.yOffset, inputTarget.globalScaleFactor,
270 pointerInfo.windowXScale, pointerInfo.windowYScale);
271 }
272
273 ALOG_ASSERT(eventEntry->type == EventEntry::Type::MOTION);
274 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(*eventEntry);
275
276 PointerCoords pointerCoords[motionEntry.pointerCount];
277
278 // Use the first pointer information to normalize all other pointers. This could be any pointer
279 // as long as all other pointers are normalized to the same value and the final DispatchEntry
280 // uses the offset and scale for the normalized pointer.
281 const PointerInfo& firstPointerInfo =
282 inputTarget.pointerInfos[inputTarget.pointerIds.firstMarkedBit()];
283
284 // Iterate through all pointers in the event to normalize against the first.
285 for (uint32_t pointerIndex = 0; pointerIndex < motionEntry.pointerCount; pointerIndex++) {
286 const PointerProperties& pointerProperties = motionEntry.pointerProperties[pointerIndex];
287 uint32_t pointerId = uint32_t(pointerProperties.id);
288 const PointerInfo& currPointerInfo = inputTarget.pointerInfos[pointerId];
289
290 // The scale factor is the ratio of the current pointers scale to the normalized scale.
291 float scaleXDiff = currPointerInfo.windowXScale / firstPointerInfo.windowXScale;
292 float scaleYDiff = currPointerInfo.windowYScale / firstPointerInfo.windowYScale;
293
294 pointerCoords[pointerIndex].copyFrom(motionEntry.pointerCoords[pointerIndex]);
295 // First apply the current pointers offset to set the window at 0,0
296 pointerCoords[pointerIndex].applyOffset(currPointerInfo.xOffset, currPointerInfo.yOffset);
297 // Next scale the coordinates.
298 pointerCoords[pointerIndex].scale(1, scaleXDiff, scaleYDiff);
299 // Lastly, offset the coordinates so they're in the normalized pointer's frame.
300 pointerCoords[pointerIndex].applyOffset(-firstPointerInfo.xOffset,
301 -firstPointerInfo.yOffset);
302 }
303
304 MotionEntry* combinedMotionEntry =
Garfield Tanc51d1ba2020-01-28 13:24:04 -0800305 new MotionEntry(motionEntry.id, motionEntry.eventTime, motionEntry.deviceId,
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000306 motionEntry.source, motionEntry.displayId, motionEntry.policyFlags,
307 motionEntry.action, motionEntry.actionButton, motionEntry.flags,
308 motionEntry.metaState, motionEntry.buttonState,
309 motionEntry.classification, motionEntry.edgeFlags,
310 motionEntry.xPrecision, motionEntry.yPrecision,
311 motionEntry.xCursorPosition, motionEntry.yCursorPosition,
312 motionEntry.downTime, motionEntry.pointerCount,
313 motionEntry.pointerProperties, pointerCoords, 0 /* xOffset */,
314 0 /* yOffset */);
315
316 if (motionEntry.injectionState) {
317 combinedMotionEntry->injectionState = motionEntry.injectionState;
318 combinedMotionEntry->injectionState->refCount += 1;
319 }
320
321 std::unique_ptr<DispatchEntry> dispatchEntry =
322 std::make_unique<DispatchEntry>(combinedMotionEntry, // increments ref
323 inputTargetFlags, firstPointerInfo.xOffset,
324 firstPointerInfo.yOffset, inputTarget.globalScaleFactor,
325 firstPointerInfo.windowXScale,
326 firstPointerInfo.windowYScale);
327 combinedMotionEntry->release();
328 return dispatchEntry;
329}
330
Gang Wang342c9272020-01-13 13:15:04 -0500331static std::array<uint8_t, 128> getRandomKey() {
332 std::array<uint8_t, 128> key;
333 if (RAND_bytes(key.data(), key.size()) != 1) {
334 LOG_ALWAYS_FATAL("Can't generate HMAC key");
335 }
336 return key;
337}
338
339// --- HmacKeyManager ---
340
341HmacKeyManager::HmacKeyManager() : mHmacKey(getRandomKey()) {}
342
343std::array<uint8_t, 32> HmacKeyManager::sign(const VerifiedInputEvent& event) const {
344 size_t size;
345 switch (event.type) {
346 case VerifiedInputEvent::Type::KEY: {
347 size = sizeof(VerifiedKeyEvent);
348 break;
349 }
350 case VerifiedInputEvent::Type::MOTION: {
351 size = sizeof(VerifiedMotionEvent);
352 break;
353 }
354 }
Gang Wang342c9272020-01-13 13:15:04 -0500355 const uint8_t* start = reinterpret_cast<const uint8_t*>(&event);
Edgar Arriaga3d61bc12020-04-16 18:46:48 -0700356 return sign(start, size);
Gang Wang342c9272020-01-13 13:15:04 -0500357}
358
Edgar Arriaga3d61bc12020-04-16 18:46:48 -0700359std::array<uint8_t, 32> HmacKeyManager::sign(const uint8_t* data, size_t size) const {
Gang Wang342c9272020-01-13 13:15:04 -0500360 // SHA256 always generates 32-bytes result
361 std::array<uint8_t, 32> hash;
362 unsigned int hashLen = 0;
Edgar Arriaga3d61bc12020-04-16 18:46:48 -0700363 uint8_t* result =
364 HMAC(EVP_sha256(), mHmacKey.data(), mHmacKey.size(), data, size, hash.data(), &hashLen);
Gang Wang342c9272020-01-13 13:15:04 -0500365 if (result == nullptr) {
366 ALOGE("Could not sign the data using HMAC");
367 return INVALID_HMAC;
368 }
369
370 if (hashLen != hash.size()) {
371 ALOGE("HMAC-SHA256 has unexpected length");
372 return INVALID_HMAC;
373 }
374
375 return hash;
376}
377
Michael Wrightd02c5b62014-02-10 15:10:22 -0800378// --- InputDispatcher ---
379
Garfield Tan00f511d2019-06-12 16:55:40 -0700380InputDispatcher::InputDispatcher(const sp<InputDispatcherPolicyInterface>& policy)
381 : mPolicy(policy),
382 mPendingEvent(nullptr),
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700383 mLastDropReason(DropReason::NOT_DROPPED),
Garfield Tan1c7bc862020-01-28 13:24:04 -0800384 mIdGenerator(IdGenerator::Source::INPUT_DISPATCHER),
Garfield Tan00f511d2019-06-12 16:55:40 -0700385 mAppSwitchSawKeyDown(false),
386 mAppSwitchDueTime(LONG_LONG_MAX),
387 mNextUnblockedEvent(nullptr),
388 mDispatchEnabled(false),
389 mDispatchFrozen(false),
390 mInputFilterEnabled(false),
Siarhei Vishniakouf3bc1aa2019-11-25 13:48:53 -0800391 // mInTouchMode will be initialized by the WindowManager to the default device config.
392 // To avoid leaking stack in case that call never comes, and for tests,
393 // initialize it here anyways.
394 mInTouchMode(true),
Garfield Tan00f511d2019-06-12 16:55:40 -0700395 mFocusedDisplayId(ADISPLAY_ID_DEFAULT),
396 mInputTargetWaitCause(INPUT_TARGET_WAIT_CAUSE_NONE) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800397 mLooper = new Looper(false);
Prabir Pradhanf93562f2018-11-29 12:13:37 -0800398 mReporter = createInputReporter();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800399
Yi Kong9b14ac62018-07-17 13:48:38 -0700400 mKeyRepeatState.lastKeyEntry = nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800401
402 policy->getDispatcherConfiguration(&mConfig);
403}
404
405InputDispatcher::~InputDispatcher() {
406 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -0800407 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800408
409 resetKeyRepeatLocked();
410 releasePendingEventLocked();
411 drainInboundQueueLocked();
412 }
413
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -0700414 while (!mConnectionsByFd.empty()) {
415 sp<Connection> connection = mConnectionsByFd.begin()->second;
416 unregisterInputChannel(connection->inputChannel);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800417 }
418}
419
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700420status_t InputDispatcher::start() {
Prabir Pradhan5a57cff2019-10-31 18:40:33 -0700421 if (mThread) {
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700422 return ALREADY_EXISTS;
423 }
Prabir Pradhan5a57cff2019-10-31 18:40:33 -0700424 mThread = std::make_unique<InputThread>(
425 "InputDispatcher", [this]() { dispatchOnce(); }, [this]() { mLooper->wake(); });
426 return OK;
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700427}
428
429status_t InputDispatcher::stop() {
Prabir Pradhan5a57cff2019-10-31 18:40:33 -0700430 if (mThread && mThread->isCallingThread()) {
431 ALOGE("InputDispatcher cannot be stopped from its own thread!");
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700432 return INVALID_OPERATION;
433 }
Prabir Pradhan5a57cff2019-10-31 18:40:33 -0700434 mThread.reset();
435 return OK;
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700436}
437
Michael Wrightd02c5b62014-02-10 15:10:22 -0800438void InputDispatcher::dispatchOnce() {
439 nsecs_t nextWakeupTime = LONG_LONG_MAX;
440 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -0800441 std::scoped_lock _l(mLock);
442 mDispatcherIsAlive.notify_all();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800443
444 // Run a dispatch loop if there are no pending commands.
445 // The dispatch loop might enqueue commands to run afterwards.
446 if (!haveCommandsLocked()) {
447 dispatchOnceInnerLocked(&nextWakeupTime);
448 }
449
450 // Run all pending commands if there are any.
451 // If any commands were run then force the next poll to wake up immediately.
452 if (runCommandsLockedInterruptible()) {
453 nextWakeupTime = LONG_LONG_MIN;
454 }
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -0800455
456 // We are about to enter an infinitely long sleep, because we have no commands or
457 // pending or queued events
458 if (nextWakeupTime == LONG_LONG_MAX) {
459 mDispatcherEnteredIdle.notify_all();
460 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800461 } // release lock
462
463 // Wait for callback or timeout or wake. (make sure we round up, not down)
464 nsecs_t currentTime = now();
465 int timeoutMillis = toMillisecondTimeoutDelay(currentTime, nextWakeupTime);
466 mLooper->pollOnce(timeoutMillis);
467}
468
469void InputDispatcher::dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) {
470 nsecs_t currentTime = now();
471
Jeff Browndc5992e2014-04-11 01:27:26 -0700472 // Reset the key repeat timer whenever normal dispatch is suspended while the
473 // device is in a non-interactive state. This is to ensure that we abort a key
474 // repeat if the device is just coming out of sleep.
475 if (!mDispatchEnabled) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800476 resetKeyRepeatLocked();
477 }
478
479 // If dispatching is frozen, do not process timeouts or try to deliver any new events.
480 if (mDispatchFrozen) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +0100481 if (DEBUG_FOCUS) {
482 ALOGD("Dispatch frozen. Waiting some more.");
483 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800484 return;
485 }
486
487 // Optimize latency of app switches.
488 // Essentially we start a short timeout when an app switch key (HOME / ENDCALL) has
489 // been pressed. When it expires, we preempt dispatch and drop all other pending events.
490 bool isAppSwitchDue = mAppSwitchDueTime <= currentTime;
491 if (mAppSwitchDueTime < *nextWakeupTime) {
492 *nextWakeupTime = mAppSwitchDueTime;
493 }
494
495 // Ready to start a new event.
496 // If we don't already have a pending event, go grab one.
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700497 if (!mPendingEvent) {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -0700498 if (mInboundQueue.empty()) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800499 if (isAppSwitchDue) {
500 // The inbound queue is empty so the app switch key we were waiting
501 // for will never arrive. Stop waiting for it.
502 resetPendingAppSwitchLocked(false);
503 isAppSwitchDue = false;
504 }
505
506 // Synthesize a key repeat if appropriate.
507 if (mKeyRepeatState.lastKeyEntry) {
508 if (currentTime >= mKeyRepeatState.nextRepeatTime) {
509 mPendingEvent = synthesizeKeyRepeatLocked(currentTime);
510 } else {
511 if (mKeyRepeatState.nextRepeatTime < *nextWakeupTime) {
512 *nextWakeupTime = mKeyRepeatState.nextRepeatTime;
513 }
514 }
515 }
516
517 // Nothing to do if there is no pending event.
518 if (!mPendingEvent) {
519 return;
520 }
521 } else {
522 // Inbound queue has at least one entry.
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -0700523 mPendingEvent = mInboundQueue.front();
524 mInboundQueue.pop_front();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800525 traceInboundQueueLengthLocked();
526 }
527
528 // Poke user activity for this event.
529 if (mPendingEvent->policyFlags & POLICY_FLAG_PASS_TO_USER) {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700530 pokeUserActivityLocked(*mPendingEvent);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800531 }
532
533 // Get ready to dispatch the event.
534 resetANRTimeoutsLocked();
535 }
536
537 // Now we have an event to dispatch.
538 // All events are eventually dequeued and processed this way, even if we intend to drop them.
Yi Kong9b14ac62018-07-17 13:48:38 -0700539 ALOG_ASSERT(mPendingEvent != nullptr);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800540 bool done = false;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700541 DropReason dropReason = DropReason::NOT_DROPPED;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800542 if (!(mPendingEvent->policyFlags & POLICY_FLAG_PASS_TO_USER)) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700543 dropReason = DropReason::POLICY;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800544 } else if (!mDispatchEnabled) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700545 dropReason = DropReason::DISABLED;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800546 }
547
548 if (mNextUnblockedEvent == mPendingEvent) {
Yi Kong9b14ac62018-07-17 13:48:38 -0700549 mNextUnblockedEvent = nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800550 }
551
552 switch (mPendingEvent->type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -0700553 case EventEntry::Type::CONFIGURATION_CHANGED: {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700554 ConfigurationChangedEntry* typedEntry =
555 static_cast<ConfigurationChangedEntry*>(mPendingEvent);
556 done = dispatchConfigurationChangedLocked(currentTime, typedEntry);
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700557 dropReason = DropReason::NOT_DROPPED; // configuration changes are never dropped
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700558 break;
559 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800560
Siarhei Vishniakou49483272019-10-22 13:13:47 -0700561 case EventEntry::Type::DEVICE_RESET: {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700562 DeviceResetEntry* typedEntry = static_cast<DeviceResetEntry*>(mPendingEvent);
563 done = dispatchDeviceResetLocked(currentTime, typedEntry);
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700564 dropReason = DropReason::NOT_DROPPED; // device resets are never dropped
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700565 break;
566 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800567
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +0100568 case EventEntry::Type::FOCUS: {
569 FocusEntry* typedEntry = static_cast<FocusEntry*>(mPendingEvent);
570 dispatchFocusLocked(currentTime, typedEntry);
571 done = true;
572 dropReason = DropReason::NOT_DROPPED; // focus events are never dropped
573 break;
574 }
575
Siarhei Vishniakou49483272019-10-22 13:13:47 -0700576 case EventEntry::Type::KEY: {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700577 KeyEntry* typedEntry = static_cast<KeyEntry*>(mPendingEvent);
578 if (isAppSwitchDue) {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700579 if (isAppSwitchKeyEvent(*typedEntry)) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700580 resetPendingAppSwitchLocked(true);
581 isAppSwitchDue = false;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700582 } else if (dropReason == DropReason::NOT_DROPPED) {
583 dropReason = DropReason::APP_SWITCH;
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700584 }
585 }
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700586 if (dropReason == DropReason::NOT_DROPPED && isStaleEvent(currentTime, *typedEntry)) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700587 dropReason = DropReason::STALE;
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700588 }
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700589 if (dropReason == DropReason::NOT_DROPPED && mNextUnblockedEvent) {
590 dropReason = DropReason::BLOCKED;
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700591 }
592 done = dispatchKeyLocked(currentTime, typedEntry, &dropReason, nextWakeupTime);
593 break;
594 }
595
Siarhei Vishniakou49483272019-10-22 13:13:47 -0700596 case EventEntry::Type::MOTION: {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700597 MotionEntry* typedEntry = static_cast<MotionEntry*>(mPendingEvent);
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700598 if (dropReason == DropReason::NOT_DROPPED && isAppSwitchDue) {
599 dropReason = DropReason::APP_SWITCH;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800600 }
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700601 if (dropReason == DropReason::NOT_DROPPED && isStaleEvent(currentTime, *typedEntry)) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700602 dropReason = DropReason::STALE;
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700603 }
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700604 if (dropReason == DropReason::NOT_DROPPED && mNextUnblockedEvent) {
605 dropReason = DropReason::BLOCKED;
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700606 }
607 done = dispatchMotionLocked(currentTime, typedEntry, &dropReason, nextWakeupTime);
608 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800609 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800610 }
611
612 if (done) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700613 if (dropReason != DropReason::NOT_DROPPED) {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700614 dropInboundEventLocked(*mPendingEvent, dropReason);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800615 }
Michael Wright3a981722015-06-10 15:26:13 +0100616 mLastDropReason = dropReason;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800617
618 releasePendingEventLocked();
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700619 *nextWakeupTime = LONG_LONG_MIN; // force next poll to wake up immediately
Michael Wrightd02c5b62014-02-10 15:10:22 -0800620 }
621}
622
623bool InputDispatcher::enqueueInboundEventLocked(EventEntry* entry) {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -0700624 bool needWake = mInboundQueue.empty();
625 mInboundQueue.push_back(entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800626 traceInboundQueueLengthLocked();
627
628 switch (entry->type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -0700629 case EventEntry::Type::KEY: {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700630 // Optimize app switch latency.
631 // If the application takes too long to catch up then we drop all events preceding
632 // the app switch key.
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700633 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(*entry);
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700634 if (isAppSwitchKeyEvent(keyEntry)) {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700635 if (keyEntry.action == AKEY_EVENT_ACTION_DOWN) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700636 mAppSwitchSawKeyDown = true;
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700637 } else if (keyEntry.action == AKEY_EVENT_ACTION_UP) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700638 if (mAppSwitchSawKeyDown) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800639#if DEBUG_APP_SWITCH
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700640 ALOGD("App switch is pending!");
Michael Wrightd02c5b62014-02-10 15:10:22 -0800641#endif
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700642 mAppSwitchDueTime = keyEntry.eventTime + APP_SWITCH_TIMEOUT;
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700643 mAppSwitchSawKeyDown = false;
644 needWake = true;
645 }
646 }
647 }
648 break;
649 }
650
Siarhei Vishniakou49483272019-10-22 13:13:47 -0700651 case EventEntry::Type::MOTION: {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700652 // Optimize case where the current application is unresponsive and the user
653 // decides to touch a window in a different application.
654 // If the application takes too long to catch up then we drop all events preceding
655 // the touch into the other window.
656 MotionEntry* motionEntry = static_cast<MotionEntry*>(entry);
657 if (motionEntry->action == AMOTION_EVENT_ACTION_DOWN &&
658 (motionEntry->source & AINPUT_SOURCE_CLASS_POINTER) &&
659 mInputTargetWaitCause == INPUT_TARGET_WAIT_CAUSE_APPLICATION_NOT_READY &&
660 mInputTargetWaitApplicationToken != nullptr) {
661 int32_t displayId = motionEntry->displayId;
662 int32_t x =
663 int32_t(motionEntry->pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X));
664 int32_t y =
665 int32_t(motionEntry->pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y));
666 sp<InputWindowHandle> touchedWindowHandle =
667 findTouchedWindowAtLocked(displayId, x, y);
668 if (touchedWindowHandle != nullptr &&
669 touchedWindowHandle->getApplicationToken() !=
670 mInputTargetWaitApplicationToken) {
671 // User touched a different application than the one we are waiting on.
672 // Flag the event, and start pruning the input queue.
673 mNextUnblockedEvent = motionEntry;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800674 needWake = true;
675 }
676 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700677 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800678 }
Siarhei Vishniakou49483272019-10-22 13:13:47 -0700679 case EventEntry::Type::CONFIGURATION_CHANGED:
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +0100680 case EventEntry::Type::DEVICE_RESET:
681 case EventEntry::Type::FOCUS: {
Siarhei Vishniakou49483272019-10-22 13:13:47 -0700682 // nothing to do
683 break;
684 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800685 }
686
687 return needWake;
688}
689
690void InputDispatcher::addRecentEventLocked(EventEntry* entry) {
691 entry->refCount += 1;
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -0700692 mRecentQueue.push_back(entry);
693 if (mRecentQueue.size() > RECENT_QUEUE_MAX_SIZE) {
694 mRecentQueue.front()->release();
695 mRecentQueue.pop_front();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800696 }
697}
698
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700699sp<InputWindowHandle> InputDispatcher::findTouchedWindowAtLocked(int32_t displayId, int32_t x,
700 int32_t y, bool addOutsideTargets,
701 bool addPortalWindows) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800702 // Traverse windows from front to back to find touched window.
Arthur Hung7c3ae9c2019-03-11 11:23:03 +0800703 const std::vector<sp<InputWindowHandle>> windowHandles = getWindowHandlesLocked(displayId);
704 for (const sp<InputWindowHandle>& windowHandle : windowHandles) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800705 const InputWindowInfo* windowInfo = windowHandle->getInfo();
706 if (windowInfo->displayId == displayId) {
707 int32_t flags = windowInfo->layoutParamsFlags;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800708
709 if (windowInfo->visible) {
710 if (!(flags & InputWindowInfo::FLAG_NOT_TOUCHABLE)) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700711 bool isTouchModal = (flags &
712 (InputWindowInfo::FLAG_NOT_FOCUSABLE |
713 InputWindowInfo::FLAG_NOT_TOUCH_MODAL)) == 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800714 if (isTouchModal || windowInfo->touchableRegionContainsPoint(x, y)) {
Tiger Huang85b8c5e2019-01-17 18:34:54 +0800715 int32_t portalToDisplayId = windowInfo->portalToDisplayId;
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700716 if (portalToDisplayId != ADISPLAY_ID_NONE &&
717 portalToDisplayId != displayId) {
Tiger Huang85b8c5e2019-01-17 18:34:54 +0800718 if (addPortalWindows) {
719 // For the monitoring channels of the display.
720 mTempTouchState.addPortalWindow(windowHandle);
721 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700722 return findTouchedWindowAtLocked(portalToDisplayId, x, y,
723 addOutsideTargets, addPortalWindows);
Tiger Huang85b8c5e2019-01-17 18:34:54 +0800724 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800725 // Found window.
726 return windowHandle;
727 }
728 }
Tiger Huang85b8c5e2019-01-17 18:34:54 +0800729
730 if (addOutsideTargets && (flags & InputWindowInfo::FLAG_WATCH_OUTSIDE_TOUCH)) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700731 mTempTouchState.addOrUpdateWindow(windowHandle,
732 InputTarget::FLAG_DISPATCH_AS_OUTSIDE,
733 BitSet32(0));
Tiger Huang85b8c5e2019-01-17 18:34:54 +0800734 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800735 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800736 }
737 }
Yi Kong9b14ac62018-07-17 13:48:38 -0700738 return nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800739}
740
Garfield Tane84e6f92019-08-29 17:28:41 -0700741std::vector<TouchedMonitor> InputDispatcher::findTouchedGestureMonitorsLocked(
Michael Wright3dd60e22019-03-27 22:06:44 +0000742 int32_t displayId, const std::vector<sp<InputWindowHandle>>& portalWindows) {
743 std::vector<TouchedMonitor> touchedMonitors;
744
745 std::vector<Monitor> monitors = getValueByKey(mGestureMonitorsByDisplay, displayId);
746 addGestureMonitors(monitors, touchedMonitors);
747 for (const sp<InputWindowHandle>& portalWindow : portalWindows) {
748 const InputWindowInfo* windowInfo = portalWindow->getInfo();
749 monitors = getValueByKey(mGestureMonitorsByDisplay, windowInfo->portalToDisplayId);
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700750 addGestureMonitors(monitors, touchedMonitors, -windowInfo->frameLeft,
751 -windowInfo->frameTop);
Michael Wright3dd60e22019-03-27 22:06:44 +0000752 }
753 return touchedMonitors;
754}
755
756void InputDispatcher::addGestureMonitors(const std::vector<Monitor>& monitors,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700757 std::vector<TouchedMonitor>& outTouchedMonitors,
758 float xOffset, float yOffset) {
Michael Wright3dd60e22019-03-27 22:06:44 +0000759 if (monitors.empty()) {
760 return;
761 }
762 outTouchedMonitors.reserve(monitors.size() + outTouchedMonitors.size());
763 for (const Monitor& monitor : monitors) {
764 outTouchedMonitors.emplace_back(monitor, xOffset, yOffset);
765 }
766}
767
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700768void InputDispatcher::dropInboundEventLocked(const EventEntry& entry, DropReason dropReason) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800769 const char* reason;
770 switch (dropReason) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700771 case DropReason::POLICY:
Michael Wrightd02c5b62014-02-10 15:10:22 -0800772#if DEBUG_INBOUND_EVENT_DETAILS
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700773 ALOGD("Dropped event because policy consumed it.");
Michael Wrightd02c5b62014-02-10 15:10:22 -0800774#endif
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700775 reason = "inbound event was dropped because the policy consumed it";
776 break;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700777 case DropReason::DISABLED:
778 if (mLastDropReason != DropReason::DISABLED) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700779 ALOGI("Dropped event because input dispatch is disabled.");
780 }
781 reason = "inbound event was dropped because input dispatch is disabled";
782 break;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700783 case DropReason::APP_SWITCH:
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700784 ALOGI("Dropped event because of pending overdue app switch.");
785 reason = "inbound event was dropped because of pending overdue app switch";
786 break;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700787 case DropReason::BLOCKED:
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700788 ALOGI("Dropped event because the current application is not responding and the user "
789 "has started interacting with a different application.");
790 reason = "inbound event was dropped because the current application is not responding "
791 "and the user has started interacting with a different application";
792 break;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700793 case DropReason::STALE:
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700794 ALOGI("Dropped event because it is stale.");
795 reason = "inbound event was dropped because it is stale";
796 break;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700797 case DropReason::NOT_DROPPED: {
798 LOG_ALWAYS_FATAL("Should not be dropping a NOT_DROPPED event");
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700799 return;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700800 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800801 }
802
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700803 switch (entry.type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -0700804 case EventEntry::Type::KEY: {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800805 CancelationOptions options(CancelationOptions::CANCEL_NON_POINTER_EVENTS, reason);
806 synthesizeCancelationEventsForAllConnectionsLocked(options);
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700807 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800808 }
Siarhei Vishniakou49483272019-10-22 13:13:47 -0700809 case EventEntry::Type::MOTION: {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700810 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(entry);
811 if (motionEntry.source & AINPUT_SOURCE_CLASS_POINTER) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700812 CancelationOptions options(CancelationOptions::CANCEL_POINTER_EVENTS, reason);
813 synthesizeCancelationEventsForAllConnectionsLocked(options);
814 } else {
815 CancelationOptions options(CancelationOptions::CANCEL_NON_POINTER_EVENTS, reason);
816 synthesizeCancelationEventsForAllConnectionsLocked(options);
817 }
818 break;
819 }
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +0100820 case EventEntry::Type::FOCUS:
Siarhei Vishniakou49483272019-10-22 13:13:47 -0700821 case EventEntry::Type::CONFIGURATION_CHANGED:
822 case EventEntry::Type::DEVICE_RESET: {
823 LOG_ALWAYS_FATAL("Should not drop %s events", EventEntry::typeToString(entry.type));
824 break;
825 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800826 }
827}
828
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800829static bool isAppSwitchKeyCode(int32_t keyCode) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700830 return keyCode == AKEYCODE_HOME || keyCode == AKEYCODE_ENDCALL ||
831 keyCode == AKEYCODE_APP_SWITCH;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800832}
833
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700834bool InputDispatcher::isAppSwitchKeyEvent(const KeyEntry& keyEntry) {
835 return !(keyEntry.flags & AKEY_EVENT_FLAG_CANCELED) && isAppSwitchKeyCode(keyEntry.keyCode) &&
836 (keyEntry.policyFlags & POLICY_FLAG_TRUSTED) &&
837 (keyEntry.policyFlags & POLICY_FLAG_PASS_TO_USER);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800838}
839
840bool InputDispatcher::isAppSwitchPendingLocked() {
841 return mAppSwitchDueTime != LONG_LONG_MAX;
842}
843
844void InputDispatcher::resetPendingAppSwitchLocked(bool handled) {
845 mAppSwitchDueTime = LONG_LONG_MAX;
846
847#if DEBUG_APP_SWITCH
848 if (handled) {
849 ALOGD("App switch has arrived.");
850 } else {
851 ALOGD("App switch was abandoned.");
852 }
853#endif
854}
855
Michael Wrightd02c5b62014-02-10 15:10:22 -0800856bool InputDispatcher::haveCommandsLocked() const {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -0700857 return !mCommandQueue.empty();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800858}
859
860bool InputDispatcher::runCommandsLockedInterruptible() {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -0700861 if (mCommandQueue.empty()) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800862 return false;
863 }
864
865 do {
Siarhei Vishniakoue7c94b92019-07-29 09:17:54 -0700866 std::unique_ptr<CommandEntry> commandEntry = std::move(mCommandQueue.front());
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -0700867 mCommandQueue.pop_front();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800868 Command command = commandEntry->command;
Siarhei Vishniakoue7c94b92019-07-29 09:17:54 -0700869 command(*this, commandEntry.get()); // commands are implicitly 'LockedInterruptible'
Michael Wrightd02c5b62014-02-10 15:10:22 -0800870
871 commandEntry->connection.clear();
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -0700872 } while (!mCommandQueue.empty());
Michael Wrightd02c5b62014-02-10 15:10:22 -0800873 return true;
874}
875
Siarhei Vishniakoue7c94b92019-07-29 09:17:54 -0700876void InputDispatcher::postCommandLocked(std::unique_ptr<CommandEntry> commandEntry) {
877 mCommandQueue.push_back(std::move(commandEntry));
Michael Wrightd02c5b62014-02-10 15:10:22 -0800878}
879
880void InputDispatcher::drainInboundQueueLocked() {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -0700881 while (!mInboundQueue.empty()) {
882 EventEntry* entry = mInboundQueue.front();
883 mInboundQueue.pop_front();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800884 releaseInboundEventLocked(entry);
885 }
886 traceInboundQueueLengthLocked();
887}
888
889void InputDispatcher::releasePendingEventLocked() {
890 if (mPendingEvent) {
891 resetANRTimeoutsLocked();
892 releaseInboundEventLocked(mPendingEvent);
Yi Kong9b14ac62018-07-17 13:48:38 -0700893 mPendingEvent = nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800894 }
895}
896
897void InputDispatcher::releaseInboundEventLocked(EventEntry* entry) {
898 InjectionState* injectionState = entry->injectionState;
899 if (injectionState && injectionState->injectionResult == INPUT_EVENT_INJECTION_PENDING) {
900#if DEBUG_DISPATCH_CYCLE
901 ALOGD("Injected inbound event was dropped.");
902#endif
Siarhei Vishniakou62683e82019-03-06 17:59:56 -0800903 setInjectionResult(entry, INPUT_EVENT_INJECTION_FAILED);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800904 }
905 if (entry == mNextUnblockedEvent) {
Yi Kong9b14ac62018-07-17 13:48:38 -0700906 mNextUnblockedEvent = nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800907 }
908 addRecentEventLocked(entry);
909 entry->release();
910}
911
912void InputDispatcher::resetKeyRepeatLocked() {
913 if (mKeyRepeatState.lastKeyEntry) {
914 mKeyRepeatState.lastKeyEntry->release();
Yi Kong9b14ac62018-07-17 13:48:38 -0700915 mKeyRepeatState.lastKeyEntry = nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800916 }
917}
918
Garfield Tane84e6f92019-08-29 17:28:41 -0700919KeyEntry* InputDispatcher::synthesizeKeyRepeatLocked(nsecs_t currentTime) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800920 KeyEntry* entry = mKeyRepeatState.lastKeyEntry;
921
922 // Reuse the repeated key entry if it is otherwise unreferenced.
Michael Wright2e732952014-09-24 13:26:59 -0700923 uint32_t policyFlags = entry->policyFlags &
924 (POLICY_FLAG_RAW_MASK | POLICY_FLAG_PASS_TO_USER | POLICY_FLAG_TRUSTED);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800925 if (entry->refCount == 1) {
926 entry->recycle();
Garfield Tan1c7bc862020-01-28 13:24:04 -0800927 entry->id = mIdGenerator.nextId();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800928 entry->eventTime = currentTime;
929 entry->policyFlags = policyFlags;
930 entry->repeatCount += 1;
931 } else {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700932 KeyEntry* newEntry =
Garfield Tan1c7bc862020-01-28 13:24:04 -0800933 new KeyEntry(mIdGenerator.nextId(), currentTime, entry->deviceId, entry->source,
Garfield Tanc51d1ba2020-01-28 13:24:04 -0800934 entry->displayId, policyFlags, entry->action, entry->flags,
935 entry->keyCode, entry->scanCode, entry->metaState,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700936 entry->repeatCount + 1, entry->downTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800937
938 mKeyRepeatState.lastKeyEntry = newEntry;
939 entry->release();
940
941 entry = newEntry;
942 }
943 entry->syntheticRepeat = true;
944
945 // Increment reference count since we keep a reference to the event in
946 // mKeyRepeatState.lastKeyEntry in addition to the one we return.
947 entry->refCount += 1;
948
949 mKeyRepeatState.nextRepeatTime = currentTime + mConfig.keyRepeatDelay;
950 return entry;
951}
952
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700953bool InputDispatcher::dispatchConfigurationChangedLocked(nsecs_t currentTime,
954 ConfigurationChangedEntry* entry) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800955#if DEBUG_OUTBOUND_EVENT_DETAILS
Siarhei Vishniakou5d83f602017-09-12 12:40:29 -0700956 ALOGD("dispatchConfigurationChanged - eventTime=%" PRId64, entry->eventTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800957#endif
958
959 // Reset key repeating in case a keyboard device was added or removed or something.
960 resetKeyRepeatLocked();
961
962 // Enqueue a command to run outside the lock to tell the policy that the configuration changed.
Siarhei Vishniakoue7c94b92019-07-29 09:17:54 -0700963 std::unique_ptr<CommandEntry> commandEntry = std::make_unique<CommandEntry>(
964 &InputDispatcher::doNotifyConfigurationChangedLockedInterruptible);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800965 commandEntry->eventTime = entry->eventTime;
Siarhei Vishniakoue7c94b92019-07-29 09:17:54 -0700966 postCommandLocked(std::move(commandEntry));
Michael Wrightd02c5b62014-02-10 15:10:22 -0800967 return true;
968}
969
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700970bool InputDispatcher::dispatchDeviceResetLocked(nsecs_t currentTime, DeviceResetEntry* entry) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800971#if DEBUG_OUTBOUND_EVENT_DETAILS
Siarhei Vishniakou5d83f602017-09-12 12:40:29 -0700972 ALOGD("dispatchDeviceReset - eventTime=%" PRId64 ", deviceId=%d", entry->eventTime,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700973 entry->deviceId);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800974#endif
975
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700976 CancelationOptions options(CancelationOptions::CANCEL_ALL_EVENTS, "device was reset");
Michael Wrightd02c5b62014-02-10 15:10:22 -0800977 options.deviceId = entry->deviceId;
978 synthesizeCancelationEventsForAllConnectionsLocked(options);
979 return true;
980}
981
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +0100982void InputDispatcher::enqueueFocusEventLocked(const InputWindowHandle& window, bool hasFocus) {
983 FocusEntry* focusEntry =
Garfield Tan1c7bc862020-01-28 13:24:04 -0800984 new FocusEntry(mIdGenerator.nextId(), now(), window.getToken(), hasFocus);
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +0100985 enqueueInboundEventLocked(focusEntry);
986}
987
988void InputDispatcher::dispatchFocusLocked(nsecs_t currentTime, FocusEntry* entry) {
989 sp<InputChannel> channel = getInputChannelLocked(entry->connectionToken);
990 if (channel == nullptr) {
991 return; // Window has gone away
992 }
993 InputTarget target;
994 target.inputChannel = channel;
995 target.flags = InputTarget::FLAG_DISPATCH_AS_IS;
996 entry->dispatchInProgress = true;
997
998 dispatchEventLocked(currentTime, entry, {target});
999}
1000
Michael Wrightd02c5b62014-02-10 15:10:22 -08001001bool InputDispatcher::dispatchKeyLocked(nsecs_t currentTime, KeyEntry* entry,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001002 DropReason* dropReason, nsecs_t* nextWakeupTime) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001003 // Preprocessing.
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001004 if (!entry->dispatchInProgress) {
1005 if (entry->repeatCount == 0 && entry->action == AKEY_EVENT_ACTION_DOWN &&
1006 (entry->policyFlags & POLICY_FLAG_TRUSTED) &&
1007 (!(entry->policyFlags & POLICY_FLAG_DISABLE_KEY_REPEAT))) {
1008 if (mKeyRepeatState.lastKeyEntry &&
1009 mKeyRepeatState.lastKeyEntry->keyCode == entry->keyCode) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001010 // We have seen two identical key downs in a row which indicates that the device
1011 // driver is automatically generating key repeats itself. We take note of the
1012 // repeat here, but we disable our own next key repeat timer since it is clear that
1013 // we will not need to synthesize key repeats ourselves.
1014 entry->repeatCount = mKeyRepeatState.lastKeyEntry->repeatCount + 1;
1015 resetKeyRepeatLocked();
1016 mKeyRepeatState.nextRepeatTime = LONG_LONG_MAX; // don't generate repeats ourselves
1017 } else {
1018 // Not a repeat. Save key down state in case we do see a repeat later.
1019 resetKeyRepeatLocked();
1020 mKeyRepeatState.nextRepeatTime = entry->eventTime + mConfig.keyRepeatTimeout;
1021 }
1022 mKeyRepeatState.lastKeyEntry = entry;
1023 entry->refCount += 1;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001024 } else if (!entry->syntheticRepeat) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001025 resetKeyRepeatLocked();
1026 }
1027
1028 if (entry->repeatCount == 1) {
1029 entry->flags |= AKEY_EVENT_FLAG_LONG_PRESS;
1030 } else {
1031 entry->flags &= ~AKEY_EVENT_FLAG_LONG_PRESS;
1032 }
1033
1034 entry->dispatchInProgress = true;
1035
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001036 logOutboundKeyDetails("dispatchKey - ", *entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001037 }
1038
1039 // Handle case where the policy asked us to try again later last time.
1040 if (entry->interceptKeyResult == KeyEntry::INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER) {
1041 if (currentTime < entry->interceptKeyWakeupTime) {
1042 if (entry->interceptKeyWakeupTime < *nextWakeupTime) {
1043 *nextWakeupTime = entry->interceptKeyWakeupTime;
1044 }
1045 return false; // wait until next wakeup
1046 }
1047 entry->interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_UNKNOWN;
1048 entry->interceptKeyWakeupTime = 0;
1049 }
1050
1051 // Give the policy a chance to intercept the key.
1052 if (entry->interceptKeyResult == KeyEntry::INTERCEPT_KEY_RESULT_UNKNOWN) {
1053 if (entry->policyFlags & POLICY_FLAG_PASS_TO_USER) {
Siarhei Vishniakoue7c94b92019-07-29 09:17:54 -07001054 std::unique_ptr<CommandEntry> commandEntry = std::make_unique<CommandEntry>(
Siarhei Vishniakou49a350a2019-07-26 18:44:23 -07001055 &InputDispatcher::doInterceptKeyBeforeDispatchingLockedInterruptible);
Tiger Huang721e26f2018-07-24 22:26:19 +08001056 sp<InputWindowHandle> focusedWindowHandle =
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001057 getValueByKey(mFocusedWindowHandlesByDisplay, getTargetDisplayId(*entry));
Tiger Huang721e26f2018-07-24 22:26:19 +08001058 if (focusedWindowHandle != nullptr) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001059 commandEntry->inputChannel = getInputChannelLocked(focusedWindowHandle->getToken());
Michael Wrightd02c5b62014-02-10 15:10:22 -08001060 }
1061 commandEntry->keyEntry = entry;
Siarhei Vishniakoue7c94b92019-07-29 09:17:54 -07001062 postCommandLocked(std::move(commandEntry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001063 entry->refCount += 1;
1064 return false; // wait for the command to run
1065 } else {
1066 entry->interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_CONTINUE;
1067 }
1068 } else if (entry->interceptKeyResult == KeyEntry::INTERCEPT_KEY_RESULT_SKIP) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001069 if (*dropReason == DropReason::NOT_DROPPED) {
1070 *dropReason = DropReason::POLICY;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001071 }
1072 }
1073
1074 // Clean up if dropping the event.
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001075 if (*dropReason != DropReason::NOT_DROPPED) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001076 setInjectionResult(entry,
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001077 *dropReason == DropReason::POLICY ? INPUT_EVENT_INJECTION_SUCCEEDED
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001078 : INPUT_EVENT_INJECTION_FAILED);
Garfield Tanc51d1ba2020-01-28 13:24:04 -08001079 mReporter->reportDroppedKey(entry->id);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001080 return true;
1081 }
1082
1083 // Identify targets.
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08001084 std::vector<InputTarget> inputTargets;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001085 int32_t injectionResult =
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001086 findFocusedWindowTargetsLocked(currentTime, *entry, inputTargets, nextWakeupTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001087 if (injectionResult == INPUT_EVENT_INJECTION_PENDING) {
1088 return false;
1089 }
1090
Siarhei Vishniakou62683e82019-03-06 17:59:56 -08001091 setInjectionResult(entry, injectionResult);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001092 if (injectionResult != INPUT_EVENT_INJECTION_SUCCEEDED) {
1093 return true;
1094 }
1095
Arthur Hung2fbf37f2018-09-13 18:16:41 +08001096 // Add monitor channels from event's or focused display.
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001097 addGlobalMonitoringTargetsLocked(inputTargets, getTargetDisplayId(*entry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001098
1099 // Dispatch the key.
1100 dispatchEventLocked(currentTime, entry, inputTargets);
1101 return true;
1102}
1103
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001104void InputDispatcher::logOutboundKeyDetails(const char* prefix, const KeyEntry& entry) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001105#if DEBUG_OUTBOUND_EVENT_DETAILS
Siarhei Vishniakoua62a8dd2018-06-08 21:17:33 +01001106 ALOGD("%seventTime=%" PRId64 ", deviceId=%d, source=0x%x, displayId=%" PRId32 ", "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001107 "policyFlags=0x%x, action=0x%x, flags=0x%x, keyCode=0x%x, scanCode=0x%x, "
1108 "metaState=0x%x, repeatCount=%d, downTime=%" PRId64,
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001109 prefix, entry.eventTime, entry.deviceId, entry.source, entry.displayId, entry.policyFlags,
1110 entry.action, entry.flags, entry.keyCode, entry.scanCode, entry.metaState,
1111 entry.repeatCount, entry.downTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001112#endif
1113}
1114
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001115bool InputDispatcher::dispatchMotionLocked(nsecs_t currentTime, MotionEntry* entry,
1116 DropReason* dropReason, nsecs_t* nextWakeupTime) {
Michael Wright3dd60e22019-03-27 22:06:44 +00001117 ATRACE_CALL();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001118 // Preprocessing.
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001119 if (!entry->dispatchInProgress) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001120 entry->dispatchInProgress = true;
1121
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001122 logOutboundMotionDetails("dispatchMotion - ", *entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001123 }
1124
1125 // Clean up if dropping the event.
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001126 if (*dropReason != DropReason::NOT_DROPPED) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001127 setInjectionResult(entry,
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001128 *dropReason == DropReason::POLICY ? INPUT_EVENT_INJECTION_SUCCEEDED
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001129 : INPUT_EVENT_INJECTION_FAILED);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001130 return true;
1131 }
1132
1133 bool isPointerEvent = entry->source & AINPUT_SOURCE_CLASS_POINTER;
1134
1135 // Identify targets.
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08001136 std::vector<InputTarget> inputTargets;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001137
1138 bool conflictingPointerActions = false;
1139 int32_t injectionResult;
1140 if (isPointerEvent) {
1141 // Pointer event. (eg. touchscreen)
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001142 injectionResult =
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001143 findTouchedWindowTargetsLocked(currentTime, *entry, inputTargets, nextWakeupTime,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001144 &conflictingPointerActions);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001145 } else {
1146 // Non touch event. (eg. trackball)
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001147 injectionResult =
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001148 findFocusedWindowTargetsLocked(currentTime, *entry, inputTargets, nextWakeupTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001149 }
1150 if (injectionResult == INPUT_EVENT_INJECTION_PENDING) {
1151 return false;
1152 }
1153
Siarhei Vishniakou62683e82019-03-06 17:59:56 -08001154 setInjectionResult(entry, injectionResult);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001155 if (injectionResult != INPUT_EVENT_INJECTION_SUCCEEDED) {
Michael Wrightfa13dcf2015-06-12 13:25:11 +01001156 if (injectionResult != INPUT_EVENT_INJECTION_PERMISSION_DENIED) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001157 CancelationOptions::Mode mode(isPointerEvent
1158 ? CancelationOptions::CANCEL_POINTER_EVENTS
1159 : CancelationOptions::CANCEL_NON_POINTER_EVENTS);
Michael Wrightfa13dcf2015-06-12 13:25:11 +01001160 CancelationOptions options(mode, "input event injection failed");
1161 synthesizeCancelationEventsForMonitorsLocked(options);
1162 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001163 return true;
1164 }
1165
Arthur Hung2fbf37f2018-09-13 18:16:41 +08001166 // Add monitor channels from event's or focused display.
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001167 addGlobalMonitoringTargetsLocked(inputTargets, getTargetDisplayId(*entry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001168
Tiger Huang85b8c5e2019-01-17 18:34:54 +08001169 if (isPointerEvent) {
1170 ssize_t stateIndex = mTouchStatesByDisplay.indexOfKey(entry->displayId);
1171 if (stateIndex >= 0) {
1172 const TouchState& state = mTouchStatesByDisplay.valueAt(stateIndex);
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08001173 if (!state.portalWindows.empty()) {
Tiger Huang85b8c5e2019-01-17 18:34:54 +08001174 // The event has gone through these portal windows, so we add monitoring targets of
1175 // the corresponding displays as well.
1176 for (size_t i = 0; i < state.portalWindows.size(); i++) {
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08001177 const InputWindowInfo* windowInfo = state.portalWindows[i]->getInfo();
Michael Wright3dd60e22019-03-27 22:06:44 +00001178 addGlobalMonitoringTargetsLocked(inputTargets, windowInfo->portalToDisplayId,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001179 -windowInfo->frameLeft, -windowInfo->frameTop);
Tiger Huang85b8c5e2019-01-17 18:34:54 +08001180 }
1181 }
1182 }
1183 }
1184
Michael Wrightd02c5b62014-02-10 15:10:22 -08001185 // Dispatch the motion.
1186 if (conflictingPointerActions) {
1187 CancelationOptions options(CancelationOptions::CANCEL_POINTER_EVENTS,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001188 "conflicting pointer actions");
Michael Wrightd02c5b62014-02-10 15:10:22 -08001189 synthesizeCancelationEventsForAllConnectionsLocked(options);
1190 }
1191 dispatchEventLocked(currentTime, entry, inputTargets);
1192 return true;
1193}
1194
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001195void InputDispatcher::logOutboundMotionDetails(const char* prefix, const MotionEntry& entry) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001196#if DEBUG_OUTBOUND_EVENT_DETAILS
Siarhei Vishniakou777a10b2018-01-31 16:45:06 -08001197 ALOGD("%seventTime=%" PRId64 ", deviceId=%d, source=0x%x, displayId=%" PRId32
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001198 ", policyFlags=0x%x, "
1199 "action=0x%x, actionButton=0x%x, flags=0x%x, "
1200 "metaState=0x%x, buttonState=0x%x,"
1201 "edgeFlags=0x%x, xPrecision=%f, yPrecision=%f, downTime=%" PRId64,
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001202 prefix, entry.eventTime, entry.deviceId, entry.source, entry.displayId, entry.policyFlags,
1203 entry.action, entry.actionButton, entry.flags, entry.metaState, entry.buttonState,
1204 entry.edgeFlags, entry.xPrecision, entry.yPrecision, entry.downTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001205
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001206 for (uint32_t i = 0; i < entry.pointerCount; i++) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001207 ALOGD(" Pointer %d: id=%d, toolType=%d, "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001208 "x=%f, y=%f, pressure=%f, size=%f, "
1209 "touchMajor=%f, touchMinor=%f, toolMajor=%f, toolMinor=%f, "
1210 "orientation=%f",
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001211 i, entry.pointerProperties[i].id, entry.pointerProperties[i].toolType,
1212 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_X),
1213 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_Y),
1214 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_PRESSURE),
1215 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_SIZE),
1216 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR),
1217 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR),
1218 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR),
1219 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR),
1220 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001221 }
1222#endif
1223}
1224
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001225void InputDispatcher::dispatchEventLocked(nsecs_t currentTime, EventEntry* eventEntry,
1226 const std::vector<InputTarget>& inputTargets) {
Michael Wright3dd60e22019-03-27 22:06:44 +00001227 ATRACE_CALL();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001228#if DEBUG_DISPATCH_CYCLE
1229 ALOGD("dispatchEventToCurrentInputTargets");
1230#endif
1231
1232 ALOG_ASSERT(eventEntry->dispatchInProgress); // should already have been set to true
1233
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001234 pokeUserActivityLocked(*eventEntry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001235
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08001236 for (const InputTarget& inputTarget : inputTargets) {
Siarhei Vishniakou26d3cfb2019-10-15 17:02:32 -07001237 sp<Connection> connection =
1238 getConnectionLocked(inputTarget.inputChannel->getConnectionToken());
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07001239 if (connection != nullptr) {
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08001240 prepareDispatchCycleLocked(currentTime, connection, eventEntry, inputTarget);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001241 } else {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01001242 if (DEBUG_FOCUS) {
1243 ALOGD("Dropping event delivery to target with channel '%s' because it "
1244 "is no longer registered with the input dispatcher.",
1245 inputTarget.inputChannel->getName().c_str());
1246 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001247 }
1248 }
1249}
1250
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001251int32_t InputDispatcher::handleTargetsNotReadyLocked(
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001252 nsecs_t currentTime, const EventEntry& entry,
Michael Wrightd02c5b62014-02-10 15:10:22 -08001253 const sp<InputApplicationHandle>& applicationHandle,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001254 const sp<InputWindowHandle>& windowHandle, nsecs_t* nextWakeupTime, const char* reason) {
Yi Kong9b14ac62018-07-17 13:48:38 -07001255 if (applicationHandle == nullptr && windowHandle == nullptr) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001256 if (mInputTargetWaitCause != INPUT_TARGET_WAIT_CAUSE_SYSTEM_NOT_READY) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01001257 if (DEBUG_FOCUS) {
1258 ALOGD("Waiting for system to become ready for input. Reason: %s", reason);
1259 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001260 mInputTargetWaitCause = INPUT_TARGET_WAIT_CAUSE_SYSTEM_NOT_READY;
1261 mInputTargetWaitStartTime = currentTime;
1262 mInputTargetWaitTimeoutTime = LONG_LONG_MAX;
1263 mInputTargetWaitTimeoutExpired = false;
Robert Carr740167f2018-10-11 19:03:41 -07001264 mInputTargetWaitApplicationToken.clear();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001265 }
1266 } else {
1267 if (mInputTargetWaitCause != INPUT_TARGET_WAIT_CAUSE_APPLICATION_NOT_READY) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01001268 if (DEBUG_FOCUS) {
1269 ALOGD("Waiting for application to become ready for input: %s. Reason: %s",
1270 getApplicationWindowLabel(applicationHandle, windowHandle).c_str(), reason);
1271 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001272 nsecs_t timeout;
Yi Kong9b14ac62018-07-17 13:48:38 -07001273 if (windowHandle != nullptr) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001274 timeout = windowHandle->getDispatchingTimeout(DEFAULT_INPUT_DISPATCHING_TIMEOUT);
Yi Kong9b14ac62018-07-17 13:48:38 -07001275 } else if (applicationHandle != nullptr) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001276 timeout =
1277 applicationHandle->getDispatchingTimeout(DEFAULT_INPUT_DISPATCHING_TIMEOUT);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001278 } else {
1279 timeout = DEFAULT_INPUT_DISPATCHING_TIMEOUT;
1280 }
1281
1282 mInputTargetWaitCause = INPUT_TARGET_WAIT_CAUSE_APPLICATION_NOT_READY;
1283 mInputTargetWaitStartTime = currentTime;
1284 mInputTargetWaitTimeoutTime = currentTime + timeout;
1285 mInputTargetWaitTimeoutExpired = false;
Robert Carr740167f2018-10-11 19:03:41 -07001286 mInputTargetWaitApplicationToken.clear();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001287
Yi Kong9b14ac62018-07-17 13:48:38 -07001288 if (windowHandle != nullptr) {
Robert Carr740167f2018-10-11 19:03:41 -07001289 mInputTargetWaitApplicationToken = windowHandle->getApplicationToken();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001290 }
Robert Carr740167f2018-10-11 19:03:41 -07001291 if (mInputTargetWaitApplicationToken == nullptr && applicationHandle != nullptr) {
1292 mInputTargetWaitApplicationToken = applicationHandle->getApplicationToken();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001293 }
1294 }
1295 }
1296
1297 if (mInputTargetWaitTimeoutExpired) {
1298 return INPUT_EVENT_INJECTION_TIMED_OUT;
1299 }
1300
1301 if (currentTime >= mInputTargetWaitTimeoutTime) {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001302 onANRLocked(currentTime, applicationHandle, windowHandle, entry.eventTime,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001303 mInputTargetWaitStartTime, reason);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001304
1305 // Force poll loop to wake up immediately on next iteration once we get the
1306 // ANR response back from the policy.
1307 *nextWakeupTime = LONG_LONG_MIN;
1308 return INPUT_EVENT_INJECTION_PENDING;
1309 } else {
1310 // Force poll loop to wake up when timeout is due.
1311 if (mInputTargetWaitTimeoutTime < *nextWakeupTime) {
1312 *nextWakeupTime = mInputTargetWaitTimeoutTime;
1313 }
1314 return INPUT_EVENT_INJECTION_PENDING;
1315 }
1316}
1317
Robert Carr803535b2018-08-02 16:38:15 -07001318void InputDispatcher::removeWindowByTokenLocked(const sp<IBinder>& token) {
1319 for (size_t d = 0; d < mTouchStatesByDisplay.size(); d++) {
1320 TouchState& state = mTouchStatesByDisplay.editValueAt(d);
1321 state.removeWindowByToken(token);
1322 }
1323}
1324
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001325void InputDispatcher::resumeAfterTargetsNotReadyTimeoutLocked(
Siarhei Vishniakoud0d71b62019-10-14 14:50:45 -07001326 nsecs_t newTimeout, const sp<IBinder>& inputConnectionToken) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001327 if (newTimeout > 0) {
1328 // Extend the timeout.
1329 mInputTargetWaitTimeoutTime = now() + newTimeout;
1330 } else {
1331 // Give up.
1332 mInputTargetWaitTimeoutExpired = true;
1333
1334 // Input state will not be realistic. Mark it out of sync.
Siarhei Vishniakoud0d71b62019-10-14 14:50:45 -07001335 sp<Connection> connection = getConnectionLocked(inputConnectionToken);
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07001336 if (connection != nullptr) {
Siarhei Vishniakoud0d71b62019-10-14 14:50:45 -07001337 removeWindowByTokenLocked(inputConnectionToken);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001338
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07001339 if (connection->status == Connection::STATUS_NORMAL) {
1340 CancelationOptions options(CancelationOptions::CANCEL_ALL_EVENTS,
1341 "application not responding");
1342 synthesizeCancelationEventsForConnectionLocked(connection, options);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001343 }
1344 }
1345 }
1346}
1347
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001348nsecs_t InputDispatcher::getTimeSpentWaitingForApplicationLocked(nsecs_t currentTime) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001349 if (mInputTargetWaitCause == INPUT_TARGET_WAIT_CAUSE_APPLICATION_NOT_READY) {
1350 return currentTime - mInputTargetWaitStartTime;
1351 }
1352 return 0;
1353}
1354
1355void InputDispatcher::resetANRTimeoutsLocked() {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01001356 if (DEBUG_FOCUS) {
1357 ALOGD("Resetting ANR timeouts.");
1358 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001359
1360 // Reset input target wait timeout.
1361 mInputTargetWaitCause = INPUT_TARGET_WAIT_CAUSE_NONE;
Robert Carr740167f2018-10-11 19:03:41 -07001362 mInputTargetWaitApplicationToken.clear();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001363}
1364
Tiger Huang721e26f2018-07-24 22:26:19 +08001365/**
1366 * Get the display id that the given event should go to. If this event specifies a valid display id,
1367 * then it should be dispatched to that display. Otherwise, the event goes to the focused display.
1368 * Focused display is the display that the user most recently interacted with.
1369 */
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001370int32_t InputDispatcher::getTargetDisplayId(const EventEntry& entry) {
Tiger Huang721e26f2018-07-24 22:26:19 +08001371 int32_t displayId;
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001372 switch (entry.type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001373 case EventEntry::Type::KEY: {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001374 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(entry);
1375 displayId = keyEntry.displayId;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001376 break;
1377 }
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001378 case EventEntry::Type::MOTION: {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001379 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(entry);
1380 displayId = motionEntry.displayId;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001381 break;
1382 }
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001383 case EventEntry::Type::FOCUS:
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001384 case EventEntry::Type::CONFIGURATION_CHANGED:
1385 case EventEntry::Type::DEVICE_RESET: {
1386 ALOGE("%s events do not have a target display", EventEntry::typeToString(entry.type));
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001387 return ADISPLAY_ID_NONE;
1388 }
Tiger Huang721e26f2018-07-24 22:26:19 +08001389 }
1390 return displayId == ADISPLAY_ID_NONE ? mFocusedDisplayId : displayId;
1391}
1392
Michael Wrightd02c5b62014-02-10 15:10:22 -08001393int32_t InputDispatcher::findFocusedWindowTargetsLocked(nsecs_t currentTime,
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001394 const EventEntry& entry,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001395 std::vector<InputTarget>& inputTargets,
1396 nsecs_t* nextWakeupTime) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001397 int32_t injectionResult;
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08001398 std::string reason;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001399
Tiger Huang721e26f2018-07-24 22:26:19 +08001400 int32_t displayId = getTargetDisplayId(entry);
1401 sp<InputWindowHandle> focusedWindowHandle =
1402 getValueByKey(mFocusedWindowHandlesByDisplay, displayId);
1403 sp<InputApplicationHandle> focusedApplicationHandle =
1404 getValueByKey(mFocusedApplicationHandlesByDisplay, displayId);
1405
Michael Wrightd02c5b62014-02-10 15:10:22 -08001406 // If there is no currently focused window and no focused application
1407 // then drop the event.
Tiger Huang721e26f2018-07-24 22:26:19 +08001408 if (focusedWindowHandle == nullptr) {
1409 if (focusedApplicationHandle != nullptr) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001410 injectionResult =
1411 handleTargetsNotReadyLocked(currentTime, entry, focusedApplicationHandle,
1412 nullptr, nextWakeupTime,
1413 "Waiting because no window has focus but there is "
1414 "a focused application that may eventually add a "
1415 "window when it finishes starting up.");
Michael Wrightd02c5b62014-02-10 15:10:22 -08001416 goto Unresponsive;
1417 }
1418
Arthur Hung3b413f22018-10-26 18:05:34 +08001419 ALOGI("Dropping event because there is no focused window or focused application in display "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001420 "%" PRId32 ".",
1421 displayId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001422 injectionResult = INPUT_EVENT_INJECTION_FAILED;
1423 goto Failed;
1424 }
1425
1426 // Check permissions.
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001427 if (!checkInjectionPermission(focusedWindowHandle, entry.injectionState)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001428 injectionResult = INPUT_EVENT_INJECTION_PERMISSION_DENIED;
1429 goto Failed;
1430 }
1431
Jeff Brownffb49772014-10-10 19:01:34 -07001432 // Check whether the window is ready for more input.
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001433 reason = checkWindowReadyForMoreInputLocked(currentTime, focusedWindowHandle, entry, "focused");
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08001434 if (!reason.empty()) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001435 injectionResult =
1436 handleTargetsNotReadyLocked(currentTime, entry, focusedApplicationHandle,
1437 focusedWindowHandle, nextWakeupTime, reason.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08001438 goto Unresponsive;
1439 }
1440
1441 // Success! Output targets.
1442 injectionResult = INPUT_EVENT_INJECTION_SUCCEEDED;
Tiger Huang721e26f2018-07-24 22:26:19 +08001443 addWindowTargetLocked(focusedWindowHandle,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001444 InputTarget::FLAG_FOREGROUND | InputTarget::FLAG_DISPATCH_AS_IS,
1445 BitSet32(0), inputTargets);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001446
1447 // Done.
1448Failed:
1449Unresponsive:
1450 nsecs_t timeSpentWaitingForApplication = getTimeSpentWaitingForApplicationLocked(currentTime);
Siarhei Vishniakou61291d42019-02-11 18:13:20 -08001451 updateDispatchStatistics(currentTime, entry, injectionResult, timeSpentWaitingForApplication);
Siarhei Vishniakou86587282019-09-09 18:20:15 +01001452 if (DEBUG_FOCUS) {
1453 ALOGD("findFocusedWindow finished: injectionResult=%d, "
1454 "timeSpentWaitingForApplication=%0.1fms",
1455 injectionResult, timeSpentWaitingForApplication / 1000000.0);
1456 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001457 return injectionResult;
1458}
1459
1460int32_t InputDispatcher::findTouchedWindowTargetsLocked(nsecs_t currentTime,
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001461 const MotionEntry& entry,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001462 std::vector<InputTarget>& inputTargets,
1463 nsecs_t* nextWakeupTime,
1464 bool* outConflictingPointerActions) {
Michael Wright3dd60e22019-03-27 22:06:44 +00001465 ATRACE_CALL();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001466 enum InjectionPermission {
1467 INJECTION_PERMISSION_UNKNOWN,
1468 INJECTION_PERMISSION_GRANTED,
1469 INJECTION_PERMISSION_DENIED
1470 };
1471
Michael Wrightd02c5b62014-02-10 15:10:22 -08001472 // For security reasons, we defer updating the touch state until we are sure that
1473 // event injection will be allowed.
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001474 int32_t displayId = entry.displayId;
1475 int32_t action = entry.action;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001476 int32_t maskedAction = action & AMOTION_EVENT_ACTION_MASK;
1477
1478 // Update the touch state as needed based on the properties of the touch event.
1479 int32_t injectionResult = INPUT_EVENT_INJECTION_PENDING;
1480 InjectionPermission injectionPermission = INJECTION_PERMISSION_UNKNOWN;
1481 sp<InputWindowHandle> newHoverWindowHandle;
1482
Jeff Brownf086ddb2014-02-11 14:28:48 -08001483 // Copy current touch state into mTempTouchState.
1484 // This state is always reset at the end of this function, so if we don't find state
1485 // for the specified display then our initial state will be empty.
Yi Kong9b14ac62018-07-17 13:48:38 -07001486 const TouchState* oldState = nullptr;
Jeff Brownf086ddb2014-02-11 14:28:48 -08001487 ssize_t oldStateIndex = mTouchStatesByDisplay.indexOfKey(displayId);
1488 if (oldStateIndex >= 0) {
1489 oldState = &mTouchStatesByDisplay.valueAt(oldStateIndex);
1490 mTempTouchState.copyFrom(*oldState);
1491 }
1492
1493 bool isSplit = mTempTouchState.split;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001494 bool switchedDevice = mTempTouchState.deviceId >= 0 && mTempTouchState.displayId >= 0 &&
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001495 (mTempTouchState.deviceId != entry.deviceId || mTempTouchState.source != entry.source ||
1496 mTempTouchState.displayId != displayId);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001497 bool isHoverAction = (maskedAction == AMOTION_EVENT_ACTION_HOVER_MOVE ||
1498 maskedAction == AMOTION_EVENT_ACTION_HOVER_ENTER ||
1499 maskedAction == AMOTION_EVENT_ACTION_HOVER_EXIT);
1500 bool newGesture = (maskedAction == AMOTION_EVENT_ACTION_DOWN ||
1501 maskedAction == AMOTION_EVENT_ACTION_SCROLL || isHoverAction);
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001502 const bool isFromMouse = entry.source == AINPUT_SOURCE_MOUSE;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001503 bool wrongDevice = false;
1504 if (newGesture) {
1505 bool down = maskedAction == AMOTION_EVENT_ACTION_DOWN;
Kevin Schoedel1eb587b2017-05-03 13:58:56 -04001506 if (switchedDevice && mTempTouchState.down && !down && !isHoverAction) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01001507 if (DEBUG_FOCUS) {
1508 ALOGD("Dropping event because a pointer for a different device is already down "
1509 "in display %" PRId32,
1510 displayId);
1511 }
Kevin Schoedel1eb587b2017-05-03 13:58:56 -04001512 // TODO: test multiple simultaneous input streams.
Michael Wrightd02c5b62014-02-10 15:10:22 -08001513 injectionResult = INPUT_EVENT_INJECTION_FAILED;
1514 switchedDevice = false;
1515 wrongDevice = true;
1516 goto Failed;
1517 }
1518 mTempTouchState.reset();
1519 mTempTouchState.down = down;
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001520 mTempTouchState.deviceId = entry.deviceId;
1521 mTempTouchState.source = entry.source;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001522 mTempTouchState.displayId = displayId;
1523 isSplit = false;
Kevin Schoedel1eb587b2017-05-03 13:58:56 -04001524 } else if (switchedDevice && maskedAction == AMOTION_EVENT_ACTION_MOVE) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01001525 if (DEBUG_FOCUS) {
1526 ALOGI("Dropping move event because a pointer for a different device is already active "
1527 "in display %" PRId32,
1528 displayId);
1529 }
Kevin Schoedel1eb587b2017-05-03 13:58:56 -04001530 // TODO: test multiple simultaneous input streams.
1531 injectionResult = INPUT_EVENT_INJECTION_PERMISSION_DENIED;
1532 switchedDevice = false;
1533 wrongDevice = true;
1534 goto Failed;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001535 }
1536
1537 if (newGesture || (isSplit && maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN)) {
1538 /* Case 1: New splittable pointer going down, or need target for hover or scroll. */
1539
Garfield Tan00f511d2019-06-12 16:55:40 -07001540 int32_t x;
1541 int32_t y;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001542 int32_t pointerIndex = getMotionEventActionPointerIndex(action);
Garfield Tan00f511d2019-06-12 16:55:40 -07001543 // Always dispatch mouse events to cursor position.
1544 if (isFromMouse) {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001545 x = int32_t(entry.xCursorPosition);
1546 y = int32_t(entry.yCursorPosition);
Garfield Tan00f511d2019-06-12 16:55:40 -07001547 } else {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001548 x = int32_t(entry.pointerCoords[pointerIndex].getAxisValue(AMOTION_EVENT_AXIS_X));
1549 y = int32_t(entry.pointerCoords[pointerIndex].getAxisValue(AMOTION_EVENT_AXIS_Y));
Garfield Tan00f511d2019-06-12 16:55:40 -07001550 }
Michael Wright3dd60e22019-03-27 22:06:44 +00001551 bool isDown = maskedAction == AMOTION_EVENT_ACTION_DOWN;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001552 sp<InputWindowHandle> newTouchedWindowHandle =
1553 findTouchedWindowAtLocked(displayId, x, y, isDown /*addOutsideTargets*/,
1554 true /*addPortalWindows*/);
Michael Wright3dd60e22019-03-27 22:06:44 +00001555
1556 std::vector<TouchedMonitor> newGestureMonitors = isDown
1557 ? findTouchedGestureMonitorsLocked(displayId, mTempTouchState.portalWindows)
1558 : std::vector<TouchedMonitor>{};
Michael Wrightd02c5b62014-02-10 15:10:22 -08001559
Michael Wrightd02c5b62014-02-10 15:10:22 -08001560 // Figure out whether splitting will be allowed for this window.
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001561 if (newTouchedWindowHandle != nullptr &&
1562 newTouchedWindowHandle->getInfo()->supportsSplitTouch()) {
Garfield Tanaddb02b2019-06-25 16:36:13 -07001563 // New window supports splitting, but we should never split mouse events.
1564 isSplit = !isFromMouse;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001565 } else if (isSplit) {
1566 // New window does not support splitting but we have already split events.
1567 // Ignore the new window.
Yi Kong9b14ac62018-07-17 13:48:38 -07001568 newTouchedWindowHandle = nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001569 }
1570
1571 // Handle the case where we did not find a window.
Yi Kong9b14ac62018-07-17 13:48:38 -07001572 if (newTouchedWindowHandle == nullptr) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001573 // Try to assign the pointer to the first foreground window we find, if there is one.
1574 newTouchedWindowHandle = mTempTouchState.getFirstForegroundWindowHandle();
Michael Wright3dd60e22019-03-27 22:06:44 +00001575 }
1576
1577 if (newTouchedWindowHandle == nullptr && newGestureMonitors.empty()) {
1578 ALOGI("Dropping event because there is no touchable window or gesture monitor at "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001579 "(%d, %d) in display %" PRId32 ".",
1580 x, y, displayId);
Michael Wright3dd60e22019-03-27 22:06:44 +00001581 injectionResult = INPUT_EVENT_INJECTION_FAILED;
1582 goto Failed;
1583 }
1584
1585 if (newTouchedWindowHandle != nullptr) {
1586 // Set target flags.
1587 int32_t targetFlags = InputTarget::FLAG_FOREGROUND | InputTarget::FLAG_DISPATCH_AS_IS;
1588 if (isSplit) {
1589 targetFlags |= InputTarget::FLAG_SPLIT;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001590 }
Michael Wright3dd60e22019-03-27 22:06:44 +00001591 if (isWindowObscuredAtPointLocked(newTouchedWindowHandle, x, y)) {
1592 targetFlags |= InputTarget::FLAG_WINDOW_IS_OBSCURED;
1593 } else if (isWindowObscuredLocked(newTouchedWindowHandle)) {
1594 targetFlags |= InputTarget::FLAG_WINDOW_IS_PARTIALLY_OBSCURED;
1595 }
1596
1597 // Update hover state.
1598 if (isHoverAction) {
1599 newHoverWindowHandle = newTouchedWindowHandle;
1600 } else if (maskedAction == AMOTION_EVENT_ACTION_SCROLL) {
1601 newHoverWindowHandle = mLastHoverWindowHandle;
1602 }
1603
1604 // Update the temporary touch state.
1605 BitSet32 pointerIds;
1606 if (isSplit) {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001607 uint32_t pointerId = entry.pointerProperties[pointerIndex].id;
Michael Wright3dd60e22019-03-27 22:06:44 +00001608 pointerIds.markBit(pointerId);
1609 }
1610 mTempTouchState.addOrUpdateWindow(newTouchedWindowHandle, targetFlags, pointerIds);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001611 }
1612
Michael Wright3dd60e22019-03-27 22:06:44 +00001613 mTempTouchState.addGestureMonitors(newGestureMonitors);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001614 } else {
1615 /* Case 2: Pointer move, up, cancel or non-splittable pointer down. */
1616
1617 // If the pointer is not currently down, then ignore the event.
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001618 if (!mTempTouchState.down) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01001619 if (DEBUG_FOCUS) {
1620 ALOGD("Dropping event because the pointer is not down or we previously "
1621 "dropped the pointer down event in display %" PRId32,
1622 displayId);
1623 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001624 injectionResult = INPUT_EVENT_INJECTION_FAILED;
1625 goto Failed;
1626 }
1627
1628 // Check whether touches should slip outside of the current foreground window.
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001629 if (maskedAction == AMOTION_EVENT_ACTION_MOVE && entry.pointerCount == 1 &&
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001630 mTempTouchState.isSlippery()) {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001631 int32_t x = int32_t(entry.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X));
1632 int32_t y = int32_t(entry.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001633
1634 sp<InputWindowHandle> oldTouchedWindowHandle =
1635 mTempTouchState.getFirstForegroundWindowHandle();
1636 sp<InputWindowHandle> newTouchedWindowHandle =
1637 findTouchedWindowAtLocked(displayId, x, y);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001638 if (oldTouchedWindowHandle != newTouchedWindowHandle &&
1639 oldTouchedWindowHandle != nullptr && newTouchedWindowHandle != nullptr) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01001640 if (DEBUG_FOCUS) {
1641 ALOGD("Touch is slipping out of window %s into window %s in display %" PRId32,
1642 oldTouchedWindowHandle->getName().c_str(),
1643 newTouchedWindowHandle->getName().c_str(), displayId);
1644 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001645 // Make a slippery exit from the old window.
1646 mTempTouchState.addOrUpdateWindow(oldTouchedWindowHandle,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001647 InputTarget::FLAG_DISPATCH_AS_SLIPPERY_EXIT,
1648 BitSet32(0));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001649
1650 // Make a slippery entrance into the new window.
1651 if (newTouchedWindowHandle->getInfo()->supportsSplitTouch()) {
1652 isSplit = true;
1653 }
1654
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001655 int32_t targetFlags =
1656 InputTarget::FLAG_FOREGROUND | InputTarget::FLAG_DISPATCH_AS_SLIPPERY_ENTER;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001657 if (isSplit) {
1658 targetFlags |= InputTarget::FLAG_SPLIT;
1659 }
1660 if (isWindowObscuredAtPointLocked(newTouchedWindowHandle, x, y)) {
1661 targetFlags |= InputTarget::FLAG_WINDOW_IS_OBSCURED;
1662 }
1663
1664 BitSet32 pointerIds;
1665 if (isSplit) {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001666 pointerIds.markBit(entry.pointerProperties[0].id);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001667 }
1668 mTempTouchState.addOrUpdateWindow(newTouchedWindowHandle, targetFlags, pointerIds);
1669 }
1670 }
1671 }
1672
1673 if (newHoverWindowHandle != mLastHoverWindowHandle) {
1674 // Let the previous window know that the hover sequence is over.
Yi Kong9b14ac62018-07-17 13:48:38 -07001675 if (mLastHoverWindowHandle != nullptr) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001676#if DEBUG_HOVER
1677 ALOGD("Sending hover exit event to window %s.",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001678 mLastHoverWindowHandle->getName().c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08001679#endif
1680 mTempTouchState.addOrUpdateWindow(mLastHoverWindowHandle,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001681 InputTarget::FLAG_DISPATCH_AS_HOVER_EXIT,
1682 BitSet32(0));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001683 }
1684
1685 // Let the new window know that the hover sequence is starting.
Yi Kong9b14ac62018-07-17 13:48:38 -07001686 if (newHoverWindowHandle != nullptr) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001687#if DEBUG_HOVER
1688 ALOGD("Sending hover enter event to window %s.",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001689 newHoverWindowHandle->getName().c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08001690#endif
1691 mTempTouchState.addOrUpdateWindow(newHoverWindowHandle,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001692 InputTarget::FLAG_DISPATCH_AS_HOVER_ENTER,
1693 BitSet32(0));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001694 }
1695 }
1696
1697 // Check permission to inject into all touched foreground windows and ensure there
1698 // is at least one touched foreground window.
1699 {
1700 bool haveForegroundWindow = false;
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08001701 for (const TouchedWindow& touchedWindow : mTempTouchState.windows) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001702 if (touchedWindow.targetFlags & InputTarget::FLAG_FOREGROUND) {
1703 haveForegroundWindow = true;
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001704 if (!checkInjectionPermission(touchedWindow.windowHandle, entry.injectionState)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001705 injectionResult = INPUT_EVENT_INJECTION_PERMISSION_DENIED;
1706 injectionPermission = INJECTION_PERMISSION_DENIED;
1707 goto Failed;
1708 }
1709 }
1710 }
Michael Wright3dd60e22019-03-27 22:06:44 +00001711 bool hasGestureMonitor = !mTempTouchState.gestureMonitors.empty();
1712 if (!haveForegroundWindow && !hasGestureMonitor) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01001713 if (DEBUG_FOCUS) {
1714 ALOGD("Dropping event because there is no touched foreground window in display "
1715 "%" PRId32 " or gesture monitor to receive it.",
1716 displayId);
1717 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001718 injectionResult = INPUT_EVENT_INJECTION_FAILED;
1719 goto Failed;
1720 }
1721
1722 // Permission granted to injection into all touched foreground windows.
1723 injectionPermission = INJECTION_PERMISSION_GRANTED;
1724 }
1725
1726 // Check whether windows listening for outside touches are owned by the same UID. If it is
1727 // set the policy flag that we will not reveal coordinate information to this window.
1728 if (maskedAction == AMOTION_EVENT_ACTION_DOWN) {
1729 sp<InputWindowHandle> foregroundWindowHandle =
1730 mTempTouchState.getFirstForegroundWindowHandle();
Michael Wright3dd60e22019-03-27 22:06:44 +00001731 if (foregroundWindowHandle) {
1732 const int32_t foregroundWindowUid = foregroundWindowHandle->getInfo()->ownerUid;
1733 for (const TouchedWindow& touchedWindow : mTempTouchState.windows) {
1734 if (touchedWindow.targetFlags & InputTarget::FLAG_DISPATCH_AS_OUTSIDE) {
1735 sp<InputWindowHandle> inputWindowHandle = touchedWindow.windowHandle;
1736 if (inputWindowHandle->getInfo()->ownerUid != foregroundWindowUid) {
1737 mTempTouchState.addOrUpdateWindow(inputWindowHandle,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001738 InputTarget::FLAG_ZERO_COORDS,
1739 BitSet32(0));
Michael Wright3dd60e22019-03-27 22:06:44 +00001740 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001741 }
1742 }
1743 }
1744 }
1745
1746 // Ensure all touched foreground windows are ready for new input.
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08001747 for (const TouchedWindow& touchedWindow : mTempTouchState.windows) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001748 if (touchedWindow.targetFlags & InputTarget::FLAG_FOREGROUND) {
Jeff Brownffb49772014-10-10 19:01:34 -07001749 // Check whether the window is ready for more input.
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001750 std::string reason =
1751 checkWindowReadyForMoreInputLocked(currentTime, touchedWindow.windowHandle,
1752 entry, "touched");
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08001753 if (!reason.empty()) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001754 injectionResult = handleTargetsNotReadyLocked(currentTime, entry, nullptr,
1755 touchedWindow.windowHandle,
1756 nextWakeupTime, reason.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08001757 goto Unresponsive;
1758 }
1759 }
1760 }
1761
1762 // If this is the first pointer going down and the touched window has a wallpaper
1763 // then also add the touched wallpaper windows so they are locked in for the duration
1764 // of the touch gesture.
1765 // We do not collect wallpapers during HOVER_MOVE or SCROLL because the wallpaper
1766 // engine only supports touch events. We would need to add a mechanism similar
1767 // to View.onGenericMotionEvent to enable wallpapers to handle these events.
1768 if (maskedAction == AMOTION_EVENT_ACTION_DOWN) {
1769 sp<InputWindowHandle> foregroundWindowHandle =
1770 mTempTouchState.getFirstForegroundWindowHandle();
Michael Wright3dd60e22019-03-27 22:06:44 +00001771 if (foregroundWindowHandle && foregroundWindowHandle->getInfo()->hasWallpaper) {
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08001772 const std::vector<sp<InputWindowHandle>> windowHandles =
1773 getWindowHandlesLocked(displayId);
1774 for (const sp<InputWindowHandle>& windowHandle : windowHandles) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001775 const InputWindowInfo* info = windowHandle->getInfo();
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001776 if (info->displayId == displayId &&
1777 windowHandle->getInfo()->layoutParamsType == InputWindowInfo::TYPE_WALLPAPER) {
1778 mTempTouchState
1779 .addOrUpdateWindow(windowHandle,
1780 InputTarget::FLAG_WINDOW_IS_OBSCURED |
1781 InputTarget::
1782 FLAG_WINDOW_IS_PARTIALLY_OBSCURED |
1783 InputTarget::FLAG_DISPATCH_AS_IS,
1784 BitSet32(0));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001785 }
1786 }
1787 }
1788 }
1789
1790 // Success! Output targets.
1791 injectionResult = INPUT_EVENT_INJECTION_SUCCEEDED;
1792
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08001793 for (const TouchedWindow& touchedWindow : mTempTouchState.windows) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001794 addWindowTargetLocked(touchedWindow.windowHandle, touchedWindow.targetFlags,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001795 touchedWindow.pointerIds, inputTargets);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001796 }
1797
Michael Wright3dd60e22019-03-27 22:06:44 +00001798 for (const TouchedMonitor& touchedMonitor : mTempTouchState.gestureMonitors) {
1799 addMonitoringTargetLocked(touchedMonitor.monitor, touchedMonitor.xOffset,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001800 touchedMonitor.yOffset, inputTargets);
Michael Wright3dd60e22019-03-27 22:06:44 +00001801 }
1802
Michael Wrightd02c5b62014-02-10 15:10:22 -08001803 // Drop the outside or hover touch windows since we will not care about them
1804 // in the next iteration.
1805 mTempTouchState.filterNonAsIsTouchWindows();
1806
1807Failed:
1808 // Check injection permission once and for all.
1809 if (injectionPermission == INJECTION_PERMISSION_UNKNOWN) {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001810 if (checkInjectionPermission(nullptr, entry.injectionState)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001811 injectionPermission = INJECTION_PERMISSION_GRANTED;
1812 } else {
1813 injectionPermission = INJECTION_PERMISSION_DENIED;
1814 }
1815 }
1816
1817 // Update final pieces of touch state if the injector had permission.
1818 if (injectionPermission == INJECTION_PERMISSION_GRANTED) {
1819 if (!wrongDevice) {
1820 if (switchedDevice) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01001821 if (DEBUG_FOCUS) {
1822 ALOGD("Conflicting pointer actions: Switched to a different device.");
1823 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001824 *outConflictingPointerActions = true;
1825 }
1826
1827 if (isHoverAction) {
1828 // Started hovering, therefore no longer down.
Jeff Brownf086ddb2014-02-11 14:28:48 -08001829 if (oldState && oldState->down) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01001830 if (DEBUG_FOCUS) {
1831 ALOGD("Conflicting pointer actions: Hover received while pointer was "
1832 "down.");
1833 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001834 *outConflictingPointerActions = true;
1835 }
Jeff Brownf086ddb2014-02-11 14:28:48 -08001836 mTempTouchState.reset();
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001837 if (maskedAction == AMOTION_EVENT_ACTION_HOVER_ENTER ||
1838 maskedAction == AMOTION_EVENT_ACTION_HOVER_MOVE) {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001839 mTempTouchState.deviceId = entry.deviceId;
1840 mTempTouchState.source = entry.source;
Jeff Brownf086ddb2014-02-11 14:28:48 -08001841 mTempTouchState.displayId = displayId;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001842 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001843 } else if (maskedAction == AMOTION_EVENT_ACTION_UP ||
1844 maskedAction == AMOTION_EVENT_ACTION_CANCEL) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001845 // All pointers up or canceled.
Jeff Brownf086ddb2014-02-11 14:28:48 -08001846 mTempTouchState.reset();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001847 } else if (maskedAction == AMOTION_EVENT_ACTION_DOWN) {
1848 // First pointer went down.
Jeff Brownf086ddb2014-02-11 14:28:48 -08001849 if (oldState && oldState->down) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01001850 if (DEBUG_FOCUS) {
1851 ALOGD("Conflicting pointer actions: Down received while already down.");
1852 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001853 *outConflictingPointerActions = true;
1854 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001855 } else if (maskedAction == AMOTION_EVENT_ACTION_POINTER_UP) {
1856 // One pointer went up.
1857 if (isSplit) {
1858 int32_t pointerIndex = getMotionEventActionPointerIndex(action);
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001859 uint32_t pointerId = entry.pointerProperties[pointerIndex].id;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001860
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001861 for (size_t i = 0; i < mTempTouchState.windows.size();) {
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08001862 TouchedWindow& touchedWindow = mTempTouchState.windows[i];
Michael Wrightd02c5b62014-02-10 15:10:22 -08001863 if (touchedWindow.targetFlags & InputTarget::FLAG_SPLIT) {
1864 touchedWindow.pointerIds.clearBit(pointerId);
1865 if (touchedWindow.pointerIds.isEmpty()) {
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08001866 mTempTouchState.windows.erase(mTempTouchState.windows.begin() + i);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001867 continue;
1868 }
1869 }
1870 i += 1;
1871 }
1872 }
Jeff Brownf086ddb2014-02-11 14:28:48 -08001873 }
1874
1875 // Save changes unless the action was scroll in which case the temporary touch
1876 // state was only valid for this one action.
1877 if (maskedAction != AMOTION_EVENT_ACTION_SCROLL) {
1878 if (mTempTouchState.displayId >= 0) {
1879 if (oldStateIndex >= 0) {
1880 mTouchStatesByDisplay.editValueAt(oldStateIndex).copyFrom(mTempTouchState);
1881 } else {
1882 mTouchStatesByDisplay.add(displayId, mTempTouchState);
1883 }
1884 } else if (oldStateIndex >= 0) {
1885 mTouchStatesByDisplay.removeItemsAt(oldStateIndex);
1886 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001887 }
1888
1889 // Update hover state.
1890 mLastHoverWindowHandle = newHoverWindowHandle;
1891 }
1892 } else {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01001893 if (DEBUG_FOCUS) {
1894 ALOGD("Not updating touch focus because injection was denied.");
1895 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001896 }
1897
1898Unresponsive:
1899 // Reset temporary touch state to ensure we release unnecessary references to input channels.
1900 mTempTouchState.reset();
1901
1902 nsecs_t timeSpentWaitingForApplication = getTimeSpentWaitingForApplicationLocked(currentTime);
Siarhei Vishniakou61291d42019-02-11 18:13:20 -08001903 updateDispatchStatistics(currentTime, entry, injectionResult, timeSpentWaitingForApplication);
Siarhei Vishniakou86587282019-09-09 18:20:15 +01001904 if (DEBUG_FOCUS) {
1905 ALOGD("findTouchedWindow finished: injectionResult=%d, injectionPermission=%d, "
1906 "timeSpentWaitingForApplication=%0.1fms",
1907 injectionResult, injectionPermission, timeSpentWaitingForApplication / 1000000.0);
1908 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001909 return injectionResult;
1910}
1911
1912void InputDispatcher::addWindowTargetLocked(const sp<InputWindowHandle>& windowHandle,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001913 int32_t targetFlags, BitSet32 pointerIds,
1914 std::vector<InputTarget>& inputTargets) {
Chavi Weingarten65f98b82020-01-16 18:56:50 +00001915 std::vector<InputTarget>::iterator it =
1916 std::find_if(inputTargets.begin(), inputTargets.end(),
1917 [&windowHandle](const InputTarget& inputTarget) {
1918 return inputTarget.inputChannel->getConnectionToken() ==
1919 windowHandle->getToken();
1920 });
Chavi Weingarten97b8eec2020-01-09 18:09:08 +00001921
Chavi Weingarten114b77f2020-01-15 22:35:10 +00001922 const InputWindowInfo* windowInfo = windowHandle->getInfo();
Chavi Weingarten65f98b82020-01-16 18:56:50 +00001923
1924 if (it == inputTargets.end()) {
1925 InputTarget inputTarget;
1926 sp<InputChannel> inputChannel = getInputChannelLocked(windowHandle->getToken());
1927 if (inputChannel == nullptr) {
1928 ALOGW("Window %s already unregistered input channel", windowHandle->getName().c_str());
1929 return;
1930 }
1931 inputTarget.inputChannel = inputChannel;
1932 inputTarget.flags = targetFlags;
1933 inputTarget.globalScaleFactor = windowInfo->globalScaleFactor;
1934 inputTargets.push_back(inputTarget);
1935 it = inputTargets.end() - 1;
1936 }
1937
1938 ALOG_ASSERT(it->flags == targetFlags);
1939 ALOG_ASSERT(it->globalScaleFactor == windowInfo->globalScaleFactor);
1940
1941 it->addPointers(pointerIds, -windowInfo->frameLeft, -windowInfo->frameTop,
1942 windowInfo->windowXScale, windowInfo->windowYScale);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001943}
1944
Michael Wright3dd60e22019-03-27 22:06:44 +00001945void InputDispatcher::addGlobalMonitoringTargetsLocked(std::vector<InputTarget>& inputTargets,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001946 int32_t displayId, float xOffset,
1947 float yOffset) {
Michael Wright3dd60e22019-03-27 22:06:44 +00001948 std::unordered_map<int32_t, std::vector<Monitor>>::const_iterator it =
1949 mGlobalMonitorsByDisplay.find(displayId);
1950
1951 if (it != mGlobalMonitorsByDisplay.end()) {
1952 const std::vector<Monitor>& monitors = it->second;
1953 for (const Monitor& monitor : monitors) {
1954 addMonitoringTargetLocked(monitor, xOffset, yOffset, inputTargets);
Arthur Hung2fbf37f2018-09-13 18:16:41 +08001955 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001956 }
1957}
1958
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001959void InputDispatcher::addMonitoringTargetLocked(const Monitor& monitor, float xOffset,
1960 float yOffset,
1961 std::vector<InputTarget>& inputTargets) {
Michael Wright3dd60e22019-03-27 22:06:44 +00001962 InputTarget target;
1963 target.inputChannel = monitor.inputChannel;
1964 target.flags = InputTarget::FLAG_DISPATCH_AS_IS;
Chavi Weingarten65f98b82020-01-16 18:56:50 +00001965 target.setDefaultPointerInfo(xOffset, yOffset, 1 /* windowXScale */, 1 /* windowYScale */);
Michael Wright3dd60e22019-03-27 22:06:44 +00001966 inputTargets.push_back(target);
1967}
1968
Michael Wrightd02c5b62014-02-10 15:10:22 -08001969bool InputDispatcher::checkInjectionPermission(const sp<InputWindowHandle>& windowHandle,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001970 const InjectionState* injectionState) {
1971 if (injectionState &&
1972 (windowHandle == nullptr ||
1973 windowHandle->getInfo()->ownerUid != injectionState->injectorUid) &&
1974 !hasInjectionPermission(injectionState->injectorPid, injectionState->injectorUid)) {
Yi Kong9b14ac62018-07-17 13:48:38 -07001975 if (windowHandle != nullptr) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001976 ALOGW("Permission denied: injecting event from pid %d uid %d to window %s "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001977 "owned by uid %d",
1978 injectionState->injectorPid, injectionState->injectorUid,
1979 windowHandle->getName().c_str(), windowHandle->getInfo()->ownerUid);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001980 } else {
1981 ALOGW("Permission denied: injecting event from pid %d uid %d",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001982 injectionState->injectorPid, injectionState->injectorUid);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001983 }
1984 return false;
1985 }
1986 return true;
1987}
1988
Robert Carr9cada032020-04-13 17:21:08 -07001989/**
1990 * Indicate whether one window handle should be considered as obscuring
1991 * another window handle. We only check a few preconditions. Actually
1992 * checking the bounds is left to the caller.
1993 */
1994static bool canBeObscuredBy(const sp<InputWindowHandle>& windowHandle,
1995 const sp<InputWindowHandle>& otherHandle) {
1996 // Compare by token so cloned layers aren't counted
1997 if (haveSameToken(windowHandle, otherHandle)) {
1998 return false;
1999 }
2000 auto info = windowHandle->getInfo();
2001 auto otherInfo = otherHandle->getInfo();
2002 if (!otherInfo->visible) {
2003 return false;
2004 } else if (info->ownerPid == otherInfo->ownerPid && otherHandle->getToken() == nullptr) {
2005 // In general, if ownerPid is the same we don't want to generate occlusion
2006 // events. This line is now necessary since we are including all Surfaces
2007 // in occlusion calculation, so if we didn't check PID like this SurfaceView
2008 // would occlude their parents. On the other hand before we started including
2009 // all surfaces in occlusion calculation and had this line, we would count
2010 // windows with an input channel from the same PID as occluding, and so we
2011 // preserve this behavior with the getToken() == null check.
2012 return false;
2013 } else if (otherInfo->isTrustedOverlay()) {
2014 return false;
2015 } else if (otherInfo->displayId != info->displayId) {
2016 return false;
2017 }
2018 return true;
2019}
2020
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002021bool InputDispatcher::isWindowObscuredAtPointLocked(const sp<InputWindowHandle>& windowHandle,
2022 int32_t x, int32_t y) const {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002023 int32_t displayId = windowHandle->getInfo()->displayId;
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08002024 const std::vector<sp<InputWindowHandle>> windowHandles = getWindowHandlesLocked(displayId);
2025 for (const sp<InputWindowHandle>& otherHandle : windowHandles) {
Robert Carr9cada032020-04-13 17:21:08 -07002026 if (windowHandle == otherHandle) {
2027 break; // All future windows are below us. Exit early.
Michael Wrightd02c5b62014-02-10 15:10:22 -08002028 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002029 const InputWindowInfo* otherInfo = otherHandle->getInfo();
Robert Carr9cada032020-04-13 17:21:08 -07002030 if (canBeObscuredBy(windowHandle, otherHandle) &&
2031 otherInfo->frameContainsPoint(x, y)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002032 return true;
2033 }
2034 }
2035 return false;
2036}
2037
Michael Wrightcdcd8f22016-03-22 16:52:13 -07002038bool InputDispatcher::isWindowObscuredLocked(const sp<InputWindowHandle>& windowHandle) const {
2039 int32_t displayId = windowHandle->getInfo()->displayId;
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08002040 const std::vector<sp<InputWindowHandle>> windowHandles = getWindowHandlesLocked(displayId);
Michael Wrightcdcd8f22016-03-22 16:52:13 -07002041 const InputWindowInfo* windowInfo = windowHandle->getInfo();
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08002042 for (const sp<InputWindowHandle>& otherHandle : windowHandles) {
Robert Carr9cada032020-04-13 17:21:08 -07002043 if (windowHandle == otherHandle) {
2044 break; // All future windows are below us. Exit early.
Michael Wrightcdcd8f22016-03-22 16:52:13 -07002045 }
2046
2047 const InputWindowInfo* otherInfo = otherHandle->getInfo();
Robert Carr9cada032020-04-13 17:21:08 -07002048 if (canBeObscuredBy(windowHandle, otherHandle) &&
2049 otherInfo->overlaps(windowInfo)) {
Michael Wrightcdcd8f22016-03-22 16:52:13 -07002050 return true;
2051 }
2052 }
2053 return false;
2054}
2055
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002056std::string InputDispatcher::checkWindowReadyForMoreInputLocked(
2057 nsecs_t currentTime, const sp<InputWindowHandle>& windowHandle,
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002058 const EventEntry& eventEntry, const char* targetType) {
Jeff Brownffb49772014-10-10 19:01:34 -07002059 // If the window is paused then keep waiting.
2060 if (windowHandle->getInfo()->paused) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002061 return StringPrintf("Waiting because the %s window is paused.", targetType);
Jeff Brownffb49772014-10-10 19:01:34 -07002062 }
2063
2064 // If the window's connection is not registered then keep waiting.
Siarhei Vishniakoud0d71b62019-10-14 14:50:45 -07002065 sp<Connection> connection = getConnectionLocked(windowHandle->getToken());
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07002066 if (connection == nullptr) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002067 return StringPrintf("Waiting because the %s window's input channel is not "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002068 "registered with the input dispatcher. The window may be in the "
2069 "process of being removed.",
2070 targetType);
Jeff Brownffb49772014-10-10 19:01:34 -07002071 }
2072
2073 // If the connection is dead then keep waiting.
Jeff Brownffb49772014-10-10 19:01:34 -07002074 if (connection->status != Connection::STATUS_NORMAL) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002075 return StringPrintf("Waiting because the %s window's input connection is %s."
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002076 "The window may be in the process of being removed.",
2077 targetType, connection->getStatusLabel());
Jeff Brownffb49772014-10-10 19:01:34 -07002078 }
2079
2080 // If the connection is backed up then keep waiting.
2081 if (connection->inputPublisherBlocked) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002082 return StringPrintf("Waiting because the %s window's input channel is full. "
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07002083 "Outbound queue length: %zu. Wait queue length: %zu.",
2084 targetType, connection->outboundQueue.size(),
2085 connection->waitQueue.size());
Jeff Brownffb49772014-10-10 19:01:34 -07002086 }
2087
2088 // Ensure that the dispatch queues aren't too far backed up for this event.
Siarhei Vishniakou49483272019-10-22 13:13:47 -07002089 if (eventEntry.type == EventEntry::Type::KEY) {
Jeff Brownffb49772014-10-10 19:01:34 -07002090 // If the event is a key event, then we must wait for all previous events to
2091 // complete before delivering it because previous events may have the
2092 // side-effect of transferring focus to a different window and we want to
2093 // ensure that the following keys are sent to the new window.
2094 //
2095 // Suppose the user touches a button in a window then immediately presses "A".
2096 // If the button causes a pop-up window to appear then we want to ensure that
2097 // the "A" key is delivered to the new pop-up window. This is because users
2098 // often anticipate pending UI changes when typing on a keyboard.
2099 // To obtain this behavior, we must serialize key events with respect to all
2100 // prior input events.
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07002101 if (!connection->outboundQueue.empty() || !connection->waitQueue.empty()) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002102 return StringPrintf("Waiting to send key event because the %s window has not "
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07002103 "finished processing all of the input events that were previously "
2104 "delivered to it. Outbound queue length: %zu. Wait queue length: "
2105 "%zu.",
2106 targetType, connection->outboundQueue.size(),
2107 connection->waitQueue.size());
Michael Wrightd02c5b62014-02-10 15:10:22 -08002108 }
Jeff Brownffb49772014-10-10 19:01:34 -07002109 } else {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002110 // Touch events can always be sent to a window immediately because the user intended
2111 // to touch whatever was visible at the time. Even if focus changes or a new
2112 // window appears moments later, the touch event was meant to be delivered to
2113 // whatever window happened to be on screen at the time.
2114 //
2115 // Generic motion events, such as trackball or joystick events are a little trickier.
2116 // Like key events, generic motion events are delivered to the focused window.
2117 // Unlike key events, generic motion events don't tend to transfer focus to other
2118 // windows and it is not important for them to be serialized. So we prefer to deliver
2119 // generic motion events as soon as possible to improve efficiency and reduce lag
2120 // through batching.
2121 //
2122 // The one case where we pause input event delivery is when the wait queue is piling
2123 // up with lots of events because the application is not responding.
2124 // This condition ensures that ANRs are detected reliably.
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07002125 if (!connection->waitQueue.empty() &&
2126 currentTime >=
2127 connection->waitQueue.front()->deliveryTime + STREAM_AHEAD_EVENT_TIMEOUT) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002128 return StringPrintf("Waiting to send non-key event because the %s window has not "
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07002129 "finished processing certain input events that were delivered to "
2130 "it over "
2131 "%0.1fms ago. Wait queue length: %zu. Wait queue head age: "
2132 "%0.1fms.",
2133 targetType, STREAM_AHEAD_EVENT_TIMEOUT * 0.000001f,
2134 connection->waitQueue.size(),
2135 (currentTime - connection->waitQueue.front()->deliveryTime) *
2136 0.000001f);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002137 }
2138 }
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002139 return "";
Michael Wrightd02c5b62014-02-10 15:10:22 -08002140}
2141
Siarhei Vishniakou61291d42019-02-11 18:13:20 -08002142std::string InputDispatcher::getApplicationWindowLabel(
Michael Wrightd02c5b62014-02-10 15:10:22 -08002143 const sp<InputApplicationHandle>& applicationHandle,
2144 const sp<InputWindowHandle>& windowHandle) {
Yi Kong9b14ac62018-07-17 13:48:38 -07002145 if (applicationHandle != nullptr) {
2146 if (windowHandle != nullptr) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002147 std::string label(applicationHandle->getName());
2148 label += " - ";
2149 label += windowHandle->getName();
Michael Wrightd02c5b62014-02-10 15:10:22 -08002150 return label;
2151 } else {
2152 return applicationHandle->getName();
2153 }
Yi Kong9b14ac62018-07-17 13:48:38 -07002154 } else if (windowHandle != nullptr) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002155 return windowHandle->getName();
2156 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002157 return "<unknown application or window>";
Michael Wrightd02c5b62014-02-10 15:10:22 -08002158 }
2159}
2160
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002161void InputDispatcher::pokeUserActivityLocked(const EventEntry& eventEntry) {
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01002162 if (eventEntry.type == EventEntry::Type::FOCUS) {
2163 // Focus events are passed to apps, but do not represent user activity.
2164 return;
2165 }
Tiger Huang721e26f2018-07-24 22:26:19 +08002166 int32_t displayId = getTargetDisplayId(eventEntry);
2167 sp<InputWindowHandle> focusedWindowHandle =
2168 getValueByKey(mFocusedWindowHandlesByDisplay, displayId);
2169 if (focusedWindowHandle != nullptr) {
2170 const InputWindowInfo* info = focusedWindowHandle->getInfo();
Michael Wrightd02c5b62014-02-10 15:10:22 -08002171 if (info->inputFeatures & InputWindowInfo::INPUT_FEATURE_DISABLE_USER_ACTIVITY) {
2172#if DEBUG_DISPATCH_CYCLE
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002173 ALOGD("Not poking user activity: disabled by window '%s'.", info->name.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08002174#endif
2175 return;
2176 }
2177 }
2178
2179 int32_t eventType = USER_ACTIVITY_EVENT_OTHER;
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002180 switch (eventEntry.type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07002181 case EventEntry::Type::MOTION: {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002182 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(eventEntry);
2183 if (motionEntry.action == AMOTION_EVENT_ACTION_CANCEL) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002184 return;
2185 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002186
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002187 if (MotionEvent::isTouchEvent(motionEntry.source, motionEntry.action)) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002188 eventType = USER_ACTIVITY_EVENT_TOUCH;
2189 }
2190 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002191 }
Siarhei Vishniakou49483272019-10-22 13:13:47 -07002192 case EventEntry::Type::KEY: {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002193 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(eventEntry);
2194 if (keyEntry.flags & AKEY_EVENT_FLAG_CANCELED) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002195 return;
2196 }
2197 eventType = USER_ACTIVITY_EVENT_BUTTON;
2198 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002199 }
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01002200 case EventEntry::Type::FOCUS:
Siarhei Vishniakou49483272019-10-22 13:13:47 -07002201 case EventEntry::Type::CONFIGURATION_CHANGED:
2202 case EventEntry::Type::DEVICE_RESET: {
2203 LOG_ALWAYS_FATAL("%s events are not user activity",
2204 EventEntry::typeToString(eventEntry.type));
2205 break;
2206 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002207 }
2208
Siarhei Vishniakoue7c94b92019-07-29 09:17:54 -07002209 std::unique_ptr<CommandEntry> commandEntry =
2210 std::make_unique<CommandEntry>(&InputDispatcher::doPokeUserActivityLockedInterruptible);
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002211 commandEntry->eventTime = eventEntry.eventTime;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002212 commandEntry->userActivityEventType = eventType;
Siarhei Vishniakoue7c94b92019-07-29 09:17:54 -07002213 postCommandLocked(std::move(commandEntry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08002214}
2215
2216void InputDispatcher::prepareDispatchCycleLocked(nsecs_t currentTime,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002217 const sp<Connection>& connection,
2218 EventEntry* eventEntry,
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08002219 const InputTarget& inputTarget) {
Michael Wright3dd60e22019-03-27 22:06:44 +00002220 if (ATRACE_ENABLED()) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002221 std::string message =
Garfield Tan1c7bc862020-01-28 13:24:04 -08002222 StringPrintf("prepareDispatchCycleLocked(inputChannel=%s, id=0x%" PRIx32 ")",
Garfield Tanc51d1ba2020-01-28 13:24:04 -08002223 connection->getInputChannelName().c_str(), eventEntry->id);
Michael Wright3dd60e22019-03-27 22:06:44 +00002224 ATRACE_NAME(message.c_str());
2225 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002226#if DEBUG_DISPATCH_CYCLE
2227 ALOGD("channel '%s' ~ prepareDispatchCycle - flags=0x%08x, "
Chavi Weingarten65f98b82020-01-16 18:56:50 +00002228 "globalScaleFactor=%f, pointerIds=0x%x %s",
2229 connection->getInputChannelName().c_str(), inputTarget.flags,
2230 inputTarget.globalScaleFactor, inputTarget.pointerIds.value,
2231 inputTarget.getPointerInfoString().c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08002232#endif
2233
2234 // Skip this event if the connection status is not normal.
2235 // We don't want to enqueue additional outbound events if the connection is broken.
2236 if (connection->status != Connection::STATUS_NORMAL) {
2237#if DEBUG_DISPATCH_CYCLE
2238 ALOGD("channel '%s' ~ Dropping event because the channel status is %s",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002239 connection->getInputChannelName().c_str(), connection->getStatusLabel());
Michael Wrightd02c5b62014-02-10 15:10:22 -08002240#endif
2241 return;
2242 }
2243
2244 // Split a motion event if needed.
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08002245 if (inputTarget.flags & InputTarget::FLAG_SPLIT) {
2246 LOG_ALWAYS_FATAL_IF(eventEntry->type != EventEntry::Type::MOTION,
2247 "Entry type %s should not have FLAG_SPLIT",
2248 EventEntry::typeToString(eventEntry->type));
Michael Wrightd02c5b62014-02-10 15:10:22 -08002249
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002250 const MotionEntry& originalMotionEntry = static_cast<const MotionEntry&>(*eventEntry);
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08002251 if (inputTarget.pointerIds.count() != originalMotionEntry.pointerCount) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002252 MotionEntry* splitMotionEntry =
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08002253 splitMotionEvent(originalMotionEntry, inputTarget.pointerIds);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002254 if (!splitMotionEntry) {
2255 return; // split event was dropped
2256 }
Siarhei Vishniakou86587282019-09-09 18:20:15 +01002257 if (DEBUG_FOCUS) {
2258 ALOGD("channel '%s' ~ Split motion event.",
2259 connection->getInputChannelName().c_str());
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002260 logOutboundMotionDetails(" ", *splitMotionEntry);
Siarhei Vishniakou86587282019-09-09 18:20:15 +01002261 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002262 enqueueDispatchEntriesLocked(currentTime, connection, splitMotionEntry, inputTarget);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002263 splitMotionEntry->release();
2264 return;
2265 }
2266 }
2267
2268 // Not splitting. Enqueue dispatch entries for the event as is.
2269 enqueueDispatchEntriesLocked(currentTime, connection, eventEntry, inputTarget);
2270}
2271
2272void InputDispatcher::enqueueDispatchEntriesLocked(nsecs_t currentTime,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002273 const sp<Connection>& connection,
2274 EventEntry* eventEntry,
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08002275 const InputTarget& inputTarget) {
Michael Wright3dd60e22019-03-27 22:06:44 +00002276 if (ATRACE_ENABLED()) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002277 std::string message =
Garfield Tan1c7bc862020-01-28 13:24:04 -08002278 StringPrintf("enqueueDispatchEntriesLocked(inputChannel=%s, id=0x%" PRIx32 ")",
Garfield Tanc51d1ba2020-01-28 13:24:04 -08002279 connection->getInputChannelName().c_str(), eventEntry->id);
Michael Wright3dd60e22019-03-27 22:06:44 +00002280 ATRACE_NAME(message.c_str());
2281 }
2282
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07002283 bool wasEmpty = connection->outboundQueue.empty();
Michael Wrightd02c5b62014-02-10 15:10:22 -08002284
2285 // Enqueue dispatch entries for the requested modes.
chaviw8c9cf542019-03-25 13:02:48 -07002286 enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002287 InputTarget::FLAG_DISPATCH_AS_HOVER_EXIT);
chaviw8c9cf542019-03-25 13:02:48 -07002288 enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002289 InputTarget::FLAG_DISPATCH_AS_OUTSIDE);
chaviw8c9cf542019-03-25 13:02:48 -07002290 enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002291 InputTarget::FLAG_DISPATCH_AS_HOVER_ENTER);
chaviw8c9cf542019-03-25 13:02:48 -07002292 enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002293 InputTarget::FLAG_DISPATCH_AS_IS);
chaviw8c9cf542019-03-25 13:02:48 -07002294 enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002295 InputTarget::FLAG_DISPATCH_AS_SLIPPERY_EXIT);
chaviw8c9cf542019-03-25 13:02:48 -07002296 enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002297 InputTarget::FLAG_DISPATCH_AS_SLIPPERY_ENTER);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002298
2299 // If the outbound queue was previously empty, start the dispatch cycle going.
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07002300 if (wasEmpty && !connection->outboundQueue.empty()) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002301 startDispatchCycleLocked(currentTime, connection);
2302 }
2303}
2304
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002305void InputDispatcher::enqueueDispatchEntryLocked(const sp<Connection>& connection,
2306 EventEntry* eventEntry,
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08002307 const InputTarget& inputTarget,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002308 int32_t dispatchMode) {
Michael Wright3dd60e22019-03-27 22:06:44 +00002309 if (ATRACE_ENABLED()) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002310 std::string message = StringPrintf("enqueueDispatchEntry(inputChannel=%s, dispatchMode=%s)",
2311 connection->getInputChannelName().c_str(),
2312 dispatchModeToString(dispatchMode).c_str());
Michael Wright3dd60e22019-03-27 22:06:44 +00002313 ATRACE_NAME(message.c_str());
2314 }
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08002315 int32_t inputTargetFlags = inputTarget.flags;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002316 if (!(inputTargetFlags & dispatchMode)) {
2317 return;
2318 }
2319 inputTargetFlags = (inputTargetFlags & ~InputTarget::FLAG_DISPATCH_MASK) | dispatchMode;
2320
2321 // This is a new event.
2322 // Enqueue a new dispatch entry onto the outbound queue for this connection.
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08002323 std::unique_ptr<DispatchEntry> dispatchEntry =
Chavi Weingarten65f98b82020-01-16 18:56:50 +00002324 createDispatchEntry(inputTarget, eventEntry, inputTargetFlags);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002325
Chavi Weingarten65f98b82020-01-16 18:56:50 +00002326 // Use the eventEntry from dispatchEntry since the entry may have changed and can now be a
2327 // different EventEntry than what was passed in.
2328 EventEntry* newEntry = dispatchEntry->eventEntry;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002329 // Apply target flags and update the connection's input state.
Chavi Weingarten65f98b82020-01-16 18:56:50 +00002330 switch (newEntry->type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07002331 case EventEntry::Type::KEY: {
Chavi Weingarten65f98b82020-01-16 18:56:50 +00002332 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(*newEntry);
Garfield Tan1c7bc862020-01-28 13:24:04 -08002333 dispatchEntry->resolvedEventId = keyEntry.id;
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002334 dispatchEntry->resolvedAction = keyEntry.action;
2335 dispatchEntry->resolvedFlags = keyEntry.flags;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002336
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002337 if (!connection->inputState.trackKey(keyEntry, dispatchEntry->resolvedAction,
2338 dispatchEntry->resolvedFlags)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002339#if DEBUG_DISPATCH_CYCLE
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002340 ALOGD("channel '%s' ~ enqueueDispatchEntryLocked: skipping inconsistent key event",
2341 connection->getInputChannelName().c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08002342#endif
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002343 return; // skip the inconsistent event
2344 }
2345 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002346 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002347
Siarhei Vishniakou49483272019-10-22 13:13:47 -07002348 case EventEntry::Type::MOTION: {
Chavi Weingarten65f98b82020-01-16 18:56:50 +00002349 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(*newEntry);
Garfield Tan1c7bc862020-01-28 13:24:04 -08002350 // Assign a default value to dispatchEntry that will never be generated by InputReader,
2351 // and assign a InputDispatcher value if it doesn't change in the if-else chain below.
2352 constexpr int32_t DEFAULT_RESOLVED_EVENT_ID =
2353 static_cast<int32_t>(IdGenerator::Source::OTHER);
2354 dispatchEntry->resolvedEventId = DEFAULT_RESOLVED_EVENT_ID;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002355 if (dispatchMode & InputTarget::FLAG_DISPATCH_AS_OUTSIDE) {
2356 dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_OUTSIDE;
2357 } else if (dispatchMode & InputTarget::FLAG_DISPATCH_AS_HOVER_EXIT) {
2358 dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_HOVER_EXIT;
2359 } else if (dispatchMode & InputTarget::FLAG_DISPATCH_AS_HOVER_ENTER) {
2360 dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_HOVER_ENTER;
2361 } else if (dispatchMode & InputTarget::FLAG_DISPATCH_AS_SLIPPERY_EXIT) {
2362 dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_CANCEL;
2363 } else if (dispatchMode & InputTarget::FLAG_DISPATCH_AS_SLIPPERY_ENTER) {
2364 dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_DOWN;
2365 } else {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002366 dispatchEntry->resolvedAction = motionEntry.action;
Garfield Tan1c7bc862020-01-28 13:24:04 -08002367 dispatchEntry->resolvedEventId = motionEntry.id;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002368 }
2369 if (dispatchEntry->resolvedAction == AMOTION_EVENT_ACTION_HOVER_MOVE &&
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002370 !connection->inputState.isHovering(motionEntry.deviceId, motionEntry.source,
2371 motionEntry.displayId)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002372#if DEBUG_DISPATCH_CYCLE
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002373 ALOGD("channel '%s' ~ enqueueDispatchEntryLocked: filling in missing hover enter "
2374 "event",
2375 connection->getInputChannelName().c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08002376#endif
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002377 dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_HOVER_ENTER;
2378 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002379
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002380 dispatchEntry->resolvedFlags = motionEntry.flags;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002381 if (dispatchEntry->targetFlags & InputTarget::FLAG_WINDOW_IS_OBSCURED) {
2382 dispatchEntry->resolvedFlags |= AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED;
2383 }
2384 if (dispatchEntry->targetFlags & InputTarget::FLAG_WINDOW_IS_PARTIALLY_OBSCURED) {
2385 dispatchEntry->resolvedFlags |= AMOTION_EVENT_FLAG_WINDOW_IS_PARTIALLY_OBSCURED;
2386 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002387
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002388 if (!connection->inputState.trackMotion(motionEntry, dispatchEntry->resolvedAction,
2389 dispatchEntry->resolvedFlags)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002390#if DEBUG_DISPATCH_CYCLE
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002391 ALOGD("channel '%s' ~ enqueueDispatchEntryLocked: skipping inconsistent motion "
2392 "event",
2393 connection->getInputChannelName().c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08002394#endif
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002395 return; // skip the inconsistent event
2396 }
2397
Garfield Tan1c7bc862020-01-28 13:24:04 -08002398 dispatchEntry->resolvedEventId =
2399 dispatchEntry->resolvedEventId == DEFAULT_RESOLVED_EVENT_ID
2400 ? mIdGenerator.nextId()
2401 : motionEntry.id;
2402 if (ATRACE_ENABLED() && dispatchEntry->resolvedEventId != motionEntry.id) {
2403 std::string message = StringPrintf("Transmute MotionEvent(id=0x%" PRIx32
2404 ") to MotionEvent(id=0x%" PRIx32 ").",
2405 motionEntry.id, dispatchEntry->resolvedEventId);
2406 ATRACE_NAME(message.c_str());
2407 }
2408
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002409 dispatchPointerDownOutsideFocus(motionEntry.source, dispatchEntry->resolvedAction,
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08002410 inputTarget.inputChannel->getConnectionToken());
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002411
2412 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002413 }
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01002414 case EventEntry::Type::FOCUS: {
2415 break;
2416 }
Siarhei Vishniakou49483272019-10-22 13:13:47 -07002417 case EventEntry::Type::CONFIGURATION_CHANGED:
2418 case EventEntry::Type::DEVICE_RESET: {
2419 LOG_ALWAYS_FATAL("%s events should not go to apps",
Chavi Weingarten65f98b82020-01-16 18:56:50 +00002420 EventEntry::typeToString(newEntry->type));
Siarhei Vishniakou49483272019-10-22 13:13:47 -07002421 break;
2422 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002423 }
2424
2425 // Remember that we are waiting for this dispatch to complete.
2426 if (dispatchEntry->hasForegroundTarget()) {
Chavi Weingarten65f98b82020-01-16 18:56:50 +00002427 incrementPendingForegroundDispatches(newEntry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002428 }
2429
2430 // Enqueue the dispatch entry.
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08002431 connection->outboundQueue.push_back(dispatchEntry.release());
Siarhei Vishniakou61291d42019-02-11 18:13:20 -08002432 traceOutboundQueueLength(connection);
chaviw8c9cf542019-03-25 13:02:48 -07002433}
2434
chaviwfd6d3512019-03-25 13:23:49 -07002435void InputDispatcher::dispatchPointerDownOutsideFocus(uint32_t source, int32_t action,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002436 const sp<IBinder>& newToken) {
chaviw8c9cf542019-03-25 13:02:48 -07002437 int32_t maskedAction = action & AMOTION_EVENT_ACTION_MASK;
chaviwfd6d3512019-03-25 13:23:49 -07002438 uint32_t maskedSource = source & AINPUT_SOURCE_CLASS_MASK;
2439 if (maskedSource != AINPUT_SOURCE_CLASS_POINTER || maskedAction != AMOTION_EVENT_ACTION_DOWN) {
chaviw8c9cf542019-03-25 13:02:48 -07002440 return;
2441 }
2442
2443 sp<InputWindowHandle> inputWindowHandle = getWindowHandleLocked(newToken);
2444 if (inputWindowHandle == nullptr) {
2445 return;
2446 }
2447
chaviw8c9cf542019-03-25 13:02:48 -07002448 sp<InputWindowHandle> focusedWindowHandle =
Tiger Huang0683fe72019-06-03 21:50:55 +08002449 getValueByKey(mFocusedWindowHandlesByDisplay, mFocusedDisplayId);
chaviw8c9cf542019-03-25 13:02:48 -07002450
2451 bool hasFocusChanged = !focusedWindowHandle || focusedWindowHandle->getToken() != newToken;
2452
2453 if (!hasFocusChanged) {
2454 return;
2455 }
2456
Siarhei Vishniakoue7c94b92019-07-29 09:17:54 -07002457 std::unique_ptr<CommandEntry> commandEntry = std::make_unique<CommandEntry>(
2458 &InputDispatcher::doOnPointerDownOutsideFocusLockedInterruptible);
chaviwfd6d3512019-03-25 13:23:49 -07002459 commandEntry->newToken = newToken;
Siarhei Vishniakoue7c94b92019-07-29 09:17:54 -07002460 postCommandLocked(std::move(commandEntry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08002461}
2462
2463void InputDispatcher::startDispatchCycleLocked(nsecs_t currentTime,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002464 const sp<Connection>& connection) {
Michael Wright3dd60e22019-03-27 22:06:44 +00002465 if (ATRACE_ENABLED()) {
2466 std::string message = StringPrintf("startDispatchCycleLocked(inputChannel=%s)",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002467 connection->getInputChannelName().c_str());
Michael Wright3dd60e22019-03-27 22:06:44 +00002468 ATRACE_NAME(message.c_str());
2469 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002470#if DEBUG_DISPATCH_CYCLE
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002471 ALOGD("channel '%s' ~ startDispatchCycle", connection->getInputChannelName().c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08002472#endif
2473
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07002474 while (connection->status == Connection::STATUS_NORMAL && !connection->outboundQueue.empty()) {
2475 DispatchEntry* dispatchEntry = connection->outboundQueue.front();
Michael Wrightd02c5b62014-02-10 15:10:22 -08002476 dispatchEntry->deliveryTime = currentTime;
2477
2478 // Publish the event.
2479 status_t status;
2480 EventEntry* eventEntry = dispatchEntry->eventEntry;
2481 switch (eventEntry->type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07002482 case EventEntry::Type::KEY: {
Edgar Arriaga3d61bc12020-04-16 18:46:48 -07002483 const KeyEntry* keyEntry = static_cast<KeyEntry*>(eventEntry);
2484 std::array<uint8_t, 32> hmac = getSignature(*keyEntry, *dispatchEntry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002485
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002486 // Publish the key event.
Garfield Tan1c7bc862020-01-28 13:24:04 -08002487 status =
2488 connection->inputPublisher
2489 .publishKeyEvent(dispatchEntry->seq, dispatchEntry->resolvedEventId,
2490 keyEntry->deviceId, keyEntry->source,
2491 keyEntry->displayId, std::move(hmac),
2492 dispatchEntry->resolvedAction,
2493 dispatchEntry->resolvedFlags, keyEntry->keyCode,
2494 keyEntry->scanCode, keyEntry->metaState,
2495 keyEntry->repeatCount, keyEntry->downTime,
2496 keyEntry->eventTime);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002497 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002498 }
2499
Siarhei Vishniakou49483272019-10-22 13:13:47 -07002500 case EventEntry::Type::MOTION: {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002501 MotionEntry* motionEntry = static_cast<MotionEntry*>(eventEntry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002502
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002503 PointerCoords scaledCoords[MAX_POINTERS];
2504 const PointerCoords* usingCoords = motionEntry->pointerCoords;
2505
chaviw82357092020-01-28 13:13:06 -08002506 // Set the X and Y offset and X and Y scale depending on the input source.
2507 float xOffset = 0.0f, yOffset = 0.0f;
2508 float xScale = 1.0f, yScale = 1.0f;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002509 if ((motionEntry->source & AINPUT_SOURCE_CLASS_POINTER) &&
2510 !(dispatchEntry->targetFlags & InputTarget::FLAG_ZERO_COORDS)) {
2511 float globalScaleFactor = dispatchEntry->globalScaleFactor;
chaviw82357092020-01-28 13:13:06 -08002512 xScale = dispatchEntry->windowXScale;
2513 yScale = dispatchEntry->windowYScale;
2514 xOffset = dispatchEntry->xOffset * xScale;
2515 yOffset = dispatchEntry->yOffset * yScale;
2516 if (globalScaleFactor != 1.0f) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002517 for (uint32_t i = 0; i < motionEntry->pointerCount; i++) {
2518 scaledCoords[i] = motionEntry->pointerCoords[i];
chaviw82357092020-01-28 13:13:06 -08002519 // Don't apply window scale here since we don't want scale to affect raw
2520 // coordinates. The scale will be sent back to the client and applied
2521 // later when requesting relative coordinates.
2522 scaledCoords[i].scale(globalScaleFactor, 1 /* windowXScale */,
2523 1 /* windowYScale */);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002524 }
2525 usingCoords = scaledCoords;
2526 }
2527 } else {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002528 // We don't want the dispatch target to know.
2529 if (dispatchEntry->targetFlags & InputTarget::FLAG_ZERO_COORDS) {
2530 for (uint32_t i = 0; i < motionEntry->pointerCount; i++) {
2531 scaledCoords[i].clear();
2532 }
2533 usingCoords = scaledCoords;
2534 }
2535 }
Edgar Arriaga3d61bc12020-04-16 18:46:48 -07002536
2537 std::array<uint8_t, 32> hmac = getSignature(*motionEntry, *dispatchEntry);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002538
2539 // Publish the motion event.
2540 status = connection->inputPublisher
Garfield Tan1c7bc862020-01-28 13:24:04 -08002541 .publishMotionEvent(dispatchEntry->seq,
2542 dispatchEntry->resolvedEventId,
2543 motionEntry->deviceId, motionEntry->source,
2544 motionEntry->displayId, std::move(hmac),
2545 dispatchEntry->resolvedAction,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002546 motionEntry->actionButton,
2547 dispatchEntry->resolvedFlags,
2548 motionEntry->edgeFlags, motionEntry->metaState,
2549 motionEntry->buttonState,
chaviw82357092020-01-28 13:13:06 -08002550 motionEntry->classification, xScale, yScale,
2551 xOffset, yOffset, motionEntry->xPrecision,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002552 motionEntry->yPrecision,
2553 motionEntry->xCursorPosition,
2554 motionEntry->yCursorPosition,
2555 motionEntry->downTime, motionEntry->eventTime,
2556 motionEntry->pointerCount,
2557 motionEntry->pointerProperties, usingCoords);
Siarhei Vishniakoude4bf152019-08-16 11:12:52 -05002558 reportTouchEventForStatistics(*motionEntry);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002559 break;
2560 }
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01002561 case EventEntry::Type::FOCUS: {
2562 FocusEntry* focusEntry = static_cast<FocusEntry*>(eventEntry);
2563 status = connection->inputPublisher.publishFocusEvent(dispatchEntry->seq,
Garfield Tan1c7bc862020-01-28 13:24:04 -08002564 focusEntry->id,
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01002565 focusEntry->hasFocus,
2566 mInTouchMode);
2567 break;
2568 }
2569
Siarhei Vishniakou3b37f9a2019-11-23 13:42:41 -08002570 case EventEntry::Type::CONFIGURATION_CHANGED:
2571 case EventEntry::Type::DEVICE_RESET: {
2572 LOG_ALWAYS_FATAL("Should never start dispatch cycles for %s events",
2573 EventEntry::typeToString(eventEntry->type));
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002574 return;
Siarhei Vishniakou3b37f9a2019-11-23 13:42:41 -08002575 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002576 }
2577
2578 // Check the result.
2579 if (status) {
2580 if (status == WOULD_BLOCK) {
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07002581 if (connection->waitQueue.empty()) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002582 ALOGE("channel '%s' ~ Could not publish event because the pipe is full. "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002583 "This is unexpected because the wait queue is empty, so the pipe "
2584 "should be empty and we shouldn't have any problems writing an "
2585 "event to it, status=%d",
2586 connection->getInputChannelName().c_str(), status);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002587 abortBrokenDispatchCycleLocked(currentTime, connection, true /*notify*/);
2588 } else {
2589 // Pipe is full and we are waiting for the app to finish process some events
2590 // before sending more events to it.
2591#if DEBUG_DISPATCH_CYCLE
2592 ALOGD("channel '%s' ~ Could not publish event because the pipe is full, "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002593 "waiting for the application to catch up",
2594 connection->getInputChannelName().c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08002595#endif
2596 connection->inputPublisherBlocked = true;
2597 }
2598 } else {
2599 ALOGE("channel '%s' ~ Could not publish event due to an unexpected error, "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002600 "status=%d",
2601 connection->getInputChannelName().c_str(), status);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002602 abortBrokenDispatchCycleLocked(currentTime, connection, true /*notify*/);
2603 }
2604 return;
2605 }
2606
2607 // Re-enqueue the event on the wait queue.
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07002608 connection->outboundQueue.erase(std::remove(connection->outboundQueue.begin(),
2609 connection->outboundQueue.end(),
2610 dispatchEntry));
Siarhei Vishniakou61291d42019-02-11 18:13:20 -08002611 traceOutboundQueueLength(connection);
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07002612 connection->waitQueue.push_back(dispatchEntry);
Siarhei Vishniakou61291d42019-02-11 18:13:20 -08002613 traceWaitQueueLength(connection);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002614 }
2615}
2616
Edgar Arriaga3d61bc12020-04-16 18:46:48 -07002617const std::array<uint8_t, 32> InputDispatcher::getSignature(
2618 const MotionEntry& motionEntry, const DispatchEntry& dispatchEntry) const {
2619 int32_t actionMasked = dispatchEntry.resolvedAction & AMOTION_EVENT_ACTION_MASK;
2620 if ((actionMasked == AMOTION_EVENT_ACTION_UP) || (actionMasked == AMOTION_EVENT_ACTION_DOWN)) {
2621 // Only sign events up and down events as the purely move events
2622 // are tied to their up/down counterparts so signing would be redundant.
2623 VerifiedMotionEvent verifiedEvent = verifiedMotionEventFromMotionEntry(motionEntry);
2624 verifiedEvent.actionMasked = actionMasked;
2625 verifiedEvent.flags = dispatchEntry.resolvedFlags & VERIFIED_MOTION_EVENT_FLAGS;
2626 return mHmacKeyManager.sign(verifiedEvent);
2627 }
2628 return INVALID_HMAC;
2629}
2630
2631const std::array<uint8_t, 32> InputDispatcher::getSignature(
2632 const KeyEntry& keyEntry, const DispatchEntry& dispatchEntry) const {
2633 VerifiedKeyEvent verifiedEvent = verifiedKeyEventFromKeyEntry(keyEntry);
2634 verifiedEvent.flags = dispatchEntry.resolvedFlags & VERIFIED_KEY_EVENT_FLAGS;
2635 verifiedEvent.action = dispatchEntry.resolvedAction;
2636 return mHmacKeyManager.sign(verifiedEvent);
2637}
2638
Michael Wrightd02c5b62014-02-10 15:10:22 -08002639void InputDispatcher::finishDispatchCycleLocked(nsecs_t currentTime,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002640 const sp<Connection>& connection, uint32_t seq,
2641 bool handled) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002642#if DEBUG_DISPATCH_CYCLE
2643 ALOGD("channel '%s' ~ finishDispatchCycle - seq=%u, handled=%s",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002644 connection->getInputChannelName().c_str(), seq, toString(handled));
Michael Wrightd02c5b62014-02-10 15:10:22 -08002645#endif
2646
2647 connection->inputPublisherBlocked = false;
2648
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002649 if (connection->status == Connection::STATUS_BROKEN ||
2650 connection->status == Connection::STATUS_ZOMBIE) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002651 return;
2652 }
2653
2654 // Notify other system components and prepare to start the next dispatch cycle.
2655 onDispatchCycleFinishedLocked(currentTime, connection, seq, handled);
2656}
2657
2658void InputDispatcher::abortBrokenDispatchCycleLocked(nsecs_t currentTime,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002659 const sp<Connection>& connection,
2660 bool notify) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002661#if DEBUG_DISPATCH_CYCLE
2662 ALOGD("channel '%s' ~ abortBrokenDispatchCycle - notify=%s",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002663 connection->getInputChannelName().c_str(), toString(notify));
Michael Wrightd02c5b62014-02-10 15:10:22 -08002664#endif
2665
2666 // Clear the dispatch queues.
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07002667 drainDispatchQueue(connection->outboundQueue);
Siarhei Vishniakou61291d42019-02-11 18:13:20 -08002668 traceOutboundQueueLength(connection);
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07002669 drainDispatchQueue(connection->waitQueue);
Siarhei Vishniakou61291d42019-02-11 18:13:20 -08002670 traceWaitQueueLength(connection);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002671
2672 // The connection appears to be unrecoverably broken.
2673 // Ignore already broken or zombie connections.
2674 if (connection->status == Connection::STATUS_NORMAL) {
2675 connection->status = Connection::STATUS_BROKEN;
2676
2677 if (notify) {
2678 // Notify other system components.
2679 onDispatchCycleBrokenLocked(currentTime, connection);
2680 }
2681 }
2682}
2683
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07002684void InputDispatcher::drainDispatchQueue(std::deque<DispatchEntry*>& queue) {
2685 while (!queue.empty()) {
2686 DispatchEntry* dispatchEntry = queue.front();
2687 queue.pop_front();
Siarhei Vishniakou62683e82019-03-06 17:59:56 -08002688 releaseDispatchEntry(dispatchEntry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002689 }
2690}
2691
Siarhei Vishniakou62683e82019-03-06 17:59:56 -08002692void InputDispatcher::releaseDispatchEntry(DispatchEntry* dispatchEntry) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002693 if (dispatchEntry->hasForegroundTarget()) {
Siarhei Vishniakou62683e82019-03-06 17:59:56 -08002694 decrementPendingForegroundDispatches(dispatchEntry->eventEntry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002695 }
2696 delete dispatchEntry;
2697}
2698
2699int InputDispatcher::handleReceiveCallback(int fd, int events, void* data) {
2700 InputDispatcher* d = static_cast<InputDispatcher*>(data);
2701
2702 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08002703 std::scoped_lock _l(d->mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002704
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07002705 if (d->mConnectionsByFd.find(fd) == d->mConnectionsByFd.end()) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002706 ALOGE("Received spurious receive callback for unknown input channel. "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002707 "fd=%d, events=0x%x",
2708 fd, events);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002709 return 0; // remove the callback
2710 }
2711
2712 bool notify;
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07002713 sp<Connection> connection = d->mConnectionsByFd[fd];
Michael Wrightd02c5b62014-02-10 15:10:22 -08002714 if (!(events & (ALOOPER_EVENT_ERROR | ALOOPER_EVENT_HANGUP))) {
2715 if (!(events & ALOOPER_EVENT_INPUT)) {
2716 ALOGW("channel '%s' ~ Received spurious callback for unhandled poll event. "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002717 "events=0x%x",
2718 connection->getInputChannelName().c_str(), events);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002719 return 1;
2720 }
2721
2722 nsecs_t currentTime = now();
2723 bool gotOne = false;
2724 status_t status;
2725 for (;;) {
2726 uint32_t seq;
2727 bool handled;
2728 status = connection->inputPublisher.receiveFinishedSignal(&seq, &handled);
2729 if (status) {
2730 break;
2731 }
2732 d->finishDispatchCycleLocked(currentTime, connection, seq, handled);
2733 gotOne = true;
2734 }
2735 if (gotOne) {
2736 d->runCommandsLockedInterruptible();
2737 if (status == WOULD_BLOCK) {
2738 return 1;
2739 }
2740 }
2741
2742 notify = status != DEAD_OBJECT || !connection->monitor;
2743 if (notify) {
2744 ALOGE("channel '%s' ~ Failed to receive finished signal. status=%d",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002745 connection->getInputChannelName().c_str(), status);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002746 }
2747 } else {
2748 // Monitor channels are never explicitly unregistered.
2749 // We do it automatically when the remote endpoint is closed so don't warn
2750 // about them.
2751 notify = !connection->monitor;
2752 if (notify) {
2753 ALOGW("channel '%s' ~ Consumer closed input channel or an error occurred. "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002754 "events=0x%x",
2755 connection->getInputChannelName().c_str(), events);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002756 }
2757 }
2758
2759 // Unregister the channel.
2760 d->unregisterInputChannelLocked(connection->inputChannel, notify);
2761 return 0; // remove the callback
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002762 } // release lock
Michael Wrightd02c5b62014-02-10 15:10:22 -08002763}
2764
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002765void InputDispatcher::synthesizeCancelationEventsForAllConnectionsLocked(
Michael Wrightd02c5b62014-02-10 15:10:22 -08002766 const CancelationOptions& options) {
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07002767 for (const auto& pair : mConnectionsByFd) {
2768 synthesizeCancelationEventsForConnectionLocked(pair.second, options);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002769 }
2770}
2771
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002772void InputDispatcher::synthesizeCancelationEventsForMonitorsLocked(
Michael Wrightfa13dcf2015-06-12 13:25:11 +01002773 const CancelationOptions& options) {
Michael Wright3dd60e22019-03-27 22:06:44 +00002774 synthesizeCancelationEventsForMonitorsLocked(options, mGlobalMonitorsByDisplay);
2775 synthesizeCancelationEventsForMonitorsLocked(options, mGestureMonitorsByDisplay);
2776}
2777
2778void InputDispatcher::synthesizeCancelationEventsForMonitorsLocked(
2779 const CancelationOptions& options,
2780 std::unordered_map<int32_t, std::vector<Monitor>>& monitorsByDisplay) {
2781 for (const auto& it : monitorsByDisplay) {
2782 const std::vector<Monitor>& monitors = it.second;
2783 for (const Monitor& monitor : monitors) {
2784 synthesizeCancelationEventsForInputChannelLocked(monitor.inputChannel, options);
Arthur Hung2fbf37f2018-09-13 18:16:41 +08002785 }
Michael Wrightfa13dcf2015-06-12 13:25:11 +01002786 }
2787}
2788
Michael Wrightd02c5b62014-02-10 15:10:22 -08002789void InputDispatcher::synthesizeCancelationEventsForInputChannelLocked(
2790 const sp<InputChannel>& channel, const CancelationOptions& options) {
Siarhei Vishniakou26d3cfb2019-10-15 17:02:32 -07002791 sp<Connection> connection = getConnectionLocked(channel->getConnectionToken());
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07002792 if (connection == nullptr) {
2793 return;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002794 }
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07002795
2796 synthesizeCancelationEventsForConnectionLocked(connection, options);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002797}
2798
2799void InputDispatcher::synthesizeCancelationEventsForConnectionLocked(
2800 const sp<Connection>& connection, const CancelationOptions& options) {
2801 if (connection->status == Connection::STATUS_BROKEN) {
2802 return;
2803 }
2804
2805 nsecs_t currentTime = now();
2806
Siarhei Vishniakou00fca7c2019-10-29 13:05:57 -07002807 std::vector<EventEntry*> cancelationEvents =
2808 connection->inputState.synthesizeCancelationEvents(currentTime, options);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002809
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08002810 if (cancelationEvents.empty()) {
2811 return;
2812 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002813#if DEBUG_OUTBOUND_EVENT_DETAILS
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08002814 ALOGD("channel '%s' ~ Synthesized %zu cancelation events to bring channel back in sync "
2815 "with reality: %s, mode=%d.",
2816 connection->getInputChannelName().c_str(), cancelationEvents.size(), options.reason,
2817 options.mode);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002818#endif
Svet Ganov5d3bc372020-01-26 23:11:07 -08002819
2820 InputTarget target;
2821 sp<InputWindowHandle> windowHandle =
2822 getWindowHandleLocked(connection->inputChannel->getConnectionToken());
2823 if (windowHandle != nullptr) {
2824 const InputWindowInfo* windowInfo = windowHandle->getInfo();
2825 target.setDefaultPointerInfo(-windowInfo->frameLeft, -windowInfo->frameTop,
2826 windowInfo->windowXScale, windowInfo->windowYScale);
2827 target.globalScaleFactor = windowInfo->globalScaleFactor;
2828 }
2829 target.inputChannel = connection->inputChannel;
2830 target.flags = InputTarget::FLAG_DISPATCH_AS_IS;
2831
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08002832 for (size_t i = 0; i < cancelationEvents.size(); i++) {
2833 EventEntry* cancelationEventEntry = cancelationEvents[i];
2834 switch (cancelationEventEntry->type) {
2835 case EventEntry::Type::KEY: {
2836 logOutboundKeyDetails("cancel - ",
2837 static_cast<const KeyEntry&>(*cancelationEventEntry));
2838 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002839 }
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08002840 case EventEntry::Type::MOTION: {
2841 logOutboundMotionDetails("cancel - ",
2842 static_cast<const MotionEntry&>(*cancelationEventEntry));
2843 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002844 }
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08002845 case EventEntry::Type::FOCUS: {
2846 LOG_ALWAYS_FATAL("Canceling focus events is not supported");
2847 break;
2848 }
2849 case EventEntry::Type::CONFIGURATION_CHANGED:
2850 case EventEntry::Type::DEVICE_RESET: {
2851 LOG_ALWAYS_FATAL("%s event should not be found inside Connections's queue",
2852 EventEntry::typeToString(cancelationEventEntry->type));
2853 break;
2854 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002855 }
2856
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08002857 enqueueDispatchEntryLocked(connection, cancelationEventEntry, // increments ref
2858 target, InputTarget::FLAG_DISPATCH_AS_IS);
2859
2860 cancelationEventEntry->release();
Michael Wrightd02c5b62014-02-10 15:10:22 -08002861 }
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08002862
2863 startDispatchCycleLocked(currentTime, connection);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002864}
2865
Svet Ganov5d3bc372020-01-26 23:11:07 -08002866void InputDispatcher::synthesizePointerDownEventsForConnectionLocked(
2867 const sp<Connection>& connection) {
2868 if (connection->status == Connection::STATUS_BROKEN) {
2869 return;
2870 }
2871
2872 nsecs_t currentTime = now();
2873
2874 std::vector<EventEntry*> downEvents =
2875 connection->inputState.synthesizePointerDownEvents(currentTime);
2876
2877 if (downEvents.empty()) {
2878 return;
2879 }
2880
2881#if DEBUG_OUTBOUND_EVENT_DETAILS
2882 ALOGD("channel '%s' ~ Synthesized %zu down events to ensure consistent event stream.",
2883 connection->getInputChannelName().c_str(), downEvents.size());
2884#endif
2885
2886 InputTarget target;
2887 sp<InputWindowHandle> windowHandle =
2888 getWindowHandleLocked(connection->inputChannel->getConnectionToken());
2889 if (windowHandle != nullptr) {
2890 const InputWindowInfo* windowInfo = windowHandle->getInfo();
2891 target.setDefaultPointerInfo(-windowInfo->frameLeft, -windowInfo->frameTop,
2892 windowInfo->windowXScale, windowInfo->windowYScale);
2893 target.globalScaleFactor = windowInfo->globalScaleFactor;
2894 }
2895 target.inputChannel = connection->inputChannel;
2896 target.flags = InputTarget::FLAG_DISPATCH_AS_IS;
2897
2898 for (EventEntry* downEventEntry : downEvents) {
2899 switch (downEventEntry->type) {
2900 case EventEntry::Type::MOTION: {
2901 logOutboundMotionDetails("down - ",
2902 static_cast<const MotionEntry&>(*downEventEntry));
2903 break;
2904 }
2905
2906 case EventEntry::Type::KEY:
2907 case EventEntry::Type::FOCUS:
2908 case EventEntry::Type::CONFIGURATION_CHANGED:
2909 case EventEntry::Type::DEVICE_RESET: {
2910 LOG_ALWAYS_FATAL("%s event should not be found inside Connections's queue",
2911 EventEntry::typeToString(downEventEntry->type));
2912 break;
2913 }
2914 }
2915
2916 enqueueDispatchEntryLocked(connection, downEventEntry, // increments ref
2917 target, InputTarget::FLAG_DISPATCH_AS_IS);
2918
2919 downEventEntry->release();
2920 }
2921
2922 startDispatchCycleLocked(currentTime, connection);
2923}
2924
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002925MotionEntry* InputDispatcher::splitMotionEvent(const MotionEntry& originalMotionEntry,
Garfield Tane84e6f92019-08-29 17:28:41 -07002926 BitSet32 pointerIds) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002927 ALOG_ASSERT(pointerIds.value != 0);
2928
2929 uint32_t splitPointerIndexMap[MAX_POINTERS];
2930 PointerProperties splitPointerProperties[MAX_POINTERS];
2931 PointerCoords splitPointerCoords[MAX_POINTERS];
2932
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002933 uint32_t originalPointerCount = originalMotionEntry.pointerCount;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002934 uint32_t splitPointerCount = 0;
2935
2936 for (uint32_t originalPointerIndex = 0; originalPointerIndex < originalPointerCount;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002937 originalPointerIndex++) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002938 const PointerProperties& pointerProperties =
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002939 originalMotionEntry.pointerProperties[originalPointerIndex];
Michael Wrightd02c5b62014-02-10 15:10:22 -08002940 uint32_t pointerId = uint32_t(pointerProperties.id);
2941 if (pointerIds.hasBit(pointerId)) {
2942 splitPointerIndexMap[splitPointerCount] = originalPointerIndex;
2943 splitPointerProperties[splitPointerCount].copyFrom(pointerProperties);
2944 splitPointerCoords[splitPointerCount].copyFrom(
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002945 originalMotionEntry.pointerCoords[originalPointerIndex]);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002946 splitPointerCount += 1;
2947 }
2948 }
2949
2950 if (splitPointerCount != pointerIds.count()) {
2951 // This is bad. We are missing some of the pointers that we expected to deliver.
2952 // Most likely this indicates that we received an ACTION_MOVE events that has
2953 // different pointer ids than we expected based on the previous ACTION_DOWN
2954 // or ACTION_POINTER_DOWN events that caused us to decide to split the pointers
2955 // in this way.
2956 ALOGW("Dropping split motion event because the pointer count is %d but "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002957 "we expected there to be %d pointers. This probably means we received "
2958 "a broken sequence of pointer ids from the input device.",
2959 splitPointerCount, pointerIds.count());
Yi Kong9b14ac62018-07-17 13:48:38 -07002960 return nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002961 }
2962
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002963 int32_t action = originalMotionEntry.action;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002964 int32_t maskedAction = action & AMOTION_EVENT_ACTION_MASK;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002965 if (maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN ||
2966 maskedAction == AMOTION_EVENT_ACTION_POINTER_UP) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002967 int32_t originalPointerIndex = getMotionEventActionPointerIndex(action);
2968 const PointerProperties& pointerProperties =
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002969 originalMotionEntry.pointerProperties[originalPointerIndex];
Michael Wrightd02c5b62014-02-10 15:10:22 -08002970 uint32_t pointerId = uint32_t(pointerProperties.id);
2971 if (pointerIds.hasBit(pointerId)) {
2972 if (pointerIds.count() == 1) {
2973 // The first/last pointer went down/up.
2974 action = maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002975 ? AMOTION_EVENT_ACTION_DOWN
2976 : AMOTION_EVENT_ACTION_UP;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002977 } else {
2978 // A secondary pointer went down/up.
2979 uint32_t splitPointerIndex = 0;
2980 while (pointerId != uint32_t(splitPointerProperties[splitPointerIndex].id)) {
2981 splitPointerIndex += 1;
2982 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002983 action = maskedAction |
2984 (splitPointerIndex << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002985 }
2986 } else {
2987 // An unrelated pointer changed.
2988 action = AMOTION_EVENT_ACTION_MOVE;
2989 }
2990 }
2991
Garfield Tan1c7bc862020-01-28 13:24:04 -08002992 int32_t newId = mIdGenerator.nextId();
2993 if (ATRACE_ENABLED()) {
2994 std::string message = StringPrintf("Split MotionEvent(id=0x%" PRIx32
2995 ") to MotionEvent(id=0x%" PRIx32 ").",
2996 originalMotionEntry.id, newId);
2997 ATRACE_NAME(message.c_str());
2998 }
Garfield Tan00f511d2019-06-12 16:55:40 -07002999 MotionEntry* splitMotionEntry =
Garfield Tan1c7bc862020-01-28 13:24:04 -08003000 new MotionEntry(newId, originalMotionEntry.eventTime, originalMotionEntry.deviceId,
3001 originalMotionEntry.source, originalMotionEntry.displayId,
3002 originalMotionEntry.policyFlags, action,
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003003 originalMotionEntry.actionButton, originalMotionEntry.flags,
3004 originalMotionEntry.metaState, originalMotionEntry.buttonState,
3005 originalMotionEntry.classification, originalMotionEntry.edgeFlags,
3006 originalMotionEntry.xPrecision, originalMotionEntry.yPrecision,
3007 originalMotionEntry.xCursorPosition,
3008 originalMotionEntry.yCursorPosition, originalMotionEntry.downTime,
Garfield Tan00f511d2019-06-12 16:55:40 -07003009 splitPointerCount, splitPointerProperties, splitPointerCoords, 0, 0);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003010
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003011 if (originalMotionEntry.injectionState) {
3012 splitMotionEntry->injectionState = originalMotionEntry.injectionState;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003013 splitMotionEntry->injectionState->refCount += 1;
3014 }
3015
3016 return splitMotionEntry;
3017}
3018
3019void InputDispatcher::notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args) {
3020#if DEBUG_INBOUND_EVENT_DETAILS
Siarhei Vishniakou5d83f602017-09-12 12:40:29 -07003021 ALOGD("notifyConfigurationChanged - eventTime=%" PRId64, args->eventTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003022#endif
3023
3024 bool needWake;
3025 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08003026 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003027
Prabir Pradhan42611e02018-11-27 14:04:02 -08003028 ConfigurationChangedEntry* newEntry =
Garfield Tanc51d1ba2020-01-28 13:24:04 -08003029 new ConfigurationChangedEntry(args->id, args->eventTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003030 needWake = enqueueInboundEventLocked(newEntry);
3031 } // release lock
3032
3033 if (needWake) {
3034 mLooper->wake();
3035 }
3036}
3037
Siarhei Vishniakou61fafdd2018-04-13 11:00:58 -05003038/**
3039 * If one of the meta shortcuts is detected, process them here:
3040 * Meta + Backspace -> generate BACK
3041 * Meta + Enter -> generate HOME
3042 * This will potentially overwrite keyCode and metaState.
3043 */
3044void InputDispatcher::accelerateMetaShortcuts(const int32_t deviceId, const int32_t action,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003045 int32_t& keyCode, int32_t& metaState) {
Siarhei Vishniakou61fafdd2018-04-13 11:00:58 -05003046 if (metaState & AMETA_META_ON && action == AKEY_EVENT_ACTION_DOWN) {
3047 int32_t newKeyCode = AKEYCODE_UNKNOWN;
3048 if (keyCode == AKEYCODE_DEL) {
3049 newKeyCode = AKEYCODE_BACK;
3050 } else if (keyCode == AKEYCODE_ENTER) {
3051 newKeyCode = AKEYCODE_HOME;
3052 }
3053 if (newKeyCode != AKEYCODE_UNKNOWN) {
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08003054 std::scoped_lock _l(mLock);
Siarhei Vishniakou61fafdd2018-04-13 11:00:58 -05003055 struct KeyReplacement replacement = {keyCode, deviceId};
3056 mReplacedKeys.add(replacement, newKeyCode);
3057 keyCode = newKeyCode;
3058 metaState &= ~(AMETA_META_ON | AMETA_META_LEFT_ON | AMETA_META_RIGHT_ON);
3059 }
3060 } else if (action == AKEY_EVENT_ACTION_UP) {
3061 // In order to maintain a consistent stream of up and down events, check to see if the key
3062 // going up is one we've replaced in a down event and haven't yet replaced in an up event,
3063 // even if the modifier was released between the down and the up events.
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08003064 std::scoped_lock _l(mLock);
Siarhei Vishniakou61fafdd2018-04-13 11:00:58 -05003065 struct KeyReplacement replacement = {keyCode, deviceId};
3066 ssize_t index = mReplacedKeys.indexOfKey(replacement);
3067 if (index >= 0) {
3068 keyCode = mReplacedKeys.valueAt(index);
3069 mReplacedKeys.removeItemsAt(index);
3070 metaState &= ~(AMETA_META_ON | AMETA_META_LEFT_ON | AMETA_META_RIGHT_ON);
3071 }
3072 }
3073}
3074
Michael Wrightd02c5b62014-02-10 15:10:22 -08003075void InputDispatcher::notifyKey(const NotifyKeyArgs* args) {
3076#if DEBUG_INBOUND_EVENT_DETAILS
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003077 ALOGD("notifyKey - eventTime=%" PRId64 ", deviceId=%d, source=0x%x, displayId=%" PRId32
3078 "policyFlags=0x%x, action=0x%x, "
3079 "flags=0x%x, keyCode=0x%x, scanCode=0x%x, metaState=0x%x, downTime=%" PRId64,
3080 args->eventTime, args->deviceId, args->source, args->displayId, args->policyFlags,
3081 args->action, args->flags, args->keyCode, args->scanCode, args->metaState,
3082 args->downTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003083#endif
3084 if (!validateKeyEvent(args->action)) {
3085 return;
3086 }
3087
3088 uint32_t policyFlags = args->policyFlags;
3089 int32_t flags = args->flags;
3090 int32_t metaState = args->metaState;
Siarhei Vishniakou622bd322018-10-29 18:02:27 -07003091 // InputDispatcher tracks and generates key repeats on behalf of
3092 // whatever notifies it, so repeatCount should always be set to 0
3093 constexpr int32_t repeatCount = 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003094 if ((policyFlags & POLICY_FLAG_VIRTUAL) || (flags & AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY)) {
3095 policyFlags |= POLICY_FLAG_VIRTUAL;
3096 flags |= AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY;
3097 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003098 if (policyFlags & POLICY_FLAG_FUNCTION) {
3099 metaState |= AMETA_FUNCTION_ON;
3100 }
3101
3102 policyFlags |= POLICY_FLAG_TRUSTED;
3103
Michael Wright78f24442014-08-06 15:55:28 -07003104 int32_t keyCode = args->keyCode;
Siarhei Vishniakou61fafdd2018-04-13 11:00:58 -05003105 accelerateMetaShortcuts(args->deviceId, args->action, keyCode, metaState);
Michael Wright78f24442014-08-06 15:55:28 -07003106
Michael Wrightd02c5b62014-02-10 15:10:22 -08003107 KeyEvent event;
Garfield Tanc51d1ba2020-01-28 13:24:04 -08003108 event.initialize(args->id, args->deviceId, args->source, args->displayId, INVALID_HMAC,
Garfield Tanfbe732e2020-01-24 11:26:14 -08003109 args->action, flags, keyCode, args->scanCode, metaState, repeatCount,
3110 args->downTime, args->eventTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003111
Michael Wright2b3c3302018-03-02 17:19:13 +00003112 android::base::Timer t;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003113 mPolicy->interceptKeyBeforeQueueing(&event, /*byref*/ policyFlags);
Michael Wright2b3c3302018-03-02 17:19:13 +00003114 if (t.duration() > SLOW_INTERCEPTION_THRESHOLD) {
3115 ALOGW("Excessive delay in interceptKeyBeforeQueueing; took %s ms",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003116 std::to_string(t.duration().count()).c_str());
Michael Wright2b3c3302018-03-02 17:19:13 +00003117 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003118
Michael Wrightd02c5b62014-02-10 15:10:22 -08003119 bool needWake;
3120 { // acquire lock
3121 mLock.lock();
3122
3123 if (shouldSendKeyToInputFilterLocked(args)) {
3124 mLock.unlock();
3125
3126 policyFlags |= POLICY_FLAG_FILTERED;
3127 if (!mPolicy->filterInputEvent(&event, policyFlags)) {
3128 return; // event was consumed by the filter
3129 }
3130
3131 mLock.lock();
3132 }
3133
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003134 KeyEntry* newEntry =
Garfield Tanc51d1ba2020-01-28 13:24:04 -08003135 new KeyEntry(args->id, args->eventTime, args->deviceId, args->source,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003136 args->displayId, policyFlags, args->action, flags, keyCode,
3137 args->scanCode, metaState, repeatCount, args->downTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003138
3139 needWake = enqueueInboundEventLocked(newEntry);
3140 mLock.unlock();
3141 } // release lock
3142
3143 if (needWake) {
3144 mLooper->wake();
3145 }
3146}
3147
3148bool InputDispatcher::shouldSendKeyToInputFilterLocked(const NotifyKeyArgs* args) {
3149 return mInputFilterEnabled;
3150}
3151
3152void InputDispatcher::notifyMotion(const NotifyMotionArgs* args) {
3153#if DEBUG_INBOUND_EVENT_DETAILS
Garfield Tanc51d1ba2020-01-28 13:24:04 -08003154 ALOGD("notifyMotion - id=%" PRIx32 " eventTime=%" PRId64 ", deviceId=%d, source=0x%x, "
3155 "displayId=%" PRId32 ", policyFlags=0x%x, "
Garfield Tan00f511d2019-06-12 16:55:40 -07003156 "action=0x%x, actionButton=0x%x, flags=0x%x, metaState=0x%x, buttonState=0x%x, "
3157 "edgeFlags=0x%x, xPrecision=%f, yPrecision=%f, xCursorPosition=%f, "
Garfield Tanab0ab9c2019-07-10 18:58:28 -07003158 "yCursorPosition=%f, downTime=%" PRId64,
Garfield Tanc51d1ba2020-01-28 13:24:04 -08003159 args->id, args->eventTime, args->deviceId, args->source, args->displayId,
3160 args->policyFlags, args->action, args->actionButton, args->flags, args->metaState,
3161 args->buttonState, args->edgeFlags, args->xPrecision, args->yPrecision,
3162 args->xCursorPosition, args->yCursorPosition, args->downTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003163 for (uint32_t i = 0; i < args->pointerCount; i++) {
3164 ALOGD(" Pointer %d: id=%d, toolType=%d, "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003165 "x=%f, y=%f, pressure=%f, size=%f, "
3166 "touchMajor=%f, touchMinor=%f, toolMajor=%f, toolMinor=%f, "
3167 "orientation=%f",
3168 i, args->pointerProperties[i].id, args->pointerProperties[i].toolType,
3169 args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_X),
3170 args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_Y),
3171 args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_PRESSURE),
3172 args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_SIZE),
3173 args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR),
3174 args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR),
3175 args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR),
3176 args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR),
3177 args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION));
Michael Wrightd02c5b62014-02-10 15:10:22 -08003178 }
3179#endif
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003180 if (!validateMotionEvent(args->action, args->actionButton, args->pointerCount,
3181 args->pointerProperties)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003182 return;
3183 }
3184
3185 uint32_t policyFlags = args->policyFlags;
3186 policyFlags |= POLICY_FLAG_TRUSTED;
Michael Wright2b3c3302018-03-02 17:19:13 +00003187
3188 android::base::Timer t;
Charles Chen3611f1f2019-01-29 17:26:18 +08003189 mPolicy->interceptMotionBeforeQueueing(args->displayId, args->eventTime, /*byref*/ policyFlags);
Michael Wright2b3c3302018-03-02 17:19:13 +00003190 if (t.duration() > SLOW_INTERCEPTION_THRESHOLD) {
3191 ALOGW("Excessive delay in interceptMotionBeforeQueueing; took %s ms",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003192 std::to_string(t.duration().count()).c_str());
Michael Wright2b3c3302018-03-02 17:19:13 +00003193 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003194
3195 bool needWake;
3196 { // acquire lock
3197 mLock.lock();
3198
3199 if (shouldSendMotionToInputFilterLocked(args)) {
3200 mLock.unlock();
3201
3202 MotionEvent event;
Garfield Tanc51d1ba2020-01-28 13:24:04 -08003203 event.initialize(args->id, args->deviceId, args->source, args->displayId, INVALID_HMAC,
3204 args->action, args->actionButton, args->flags, args->edgeFlags,
3205 args->metaState, args->buttonState, args->classification, 1 /*xScale*/,
3206 1 /*yScale*/, 0 /* xOffset */, 0 /* yOffset */, args->xPrecision,
3207 args->yPrecision, args->xCursorPosition, args->yCursorPosition,
3208 args->downTime, args->eventTime, args->pointerCount,
3209 args->pointerProperties, args->pointerCoords);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003210
3211 policyFlags |= POLICY_FLAG_FILTERED;
3212 if (!mPolicy->filterInputEvent(&event, policyFlags)) {
3213 return; // event was consumed by the filter
3214 }
3215
3216 mLock.lock();
3217 }
3218
3219 // Just enqueue a new motion event.
Garfield Tan00f511d2019-06-12 16:55:40 -07003220 MotionEntry* newEntry =
Garfield Tanc51d1ba2020-01-28 13:24:04 -08003221 new MotionEntry(args->id, args->eventTime, args->deviceId, args->source,
Garfield Tan00f511d2019-06-12 16:55:40 -07003222 args->displayId, policyFlags, args->action, args->actionButton,
3223 args->flags, args->metaState, args->buttonState,
3224 args->classification, args->edgeFlags, args->xPrecision,
3225 args->yPrecision, args->xCursorPosition, args->yCursorPosition,
3226 args->downTime, args->pointerCount, args->pointerProperties,
3227 args->pointerCoords, 0, 0);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003228
3229 needWake = enqueueInboundEventLocked(newEntry);
3230 mLock.unlock();
3231 } // release lock
3232
3233 if (needWake) {
3234 mLooper->wake();
3235 }
3236}
3237
3238bool InputDispatcher::shouldSendMotionToInputFilterLocked(const NotifyMotionArgs* args) {
Jackal Guof9696682018-10-05 12:23:23 +08003239 return mInputFilterEnabled;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003240}
3241
3242void InputDispatcher::notifySwitch(const NotifySwitchArgs* args) {
3243#if DEBUG_INBOUND_EVENT_DETAILS
Siarhei Vishniakou5d83f602017-09-12 12:40:29 -07003244 ALOGD("notifySwitch - eventTime=%" PRId64 ", policyFlags=0x%x, switchValues=0x%08x, "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003245 "switchMask=0x%08x",
3246 args->eventTime, args->policyFlags, args->switchValues, args->switchMask);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003247#endif
3248
3249 uint32_t policyFlags = args->policyFlags;
3250 policyFlags |= POLICY_FLAG_TRUSTED;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003251 mPolicy->notifySwitch(args->eventTime, args->switchValues, args->switchMask, policyFlags);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003252}
3253
3254void InputDispatcher::notifyDeviceReset(const NotifyDeviceResetArgs* args) {
3255#if DEBUG_INBOUND_EVENT_DETAILS
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003256 ALOGD("notifyDeviceReset - eventTime=%" PRId64 ", deviceId=%d", args->eventTime,
3257 args->deviceId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003258#endif
3259
3260 bool needWake;
3261 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08003262 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003263
Prabir Pradhan42611e02018-11-27 14:04:02 -08003264 DeviceResetEntry* newEntry =
Garfield Tanc51d1ba2020-01-28 13:24:04 -08003265 new DeviceResetEntry(args->id, args->eventTime, args->deviceId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003266 needWake = enqueueInboundEventLocked(newEntry);
3267 } // release lock
3268
3269 if (needWake) {
3270 mLooper->wake();
3271 }
3272}
3273
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003274int32_t InputDispatcher::injectInputEvent(const InputEvent* event, int32_t injectorPid,
3275 int32_t injectorUid, int32_t syncMode,
Siarhei Vishniakou097c3db2020-05-06 14:18:38 -07003276 std::chrono::milliseconds timeout, uint32_t policyFlags) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003277#if DEBUG_INBOUND_EVENT_DETAILS
3278 ALOGD("injectInputEvent - eventType=%d, injectorPid=%d, injectorUid=%d, "
Siarhei Vishniakou097c3db2020-05-06 14:18:38 -07003279 "syncMode=%d, timeout=%lld, policyFlags=0x%08x",
3280 event->getType(), injectorPid, injectorUid, syncMode, timeout.count(), policyFlags);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003281#endif
3282
Siarhei Vishniakou097c3db2020-05-06 14:18:38 -07003283 nsecs_t endTime = now() + std::chrono::duration_cast<std::chrono::nanoseconds>(timeout).count();
Michael Wrightd02c5b62014-02-10 15:10:22 -08003284
3285 policyFlags |= POLICY_FLAG_INJECTED;
3286 if (hasInjectionPermission(injectorPid, injectorUid)) {
3287 policyFlags |= POLICY_FLAG_TRUSTED;
3288 }
3289
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07003290 std::queue<EventEntry*> injectedEntries;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003291 switch (event->getType()) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003292 case AINPUT_EVENT_TYPE_KEY: {
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -08003293 const KeyEvent& incomingKey = static_cast<const KeyEvent&>(*event);
3294 int32_t action = incomingKey.getAction();
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003295 if (!validateKeyEvent(action)) {
3296 return INPUT_EVENT_INJECTION_FAILED;
Michael Wright2b3c3302018-03-02 17:19:13 +00003297 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003298
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -08003299 int32_t flags = incomingKey.getFlags();
3300 int32_t keyCode = incomingKey.getKeyCode();
3301 int32_t metaState = incomingKey.getMetaState();
3302 accelerateMetaShortcuts(VIRTUAL_KEYBOARD_ID, action,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003303 /*byref*/ keyCode, /*byref*/ metaState);
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -08003304 KeyEvent keyEvent;
Garfield Tanfbe732e2020-01-24 11:26:14 -08003305 keyEvent.initialize(incomingKey.getId(), VIRTUAL_KEYBOARD_ID, incomingKey.getSource(),
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -08003306 incomingKey.getDisplayId(), INVALID_HMAC, action, flags, keyCode,
3307 incomingKey.getScanCode(), metaState, incomingKey.getRepeatCount(),
3308 incomingKey.getDownTime(), incomingKey.getEventTime());
Michael Wrightd02c5b62014-02-10 15:10:22 -08003309
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003310 if (flags & AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY) {
3311 policyFlags |= POLICY_FLAG_VIRTUAL;
Michael Wright2b3c3302018-03-02 17:19:13 +00003312 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003313
3314 if (!(policyFlags & POLICY_FLAG_FILTERED)) {
3315 android::base::Timer t;
3316 mPolicy->interceptKeyBeforeQueueing(&keyEvent, /*byref*/ policyFlags);
3317 if (t.duration() > SLOW_INTERCEPTION_THRESHOLD) {
3318 ALOGW("Excessive delay in interceptKeyBeforeQueueing; took %s ms",
3319 std::to_string(t.duration().count()).c_str());
3320 }
3321 }
3322
3323 mLock.lock();
3324 KeyEntry* injectedEntry =
Garfield Tanfbe732e2020-01-24 11:26:14 -08003325 new KeyEntry(incomingKey.getId(), incomingKey.getEventTime(),
3326 VIRTUAL_KEYBOARD_ID, incomingKey.getSource(),
arthurhungb1462ec2020-04-20 17:18:37 +08003327 incomingKey.getDisplayId(), policyFlags, action, flags, keyCode,
3328 incomingKey.getScanCode(), metaState, incomingKey.getRepeatCount(),
Garfield Tanfbe732e2020-01-24 11:26:14 -08003329 incomingKey.getDownTime());
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003330 injectedEntries.push(injectedEntry);
3331 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003332 }
3333
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003334 case AINPUT_EVENT_TYPE_MOTION: {
3335 const MotionEvent* motionEvent = static_cast<const MotionEvent*>(event);
3336 int32_t action = motionEvent->getAction();
3337 size_t pointerCount = motionEvent->getPointerCount();
3338 const PointerProperties* pointerProperties = motionEvent->getPointerProperties();
3339 int32_t actionButton = motionEvent->getActionButton();
3340 int32_t displayId = motionEvent->getDisplayId();
3341 if (!validateMotionEvent(action, actionButton, pointerCount, pointerProperties)) {
3342 return INPUT_EVENT_INJECTION_FAILED;
3343 }
3344
3345 if (!(policyFlags & POLICY_FLAG_FILTERED)) {
3346 nsecs_t eventTime = motionEvent->getEventTime();
3347 android::base::Timer t;
3348 mPolicy->interceptMotionBeforeQueueing(displayId, eventTime, /*byref*/ policyFlags);
3349 if (t.duration() > SLOW_INTERCEPTION_THRESHOLD) {
3350 ALOGW("Excessive delay in interceptMotionBeforeQueueing; took %s ms",
3351 std::to_string(t.duration().count()).c_str());
3352 }
3353 }
3354
3355 mLock.lock();
3356 const nsecs_t* sampleEventTimes = motionEvent->getSampleEventTimes();
3357 const PointerCoords* samplePointerCoords = motionEvent->getSamplePointerCoords();
3358 MotionEntry* injectedEntry =
Garfield Tanfbe732e2020-01-24 11:26:14 -08003359 new MotionEntry(motionEvent->getId(), *sampleEventTimes, VIRTUAL_KEYBOARD_ID,
3360 motionEvent->getSource(), motionEvent->getDisplayId(),
3361 policyFlags, action, actionButton, motionEvent->getFlags(),
3362 motionEvent->getMetaState(), motionEvent->getButtonState(),
3363 motionEvent->getClassification(), motionEvent->getEdgeFlags(),
3364 motionEvent->getXPrecision(), motionEvent->getYPrecision(),
Garfield Tan00f511d2019-06-12 16:55:40 -07003365 motionEvent->getRawXCursorPosition(),
3366 motionEvent->getRawYCursorPosition(),
3367 motionEvent->getDownTime(), uint32_t(pointerCount),
3368 pointerProperties, samplePointerCoords,
3369 motionEvent->getXOffset(), motionEvent->getYOffset());
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003370 injectedEntries.push(injectedEntry);
3371 for (size_t i = motionEvent->getHistorySize(); i > 0; i--) {
3372 sampleEventTimes += 1;
3373 samplePointerCoords += pointerCount;
3374 MotionEntry* nextInjectedEntry =
Garfield Tanfbe732e2020-01-24 11:26:14 -08003375 new MotionEntry(motionEvent->getId(), *sampleEventTimes,
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -08003376 VIRTUAL_KEYBOARD_ID, motionEvent->getSource(),
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003377 motionEvent->getDisplayId(), policyFlags, action,
3378 actionButton, motionEvent->getFlags(),
3379 motionEvent->getMetaState(), motionEvent->getButtonState(),
3380 motionEvent->getClassification(),
3381 motionEvent->getEdgeFlags(), motionEvent->getXPrecision(),
3382 motionEvent->getYPrecision(),
3383 motionEvent->getRawXCursorPosition(),
3384 motionEvent->getRawYCursorPosition(),
3385 motionEvent->getDownTime(), uint32_t(pointerCount),
3386 pointerProperties, samplePointerCoords,
3387 motionEvent->getXOffset(), motionEvent->getYOffset());
3388 injectedEntries.push(nextInjectedEntry);
3389 }
3390 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003391 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003392
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003393 default:
Siarhei Vishniakou7feb2ea2019-11-25 15:11:23 -08003394 ALOGW("Cannot inject %s events", inputEventTypeToString(event->getType()));
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003395 return INPUT_EVENT_INJECTION_FAILED;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003396 }
3397
3398 InjectionState* injectionState = new InjectionState(injectorPid, injectorUid);
3399 if (syncMode == INPUT_EVENT_INJECTION_SYNC_NONE) {
3400 injectionState->injectionIsAsync = true;
3401 }
3402
3403 injectionState->refCount += 1;
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07003404 injectedEntries.back()->injectionState = injectionState;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003405
3406 bool needWake = false;
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07003407 while (!injectedEntries.empty()) {
3408 needWake |= enqueueInboundEventLocked(injectedEntries.front());
3409 injectedEntries.pop();
Michael Wrightd02c5b62014-02-10 15:10:22 -08003410 }
3411
3412 mLock.unlock();
3413
3414 if (needWake) {
3415 mLooper->wake();
3416 }
3417
3418 int32_t injectionResult;
3419 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08003420 std::unique_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003421
3422 if (syncMode == INPUT_EVENT_INJECTION_SYNC_NONE) {
3423 injectionResult = INPUT_EVENT_INJECTION_SUCCEEDED;
3424 } else {
3425 for (;;) {
3426 injectionResult = injectionState->injectionResult;
3427 if (injectionResult != INPUT_EVENT_INJECTION_PENDING) {
3428 break;
3429 }
3430
3431 nsecs_t remainingTimeout = endTime - now();
3432 if (remainingTimeout <= 0) {
3433#if DEBUG_INJECTION
3434 ALOGD("injectInputEvent - Timed out waiting for injection result "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003435 "to become available.");
Michael Wrightd02c5b62014-02-10 15:10:22 -08003436#endif
3437 injectionResult = INPUT_EVENT_INJECTION_TIMED_OUT;
3438 break;
3439 }
3440
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08003441 mInjectionResultAvailable.wait_for(_l, std::chrono::nanoseconds(remainingTimeout));
Michael Wrightd02c5b62014-02-10 15:10:22 -08003442 }
3443
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003444 if (injectionResult == INPUT_EVENT_INJECTION_SUCCEEDED &&
3445 syncMode == INPUT_EVENT_INJECTION_SYNC_WAIT_FOR_FINISHED) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003446 while (injectionState->pendingForegroundDispatches != 0) {
3447#if DEBUG_INJECTION
3448 ALOGD("injectInputEvent - Waiting for %d pending foreground dispatches.",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003449 injectionState->pendingForegroundDispatches);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003450#endif
3451 nsecs_t remainingTimeout = endTime - now();
3452 if (remainingTimeout <= 0) {
3453#if DEBUG_INJECTION
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003454 ALOGD("injectInputEvent - Timed out waiting for pending foreground "
3455 "dispatches to finish.");
Michael Wrightd02c5b62014-02-10 15:10:22 -08003456#endif
3457 injectionResult = INPUT_EVENT_INJECTION_TIMED_OUT;
3458 break;
3459 }
3460
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08003461 mInjectionSyncFinished.wait_for(_l, std::chrono::nanoseconds(remainingTimeout));
Michael Wrightd02c5b62014-02-10 15:10:22 -08003462 }
3463 }
3464 }
3465
3466 injectionState->release();
3467 } // release lock
3468
3469#if DEBUG_INJECTION
Siarhei Vishniakou097c3db2020-05-06 14:18:38 -07003470 ALOGD("injectInputEvent - Finished with result %d. injectorPid=%d, injectorUid=%d",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003471 injectionResult, injectorPid, injectorUid);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003472#endif
3473
3474 return injectionResult;
3475}
3476
Siarhei Vishniakou54d3e182020-01-15 17:38:38 -08003477std::unique_ptr<VerifiedInputEvent> InputDispatcher::verifyInputEvent(const InputEvent& event) {
Gang Wange9087892020-01-07 12:17:14 -05003478 std::array<uint8_t, 32> calculatedHmac;
3479 std::unique_ptr<VerifiedInputEvent> result;
3480 switch (event.getType()) {
3481 case AINPUT_EVENT_TYPE_KEY: {
3482 const KeyEvent& keyEvent = static_cast<const KeyEvent&>(event);
3483 VerifiedKeyEvent verifiedKeyEvent = verifiedKeyEventFromKeyEvent(keyEvent);
3484 result = std::make_unique<VerifiedKeyEvent>(verifiedKeyEvent);
3485 calculatedHmac = mHmacKeyManager.sign(verifiedKeyEvent);
3486 break;
3487 }
3488 case AINPUT_EVENT_TYPE_MOTION: {
3489 const MotionEvent& motionEvent = static_cast<const MotionEvent&>(event);
3490 VerifiedMotionEvent verifiedMotionEvent =
3491 verifiedMotionEventFromMotionEvent(motionEvent);
3492 result = std::make_unique<VerifiedMotionEvent>(verifiedMotionEvent);
3493 calculatedHmac = mHmacKeyManager.sign(verifiedMotionEvent);
3494 break;
3495 }
3496 default: {
3497 ALOGE("Cannot verify events of type %" PRId32, event.getType());
3498 return nullptr;
3499 }
3500 }
3501 if (calculatedHmac == INVALID_HMAC) {
3502 return nullptr;
3503 }
3504 if (calculatedHmac != event.getHmac()) {
3505 return nullptr;
3506 }
3507 return result;
Siarhei Vishniakou54d3e182020-01-15 17:38:38 -08003508}
3509
Michael Wrightd02c5b62014-02-10 15:10:22 -08003510bool InputDispatcher::hasInjectionPermission(int32_t injectorPid, int32_t injectorUid) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003511 return injectorUid == 0 ||
3512 mPolicy->checkInjectEventsPermissionNonReentrant(injectorPid, injectorUid);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003513}
3514
Siarhei Vishniakou62683e82019-03-06 17:59:56 -08003515void InputDispatcher::setInjectionResult(EventEntry* entry, int32_t injectionResult) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003516 InjectionState* injectionState = entry->injectionState;
3517 if (injectionState) {
3518#if DEBUG_INJECTION
3519 ALOGD("Setting input event injection result to %d. "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003520 "injectorPid=%d, injectorUid=%d",
3521 injectionResult, injectionState->injectorPid, injectionState->injectorUid);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003522#endif
3523
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003524 if (injectionState->injectionIsAsync && !(entry->policyFlags & POLICY_FLAG_FILTERED)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003525 // Log the outcome since the injector did not wait for the injection result.
3526 switch (injectionResult) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003527 case INPUT_EVENT_INJECTION_SUCCEEDED:
3528 ALOGV("Asynchronous input event injection succeeded.");
3529 break;
3530 case INPUT_EVENT_INJECTION_FAILED:
3531 ALOGW("Asynchronous input event injection failed.");
3532 break;
3533 case INPUT_EVENT_INJECTION_PERMISSION_DENIED:
3534 ALOGW("Asynchronous input event injection permission denied.");
3535 break;
3536 case INPUT_EVENT_INJECTION_TIMED_OUT:
3537 ALOGW("Asynchronous input event injection timed out.");
3538 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003539 }
3540 }
3541
3542 injectionState->injectionResult = injectionResult;
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08003543 mInjectionResultAvailable.notify_all();
Michael Wrightd02c5b62014-02-10 15:10:22 -08003544 }
3545}
3546
Siarhei Vishniakou61291d42019-02-11 18:13:20 -08003547void InputDispatcher::incrementPendingForegroundDispatches(EventEntry* entry) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003548 InjectionState* injectionState = entry->injectionState;
3549 if (injectionState) {
3550 injectionState->pendingForegroundDispatches += 1;
3551 }
3552}
3553
Siarhei Vishniakou62683e82019-03-06 17:59:56 -08003554void InputDispatcher::decrementPendingForegroundDispatches(EventEntry* entry) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003555 InjectionState* injectionState = entry->injectionState;
3556 if (injectionState) {
3557 injectionState->pendingForegroundDispatches -= 1;
3558
3559 if (injectionState->pendingForegroundDispatches == 0) {
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08003560 mInjectionSyncFinished.notify_all();
Michael Wrightd02c5b62014-02-10 15:10:22 -08003561 }
3562 }
3563}
3564
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08003565std::vector<sp<InputWindowHandle>> InputDispatcher::getWindowHandlesLocked(
3566 int32_t displayId) const {
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07003567 return getValueByKey(mWindowHandlesByDisplay, displayId);
Arthur Hungb92218b2018-08-14 12:00:21 +08003568}
3569
Michael Wrightd02c5b62014-02-10 15:10:22 -08003570sp<InputWindowHandle> InputDispatcher::getWindowHandleLocked(
chaviwfbe5d9c2018-12-26 12:23:37 -08003571 const sp<IBinder>& windowHandleToken) const {
Arthur Hungb92218b2018-08-14 12:00:21 +08003572 for (auto& it : mWindowHandlesByDisplay) {
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08003573 const std::vector<sp<InputWindowHandle>> windowHandles = it.second;
3574 for (const sp<InputWindowHandle>& windowHandle : windowHandles) {
chaviwfbe5d9c2018-12-26 12:23:37 -08003575 if (windowHandle->getToken() == windowHandleToken) {
Arthur Hungb92218b2018-08-14 12:00:21 +08003576 return windowHandle;
3577 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003578 }
3579 }
Yi Kong9b14ac62018-07-17 13:48:38 -07003580 return nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003581}
3582
Siarhei Vishniakou61291d42019-02-11 18:13:20 -08003583bool InputDispatcher::hasWindowHandleLocked(const sp<InputWindowHandle>& windowHandle) const {
Arthur Hungb92218b2018-08-14 12:00:21 +08003584 for (auto& it : mWindowHandlesByDisplay) {
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08003585 const std::vector<sp<InputWindowHandle>> windowHandles = it.second;
3586 for (const sp<InputWindowHandle>& handle : windowHandles) {
3587 if (handle->getToken() == windowHandle->getToken()) {
Arthur Hungb92218b2018-08-14 12:00:21 +08003588 if (windowHandle->getInfo()->displayId != it.first) {
Arthur Hung3b413f22018-10-26 18:05:34 +08003589 ALOGE("Found window %s in display %" PRId32
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003590 ", but it should belong to display %" PRId32,
3591 windowHandle->getName().c_str(), it.first,
3592 windowHandle->getInfo()->displayId);
Arthur Hungb92218b2018-08-14 12:00:21 +08003593 }
3594 return true;
3595 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003596 }
3597 }
3598 return false;
3599}
3600
Robert Carr5c8a0262018-10-03 16:30:44 -07003601sp<InputChannel> InputDispatcher::getInputChannelLocked(const sp<IBinder>& token) const {
3602 size_t count = mInputChannelsByToken.count(token);
3603 if (count == 0) {
3604 return nullptr;
3605 }
3606 return mInputChannelsByToken.at(token);
3607}
3608
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07003609void InputDispatcher::updateWindowHandlesForDisplayLocked(
3610 const std::vector<sp<InputWindowHandle>>& inputWindowHandles, int32_t displayId) {
3611 if (inputWindowHandles.empty()) {
3612 // Remove all handles on a display if there are no windows left.
3613 mWindowHandlesByDisplay.erase(displayId);
3614 return;
3615 }
3616
3617 // Since we compare the pointer of input window handles across window updates, we need
3618 // to make sure the handle object for the same window stays unchanged across updates.
3619 const std::vector<sp<InputWindowHandle>>& oldHandles = getWindowHandlesLocked(displayId);
chaviwaf87b3e2019-10-01 16:59:28 -07003620 std::unordered_map<int32_t /*id*/, sp<InputWindowHandle>> oldHandlesById;
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07003621 for (const sp<InputWindowHandle>& handle : oldHandles) {
chaviwaf87b3e2019-10-01 16:59:28 -07003622 oldHandlesById[handle->getId()] = handle;
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07003623 }
3624
3625 std::vector<sp<InputWindowHandle>> newHandles;
3626 for (const sp<InputWindowHandle>& handle : inputWindowHandles) {
3627 if (!handle->updateInfo()) {
3628 // handle no longer valid
3629 continue;
3630 }
3631
3632 const InputWindowInfo* info = handle->getInfo();
3633 if ((getInputChannelLocked(handle->getToken()) == nullptr &&
3634 info->portalToDisplayId == ADISPLAY_ID_NONE)) {
3635 const bool noInputChannel =
3636 info->inputFeatures & InputWindowInfo::INPUT_FEATURE_NO_INPUT_CHANNEL;
3637 const bool canReceiveInput =
3638 !(info->layoutParamsFlags & InputWindowInfo::FLAG_NOT_TOUCHABLE) ||
3639 !(info->layoutParamsFlags & InputWindowInfo::FLAG_NOT_FOCUSABLE);
3640 if (canReceiveInput && !noInputChannel) {
John Recke0710582019-09-26 13:46:12 -07003641 ALOGV("Window handle %s has no registered input channel",
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07003642 handle->getName().c_str());
Robert Carr2984b7a2020-04-13 17:06:45 -07003643 continue;
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07003644 }
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07003645 }
3646
3647 if (info->displayId != displayId) {
3648 ALOGE("Window %s updated by wrong display %d, should belong to display %d",
3649 handle->getName().c_str(), displayId, info->displayId);
3650 continue;
3651 }
3652
chaviwaf87b3e2019-10-01 16:59:28 -07003653 if (oldHandlesById.find(handle->getId()) != oldHandlesById.end()) {
3654 const sp<InputWindowHandle>& oldHandle = oldHandlesById.at(handle->getId());
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07003655 oldHandle->updateFrom(handle);
3656 newHandles.push_back(oldHandle);
3657 } else {
3658 newHandles.push_back(handle);
3659 }
3660 }
3661
3662 // Insert or replace
3663 mWindowHandlesByDisplay[displayId] = newHandles;
3664}
3665
Arthur Hung72d8dc32020-03-28 00:48:39 +00003666void InputDispatcher::setInputWindows(
3667 const std::unordered_map<int32_t, std::vector<sp<InputWindowHandle>>>& handlesPerDisplay) {
3668 { // acquire lock
3669 std::scoped_lock _l(mLock);
3670 for (auto const& i : handlesPerDisplay) {
3671 setInputWindowsLocked(i.second, i.first);
3672 }
3673 }
3674 // Wake up poll loop since it may need to make new input dispatching choices.
3675 mLooper->wake();
3676}
3677
Arthur Hungb92218b2018-08-14 12:00:21 +08003678/**
3679 * Called from InputManagerService, update window handle list by displayId that can receive input.
3680 * A window handle contains information about InputChannel, Touch Region, Types, Focused,...
3681 * If set an empty list, remove all handles from the specific display.
3682 * For focused handle, check if need to change and send a cancel event to previous one.
3683 * For removed handle, check if need to send a cancel event if already in touch.
3684 */
Arthur Hung72d8dc32020-03-28 00:48:39 +00003685void InputDispatcher::setInputWindowsLocked(
3686 const std::vector<sp<InputWindowHandle>>& inputWindowHandles, int32_t displayId) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01003687 if (DEBUG_FOCUS) {
3688 std::string windowList;
3689 for (const sp<InputWindowHandle>& iwh : inputWindowHandles) {
3690 windowList += iwh->getName() + " ";
3691 }
3692 ALOGD("setInputWindows displayId=%" PRId32 " %s", displayId, windowList.c_str());
3693 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003694
Arthur Hung72d8dc32020-03-28 00:48:39 +00003695 // Copy old handles for release if they are no longer present.
3696 const std::vector<sp<InputWindowHandle>> oldWindowHandles = getWindowHandlesLocked(displayId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003697
Arthur Hung72d8dc32020-03-28 00:48:39 +00003698 updateWindowHandlesForDisplayLocked(inputWindowHandles, displayId);
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07003699
Arthur Hung72d8dc32020-03-28 00:48:39 +00003700 sp<InputWindowHandle> newFocusedWindowHandle = nullptr;
3701 bool foundHoveredWindow = false;
3702 for (const sp<InputWindowHandle>& windowHandle : getWindowHandlesLocked(displayId)) {
3703 // Set newFocusedWindowHandle to the top most focused window instead of the last one
3704 if (!newFocusedWindowHandle && windowHandle->getInfo()->hasFocus &&
3705 windowHandle->getInfo()->visible) {
3706 newFocusedWindowHandle = windowHandle;
3707 }
3708 if (windowHandle == mLastHoverWindowHandle) {
3709 foundHoveredWindow = true;
3710 }
3711 }
3712
3713 if (!foundHoveredWindow) {
3714 mLastHoverWindowHandle = nullptr;
3715 }
3716
3717 sp<InputWindowHandle> oldFocusedWindowHandle =
3718 getValueByKey(mFocusedWindowHandlesByDisplay, displayId);
3719
3720 if (!haveSameToken(oldFocusedWindowHandle, newFocusedWindowHandle)) {
3721 if (oldFocusedWindowHandle != nullptr) {
3722 if (DEBUG_FOCUS) {
3723 ALOGD("Focus left window: %s in display %" PRId32,
3724 oldFocusedWindowHandle->getName().c_str(), displayId);
Garfield Tanbd0fbcd2018-11-30 12:45:03 -08003725 }
Arthur Hung72d8dc32020-03-28 00:48:39 +00003726 sp<InputChannel> focusedInputChannel =
3727 getInputChannelLocked(oldFocusedWindowHandle->getToken());
3728 if (focusedInputChannel != nullptr) {
3729 CancelationOptions options(CancelationOptions::CANCEL_NON_POINTER_EVENTS,
3730 "focus left window");
3731 synthesizeCancelationEventsForInputChannelLocked(focusedInputChannel, options);
3732 enqueueFocusEventLocked(*oldFocusedWindowHandle, false /*hasFocus*/);
Garfield Tanbd0fbcd2018-11-30 12:45:03 -08003733 }
Arthur Hung72d8dc32020-03-28 00:48:39 +00003734 mFocusedWindowHandlesByDisplay.erase(displayId);
3735 }
3736 if (newFocusedWindowHandle != nullptr) {
3737 if (DEBUG_FOCUS) {
3738 ALOGD("Focus entered window: %s in display %" PRId32,
3739 newFocusedWindowHandle->getName().c_str(), displayId);
3740 }
3741 mFocusedWindowHandlesByDisplay[displayId] = newFocusedWindowHandle;
3742 enqueueFocusEventLocked(*newFocusedWindowHandle, true /*hasFocus*/);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003743 }
3744
Arthur Hung72d8dc32020-03-28 00:48:39 +00003745 if (mFocusedDisplayId == displayId) {
3746 onFocusChangedLocked(oldFocusedWindowHandle, newFocusedWindowHandle);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003747 }
Arthur Hung72d8dc32020-03-28 00:48:39 +00003748 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003749
Arthur Hung72d8dc32020-03-28 00:48:39 +00003750 ssize_t stateIndex = mTouchStatesByDisplay.indexOfKey(displayId);
3751 if (stateIndex >= 0) {
3752 TouchState& state = mTouchStatesByDisplay.editValueAt(stateIndex);
3753 for (size_t i = 0; i < state.windows.size();) {
3754 TouchedWindow& touchedWindow = state.windows[i];
3755 if (!hasWindowHandleLocked(touchedWindow.windowHandle)) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01003756 if (DEBUG_FOCUS) {
Arthur Hung72d8dc32020-03-28 00:48:39 +00003757 ALOGD("Touched window was removed: %s in display %" PRId32,
3758 touchedWindow.windowHandle->getName().c_str(), displayId);
Siarhei Vishniakou86587282019-09-09 18:20:15 +01003759 }
Arthur Hung72d8dc32020-03-28 00:48:39 +00003760 sp<InputChannel> touchedInputChannel =
3761 getInputChannelLocked(touchedWindow.windowHandle->getToken());
3762 if (touchedInputChannel != nullptr) {
3763 CancelationOptions options(CancelationOptions::CANCEL_POINTER_EVENTS,
3764 "touched window was removed");
3765 synthesizeCancelationEventsForInputChannelLocked(touchedInputChannel, options);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003766 }
Arthur Hung72d8dc32020-03-28 00:48:39 +00003767 state.windows.erase(state.windows.begin() + i);
3768 } else {
3769 ++i;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003770 }
3771 }
Arthur Hung72d8dc32020-03-28 00:48:39 +00003772 }
Arthur Hung25e2af12020-03-26 12:58:37 +00003773
Arthur Hung72d8dc32020-03-28 00:48:39 +00003774 // Release information for windows that are no longer present.
3775 // This ensures that unused input channels are released promptly.
3776 // Otherwise, they might stick around until the window handle is destroyed
3777 // which might not happen until the next GC.
3778 for (const sp<InputWindowHandle>& oldWindowHandle : oldWindowHandles) {
3779 if (!hasWindowHandleLocked(oldWindowHandle)) {
3780 if (DEBUG_FOCUS) {
3781 ALOGD("Window went away: %s", oldWindowHandle->getName().c_str());
Arthur Hung25e2af12020-03-26 12:58:37 +00003782 }
Arthur Hung72d8dc32020-03-28 00:48:39 +00003783 oldWindowHandle->releaseChannel();
Arthur Hung25e2af12020-03-26 12:58:37 +00003784 }
chaviw291d88a2019-02-14 10:33:58 -08003785 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003786}
3787
3788void InputDispatcher::setFocusedApplication(
Tiger Huang721e26f2018-07-24 22:26:19 +08003789 int32_t displayId, const sp<InputApplicationHandle>& inputApplicationHandle) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01003790 if (DEBUG_FOCUS) {
3791 ALOGD("setFocusedApplication displayId=%" PRId32 " %s", displayId,
3792 inputApplicationHandle ? inputApplicationHandle->getName().c_str() : "<nullptr>");
3793 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003794 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08003795 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003796
Tiger Huang721e26f2018-07-24 22:26:19 +08003797 sp<InputApplicationHandle> oldFocusedApplicationHandle =
3798 getValueByKey(mFocusedApplicationHandlesByDisplay, displayId);
Yi Kong9b14ac62018-07-17 13:48:38 -07003799 if (inputApplicationHandle != nullptr && inputApplicationHandle->updateInfo()) {
Tiger Huang721e26f2018-07-24 22:26:19 +08003800 if (oldFocusedApplicationHandle != inputApplicationHandle) {
3801 if (oldFocusedApplicationHandle != nullptr) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003802 resetANRTimeoutsLocked();
Michael Wrightd02c5b62014-02-10 15:10:22 -08003803 }
Tiger Huang721e26f2018-07-24 22:26:19 +08003804 mFocusedApplicationHandlesByDisplay[displayId] = inputApplicationHandle;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003805 }
Tiger Huang721e26f2018-07-24 22:26:19 +08003806 } else if (oldFocusedApplicationHandle != nullptr) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003807 resetANRTimeoutsLocked();
Tiger Huang721e26f2018-07-24 22:26:19 +08003808 oldFocusedApplicationHandle.clear();
3809 mFocusedApplicationHandlesByDisplay.erase(displayId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003810 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003811 } // release lock
3812
3813 // Wake up poll loop since it may need to make new input dispatching choices.
3814 mLooper->wake();
3815}
3816
Tiger Huang721e26f2018-07-24 22:26:19 +08003817/**
3818 * Sets the focused display, which is responsible for receiving focus-dispatched input events where
3819 * the display not specified.
3820 *
3821 * We track any unreleased events for each window. If a window loses the ability to receive the
3822 * released event, we will send a cancel event to it. So when the focused display is changed, we
3823 * cancel all the unreleased display-unspecified events for the focused window on the old focused
3824 * display. The display-specified events won't be affected.
3825 */
3826void InputDispatcher::setFocusedDisplay(int32_t displayId) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01003827 if (DEBUG_FOCUS) {
3828 ALOGD("setFocusedDisplay displayId=%" PRId32, displayId);
3829 }
Tiger Huang721e26f2018-07-24 22:26:19 +08003830 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08003831 std::scoped_lock _l(mLock);
Tiger Huang721e26f2018-07-24 22:26:19 +08003832
3833 if (mFocusedDisplayId != displayId) {
3834 sp<InputWindowHandle> oldFocusedWindowHandle =
3835 getValueByKey(mFocusedWindowHandlesByDisplay, mFocusedDisplayId);
3836 if (oldFocusedWindowHandle != nullptr) {
Robert Carr5c8a0262018-10-03 16:30:44 -07003837 sp<InputChannel> inputChannel =
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003838 getInputChannelLocked(oldFocusedWindowHandle->getToken());
Tiger Huang721e26f2018-07-24 22:26:19 +08003839 if (inputChannel != nullptr) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003840 CancelationOptions
3841 options(CancelationOptions::CANCEL_NON_POINTER_EVENTS,
3842 "The display which contains this window no longer has focus.");
Michael Wright3dd60e22019-03-27 22:06:44 +00003843 options.displayId = ADISPLAY_ID_NONE;
Tiger Huang721e26f2018-07-24 22:26:19 +08003844 synthesizeCancelationEventsForInputChannelLocked(inputChannel, options);
3845 }
3846 }
3847 mFocusedDisplayId = displayId;
3848
3849 // Sanity check
3850 sp<InputWindowHandle> newFocusedWindowHandle =
3851 getValueByKey(mFocusedWindowHandlesByDisplay, displayId);
chaviw0c06c6e2019-01-09 13:27:07 -08003852 onFocusChangedLocked(oldFocusedWindowHandle, newFocusedWindowHandle);
Robert Carrf759f162018-11-13 12:57:11 -08003853
Tiger Huang721e26f2018-07-24 22:26:19 +08003854 if (newFocusedWindowHandle == nullptr) {
3855 ALOGW("Focused display #%" PRId32 " does not have a focused window.", displayId);
3856 if (!mFocusedWindowHandlesByDisplay.empty()) {
3857 ALOGE("But another display has a focused window:");
3858 for (auto& it : mFocusedWindowHandlesByDisplay) {
3859 const int32_t displayId = it.first;
3860 const sp<InputWindowHandle>& windowHandle = it.second;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003861 ALOGE("Display #%" PRId32 " has focused window: '%s'\n", displayId,
3862 windowHandle->getName().c_str());
Tiger Huang721e26f2018-07-24 22:26:19 +08003863 }
3864 }
3865 }
3866 }
3867
Siarhei Vishniakou86587282019-09-09 18:20:15 +01003868 if (DEBUG_FOCUS) {
3869 logDispatchStateLocked();
3870 }
Tiger Huang721e26f2018-07-24 22:26:19 +08003871 } // release lock
3872
3873 // Wake up poll loop since it may need to make new input dispatching choices.
3874 mLooper->wake();
3875}
3876
Michael Wrightd02c5b62014-02-10 15:10:22 -08003877void InputDispatcher::setInputDispatchMode(bool enabled, bool frozen) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01003878 if (DEBUG_FOCUS) {
3879 ALOGD("setInputDispatchMode: enabled=%d, frozen=%d", enabled, frozen);
3880 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003881
3882 bool changed;
3883 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08003884 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003885
3886 if (mDispatchEnabled != enabled || mDispatchFrozen != frozen) {
3887 if (mDispatchFrozen && !frozen) {
3888 resetANRTimeoutsLocked();
3889 }
3890
3891 if (mDispatchEnabled && !enabled) {
3892 resetAndDropEverythingLocked("dispatcher is being disabled");
3893 }
3894
3895 mDispatchEnabled = enabled;
3896 mDispatchFrozen = frozen;
3897 changed = true;
3898 } else {
3899 changed = false;
3900 }
3901
Siarhei Vishniakou86587282019-09-09 18:20:15 +01003902 if (DEBUG_FOCUS) {
3903 logDispatchStateLocked();
3904 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003905 } // release lock
3906
3907 if (changed) {
3908 // Wake up poll loop since it may need to make new input dispatching choices.
3909 mLooper->wake();
3910 }
3911}
3912
3913void InputDispatcher::setInputFilterEnabled(bool enabled) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01003914 if (DEBUG_FOCUS) {
3915 ALOGD("setInputFilterEnabled: enabled=%d", enabled);
3916 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003917
3918 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08003919 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003920
3921 if (mInputFilterEnabled == enabled) {
3922 return;
3923 }
3924
3925 mInputFilterEnabled = enabled;
3926 resetAndDropEverythingLocked("input filter is being enabled or disabled");
3927 } // release lock
3928
3929 // Wake up poll loop since there might be work to do to drop everything.
3930 mLooper->wake();
3931}
3932
Siarhei Vishniakouf3bc1aa2019-11-25 13:48:53 -08003933void InputDispatcher::setInTouchMode(bool inTouchMode) {
3934 std::scoped_lock lock(mLock);
3935 mInTouchMode = inTouchMode;
3936}
3937
chaviwfbe5d9c2018-12-26 12:23:37 -08003938bool InputDispatcher::transferTouchFocus(const sp<IBinder>& fromToken, const sp<IBinder>& toToken) {
3939 if (fromToken == toToken) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01003940 if (DEBUG_FOCUS) {
3941 ALOGD("Trivial transfer to same window.");
3942 }
chaviwfbe5d9c2018-12-26 12:23:37 -08003943 return true;
3944 }
3945
Michael Wrightd02c5b62014-02-10 15:10:22 -08003946 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08003947 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003948
chaviwfbe5d9c2018-12-26 12:23:37 -08003949 sp<InputWindowHandle> fromWindowHandle = getWindowHandleLocked(fromToken);
3950 sp<InputWindowHandle> toWindowHandle = getWindowHandleLocked(toToken);
Yi Kong9b14ac62018-07-17 13:48:38 -07003951 if (fromWindowHandle == nullptr || toWindowHandle == nullptr) {
chaviwfbe5d9c2018-12-26 12:23:37 -08003952 ALOGW("Cannot transfer focus because from or to window not found.");
Michael Wrightd02c5b62014-02-10 15:10:22 -08003953 return false;
3954 }
Siarhei Vishniakou86587282019-09-09 18:20:15 +01003955 if (DEBUG_FOCUS) {
3956 ALOGD("transferTouchFocus: fromWindowHandle=%s, toWindowHandle=%s",
3957 fromWindowHandle->getName().c_str(), toWindowHandle->getName().c_str());
3958 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003959 if (fromWindowHandle->getInfo()->displayId != toWindowHandle->getInfo()->displayId) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01003960 if (DEBUG_FOCUS) {
3961 ALOGD("Cannot transfer focus because windows are on different displays.");
3962 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003963 return false;
3964 }
3965
3966 bool found = false;
Jeff Brownf086ddb2014-02-11 14:28:48 -08003967 for (size_t d = 0; d < mTouchStatesByDisplay.size(); d++) {
3968 TouchState& state = mTouchStatesByDisplay.editValueAt(d);
3969 for (size_t i = 0; i < state.windows.size(); i++) {
3970 const TouchedWindow& touchedWindow = state.windows[i];
3971 if (touchedWindow.windowHandle == fromWindowHandle) {
3972 int32_t oldTargetFlags = touchedWindow.targetFlags;
3973 BitSet32 pointerIds = touchedWindow.pointerIds;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003974
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08003975 state.windows.erase(state.windows.begin() + i);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003976
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003977 int32_t newTargetFlags = oldTargetFlags &
3978 (InputTarget::FLAG_FOREGROUND | InputTarget::FLAG_SPLIT |
3979 InputTarget::FLAG_DISPATCH_AS_IS);
Jeff Brownf086ddb2014-02-11 14:28:48 -08003980 state.addOrUpdateWindow(toWindowHandle, newTargetFlags, pointerIds);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003981
Jeff Brownf086ddb2014-02-11 14:28:48 -08003982 found = true;
3983 goto Found;
3984 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003985 }
3986 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003987 Found:
Michael Wrightd02c5b62014-02-10 15:10:22 -08003988
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003989 if (!found) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01003990 if (DEBUG_FOCUS) {
3991 ALOGD("Focus transfer failed because from window did not have focus.");
3992 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003993 return false;
3994 }
3995
Siarhei Vishniakoud0d71b62019-10-14 14:50:45 -07003996 sp<Connection> fromConnection = getConnectionLocked(fromToken);
3997 sp<Connection> toConnection = getConnectionLocked(toToken);
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07003998 if (fromConnection != nullptr && toConnection != nullptr) {
Svet Ganov5d3bc372020-01-26 23:11:07 -08003999 fromConnection->inputState.mergePointerStateTo(toConnection->inputState);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004000 CancelationOptions
4001 options(CancelationOptions::CANCEL_POINTER_EVENTS,
4002 "transferring touch focus from this window to another window");
Michael Wrightd02c5b62014-02-10 15:10:22 -08004003 synthesizeCancelationEventsForConnectionLocked(fromConnection, options);
Svet Ganov5d3bc372020-01-26 23:11:07 -08004004 synthesizePointerDownEventsForConnectionLocked(toConnection);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004005 }
4006
Siarhei Vishniakou86587282019-09-09 18:20:15 +01004007 if (DEBUG_FOCUS) {
4008 logDispatchStateLocked();
4009 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004010 } // release lock
4011
4012 // Wake up poll loop since it may need to make new input dispatching choices.
4013 mLooper->wake();
4014 return true;
4015}
4016
4017void InputDispatcher::resetAndDropEverythingLocked(const char* reason) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01004018 if (DEBUG_FOCUS) {
4019 ALOGD("Resetting and dropping all events (%s).", reason);
4020 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004021
4022 CancelationOptions options(CancelationOptions::CANCEL_ALL_EVENTS, reason);
4023 synthesizeCancelationEventsForAllConnectionsLocked(options);
4024
4025 resetKeyRepeatLocked();
4026 releasePendingEventLocked();
4027 drainInboundQueueLocked();
4028 resetANRTimeoutsLocked();
4029
Jeff Brownf086ddb2014-02-11 14:28:48 -08004030 mTouchStatesByDisplay.clear();
Michael Wrightd02c5b62014-02-10 15:10:22 -08004031 mLastHoverWindowHandle.clear();
Michael Wright78f24442014-08-06 15:55:28 -07004032 mReplacedKeys.clear();
Michael Wrightd02c5b62014-02-10 15:10:22 -08004033}
4034
4035void InputDispatcher::logDispatchStateLocked() {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004036 std::string dump;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004037 dumpDispatchStateLocked(dump);
4038
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004039 std::istringstream stream(dump);
4040 std::string line;
4041
4042 while (std::getline(stream, line, '\n')) {
4043 ALOGD("%s", line.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08004044 }
4045}
4046
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004047void InputDispatcher::dumpDispatchStateLocked(std::string& dump) {
Siarhei Vishniakou043a3ec2019-05-01 11:30:46 -07004048 dump += StringPrintf(INDENT "DispatchEnabled: %s\n", toString(mDispatchEnabled));
4049 dump += StringPrintf(INDENT "DispatchFrozen: %s\n", toString(mDispatchFrozen));
4050 dump += StringPrintf(INDENT "InputFilterEnabled: %s\n", toString(mInputFilterEnabled));
Tiger Huang721e26f2018-07-24 22:26:19 +08004051 dump += StringPrintf(INDENT "FocusedDisplayId: %" PRId32 "\n", mFocusedDisplayId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004052
Tiger Huang721e26f2018-07-24 22:26:19 +08004053 if (!mFocusedApplicationHandlesByDisplay.empty()) {
4054 dump += StringPrintf(INDENT "FocusedApplications:\n");
4055 for (auto& it : mFocusedApplicationHandlesByDisplay) {
4056 const int32_t displayId = it.first;
4057 const sp<InputApplicationHandle>& applicationHandle = it.second;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004058 dump += StringPrintf(INDENT2 "displayId=%" PRId32
4059 ", name='%s', dispatchingTimeout=%0.3fms\n",
4060 displayId, applicationHandle->getName().c_str(),
4061 applicationHandle->getDispatchingTimeout(
4062 DEFAULT_INPUT_DISPATCHING_TIMEOUT) /
4063 1000000.0);
Tiger Huang721e26f2018-07-24 22:26:19 +08004064 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004065 } else {
Tiger Huang721e26f2018-07-24 22:26:19 +08004066 dump += StringPrintf(INDENT "FocusedApplications: <none>\n");
Michael Wrightd02c5b62014-02-10 15:10:22 -08004067 }
Tiger Huang721e26f2018-07-24 22:26:19 +08004068
4069 if (!mFocusedWindowHandlesByDisplay.empty()) {
4070 dump += StringPrintf(INDENT "FocusedWindows:\n");
4071 for (auto& it : mFocusedWindowHandlesByDisplay) {
4072 const int32_t displayId = it.first;
4073 const sp<InputWindowHandle>& windowHandle = it.second;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004074 dump += StringPrintf(INDENT2 "displayId=%" PRId32 ", name='%s'\n", displayId,
4075 windowHandle->getName().c_str());
Tiger Huang721e26f2018-07-24 22:26:19 +08004076 }
4077 } else {
4078 dump += StringPrintf(INDENT "FocusedWindows: <none>\n");
4079 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004080
Jeff Brownf086ddb2014-02-11 14:28:48 -08004081 if (!mTouchStatesByDisplay.isEmpty()) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004082 dump += StringPrintf(INDENT "TouchStatesByDisplay:\n");
Jeff Brownf086ddb2014-02-11 14:28:48 -08004083 for (size_t i = 0; i < mTouchStatesByDisplay.size(); i++) {
4084 const TouchState& state = mTouchStatesByDisplay.valueAt(i);
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004085 dump += StringPrintf(INDENT2 "%d: down=%s, split=%s, deviceId=%d, source=0x%08x\n",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004086 state.displayId, toString(state.down), toString(state.split),
4087 state.deviceId, state.source);
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08004088 if (!state.windows.empty()) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004089 dump += INDENT3 "Windows:\n";
Jeff Brownf086ddb2014-02-11 14:28:48 -08004090 for (size_t i = 0; i < state.windows.size(); i++) {
4091 const TouchedWindow& touchedWindow = state.windows[i];
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004092 dump += StringPrintf(INDENT4
4093 "%zu: name='%s', pointerIds=0x%0x, targetFlags=0x%x\n",
4094 i, touchedWindow.windowHandle->getName().c_str(),
4095 touchedWindow.pointerIds.value, touchedWindow.targetFlags);
Jeff Brownf086ddb2014-02-11 14:28:48 -08004096 }
4097 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004098 dump += INDENT3 "Windows: <none>\n";
Jeff Brownf086ddb2014-02-11 14:28:48 -08004099 }
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08004100 if (!state.portalWindows.empty()) {
Tiger Huang85b8c5e2019-01-17 18:34:54 +08004101 dump += INDENT3 "Portal windows:\n";
4102 for (size_t i = 0; i < state.portalWindows.size(); i++) {
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08004103 const sp<InputWindowHandle> portalWindowHandle = state.portalWindows[i];
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004104 dump += StringPrintf(INDENT4 "%zu: name='%s'\n", i,
4105 portalWindowHandle->getName().c_str());
Tiger Huang85b8c5e2019-01-17 18:34:54 +08004106 }
4107 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004108 }
4109 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004110 dump += INDENT "TouchStates: <no displays touched>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08004111 }
4112
Arthur Hungb92218b2018-08-14 12:00:21 +08004113 if (!mWindowHandlesByDisplay.empty()) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004114 for (auto& it : mWindowHandlesByDisplay) {
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08004115 const std::vector<sp<InputWindowHandle>> windowHandles = it.second;
Arthur Hung3b413f22018-10-26 18:05:34 +08004116 dump += StringPrintf(INDENT "Display: %" PRId32 "\n", it.first);
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08004117 if (!windowHandles.empty()) {
Arthur Hungb92218b2018-08-14 12:00:21 +08004118 dump += INDENT2 "Windows:\n";
4119 for (size_t i = 0; i < windowHandles.size(); i++) {
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08004120 const sp<InputWindowHandle>& windowHandle = windowHandles[i];
Arthur Hungb92218b2018-08-14 12:00:21 +08004121 const InputWindowInfo* windowInfo = windowHandle->getInfo();
Michael Wrightd02c5b62014-02-10 15:10:22 -08004122
Arthur Hungb92218b2018-08-14 12:00:21 +08004123 dump += StringPrintf(INDENT3 "%zu: name='%s', displayId=%d, "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004124 "portalToDisplayId=%d, paused=%s, hasFocus=%s, "
chaviwcb923212019-12-30 14:05:11 -08004125 "hasWallpaper=%s, visible=%s, canReceiveKeys=%s, "
4126 "flags=0x%08x, type=0x%08x, "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004127 "frame=[%d,%d][%d,%d], globalScale=%f, "
chaviwcb923212019-12-30 14:05:11 -08004128 "windowScale=(%f,%f), touchableRegion=",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004129 i, windowInfo->name.c_str(), windowInfo->displayId,
4130 windowInfo->portalToDisplayId,
4131 toString(windowInfo->paused),
4132 toString(windowInfo->hasFocus),
4133 toString(windowInfo->hasWallpaper),
4134 toString(windowInfo->visible),
4135 toString(windowInfo->canReceiveKeys),
4136 windowInfo->layoutParamsFlags,
chaviwcb923212019-12-30 14:05:11 -08004137 windowInfo->layoutParamsType, windowInfo->frameLeft,
4138 windowInfo->frameTop, windowInfo->frameRight,
4139 windowInfo->frameBottom, windowInfo->globalScaleFactor,
4140 windowInfo->windowXScale, windowInfo->windowYScale);
Arthur Hungb92218b2018-08-14 12:00:21 +08004141 dumpRegion(dump, windowInfo->touchableRegion);
4142 dump += StringPrintf(", inputFeatures=0x%08x", windowInfo->inputFeatures);
4143 dump += StringPrintf(", ownerPid=%d, ownerUid=%d, dispatchingTimeout=%0.3fms\n",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004144 windowInfo->ownerPid, windowInfo->ownerUid,
4145 windowInfo->dispatchingTimeout / 1000000.0);
Arthur Hungb92218b2018-08-14 12:00:21 +08004146 }
4147 } else {
4148 dump += INDENT2 "Windows: <none>\n";
4149 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004150 }
4151 } else {
Arthur Hungb92218b2018-08-14 12:00:21 +08004152 dump += INDENT "Displays: <none>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08004153 }
4154
Michael Wright3dd60e22019-03-27 22:06:44 +00004155 if (!mGlobalMonitorsByDisplay.empty() || !mGestureMonitorsByDisplay.empty()) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004156 for (auto& it : mGlobalMonitorsByDisplay) {
Michael Wright3dd60e22019-03-27 22:06:44 +00004157 const std::vector<Monitor>& monitors = it.second;
4158 dump += StringPrintf(INDENT "Global monitors in display %" PRId32 ":\n", it.first);
4159 dumpMonitors(dump, monitors);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004160 }
4161 for (auto& it : mGestureMonitorsByDisplay) {
Michael Wright3dd60e22019-03-27 22:06:44 +00004162 const std::vector<Monitor>& monitors = it.second;
4163 dump += StringPrintf(INDENT "Gesture monitors in display %" PRId32 ":\n", it.first);
4164 dumpMonitors(dump, monitors);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004165 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004166 } else {
Michael Wright3dd60e22019-03-27 22:06:44 +00004167 dump += INDENT "Monitors: <none>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08004168 }
4169
4170 nsecs_t currentTime = now();
4171
4172 // Dump recently dispatched or dropped events from oldest to newest.
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07004173 if (!mRecentQueue.empty()) {
4174 dump += StringPrintf(INDENT "RecentQueue: length=%zu\n", mRecentQueue.size());
4175 for (EventEntry* entry : mRecentQueue) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004176 dump += INDENT2;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004177 entry->appendDescription(dump);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004178 dump += StringPrintf(", age=%0.1fms\n", (currentTime - entry->eventTime) * 0.000001f);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004179 }
4180 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004181 dump += INDENT "RecentQueue: <empty>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08004182 }
4183
4184 // Dump event currently being dispatched.
4185 if (mPendingEvent) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004186 dump += INDENT "PendingEvent:\n";
4187 dump += INDENT2;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004188 mPendingEvent->appendDescription(dump);
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004189 dump += StringPrintf(", age=%0.1fms\n",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004190 (currentTime - mPendingEvent->eventTime) * 0.000001f);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004191 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004192 dump += INDENT "PendingEvent: <none>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08004193 }
4194
4195 // Dump inbound events from oldest to newest.
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07004196 if (!mInboundQueue.empty()) {
4197 dump += StringPrintf(INDENT "InboundQueue: length=%zu\n", mInboundQueue.size());
4198 for (EventEntry* entry : mInboundQueue) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004199 dump += INDENT2;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004200 entry->appendDescription(dump);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004201 dump += StringPrintf(", age=%0.1fms\n", (currentTime - entry->eventTime) * 0.000001f);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004202 }
4203 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004204 dump += INDENT "InboundQueue: <empty>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08004205 }
4206
Michael Wright78f24442014-08-06 15:55:28 -07004207 if (!mReplacedKeys.isEmpty()) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004208 dump += INDENT "ReplacedKeys:\n";
Michael Wright78f24442014-08-06 15:55:28 -07004209 for (size_t i = 0; i < mReplacedKeys.size(); i++) {
4210 const KeyReplacement& replacement = mReplacedKeys.keyAt(i);
4211 int32_t newKeyCode = mReplacedKeys.valueAt(i);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004212 dump += StringPrintf(INDENT2 "%zu: originalKeyCode=%d, deviceId=%d, newKeyCode=%d\n", i,
4213 replacement.keyCode, replacement.deviceId, newKeyCode);
Michael Wright78f24442014-08-06 15:55:28 -07004214 }
4215 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004216 dump += INDENT "ReplacedKeys: <empty>\n";
Michael Wright78f24442014-08-06 15:55:28 -07004217 }
4218
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07004219 if (!mConnectionsByFd.empty()) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004220 dump += INDENT "Connections:\n";
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07004221 for (const auto& pair : mConnectionsByFd) {
4222 const sp<Connection>& connection = pair.second;
4223 dump += StringPrintf(INDENT2 "%i: channelName='%s', windowName='%s', "
4224 "status=%s, monitor=%s, inputPublisherBlocked=%s\n",
4225 pair.first, connection->getInputChannelName().c_str(),
4226 connection->getWindowName().c_str(), connection->getStatusLabel(),
4227 toString(connection->monitor),
4228 toString(connection->inputPublisherBlocked));
Michael Wrightd02c5b62014-02-10 15:10:22 -08004229
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07004230 if (!connection->outboundQueue.empty()) {
4231 dump += StringPrintf(INDENT3 "OutboundQueue: length=%zu\n",
4232 connection->outboundQueue.size());
4233 for (DispatchEntry* entry : connection->outboundQueue) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004234 dump.append(INDENT4);
4235 entry->eventEntry->appendDescription(dump);
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004236 dump += StringPrintf(", targetFlags=0x%08x, resolvedAction=%d, age=%0.1fms\n",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004237 entry->targetFlags, entry->resolvedAction,
4238 (currentTime - entry->eventEntry->eventTime) * 0.000001f);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004239 }
4240 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004241 dump += INDENT3 "OutboundQueue: <empty>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08004242 }
4243
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07004244 if (!connection->waitQueue.empty()) {
4245 dump += StringPrintf(INDENT3 "WaitQueue: length=%zu\n",
4246 connection->waitQueue.size());
4247 for (DispatchEntry* entry : connection->waitQueue) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004248 dump += INDENT4;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004249 entry->eventEntry->appendDescription(dump);
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004250 dump += StringPrintf(", targetFlags=0x%08x, resolvedAction=%d, "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004251 "age=%0.1fms, wait=%0.1fms\n",
4252 entry->targetFlags, entry->resolvedAction,
4253 (currentTime - entry->eventEntry->eventTime) * 0.000001f,
4254 (currentTime - entry->deliveryTime) * 0.000001f);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004255 }
4256 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004257 dump += INDENT3 "WaitQueue: <empty>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08004258 }
4259 }
4260 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004261 dump += INDENT "Connections: <none>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08004262 }
4263
4264 if (isAppSwitchPendingLocked()) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004265 dump += StringPrintf(INDENT "AppSwitch: pending, due in %0.1fms\n",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004266 (mAppSwitchDueTime - now()) / 1000000.0);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004267 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004268 dump += INDENT "AppSwitch: not pending\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08004269 }
4270
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004271 dump += INDENT "Configuration:\n";
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004272 dump += StringPrintf(INDENT2 "KeyRepeatDelay: %0.1fms\n", mConfig.keyRepeatDelay * 0.000001f);
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004273 dump += StringPrintf(INDENT2 "KeyRepeatTimeout: %0.1fms\n",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004274 mConfig.keyRepeatTimeout * 0.000001f);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004275}
4276
Michael Wright3dd60e22019-03-27 22:06:44 +00004277void InputDispatcher::dumpMonitors(std::string& dump, const std::vector<Monitor>& monitors) {
4278 const size_t numMonitors = monitors.size();
4279 for (size_t i = 0; i < numMonitors; i++) {
4280 const Monitor& monitor = monitors[i];
4281 const sp<InputChannel>& channel = monitor.inputChannel;
4282 dump += StringPrintf(INDENT2 "%zu: '%s', ", i, channel->getName().c_str());
4283 dump += "\n";
4284 }
4285}
4286
Siarhei Vishniakou7c34b232019-10-11 19:08:48 -07004287status_t InputDispatcher::registerInputChannel(const sp<InputChannel>& inputChannel) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004288#if DEBUG_REGISTRATION
Siarhei Vishniakou7c34b232019-10-11 19:08:48 -07004289 ALOGD("channel '%s' ~ registerInputChannel", inputChannel->getName().c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08004290#endif
4291
4292 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004293 std::scoped_lock _l(mLock);
Siarhei Vishniakou26d3cfb2019-10-15 17:02:32 -07004294 sp<Connection> existingConnection = getConnectionLocked(inputChannel->getConnectionToken());
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07004295 if (existingConnection != nullptr) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004296 ALOGW("Attempted to register already registered input channel '%s'",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004297 inputChannel->getName().c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08004298 return BAD_VALUE;
4299 }
4300
Garfield Tan1c7bc862020-01-28 13:24:04 -08004301 sp<Connection> connection = new Connection(inputChannel, false /*monitor*/, mIdGenerator);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004302
4303 int fd = inputChannel->getFd();
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07004304 mConnectionsByFd[fd] = connection;
Siarhei Vishniakou26d3cfb2019-10-15 17:02:32 -07004305 mInputChannelsByToken[inputChannel->getConnectionToken()] = inputChannel;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004306
Michael Wrightd02c5b62014-02-10 15:10:22 -08004307 mLooper->addFd(fd, 0, ALOOPER_EVENT_INPUT, handleReceiveCallback, this);
4308 } // release lock
4309
4310 // Wake the looper because some connections have changed.
4311 mLooper->wake();
4312 return OK;
4313}
4314
Michael Wright3dd60e22019-03-27 22:06:44 +00004315status_t InputDispatcher::registerInputMonitor(const sp<InputChannel>& inputChannel,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004316 int32_t displayId, bool isGestureMonitor) {
Michael Wright3dd60e22019-03-27 22:06:44 +00004317 { // acquire lock
4318 std::scoped_lock _l(mLock);
4319
4320 if (displayId < 0) {
4321 ALOGW("Attempted to register input monitor without a specified display.");
4322 return BAD_VALUE;
4323 }
4324
Siarhei Vishniakou26d3cfb2019-10-15 17:02:32 -07004325 if (inputChannel->getConnectionToken() == nullptr) {
Michael Wright3dd60e22019-03-27 22:06:44 +00004326 ALOGW("Attempted to register input monitor without an identifying token.");
4327 return BAD_VALUE;
4328 }
4329
Garfield Tan1c7bc862020-01-28 13:24:04 -08004330 sp<Connection> connection = new Connection(inputChannel, true /*monitor*/, mIdGenerator);
Michael Wright3dd60e22019-03-27 22:06:44 +00004331
4332 const int fd = inputChannel->getFd();
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07004333 mConnectionsByFd[fd] = connection;
Siarhei Vishniakou26d3cfb2019-10-15 17:02:32 -07004334 mInputChannelsByToken[inputChannel->getConnectionToken()] = inputChannel;
Michael Wright3dd60e22019-03-27 22:06:44 +00004335
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004336 auto& monitorsByDisplay =
4337 isGestureMonitor ? mGestureMonitorsByDisplay : mGlobalMonitorsByDisplay;
Michael Wright3dd60e22019-03-27 22:06:44 +00004338 monitorsByDisplay[displayId].emplace_back(inputChannel);
4339
4340 mLooper->addFd(fd, 0, ALOOPER_EVENT_INPUT, handleReceiveCallback, this);
Michael Wright3dd60e22019-03-27 22:06:44 +00004341 }
4342 // Wake the looper because some connections have changed.
4343 mLooper->wake();
4344 return OK;
4345}
4346
Michael Wrightd02c5b62014-02-10 15:10:22 -08004347status_t InputDispatcher::unregisterInputChannel(const sp<InputChannel>& inputChannel) {
4348#if DEBUG_REGISTRATION
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004349 ALOGD("channel '%s' ~ unregisterInputChannel", inputChannel->getName().c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08004350#endif
4351
4352 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004353 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004354
4355 status_t status = unregisterInputChannelLocked(inputChannel, false /*notify*/);
4356 if (status) {
4357 return status;
4358 }
4359 } // release lock
4360
4361 // Wake the poll loop because removing the connection may have changed the current
4362 // synchronization state.
4363 mLooper->wake();
4364 return OK;
4365}
4366
4367status_t InputDispatcher::unregisterInputChannelLocked(const sp<InputChannel>& inputChannel,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004368 bool notify) {
Siarhei Vishniakou26d3cfb2019-10-15 17:02:32 -07004369 sp<Connection> connection = getConnectionLocked(inputChannel->getConnectionToken());
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07004370 if (connection == nullptr) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004371 ALOGW("Attempted to unregister already unregistered input channel '%s'",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004372 inputChannel->getName().c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08004373 return BAD_VALUE;
4374 }
4375
John Recke0710582019-09-26 13:46:12 -07004376 [[maybe_unused]] const bool removed = removeByValue(mConnectionsByFd, connection);
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07004377 ALOG_ASSERT(removed);
Siarhei Vishniakou26d3cfb2019-10-15 17:02:32 -07004378 mInputChannelsByToken.erase(inputChannel->getConnectionToken());
Robert Carr5c8a0262018-10-03 16:30:44 -07004379
Michael Wrightd02c5b62014-02-10 15:10:22 -08004380 if (connection->monitor) {
4381 removeMonitorChannelLocked(inputChannel);
4382 }
4383
4384 mLooper->removeFd(inputChannel->getFd());
4385
4386 nsecs_t currentTime = now();
4387 abortBrokenDispatchCycleLocked(currentTime, connection, notify);
4388
4389 connection->status = Connection::STATUS_ZOMBIE;
4390 return OK;
4391}
4392
4393void InputDispatcher::removeMonitorChannelLocked(const sp<InputChannel>& inputChannel) {
Michael Wright3dd60e22019-03-27 22:06:44 +00004394 removeMonitorChannelLocked(inputChannel, mGlobalMonitorsByDisplay);
4395 removeMonitorChannelLocked(inputChannel, mGestureMonitorsByDisplay);
4396}
4397
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004398void InputDispatcher::removeMonitorChannelLocked(
4399 const sp<InputChannel>& inputChannel,
Michael Wright3dd60e22019-03-27 22:06:44 +00004400 std::unordered_map<int32_t, std::vector<Monitor>>& monitorsByDisplay) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004401 for (auto it = monitorsByDisplay.begin(); it != monitorsByDisplay.end();) {
Michael Wright3dd60e22019-03-27 22:06:44 +00004402 std::vector<Monitor>& monitors = it->second;
4403 const size_t numMonitors = monitors.size();
4404 for (size_t i = 0; i < numMonitors; i++) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004405 if (monitors[i].inputChannel == inputChannel) {
4406 monitors.erase(monitors.begin() + i);
4407 break;
4408 }
Arthur Hung2fbf37f2018-09-13 18:16:41 +08004409 }
Michael Wright3dd60e22019-03-27 22:06:44 +00004410 if (monitors.empty()) {
4411 it = monitorsByDisplay.erase(it);
Arthur Hung2fbf37f2018-09-13 18:16:41 +08004412 } else {
4413 ++it;
4414 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004415 }
4416}
4417
Michael Wright3dd60e22019-03-27 22:06:44 +00004418status_t InputDispatcher::pilferPointers(const sp<IBinder>& token) {
4419 { // acquire lock
4420 std::scoped_lock _l(mLock);
4421 std::optional<int32_t> foundDisplayId = findGestureMonitorDisplayByTokenLocked(token);
4422
4423 if (!foundDisplayId) {
4424 ALOGW("Attempted to pilfer pointers from an un-registered monitor or invalid token");
4425 return BAD_VALUE;
4426 }
4427 int32_t displayId = foundDisplayId.value();
4428
4429 ssize_t stateIndex = mTouchStatesByDisplay.indexOfKey(displayId);
4430 if (stateIndex < 0) {
4431 ALOGW("Failed to pilfer pointers: no pointers on display %" PRId32 ".", displayId);
4432 return BAD_VALUE;
4433 }
4434
4435 TouchState& state = mTouchStatesByDisplay.editValueAt(stateIndex);
4436 std::optional<int32_t> foundDeviceId;
4437 for (const TouchedMonitor& touchedMonitor : state.gestureMonitors) {
Siarhei Vishniakou26d3cfb2019-10-15 17:02:32 -07004438 if (touchedMonitor.monitor.inputChannel->getConnectionToken() == token) {
Michael Wright3dd60e22019-03-27 22:06:44 +00004439 foundDeviceId = state.deviceId;
4440 }
4441 }
4442 if (!foundDeviceId || !state.down) {
4443 ALOGW("Attempted to pilfer points from a monitor without any on-going pointer streams."
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004444 " Ignoring.");
Michael Wright3dd60e22019-03-27 22:06:44 +00004445 return BAD_VALUE;
4446 }
4447 int32_t deviceId = foundDeviceId.value();
4448
4449 // Send cancel events to all the input channels we're stealing from.
4450 CancelationOptions options(CancelationOptions::CANCEL_POINTER_EVENTS,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004451 "gesture monitor stole pointer stream");
Michael Wright3dd60e22019-03-27 22:06:44 +00004452 options.deviceId = deviceId;
4453 options.displayId = displayId;
4454 for (const TouchedWindow& window : state.windows) {
4455 sp<InputChannel> channel = getInputChannelLocked(window.windowHandle->getToken());
Michael Wright3a240c42019-12-10 20:53:41 +00004456 if (channel != nullptr) {
4457 synthesizeCancelationEventsForInputChannelLocked(channel, options);
4458 }
Michael Wright3dd60e22019-03-27 22:06:44 +00004459 }
4460 // Then clear the current touch state so we stop dispatching to them as well.
4461 state.filterNonMonitors();
4462 }
4463 return OK;
4464}
4465
Michael Wright3dd60e22019-03-27 22:06:44 +00004466std::optional<int32_t> InputDispatcher::findGestureMonitorDisplayByTokenLocked(
4467 const sp<IBinder>& token) {
4468 for (const auto& it : mGestureMonitorsByDisplay) {
4469 const std::vector<Monitor>& monitors = it.second;
4470 for (const Monitor& monitor : monitors) {
Siarhei Vishniakou26d3cfb2019-10-15 17:02:32 -07004471 if (monitor.inputChannel->getConnectionToken() == token) {
Michael Wright3dd60e22019-03-27 22:06:44 +00004472 return it.first;
4473 }
4474 }
4475 }
4476 return std::nullopt;
4477}
4478
Siarhei Vishniakoud0d71b62019-10-14 14:50:45 -07004479sp<Connection> InputDispatcher::getConnectionLocked(const sp<IBinder>& inputConnectionToken) {
4480 if (inputConnectionToken == nullptr) {
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07004481 return nullptr;
Arthur Hung3b413f22018-10-26 18:05:34 +08004482 }
4483
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07004484 for (const auto& pair : mConnectionsByFd) {
Siarhei Vishniakoud0d71b62019-10-14 14:50:45 -07004485 const sp<Connection>& connection = pair.second;
Siarhei Vishniakou26d3cfb2019-10-15 17:02:32 -07004486 if (connection->inputChannel->getConnectionToken() == inputConnectionToken) {
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07004487 return connection;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004488 }
4489 }
Robert Carr4e670e52018-08-15 13:26:12 -07004490
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07004491 return nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004492}
4493
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004494void InputDispatcher::onDispatchCycleFinishedLocked(nsecs_t currentTime,
4495 const sp<Connection>& connection, uint32_t seq,
4496 bool handled) {
Siarhei Vishniakoue7c94b92019-07-29 09:17:54 -07004497 std::unique_ptr<CommandEntry> commandEntry = std::make_unique<CommandEntry>(
4498 &InputDispatcher::doDispatchCycleFinishedLockedInterruptible);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004499 commandEntry->connection = connection;
4500 commandEntry->eventTime = currentTime;
4501 commandEntry->seq = seq;
4502 commandEntry->handled = handled;
Siarhei Vishniakoue7c94b92019-07-29 09:17:54 -07004503 postCommandLocked(std::move(commandEntry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08004504}
4505
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004506void InputDispatcher::onDispatchCycleBrokenLocked(nsecs_t currentTime,
4507 const sp<Connection>& connection) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004508 ALOGE("channel '%s' ~ Channel is unrecoverably broken and will be disposed!",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004509 connection->getInputChannelName().c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08004510
Siarhei Vishniakoue7c94b92019-07-29 09:17:54 -07004511 std::unique_ptr<CommandEntry> commandEntry = std::make_unique<CommandEntry>(
4512 &InputDispatcher::doNotifyInputChannelBrokenLockedInterruptible);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004513 commandEntry->connection = connection;
Siarhei Vishniakoue7c94b92019-07-29 09:17:54 -07004514 postCommandLocked(std::move(commandEntry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08004515}
4516
chaviw0c06c6e2019-01-09 13:27:07 -08004517void InputDispatcher::onFocusChangedLocked(const sp<InputWindowHandle>& oldFocus,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004518 const sp<InputWindowHandle>& newFocus) {
chaviw0c06c6e2019-01-09 13:27:07 -08004519 sp<IBinder> oldToken = oldFocus != nullptr ? oldFocus->getToken() : nullptr;
4520 sp<IBinder> newToken = newFocus != nullptr ? newFocus->getToken() : nullptr;
Siarhei Vishniakoue7c94b92019-07-29 09:17:54 -07004521 std::unique_ptr<CommandEntry> commandEntry = std::make_unique<CommandEntry>(
4522 &InputDispatcher::doNotifyFocusChangedLockedInterruptible);
chaviw0c06c6e2019-01-09 13:27:07 -08004523 commandEntry->oldToken = oldToken;
4524 commandEntry->newToken = newToken;
Siarhei Vishniakoue7c94b92019-07-29 09:17:54 -07004525 postCommandLocked(std::move(commandEntry));
Robert Carrf759f162018-11-13 12:57:11 -08004526}
4527
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004528void InputDispatcher::onANRLocked(nsecs_t currentTime,
4529 const sp<InputApplicationHandle>& applicationHandle,
4530 const sp<InputWindowHandle>& windowHandle, nsecs_t eventTime,
4531 nsecs_t waitStartTime, const char* reason) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004532 float dispatchLatency = (currentTime - eventTime) * 0.000001f;
4533 float waitDuration = (currentTime - waitStartTime) * 0.000001f;
4534 ALOGI("Application is not responding: %s. "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004535 "It has been %0.1fms since event, %0.1fms since wait started. Reason: %s",
4536 getApplicationWindowLabel(applicationHandle, windowHandle).c_str(), dispatchLatency,
4537 waitDuration, reason);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004538
4539 // Capture a record of the InputDispatcher state at the time of the ANR.
Yi Kong9b14ac62018-07-17 13:48:38 -07004540 time_t t = time(nullptr);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004541 struct tm tm;
4542 localtime_r(&t, &tm);
4543 char timestr[64];
4544 strftime(timestr, sizeof(timestr), "%F %T", &tm);
4545 mLastANRState.clear();
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004546 mLastANRState += INDENT "ANR:\n";
4547 mLastANRState += StringPrintf(INDENT2 "Time: %s\n", timestr);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004548 mLastANRState +=
4549 StringPrintf(INDENT2 "Window: %s\n",
4550 getApplicationWindowLabel(applicationHandle, windowHandle).c_str());
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004551 mLastANRState += StringPrintf(INDENT2 "DispatchLatency: %0.1fms\n", dispatchLatency);
4552 mLastANRState += StringPrintf(INDENT2 "WaitDuration: %0.1fms\n", waitDuration);
4553 mLastANRState += StringPrintf(INDENT2 "Reason: %s\n", reason);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004554 dumpDispatchStateLocked(mLastANRState);
4555
Siarhei Vishniakoue7c94b92019-07-29 09:17:54 -07004556 std::unique_ptr<CommandEntry> commandEntry =
4557 std::make_unique<CommandEntry>(&InputDispatcher::doNotifyANRLockedInterruptible);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004558 commandEntry->inputApplicationHandle = applicationHandle;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004559 commandEntry->inputChannel =
4560 windowHandle != nullptr ? getInputChannelLocked(windowHandle->getToken()) : nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004561 commandEntry->reason = reason;
Siarhei Vishniakoue7c94b92019-07-29 09:17:54 -07004562 postCommandLocked(std::move(commandEntry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08004563}
4564
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004565void InputDispatcher::doNotifyConfigurationChangedLockedInterruptible(CommandEntry* commandEntry) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004566 mLock.unlock();
4567
4568 mPolicy->notifyConfigurationChanged(commandEntry->eventTime);
4569
4570 mLock.lock();
4571}
4572
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004573void InputDispatcher::doNotifyInputChannelBrokenLockedInterruptible(CommandEntry* commandEntry) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004574 sp<Connection> connection = commandEntry->connection;
4575
4576 if (connection->status != Connection::STATUS_ZOMBIE) {
4577 mLock.unlock();
4578
Siarhei Vishniakou26d3cfb2019-10-15 17:02:32 -07004579 mPolicy->notifyInputChannelBroken(connection->inputChannel->getConnectionToken());
Michael Wrightd02c5b62014-02-10 15:10:22 -08004580
4581 mLock.lock();
4582 }
4583}
4584
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004585void InputDispatcher::doNotifyFocusChangedLockedInterruptible(CommandEntry* commandEntry) {
chaviw0c06c6e2019-01-09 13:27:07 -08004586 sp<IBinder> oldToken = commandEntry->oldToken;
4587 sp<IBinder> newToken = commandEntry->newToken;
Robert Carrf759f162018-11-13 12:57:11 -08004588 mLock.unlock();
chaviw0c06c6e2019-01-09 13:27:07 -08004589 mPolicy->notifyFocusChanged(oldToken, newToken);
Robert Carrf759f162018-11-13 12:57:11 -08004590 mLock.lock();
4591}
4592
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004593void InputDispatcher::doNotifyANRLockedInterruptible(CommandEntry* commandEntry) {
Siarhei Vishniakoud0d71b62019-10-14 14:50:45 -07004594 sp<IBinder> token =
Siarhei Vishniakou26d3cfb2019-10-15 17:02:32 -07004595 commandEntry->inputChannel ? commandEntry->inputChannel->getConnectionToken() : nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004596 mLock.unlock();
4597
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004598 nsecs_t newTimeout =
Siarhei Vishniakoud0d71b62019-10-14 14:50:45 -07004599 mPolicy->notifyANR(commandEntry->inputApplicationHandle, token, commandEntry->reason);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004600
4601 mLock.lock();
4602
Siarhei Vishniakoud0d71b62019-10-14 14:50:45 -07004603 resumeAfterTargetsNotReadyTimeoutLocked(newTimeout, token);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004604}
4605
4606void InputDispatcher::doInterceptKeyBeforeDispatchingLockedInterruptible(
4607 CommandEntry* commandEntry) {
4608 KeyEntry* entry = commandEntry->keyEntry;
4609
Siarhei Vishniakou9757f782019-10-29 12:53:08 -07004610 KeyEvent event = createKeyEvent(*entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004611
4612 mLock.unlock();
4613
Michael Wright2b3c3302018-03-02 17:19:13 +00004614 android::base::Timer t;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004615 sp<IBinder> token = commandEntry->inputChannel != nullptr
Siarhei Vishniakou26d3cfb2019-10-15 17:02:32 -07004616 ? commandEntry->inputChannel->getConnectionToken()
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004617 : nullptr;
4618 nsecs_t delay = mPolicy->interceptKeyBeforeDispatching(token, &event, entry->policyFlags);
Michael Wright2b3c3302018-03-02 17:19:13 +00004619 if (t.duration() > SLOW_INTERCEPTION_THRESHOLD) {
4620 ALOGW("Excessive delay in interceptKeyBeforeDispatching; took %s ms",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004621 std::to_string(t.duration().count()).c_str());
Michael Wright2b3c3302018-03-02 17:19:13 +00004622 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004623
4624 mLock.lock();
4625
4626 if (delay < 0) {
4627 entry->interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_SKIP;
4628 } else if (!delay) {
4629 entry->interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_CONTINUE;
4630 } else {
4631 entry->interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER;
4632 entry->interceptKeyWakeupTime = now() + delay;
4633 }
4634 entry->release();
4635}
4636
chaviwfd6d3512019-03-25 13:23:49 -07004637void InputDispatcher::doOnPointerDownOutsideFocusLockedInterruptible(CommandEntry* commandEntry) {
4638 mLock.unlock();
4639 mPolicy->onPointerDownOutsideFocus(commandEntry->newToken);
4640 mLock.lock();
4641}
4642
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004643void InputDispatcher::doDispatchCycleFinishedLockedInterruptible(CommandEntry* commandEntry) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004644 sp<Connection> connection = commandEntry->connection;
Siarhei Vishniakou4e68fbf2019-07-31 14:00:52 -07004645 const nsecs_t finishTime = commandEntry->eventTime;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004646 uint32_t seq = commandEntry->seq;
Siarhei Vishniakou4e68fbf2019-07-31 14:00:52 -07004647 const bool handled = commandEntry->handled;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004648
4649 // Handle post-event policy actions.
Garfield Tane84e6f92019-08-29 17:28:41 -07004650 std::deque<DispatchEntry*>::iterator dispatchEntryIt = connection->findWaitQueueEntry(seq);
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07004651 if (dispatchEntryIt == connection->waitQueue.end()) {
Siarhei Vishniakou4e68fbf2019-07-31 14:00:52 -07004652 return;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004653 }
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07004654 DispatchEntry* dispatchEntry = *dispatchEntryIt;
Siarhei Vishniakou4e68fbf2019-07-31 14:00:52 -07004655
4656 nsecs_t eventDuration = finishTime - dispatchEntry->deliveryTime;
4657 if (eventDuration > SLOW_EVENT_PROCESSING_WARNING_TIMEOUT) {
4658 std::string msg =
4659 StringPrintf("Window '%s' spent %0.1fms processing the last input event: ",
4660 connection->getWindowName().c_str(), eventDuration * 0.000001f);
4661 dispatchEntry->eventEntry->appendDescription(msg);
4662 ALOGI("%s", msg.c_str());
4663 }
4664
4665 bool restartEvent;
Siarhei Vishniakou49483272019-10-22 13:13:47 -07004666 if (dispatchEntry->eventEntry->type == EventEntry::Type::KEY) {
Siarhei Vishniakou4e68fbf2019-07-31 14:00:52 -07004667 KeyEntry* keyEntry = static_cast<KeyEntry*>(dispatchEntry->eventEntry);
4668 restartEvent =
4669 afterKeyEventLockedInterruptible(connection, dispatchEntry, keyEntry, handled);
Siarhei Vishniakou49483272019-10-22 13:13:47 -07004670 } else if (dispatchEntry->eventEntry->type == EventEntry::Type::MOTION) {
Siarhei Vishniakou4e68fbf2019-07-31 14:00:52 -07004671 MotionEntry* motionEntry = static_cast<MotionEntry*>(dispatchEntry->eventEntry);
4672 restartEvent = afterMotionEventLockedInterruptible(connection, dispatchEntry, motionEntry,
4673 handled);
4674 } else {
4675 restartEvent = false;
4676 }
4677
4678 // Dequeue the event and start the next cycle.
4679 // Note that because the lock might have been released, it is possible that the
4680 // contents of the wait queue to have been drained, so we need to double-check
4681 // a few things.
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07004682 dispatchEntryIt = connection->findWaitQueueEntry(seq);
4683 if (dispatchEntryIt != connection->waitQueue.end()) {
4684 dispatchEntry = *dispatchEntryIt;
4685 connection->waitQueue.erase(dispatchEntryIt);
Siarhei Vishniakou4e68fbf2019-07-31 14:00:52 -07004686 traceWaitQueueLength(connection);
4687 if (restartEvent && connection->status == Connection::STATUS_NORMAL) {
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07004688 connection->outboundQueue.push_front(dispatchEntry);
Siarhei Vishniakou4e68fbf2019-07-31 14:00:52 -07004689 traceOutboundQueueLength(connection);
4690 } else {
4691 releaseDispatchEntry(dispatchEntry);
4692 }
4693 }
4694
4695 // Start the next dispatch cycle for this connection.
4696 startDispatchCycleLocked(now(), connection);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004697}
4698
4699bool InputDispatcher::afterKeyEventLockedInterruptible(const sp<Connection>& connection,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004700 DispatchEntry* dispatchEntry,
4701 KeyEntry* keyEntry, bool handled) {
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08004702 if (keyEntry->flags & AKEY_EVENT_FLAG_FALLBACK) {
Prabir Pradhanf93562f2018-11-29 12:13:37 -08004703 if (!handled) {
4704 // Report the key as unhandled, since the fallback was not handled.
Garfield Tanc51d1ba2020-01-28 13:24:04 -08004705 mReporter->reportUnhandledKey(keyEntry->id);
Prabir Pradhanf93562f2018-11-29 12:13:37 -08004706 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08004707 return false;
4708 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004709
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08004710 // Get the fallback key state.
4711 // Clear it out after dispatching the UP.
4712 int32_t originalKeyCode = keyEntry->keyCode;
4713 int32_t fallbackKeyCode = connection->inputState.getFallbackKey(originalKeyCode);
4714 if (keyEntry->action == AKEY_EVENT_ACTION_UP) {
4715 connection->inputState.removeFallbackKey(originalKeyCode);
4716 }
4717
4718 if (handled || !dispatchEntry->hasForegroundTarget()) {
4719 // If the application handles the original key for which we previously
4720 // generated a fallback or if the window is not a foreground window,
4721 // then cancel the associated fallback key, if any.
4722 if (fallbackKeyCode != -1) {
4723 // Dispatch the unhandled key to the policy with the cancel flag.
Michael Wrightd02c5b62014-02-10 15:10:22 -08004724#if DEBUG_OUTBOUND_EVENT_DETAILS
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08004725 ALOGD("Unhandled key event: Asking policy to cancel fallback action. "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004726 "keyCode=%d, action=%d, repeatCount=%d, policyFlags=0x%08x",
4727 keyEntry->keyCode, keyEntry->action, keyEntry->repeatCount,
4728 keyEntry->policyFlags);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004729#endif
Siarhei Vishniakou9757f782019-10-29 12:53:08 -07004730 KeyEvent event = createKeyEvent(*keyEntry);
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08004731 event.setFlags(event.getFlags() | AKEY_EVENT_FLAG_CANCELED);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004732
4733 mLock.unlock();
4734
Siarhei Vishniakou26d3cfb2019-10-15 17:02:32 -07004735 mPolicy->dispatchUnhandledKey(connection->inputChannel->getConnectionToken(), &event,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004736 keyEntry->policyFlags, &event);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004737
4738 mLock.lock();
4739
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08004740 // Cancel the fallback key.
4741 if (fallbackKeyCode != AKEYCODE_UNKNOWN) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004742 CancelationOptions options(CancelationOptions::CANCEL_FALLBACK_EVENTS,
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08004743 "application handled the original non-fallback key "
4744 "or is no longer a foreground target, "
4745 "canceling previously dispatched fallback key");
Michael Wrightd02c5b62014-02-10 15:10:22 -08004746 options.keyCode = fallbackKeyCode;
4747 synthesizeCancelationEventsForConnectionLocked(connection, options);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004748 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08004749 connection->inputState.removeFallbackKey(originalKeyCode);
4750 }
4751 } else {
4752 // If the application did not handle a non-fallback key, first check
4753 // that we are in a good state to perform unhandled key event processing
4754 // Then ask the policy what to do with it.
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004755 bool initialDown = keyEntry->action == AKEY_EVENT_ACTION_DOWN && keyEntry->repeatCount == 0;
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08004756 if (fallbackKeyCode == -1 && !initialDown) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004757#if DEBUG_OUTBOUND_EVENT_DETAILS
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08004758 ALOGD("Unhandled key event: Skipping unhandled key event processing "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004759 "since this is not an initial down. "
4760 "keyCode=%d, action=%d, repeatCount=%d, policyFlags=0x%08x",
4761 originalKeyCode, keyEntry->action, keyEntry->repeatCount, keyEntry->policyFlags);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004762#endif
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08004763 return false;
4764 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004765
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08004766 // Dispatch the unhandled key to the policy.
4767#if DEBUG_OUTBOUND_EVENT_DETAILS
4768 ALOGD("Unhandled key event: Asking policy to perform fallback action. "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004769 "keyCode=%d, action=%d, repeatCount=%d, policyFlags=0x%08x",
4770 keyEntry->keyCode, keyEntry->action, keyEntry->repeatCount, keyEntry->policyFlags);
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08004771#endif
Siarhei Vishniakou9757f782019-10-29 12:53:08 -07004772 KeyEvent event = createKeyEvent(*keyEntry);
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08004773
4774 mLock.unlock();
4775
Siarhei Vishniakou26d3cfb2019-10-15 17:02:32 -07004776 bool fallback =
4777 mPolicy->dispatchUnhandledKey(connection->inputChannel->getConnectionToken(),
4778 &event, keyEntry->policyFlags, &event);
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08004779
4780 mLock.lock();
4781
4782 if (connection->status != Connection::STATUS_NORMAL) {
4783 connection->inputState.removeFallbackKey(originalKeyCode);
4784 return false;
4785 }
4786
4787 // Latch the fallback keycode for this key on an initial down.
4788 // The fallback keycode cannot change at any other point in the lifecycle.
4789 if (initialDown) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004790 if (fallback) {
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08004791 fallbackKeyCode = event.getKeyCode();
4792 } else {
4793 fallbackKeyCode = AKEYCODE_UNKNOWN;
4794 }
4795 connection->inputState.setFallbackKey(originalKeyCode, fallbackKeyCode);
4796 }
4797
4798 ALOG_ASSERT(fallbackKeyCode != -1);
4799
4800 // Cancel the fallback key if the policy decides not to send it anymore.
4801 // We will continue to dispatch the key to the policy but we will no
4802 // longer dispatch a fallback key to the application.
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004803 if (fallbackKeyCode != AKEYCODE_UNKNOWN &&
4804 (!fallback || fallbackKeyCode != event.getKeyCode())) {
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08004805#if DEBUG_OUTBOUND_EVENT_DETAILS
4806 if (fallback) {
4807 ALOGD("Unhandled key event: Policy requested to send key %d"
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004808 "as a fallback for %d, but on the DOWN it had requested "
4809 "to send %d instead. Fallback canceled.",
4810 event.getKeyCode(), originalKeyCode, fallbackKeyCode);
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08004811 } else {
4812 ALOGD("Unhandled key event: Policy did not request fallback for %d, "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004813 "but on the DOWN it had requested to send %d. "
4814 "Fallback canceled.",
4815 originalKeyCode, fallbackKeyCode);
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08004816 }
4817#endif
4818
4819 CancelationOptions options(CancelationOptions::CANCEL_FALLBACK_EVENTS,
4820 "canceling fallback, policy no longer desires it");
4821 options.keyCode = fallbackKeyCode;
4822 synthesizeCancelationEventsForConnectionLocked(connection, options);
4823
4824 fallback = false;
4825 fallbackKeyCode = AKEYCODE_UNKNOWN;
4826 if (keyEntry->action != AKEY_EVENT_ACTION_UP) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004827 connection->inputState.setFallbackKey(originalKeyCode, fallbackKeyCode);
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08004828 }
4829 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004830
4831#if DEBUG_OUTBOUND_EVENT_DETAILS
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08004832 {
4833 std::string msg;
4834 const KeyedVector<int32_t, int32_t>& fallbackKeys =
4835 connection->inputState.getFallbackKeys();
4836 for (size_t i = 0; i < fallbackKeys.size(); i++) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004837 msg += StringPrintf(", %d->%d", fallbackKeys.keyAt(i), fallbackKeys.valueAt(i));
Michael Wrightd02c5b62014-02-10 15:10:22 -08004838 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08004839 ALOGD("Unhandled key event: %zu currently tracked fallback keys%s.",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004840 fallbackKeys.size(), msg.c_str());
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08004841 }
4842#endif
4843
4844 if (fallback) {
4845 // Restart the dispatch cycle using the fallback key.
4846 keyEntry->eventTime = event.getEventTime();
4847 keyEntry->deviceId = event.getDeviceId();
4848 keyEntry->source = event.getSource();
4849 keyEntry->displayId = event.getDisplayId();
4850 keyEntry->flags = event.getFlags() | AKEY_EVENT_FLAG_FALLBACK;
4851 keyEntry->keyCode = fallbackKeyCode;
4852 keyEntry->scanCode = event.getScanCode();
4853 keyEntry->metaState = event.getMetaState();
4854 keyEntry->repeatCount = event.getRepeatCount();
4855 keyEntry->downTime = event.getDownTime();
4856 keyEntry->syntheticRepeat = false;
4857
4858#if DEBUG_OUTBOUND_EVENT_DETAILS
4859 ALOGD("Unhandled key event: Dispatching fallback key. "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004860 "originalKeyCode=%d, fallbackKeyCode=%d, fallbackMetaState=%08x",
4861 originalKeyCode, fallbackKeyCode, keyEntry->metaState);
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08004862#endif
4863 return true; // restart the event
4864 } else {
4865#if DEBUG_OUTBOUND_EVENT_DETAILS
4866 ALOGD("Unhandled key event: No fallback key.");
4867#endif
Prabir Pradhanf93562f2018-11-29 12:13:37 -08004868
4869 // Report the key as unhandled, since there is no fallback key.
Garfield Tanc51d1ba2020-01-28 13:24:04 -08004870 mReporter->reportUnhandledKey(keyEntry->id);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004871 }
4872 }
4873 return false;
4874}
4875
4876bool InputDispatcher::afterMotionEventLockedInterruptible(const sp<Connection>& connection,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004877 DispatchEntry* dispatchEntry,
4878 MotionEntry* motionEntry, bool handled) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004879 return false;
4880}
4881
4882void InputDispatcher::doPokeUserActivityLockedInterruptible(CommandEntry* commandEntry) {
4883 mLock.unlock();
4884
4885 mPolicy->pokeUserActivity(commandEntry->eventTime, commandEntry->userActivityEventType);
4886
4887 mLock.lock();
4888}
4889
Siarhei Vishniakou9757f782019-10-29 12:53:08 -07004890KeyEvent InputDispatcher::createKeyEvent(const KeyEntry& entry) {
4891 KeyEvent event;
Garfield Tanc51d1ba2020-01-28 13:24:04 -08004892 event.initialize(entry.id, entry.deviceId, entry.source, entry.displayId, INVALID_HMAC,
Garfield Tanfbe732e2020-01-24 11:26:14 -08004893 entry.action, entry.flags, entry.keyCode, entry.scanCode, entry.metaState,
4894 entry.repeatCount, entry.downTime, entry.eventTime);
Siarhei Vishniakou9757f782019-10-29 12:53:08 -07004895 return event;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004896}
4897
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07004898void InputDispatcher::updateDispatchStatistics(nsecs_t currentTime, const EventEntry& entry,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004899 int32_t injectionResult,
4900 nsecs_t timeSpentWaitingForApplication) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004901 // TODO Write some statistics about how long we spend waiting.
4902}
4903
Siarhei Vishniakoude4bf152019-08-16 11:12:52 -05004904/**
4905 * Report the touch event latency to the statsd server.
4906 * Input events are reported for statistics if:
4907 * - This is a touchscreen event
4908 * - InputFilter is not enabled
4909 * - Event is not injected or synthesized
4910 *
4911 * Statistics should be reported before calling addValue, to prevent a fresh new sample
4912 * from getting aggregated with the "old" data.
4913 */
4914void InputDispatcher::reportTouchEventForStatistics(const MotionEntry& motionEntry)
4915 REQUIRES(mLock) {
4916 const bool reportForStatistics = (motionEntry.source == AINPUT_SOURCE_TOUCHSCREEN) &&
4917 !(motionEntry.isSynthesized()) && !mInputFilterEnabled;
4918 if (!reportForStatistics) {
4919 return;
4920 }
4921
4922 if (mTouchStatistics.shouldReport()) {
4923 android::util::stats_write(android::util::TOUCH_EVENT_REPORTED, mTouchStatistics.getMin(),
4924 mTouchStatistics.getMax(), mTouchStatistics.getMean(),
4925 mTouchStatistics.getStDev(), mTouchStatistics.getCount());
4926 mTouchStatistics.reset();
4927 }
4928 const float latencyMicros = nanoseconds_to_microseconds(now() - motionEntry.eventTime);
4929 mTouchStatistics.addValue(latencyMicros);
4930}
4931
Michael Wrightd02c5b62014-02-10 15:10:22 -08004932void InputDispatcher::traceInboundQueueLengthLocked() {
4933 if (ATRACE_ENABLED()) {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07004934 ATRACE_INT("iq", mInboundQueue.size());
Michael Wrightd02c5b62014-02-10 15:10:22 -08004935 }
4936}
4937
Siarhei Vishniakou61291d42019-02-11 18:13:20 -08004938void InputDispatcher::traceOutboundQueueLength(const sp<Connection>& connection) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004939 if (ATRACE_ENABLED()) {
4940 char counterName[40];
Siarhei Vishniakou587c3f02018-01-04 11:46:44 -08004941 snprintf(counterName, sizeof(counterName), "oq:%s", connection->getWindowName().c_str());
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07004942 ATRACE_INT(counterName, connection->outboundQueue.size());
Michael Wrightd02c5b62014-02-10 15:10:22 -08004943 }
4944}
4945
Siarhei Vishniakou61291d42019-02-11 18:13:20 -08004946void InputDispatcher::traceWaitQueueLength(const sp<Connection>& connection) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004947 if (ATRACE_ENABLED()) {
4948 char counterName[40];
Siarhei Vishniakou587c3f02018-01-04 11:46:44 -08004949 snprintf(counterName, sizeof(counterName), "wq:%s", connection->getWindowName().c_str());
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07004950 ATRACE_INT(counterName, connection->waitQueue.size());
Michael Wrightd02c5b62014-02-10 15:10:22 -08004951 }
4952}
4953
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004954void InputDispatcher::dump(std::string& dump) {
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004955 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004956
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004957 dump += "Input Dispatcher State:\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08004958 dumpDispatchStateLocked(dump);
4959
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08004960 if (!mLastANRState.empty()) {
4961 dump += "\nInput Dispatcher State at time of last ANR:\n";
4962 dump += mLastANRState;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004963 }
4964}
4965
4966void InputDispatcher::monitor() {
4967 // Acquire and release the lock to ensure that the dispatcher has not deadlocked.
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004968 std::unique_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004969 mLooper->wake();
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004970 mDispatcherIsAlive.wait(_l);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004971}
4972
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -08004973/**
4974 * Wake up the dispatcher and wait until it processes all events and commands.
4975 * The notification of mDispatcherEnteredIdle is guaranteed to happen after wake(), so
4976 * this method can be safely called from any thread, as long as you've ensured that
4977 * the work you are interested in completing has already been queued.
4978 */
4979bool InputDispatcher::waitForIdle() {
4980 /**
4981 * Timeout should represent the longest possible time that a device might spend processing
4982 * events and commands.
4983 */
4984 constexpr std::chrono::duration TIMEOUT = 100ms;
4985 std::unique_lock lock(mLock);
4986 mLooper->wake();
4987 std::cv_status result = mDispatcherEnteredIdle.wait_for(lock, TIMEOUT);
4988 return result == std::cv_status::no_timeout;
4989}
4990
Garfield Tane84e6f92019-08-29 17:28:41 -07004991} // namespace android::inputdispatcher