blob: 4825cc8eab130fd1f3e4f0b32d4e49344fe72b31 [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
Michael Wright2b3c3302018-03-02 17:19:13 +000022#include <android-base/chrono_utils.h>
Siarhei Vishniakoud010b012023-01-18 15:00:53 -080023#include <android-base/logging.h>
Peter Collingbourneb04b9b82021-02-08 12:09:47 -080024#include <android-base/properties.h>
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -080025#include <android-base/stringprintf.h>
Siarhei Vishniakou70622952020-07-30 11:17:23 -050026#include <android/os/IInputConstants.h>
Robert Carr4e670e52018-08-15 13:26:12 -070027#include <binder/Binder.h>
Ameer Armalycff4fa52023-10-04 23:45:11 +000028#include <com_android_input_flags.h>
Dominik Laskowski75788452021-02-09 18:51:25 -080029#include <ftl/enum.h>
Siarhei Vishniakou5c02a712023-05-15 15:45:02 -070030#include <log/log_event_list.h>
Siarhei Vishniakou31977182022-09-30 08:51:23 -070031#if defined(__ANDROID__)
chaviw15fab6f2021-06-07 14:15:52 -050032#include <gui/SurfaceComposerClient.h>
Siarhei Vishniakou31977182022-09-30 08:51:23 -070033#endif
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -080034#include <input/InputDevice.h>
Siarhei Vishniakou6e1e9872022-11-08 17:51:35 -080035#include <input/PrintTools.h>
Prabir Pradhana37bad12023-08-18 15:55:32 +000036#include <input/TraceTools.h>
tyiu1573a672023-02-21 22:38:32 +000037#include <openssl/mem.h>
Prabir Pradhanadc59b42023-12-15 05:34:11 +000038#include <private/android_filesystem_config.h>
Michael Wright44753b12020-07-08 13:48:11 +010039#include <unistd.h>
Garfield Tan0fc2fa72019-08-29 17:22:15 -070040#include <utils/Trace.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080041
Michael Wright44753b12020-07-08 13:48:11 +010042#include <cerrno>
43#include <cinttypes>
44#include <climits>
45#include <cstddef>
46#include <ctime>
47#include <queue>
48#include <sstream>
49
Asmita Poddardd9a6cd2023-09-26 15:35:12 +000050#include "../InputDeviceMetricsSource.h"
51
Michael Wright44753b12020-07-08 13:48:11 +010052#include "Connection.h"
Arthur Hung1a1007b2022-05-11 07:15:01 +000053#include "DebugConfig.h"
Chris Yef59a2f42020-10-16 12:55:26 -070054#include "InputDispatcher.h"
Prabir Pradhandae52792023-12-15 07:36:40 +000055#include "trace/InputTracer.h"
56#include "trace/InputTracingPerfettoBackend.h"
Prabir Pradhanbb7a0202024-02-10 02:09:01 +000057#include "trace/ThreadedBackend.h"
Michael Wright44753b12020-07-08 13:48:11 +010058
Michael Wrightd02c5b62014-02-10 15:10:22 -080059#define INDENT " "
60#define INDENT2 " "
61#define INDENT3 " "
62#define INDENT4 " "
63
Siarhei Vishniakou253f4642022-11-09 13:42:06 -080064using namespace android::ftl::flag_operators;
Siarhei Vishniakou23740b92023-04-21 11:30:20 -070065using android::base::Error;
Peter Collingbourneb04b9b82021-02-08 12:09:47 -080066using android::base::HwTimeoutMultiplier;
Siarhei Vishniakoueedd0fc2021-03-12 09:50:36 +000067using android::base::Result;
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -080068using android::base::StringPrintf;
Prabir Pradhan48f8cb92021-08-26 14:05:36 -070069using android::gui::DisplayInfo;
chaviw98318de2021-05-19 16:45:23 -050070using android::gui::FocusRequest;
71using android::gui::TouchOcclusionMode;
72using android::gui::WindowInfo;
73using android::gui::WindowInfoHandle;
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -080074using android::os::InputEventInjectionResult;
75using android::os::InputEventInjectionSync;
Ameer Armalycff4fa52023-10-04 23:45:11 +000076namespace input_flags = com::android::input::flags;
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -080077
Garfield Tane84e6f92019-08-29 17:28:41 -070078namespace android::inputdispatcher {
Michael Wrightd02c5b62014-02-10 15:10:22 -080079
Prabir Pradhancef936d2021-07-21 16:17:52 +000080namespace {
Prabir Pradhanabcdf5c2023-12-15 07:30:22 +000081
Prabir Pradhandae52792023-12-15 07:36:40 +000082// Input tracing is only available on debuggable builds (userdebug and eng) when the feature
83// flag is enabled. When the flag is changed, tracing will only be available after reboot.
84bool isInputTracingEnabled() {
85 static const std::string buildType = base::GetProperty("ro.build.type", "user");
86 static const bool isUserdebugOrEng = buildType == "userdebug" || buildType == "eng";
87 return input_flags::enable_input_event_tracing() && isUserdebugOrEng;
88}
89
Prabir Pradhanbb7a0202024-02-10 02:09:01 +000090// Create the input tracing backend that writes to perfetto from a single thread.
Prabir Pradhanbf3c8322024-02-23 02:38:36 +000091std::unique_ptr<trace::InputTracingBackendInterface> createInputTracingBackendIfEnabled(
92 trace::impl::PerfettoBackend::GetPackageUid getPackageUid) {
Prabir Pradhanbb7a0202024-02-10 02:09:01 +000093 if (!isInputTracingEnabled()) {
94 return nullptr;
95 }
96 return std::make_unique<trace::impl::ThreadedBackend<trace::impl::PerfettoBackend>>(
Prabir Pradhanbf3c8322024-02-23 02:38:36 +000097 trace::impl::PerfettoBackend(getPackageUid));
Prabir Pradhanbb7a0202024-02-10 02:09:01 +000098}
99
Prabir Pradhanabcdf5c2023-12-15 07:30:22 +0000100template <class Entry>
101void ensureEventTraced(const Entry& entry) {
102 if (!entry.traceTracker) {
103 LOG(FATAL) << "Expected event entry to be traced, but it wasn't: " << entry;
104 }
105}
106
Prabir Pradhan052fb0b2024-02-23 21:03:12 +0000107// Helper to get a trace tracker from a traced key or motion entry.
108const std::unique_ptr<trace::EventTrackerInterface>& getTraceTracker(const EventEntry& entry) {
109 switch (entry.type) {
110 case EventEntry::Type::MOTION: {
111 const auto& motion = static_cast<const MotionEntry&>(entry);
112 ensureEventTraced(motion);
113 return motion.traceTracker;
114 }
115 case EventEntry::Type::KEY: {
116 const auto& key = static_cast<const KeyEntry&>(entry);
117 ensureEventTraced(key);
118 return key.traceTracker;
119 }
120 default: {
121 const static std::unique_ptr<trace::EventTrackerInterface> kNullTracker;
122 return kNullTracker;
123 }
124 }
125}
126
Prabir Pradhancef936d2021-07-21 16:17:52 +0000127// Temporarily releases a held mutex for the lifetime of the instance.
128// Named to match std::scoped_lock
129class scoped_unlock {
130public:
131 explicit scoped_unlock(std::mutex& mutex) : mMutex(mutex) { mMutex.unlock(); }
132 ~scoped_unlock() { mMutex.lock(); }
133
134private:
135 std::mutex& mMutex;
136};
137
Michael Wrightd02c5b62014-02-10 15:10:22 -0800138// Default input dispatching timeout if there is no focused application or paused window
139// from which to determine an appropriate dispatching timeout.
Peter Collingbourneb04b9b82021-02-08 12:09:47 -0800140const std::chrono::duration DEFAULT_INPUT_DISPATCHING_TIMEOUT = std::chrono::milliseconds(
141 android::os::IInputConstants::UNMULTIPLIED_DEFAULT_DISPATCHING_TIMEOUT_MILLIS *
142 HwTimeoutMultiplier());
Michael Wrightd02c5b62014-02-10 15:10:22 -0800143
Yeabkal Wubshitb8aadfa2024-01-17 17:03:42 -0800144// The default minimum time gap between two user activity poke events.
145const std::chrono::milliseconds DEFAULT_USER_ACTIVITY_POKE_INTERVAL = 100ms;
146
Siarhei Vishniakou289e9242022-02-15 14:50:16 -0800147const std::chrono::duration STALE_EVENT_TIMEOUT = std::chrono::seconds(10) * HwTimeoutMultiplier();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800148
Michael Wrightd02c5b62014-02-10 15:10:22 -0800149// 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 +0000150constexpr nsecs_t SLOW_EVENT_PROCESSING_WARNING_TIMEOUT = 2000 * 1000000LL; // 2sec
151
152// Log a warning when an interception call takes longer than this to process.
153constexpr std::chrono::milliseconds SLOW_INTERCEPTION_THRESHOLD = 50ms;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800154
155// Number of recent events to keep for debugging purposes.
Michael Wright2b3c3302018-03-02 17:19:13 +0000156constexpr size_t RECENT_QUEUE_MAX_SIZE = 10;
157
Antonio Kantekea47acb2021-12-23 12:41:25 -0800158// Event log tags. See EventLogTags.logtags for reference.
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +0000159constexpr int LOGTAG_INPUT_INTERACTION = 62000;
160constexpr int LOGTAG_INPUT_FOCUS = 62001;
Arthur Hungb3307ee2021-10-14 10:57:37 +0000161constexpr int LOGTAG_INPUT_CANCEL = 62003;
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +0000162
Prabir Pradhan33e3baa2022-12-06 20:30:22 +0000163const ui::Transform kIdentityTransform;
164
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000165inline nsecs_t now() {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800166 return systemTime(SYSTEM_TIME_MONOTONIC);
167}
168
Siarhei Vishniakou63b63612023-04-12 11:00:23 -0700169inline const std::string binderToString(const sp<IBinder>& binder) {
Bernardo Rufino49d99e42021-01-18 15:16:59 +0000170 if (binder == nullptr) {
171 return "<null>";
172 }
173 return StringPrintf("%p", binder.get());
174}
175
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +0000176static std::string uidString(const gui::Uid& uid) {
177 return uid.toString();
178}
179
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700180Result<void> checkKeyAction(int32_t action) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800181 switch (action) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700182 case AKEY_EVENT_ACTION_DOWN:
183 case AKEY_EVENT_ACTION_UP:
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700184 return {};
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700185 default:
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700186 return Error() << "Key event has invalid action code " << action;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800187 }
188}
189
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700190Result<void> validateKeyEvent(int32_t action) {
191 return checkKeyAction(action);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800192}
193
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700194Result<void> checkMotionAction(int32_t action, int32_t actionButton, int32_t pointerCount) {
Siarhei Vishniakou2f61bdc2022-12-02 08:55:51 -0800195 switch (MotionEvent::getActionMasked(action)) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700196 case AMOTION_EVENT_ACTION_DOWN:
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700197 case AMOTION_EVENT_ACTION_UP: {
198 if (pointerCount != 1) {
199 return Error() << "invalid pointer count " << pointerCount;
200 }
201 return {};
202 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700203 case AMOTION_EVENT_ACTION_MOVE:
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700204 case AMOTION_EVENT_ACTION_HOVER_ENTER:
205 case AMOTION_EVENT_ACTION_HOVER_MOVE:
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700206 case AMOTION_EVENT_ACTION_HOVER_EXIT: {
207 if (pointerCount < 1) {
208 return Error() << "invalid pointer count " << pointerCount;
209 }
210 return {};
211 }
Siarhei Vishniakou2f61bdc2022-12-02 08:55:51 -0800212 case AMOTION_EVENT_ACTION_CANCEL:
213 case AMOTION_EVENT_ACTION_OUTSIDE:
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700214 case AMOTION_EVENT_ACTION_SCROLL:
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700215 return {};
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700216 case AMOTION_EVENT_ACTION_POINTER_DOWN:
217 case AMOTION_EVENT_ACTION_POINTER_UP: {
Siarhei Vishniakou2f61bdc2022-12-02 08:55:51 -0800218 const int32_t index = MotionEvent::getActionIndex(action);
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700219 if (index < 0) {
220 return Error() << "invalid index " << index << " for "
221 << MotionEvent::actionToString(action);
222 }
223 if (index >= pointerCount) {
224 return Error() << "invalid index " << index << " for pointerCount " << pointerCount;
225 }
226 if (pointerCount <= 1) {
227 return Error() << "invalid pointer count " << pointerCount << " for "
228 << MotionEvent::actionToString(action);
229 }
230 return {};
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700231 }
232 case AMOTION_EVENT_ACTION_BUTTON_PRESS:
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700233 case AMOTION_EVENT_ACTION_BUTTON_RELEASE: {
234 if (actionButton == 0) {
235 return Error() << "action button should be nonzero for "
236 << MotionEvent::actionToString(action);
237 }
238 return {};
239 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700240 default:
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700241 return Error() << "invalid action " << action;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800242 }
243}
244
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000245int64_t millis(std::chrono::nanoseconds t) {
Siarhei Vishniakouc1ae5562020-06-30 14:22:57 -0500246 return std::chrono::duration_cast<std::chrono::milliseconds>(t).count();
247}
248
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700249Result<void> validateMotionEvent(int32_t action, int32_t actionButton, size_t pointerCount,
250 const PointerProperties* pointerProperties) {
251 Result<void> actionCheck = checkMotionAction(action, actionButton, pointerCount);
252 if (!actionCheck.ok()) {
253 return actionCheck;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800254 }
255 if (pointerCount < 1 || pointerCount > MAX_POINTERS) {
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700256 return Error() << "Motion event has invalid pointer count " << pointerCount
257 << "; value must be between 1 and " << MAX_POINTERS << ".";
Michael Wrightd02c5b62014-02-10 15:10:22 -0800258 }
Siarhei Vishniakou8a878352023-01-30 14:05:01 -0800259 std::bitset<MAX_POINTER_ID + 1> pointerIdBits;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800260 for (size_t i = 0; i < pointerCount; i++) {
261 int32_t id = pointerProperties[i].id;
262 if (id < 0 || id > MAX_POINTER_ID) {
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700263 return Error() << "Motion event has invalid pointer id " << id
264 << "; value must be between 0 and " << MAX_POINTER_ID;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800265 }
Siarhei Vishniakou8a878352023-01-30 14:05:01 -0800266 if (pointerIdBits.test(id)) {
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700267 return Error() << "Motion event has duplicate pointer id " << id;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800268 }
Siarhei Vishniakou8a878352023-01-30 14:05:01 -0800269 pointerIdBits.set(id);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800270 }
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700271 return {};
272}
273
274Result<void> validateInputEvent(const InputEvent& event) {
275 switch (event.getType()) {
276 case InputEventType::KEY: {
277 const KeyEvent& key = static_cast<const KeyEvent&>(event);
278 const int32_t action = key.getAction();
279 return validateKeyEvent(action);
280 }
281 case InputEventType::MOTION: {
282 const MotionEvent& motion = static_cast<const MotionEvent&>(event);
283 const int32_t action = motion.getAction();
284 const size_t pointerCount = motion.getPointerCount();
285 const PointerProperties* pointerProperties = motion.getPointerProperties();
286 const int32_t actionButton = motion.getActionButton();
287 return validateMotionEvent(action, actionButton, pointerCount, pointerProperties);
288 }
289 default: {
290 return {};
291 }
292 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800293}
294
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -0800295std::bitset<MAX_POINTER_ID + 1> getPointerIds(const std::vector<PointerProperties>& pointers) {
296 std::bitset<MAX_POINTER_ID + 1> pointerIds;
297 for (const PointerProperties& pointer : pointers) {
298 pointerIds.set(pointer.id);
299 }
300 return pointerIds;
301}
302
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000303std::string dumpRegion(const Region& region) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800304 if (region.isEmpty()) {
Bernardo Rufino53fc31e2020-11-03 11:01:07 +0000305 return "<empty>";
Michael Wrightd02c5b62014-02-10 15:10:22 -0800306 }
307
Bernardo Rufino53fc31e2020-11-03 11:01:07 +0000308 std::string dump;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800309 bool first = true;
310 Region::const_iterator cur = region.begin();
311 Region::const_iterator const tail = region.end();
312 while (cur != tail) {
313 if (first) {
314 first = false;
315 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -0800316 dump += "|";
Michael Wrightd02c5b62014-02-10 15:10:22 -0800317 }
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -0800318 dump += StringPrintf("[%d,%d][%d,%d]", cur->left, cur->top, cur->right, cur->bottom);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800319 cur++;
320 }
Bernardo Rufino53fc31e2020-11-03 11:01:07 +0000321 return dump;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800322}
323
Prabir Pradhan8c90d782023-09-15 21:16:44 +0000324std::string dumpQueue(const std::deque<std::unique_ptr<DispatchEntry>>& queue,
325 nsecs_t currentTime) {
Siarhei Vishniakou14411c92020-09-18 21:15:05 -0500326 constexpr size_t maxEntries = 50; // max events to print
327 constexpr size_t skipBegin = maxEntries / 2;
328 const size_t skipEnd = queue.size() - maxEntries / 2;
329 // skip from maxEntries / 2 ... size() - maxEntries/2
330 // only print from 0 .. skipBegin and then from skipEnd .. size()
331
332 std::string dump;
333 for (size_t i = 0; i < queue.size(); i++) {
334 const DispatchEntry& entry = *queue[i];
335 if (i >= skipBegin && i < skipEnd) {
336 dump += StringPrintf(INDENT4 "<skipped %zu entries>\n", skipEnd - skipBegin);
337 i = skipEnd - 1; // it will be incremented to "skipEnd" by 'continue'
338 continue;
339 }
340 dump.append(INDENT4);
341 dump += entry.eventEntry->getDescription();
Prabir Pradhan2a2da1d2023-11-03 02:16:20 +0000342 dump += StringPrintf(", seq=%" PRIu32 ", targetFlags=%s, age=%" PRId64 "ms", entry.seq,
343 entry.targetFlags.string().c_str(),
Siarhei Vishniakou14411c92020-09-18 21:15:05 -0500344 ns2ms(currentTime - entry.eventEntry->eventTime));
345 if (entry.deliveryTime != 0) {
346 // This entry was delivered, so add information on how long we've been waiting
347 dump += StringPrintf(", wait=%" PRId64 "ms", ns2ms(currentTime - entry.deliveryTime));
348 }
349 dump.append("\n");
350 }
351 return dump;
352}
353
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -0700354/**
355 * Find the entry in std::unordered_map by key, and return it.
356 * If the entry is not found, return a default constructed entry.
357 *
358 * Useful when the entries are vectors, since an empty vector will be returned
359 * if the entry is not found.
360 * Also useful when the entries are sp<>. If an entry is not found, nullptr is returned.
361 */
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -0700362template <typename K, typename V>
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000363V getValueByKey(const std::unordered_map<K, V>& map, K key) {
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -0700364 auto it = map.find(key);
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -0700365 return it != map.end() ? it->second : V{};
Tiger Huang721e26f2018-07-24 22:26:19 +0800366}
367
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000368bool haveSameToken(const sp<WindowInfoHandle>& first, const sp<WindowInfoHandle>& second) {
chaviwaf87b3e2019-10-01 16:59:28 -0700369 if (first == second) {
370 return true;
371 }
372
373 if (first == nullptr || second == nullptr) {
374 return false;
375 }
376
377 return first->getToken() == second->getToken();
378}
379
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000380bool haveSameApplicationToken(const WindowInfo* first, const WindowInfo* second) {
Bernardo Rufino1ff9d592021-01-18 16:58:57 +0000381 if (first == nullptr || second == nullptr) {
382 return false;
383 }
384 return first->applicationInfo.token != nullptr &&
385 first->applicationInfo.token == second->applicationInfo.token;
386}
387
Siarhei Vishniakou8a878352023-01-30 14:05:01 -0800388template <typename T>
389size_t firstMarkedBit(T set) {
390 // TODO: replace with std::countr_zero from <bit> when that's available
391 LOG_ALWAYS_FATAL_IF(set.none());
392 size_t i = 0;
393 while (!set.test(i)) {
394 i++;
395 }
396 return i;
397}
398
Prabir Pradhanc88b1fa2024-01-23 21:48:03 +0000399std::unique_ptr<DispatchEntry> createDispatchEntry(const IdGenerator& idGenerator,
400 const InputTarget& inputTarget,
Prabir Pradhanadc59b42023-12-15 05:34:11 +0000401 std::shared_ptr<const EventEntry> eventEntry,
402 ftl::Flags<InputTarget::Flags> inputTargetFlags,
Prabir Pradhana67623c2024-02-21 06:57:36 +0000403 int64_t vsyncId,
404 trace::InputTracerInterface* tracer) {
Prabir Pradhanc88b1fa2024-01-23 21:48:03 +0000405 const bool zeroCoords = inputTargetFlags.test(InputTarget::Flags::ZERO_COORDS);
Prabir Pradhanadc59b42023-12-15 05:34:11 +0000406 const sp<WindowInfoHandle> win = inputTarget.windowHandle;
407 const std::optional<int32_t> windowId =
408 win ? std::make_optional(win->getInfo()->id) : std::nullopt;
409 // Assume the only targets that are not associated with a window are global monitors, and use
410 // the system UID for global monitors for tracing purposes.
411 const gui::Uid uid = win ? win->getInfo()->ownerUid : gui::Uid(AID_SYSTEM);
Prabir Pradhanc88b1fa2024-01-23 21:48:03 +0000412
413 if (inputTarget.useDefaultPointerTransform() && !zeroCoords) {
chaviw1ff3d1e2020-07-01 15:53:47 -0700414 const ui::Transform& transform = inputTarget.getDefaultPointerTransform();
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700415 return std::make_unique<DispatchEntry>(eventEntry, inputTargetFlags, transform,
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700416 inputTarget.displayTransform,
Prabir Pradhanadc59b42023-12-15 05:34:11 +0000417 inputTarget.globalScaleFactor, uid, vsyncId,
418 windowId);
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000419 }
420
421 ALOG_ASSERT(eventEntry->type == EventEntry::Type::MOTION);
422 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(*eventEntry);
423
Prabir Pradhanc88b1fa2024-01-23 21:48:03 +0000424 std::vector<PointerCoords> pointerCoords{motionEntry.getPointerCount()};
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000425
Prabir Pradhanc88b1fa2024-01-23 21:48:03 +0000426 const ui::Transform* transform = &kIdentityTransform;
427 const ui::Transform* displayTransform = &kIdentityTransform;
428 if (zeroCoords) {
429 std::for_each(pointerCoords.begin(), pointerCoords.end(), [](auto& pc) { pc.clear(); });
430 } else {
431 // Use the first pointer information to normalize all other pointers. This could be any
432 // pointer as long as all other pointers are normalized to the same value and the final
433 // DispatchEntry uses the transform for the normalized pointer.
434 transform =
435 &inputTarget.getTransformForPointer(firstMarkedBit(inputTarget.getPointerIds()));
436 const ui::Transform inverseTransform = transform->inverse();
437 displayTransform = &inputTarget.displayTransform;
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000438
Prabir Pradhanc88b1fa2024-01-23 21:48:03 +0000439 // Iterate through all pointers in the event to normalize against the first.
440 for (size_t i = 0; i < motionEntry.getPointerCount(); i++) {
441 PointerCoords& newCoords = pointerCoords[i];
442 const auto pointerId = motionEntry.pointerProperties[i].id;
443 const ui::Transform& currTransform = inputTarget.getTransformForPointer(pointerId);
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000444
Prabir Pradhanc88b1fa2024-01-23 21:48:03 +0000445 newCoords.copyFrom(motionEntry.pointerCoords[i]);
446 // First, apply the current pointer's transform to update the coordinates into
447 // window space.
448 newCoords.transform(currTransform);
449 // Next, apply the inverse transform of the normalized coordinates so the
450 // current coordinates are transformed into the normalized coordinate space.
451 newCoords.transform(inverseTransform);
452 }
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000453 }
454
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700455 std::unique_ptr<MotionEntry> combinedMotionEntry =
Prabir Pradhanc88b1fa2024-01-23 21:48:03 +0000456 std::make_unique<MotionEntry>(idGenerator.nextId(), motionEntry.injectionState,
Prabir Pradhana8cdbe12023-11-01 21:30:02 +0000457 motionEntry.eventTime, motionEntry.deviceId,
458 motionEntry.source, motionEntry.displayId,
459 motionEntry.policyFlags, motionEntry.action,
460 motionEntry.actionButton, motionEntry.flags,
461 motionEntry.metaState, motionEntry.buttonState,
462 motionEntry.classification, motionEntry.edgeFlags,
463 motionEntry.xPrecision, motionEntry.yPrecision,
464 motionEntry.xCursorPosition, motionEntry.yCursorPosition,
465 motionEntry.downTime, motionEntry.pointerProperties,
466 pointerCoords);
Prabir Pradhana67623c2024-02-21 06:57:36 +0000467 if (tracer) {
468 combinedMotionEntry->traceTracker =
469 tracer->traceDerivedEvent(*combinedMotionEntry, *motionEntry.traceTracker);
470 }
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000471
472 std::unique_ptr<DispatchEntry> dispatchEntry =
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700473 std::make_unique<DispatchEntry>(std::move(combinedMotionEntry), inputTargetFlags,
Prabir Pradhanc88b1fa2024-01-23 21:48:03 +0000474 *transform, *displayTransform,
Prabir Pradhanadc59b42023-12-15 05:34:11 +0000475 inputTarget.globalScaleFactor, uid, vsyncId, windowId);
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000476 return dispatchEntry;
477}
478
Siarhei Vishniakoue41c4512020-09-08 19:35:58 -0500479template <typename T>
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000480bool sharedPointersEqual(const std::shared_ptr<T>& lhs, const std::shared_ptr<T>& rhs) {
Siarhei Vishniakoue41c4512020-09-08 19:35:58 -0500481 if (lhs == nullptr && rhs == nullptr) {
482 return true;
483 }
484 if (lhs == nullptr || rhs == nullptr) {
485 return false;
486 }
487 return *lhs == *rhs;
488}
489
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000490KeyEvent createKeyEvent(const KeyEntry& entry) {
Siarhei Vishniakou2e2ea992020-12-15 02:57:19 +0000491 KeyEvent event;
492 event.initialize(entry.id, entry.deviceId, entry.source, entry.displayId, INVALID_HMAC,
493 entry.action, entry.flags, entry.keyCode, entry.scanCode, entry.metaState,
494 entry.repeatCount, entry.downTime, entry.eventTime);
495 return event;
496}
497
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000498bool shouldReportMetricsForConnection(const Connection& connection) {
Siarhei Vishniakouf2652122021-03-05 21:39:46 +0000499 // Do not keep track of gesture monitors. They receive every event and would disproportionately
500 // affect the statistics.
501 if (connection.monitor) {
502 return false;
503 }
504 // If the connection is experiencing ANR, let's skip it. We have separate ANR metrics
505 if (!connection.responsive) {
506 return false;
507 }
508 return true;
509}
510
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000511bool shouldReportFinishedEvent(const DispatchEntry& dispatchEntry, const Connection& connection) {
Siarhei Vishniakouf2652122021-03-05 21:39:46 +0000512 const EventEntry& eventEntry = *dispatchEntry.eventEntry;
513 const int32_t& inputEventId = eventEntry.id;
Siarhei Vishniakouf2652122021-03-05 21:39:46 +0000514 if (inputEventId == android::os::IInputConstants::INVALID_INPUT_EVENT_ID) {
515 return false;
516 }
517 // Only track latency for events that originated from hardware
518 if (eventEntry.isSynthesized()) {
519 return false;
520 }
521 const EventEntry::Type& inputEventEntryType = eventEntry.type;
522 if (inputEventEntryType == EventEntry::Type::KEY) {
523 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(eventEntry);
524 if (keyEntry.flags & AKEY_EVENT_FLAG_CANCELED) {
525 return false;
526 }
527 } else if (inputEventEntryType == EventEntry::Type::MOTION) {
528 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(eventEntry);
529 if (motionEntry.action == AMOTION_EVENT_ACTION_CANCEL ||
530 motionEntry.action == AMOTION_EVENT_ACTION_HOVER_EXIT) {
531 return false;
532 }
533 } else {
534 // Not a key or a motion
535 return false;
536 }
537 if (!shouldReportMetricsForConnection(connection)) {
538 return false;
539 }
540 return true;
541}
542
Prabir Pradhancef936d2021-07-21 16:17:52 +0000543/**
544 * Connection is responsive if it has no events in the waitQueue that are older than the
545 * current time.
546 */
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000547bool isConnectionResponsive(const Connection& connection) {
Prabir Pradhancef936d2021-07-21 16:17:52 +0000548 const nsecs_t currentTime = now();
Prabir Pradhan8c90d782023-09-15 21:16:44 +0000549 for (const auto& dispatchEntry : connection.waitQueue) {
550 if (dispatchEntry->timeoutTime < currentTime) {
Prabir Pradhancef936d2021-07-21 16:17:52 +0000551 return false;
552 }
553 }
554 return true;
555}
556
Antonio Kantekf16f2832021-09-28 04:39:20 +0000557// Returns true if the event type passed as argument represents a user activity.
558bool isUserActivityEvent(const EventEntry& eventEntry) {
559 switch (eventEntry.type) {
Josep del Riob3981622023-04-18 15:49:45 +0000560 case EventEntry::Type::CONFIGURATION_CHANGED:
561 case EventEntry::Type::DEVICE_RESET:
562 case EventEntry::Type::DRAG:
Antonio Kantekf16f2832021-09-28 04:39:20 +0000563 case EventEntry::Type::FOCUS:
564 case EventEntry::Type::POINTER_CAPTURE_CHANGED:
Antonio Kantekf16f2832021-09-28 04:39:20 +0000565 case EventEntry::Type::SENSOR:
Josep del Riob3981622023-04-18 15:49:45 +0000566 case EventEntry::Type::TOUCH_MODE_CHANGED:
Antonio Kantekf16f2832021-09-28 04:39:20 +0000567 return false;
Antonio Kantekf16f2832021-09-28 04:39:20 +0000568 case EventEntry::Type::KEY:
569 case EventEntry::Type::MOTION:
570 return true;
571 }
572}
573
Prabir Pradhan3f90d312021-11-19 03:57:24 -0800574// Returns true if the given window can accept pointer events at the given display location.
Prabir Pradhan82e081e2022-12-06 09:50:09 +0000575bool windowAcceptsTouchAt(const WindowInfo& windowInfo, int32_t displayId, float x, float y,
Prabir Pradhan33e3baa2022-12-06 20:30:22 +0000576 bool isStylus, const ui::Transform& displayTransform) {
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -0800577 const auto inputConfig = windowInfo.inputConfig;
578 if (windowInfo.displayId != displayId ||
579 inputConfig.test(WindowInfo::InputConfig::NOT_VISIBLE)) {
Prabir Pradhan3f90d312021-11-19 03:57:24 -0800580 return false;
581 }
Prabir Pradhand65552b2021-10-07 11:23:50 -0700582 const bool windowCanInterceptTouch = isStylus && windowInfo.interceptsStylus();
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -0800583 if (inputConfig.test(WindowInfo::InputConfig::NOT_TOUCHABLE) && !windowCanInterceptTouch) {
Prabir Pradhan3f90d312021-11-19 03:57:24 -0800584 return false;
585 }
Prabir Pradhan33e3baa2022-12-06 20:30:22 +0000586
587 // Window Manager works in the logical display coordinate space. When it specifies bounds for a
588 // window as (l, t, r, b), the range of x in [l, r) and y in [t, b) are considered to be inside
589 // the window. Points on the right and bottom edges should not be inside the window, so we need
590 // to be careful about performing a hit test when the display is rotated, since the "right" and
591 // "bottom" of the window will be different in the display (un-rotated) space compared to in the
592 // logical display in which WM determined the bounds. Perform the hit test in the logical
593 // display space to ensure these edges are considered correctly in all orientations.
594 const auto touchableRegion = displayTransform.transform(windowInfo.touchableRegion);
595 const auto p = displayTransform.transform(x, y);
596 if (!touchableRegion.contains(std::floor(p.x), std::floor(p.y))) {
Prabir Pradhan3f90d312021-11-19 03:57:24 -0800597 return false;
598 }
599 return true;
600}
601
Linnan Li5e5645e2024-03-05 14:43:05 +0000602// Returns true if the given window's frame can occlude pointer events at the given display
603// location.
604bool windowOccludesTouchAt(const WindowInfo& windowInfo, int displayId, float x, float y,
605 const ui::Transform& displayTransform) {
606 if (windowInfo.displayId != displayId) {
607 return false;
608 }
609 const auto frame = displayTransform.transform(windowInfo.frame);
610 const auto p = floor(displayTransform.transform(x, y));
611 return p.x >= frame.left && p.x < frame.right && p.y >= frame.top && p.y < frame.bottom;
612}
613
Prabir Pradhand65552b2021-10-07 11:23:50 -0700614bool isPointerFromStylus(const MotionEntry& entry, int32_t pointerIndex) {
615 return isFromSource(entry.source, AINPUT_SOURCE_STYLUS) &&
Prabir Pradhane5626962022-10-27 20:30:53 +0000616 isStylusToolType(entry.pointerProperties[pointerIndex].toolType);
Prabir Pradhand65552b2021-10-07 11:23:50 -0700617}
618
Siarhei Vishniakou253f4642022-11-09 13:42:06 -0800619// Determines if the given window can be targeted as InputTarget::Flags::FOREGROUND.
Prabir Pradhan6dfbf262022-03-14 15:24:30 +0000620// Foreground events are only sent to "foreground targetable" windows, but not all gestures sent to
621// such window are necessarily targeted with the flag. For example, an event with ACTION_OUTSIDE can
622// be sent to such a window, but it is not a foreground event and doesn't use
Siarhei Vishniakou253f4642022-11-09 13:42:06 -0800623// InputTarget::Flags::FOREGROUND.
Prabir Pradhan6dfbf262022-03-14 15:24:30 +0000624bool canReceiveForegroundTouches(const WindowInfo& info) {
625 // A non-touchable window can still receive touch events (e.g. in the case of
626 // STYLUS_INTERCEPTOR), so prevent such windows from receiving foreground events for touches.
627 return !info.inputConfig.test(gui::WindowInfo::InputConfig::NOT_TOUCHABLE) && !info.isSpy();
628}
629
Prabir Pradhanaeebeb42023-06-13 19:53:03 +0000630bool isWindowOwnedBy(const sp<WindowInfoHandle>& windowHandle, gui::Pid pid, gui::Uid uid) {
Antonio Kantek48710e42022-03-24 14:19:30 -0700631 if (windowHandle == nullptr) {
632 return false;
633 }
634 const WindowInfo* windowInfo = windowHandle->getInfo();
635 if (pid == windowInfo->ownerPid && uid == windowInfo->ownerUid) {
636 return true;
637 }
638 return false;
639}
640
Prabir Pradhan5735a322022-04-11 17:23:34 +0000641// Checks targeted injection using the window's owner's uid.
642// Returns an empty string if an entry can be sent to the given window, or an error message if the
643// entry is a targeted injection whose uid target doesn't match the window owner.
644std::optional<std::string> verifyTargetedInjection(const sp<WindowInfoHandle>& window,
645 const EventEntry& entry) {
646 if (entry.injectionState == nullptr || !entry.injectionState->targetUid) {
647 // The event was not injected, or the injected event does not target a window.
648 return {};
649 }
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +0000650 const auto uid = *entry.injectionState->targetUid;
Prabir Pradhan5735a322022-04-11 17:23:34 +0000651 if (window == nullptr) {
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +0000652 return StringPrintf("No valid window target for injection into uid %s.",
653 uid.toString().c_str());
Prabir Pradhan5735a322022-04-11 17:23:34 +0000654 }
655 if (entry.injectionState->targetUid != window->getInfo()->ownerUid) {
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +0000656 return StringPrintf("Injected event targeted at uid %s would be dispatched to window '%s' "
657 "owned by uid %s.",
658 uid.toString().c_str(), window->getName().c_str(),
659 window->getInfo()->ownerUid.toString().c_str());
Prabir Pradhan5735a322022-04-11 17:23:34 +0000660 }
661 return {};
662}
663
Prabir Pradhan82e081e2022-12-06 09:50:09 +0000664std::pair<float, float> resolveTouchedPosition(const MotionEntry& entry) {
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -0700665 const bool isFromMouse = isFromSource(entry.source, AINPUT_SOURCE_MOUSE);
666 // Always dispatch mouse events to cursor position.
667 if (isFromMouse) {
Prabir Pradhan82e081e2022-12-06 09:50:09 +0000668 return {entry.xCursorPosition, entry.yCursorPosition};
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -0700669 }
670
Siarhei Vishniakou5b9766d2023-07-18 14:06:29 -0700671 const int32_t pointerIndex = MotionEvent::getActionIndex(entry.action);
Prabir Pradhan82e081e2022-12-06 09:50:09 +0000672 return {entry.pointerCoords[pointerIndex].getAxisValue(AMOTION_EVENT_AXIS_X),
673 entry.pointerCoords[pointerIndex].getAxisValue(AMOTION_EVENT_AXIS_Y)};
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -0700674}
675
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -0700676std::optional<nsecs_t> getDownTime(const EventEntry& eventEntry) {
677 if (eventEntry.type == EventEntry::Type::KEY) {
678 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(eventEntry);
679 return keyEntry.downTime;
680 } else if (eventEntry.type == EventEntry::Type::MOTION) {
681 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(eventEntry);
682 return motionEntry.downTime;
683 }
684 return std::nullopt;
685}
686
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +0000687/**
688 * Compare the old touch state to the new touch state, and generate the corresponding touched
689 * windows (== input targets).
690 * If a window had the hovering pointer, but now it doesn't, produce HOVER_EXIT for that window.
691 * If the pointer just entered the new window, produce HOVER_ENTER.
692 * For pointers remaining in the window, produce HOVER_MOVE.
693 */
694std::vector<TouchedWindow> getHoveringWindowsLocked(const TouchState* oldState,
695 const TouchState& newTouchState,
696 const MotionEntry& entry) {
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +0000697 const int32_t maskedAction = MotionEvent::getActionMasked(entry.action);
Siarhei Vishniakou2899c552023-07-10 18:20:46 -0700698
699 if (maskedAction == AMOTION_EVENT_ACTION_SCROLL) {
700 // ACTION_SCROLL events should not affect the hovering pointer dispatch
701 return {};
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +0000702 }
Linnan Li41859c42024-03-05 16:20:34 +0000703 std::vector<TouchedWindow> out;
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +0000704
705 // We should consider all hovering pointers here. But for now, just use the first one
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -0800706 const PointerProperties& pointer = entry.pointerProperties[0];
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +0000707
708 std::set<sp<WindowInfoHandle>> oldWindows;
709 if (oldState != nullptr) {
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -0800710 oldWindows = oldState->getWindowsWithHoveringPointer(entry.deviceId, pointer.id);
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +0000711 }
712
713 std::set<sp<WindowInfoHandle>> newWindows =
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -0800714 newTouchState.getWindowsWithHoveringPointer(entry.deviceId, pointer.id);
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +0000715
716 // If the pointer is no longer in the new window set, send HOVER_EXIT.
717 for (const sp<WindowInfoHandle>& oldWindow : oldWindows) {
718 if (newWindows.find(oldWindow) == newWindows.end()) {
719 TouchedWindow touchedWindow;
720 touchedWindow.windowHandle = oldWindow;
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +0000721 touchedWindow.dispatchMode = InputTarget::DispatchMode::HOVER_EXIT;
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +0000722 out.push_back(touchedWindow);
723 }
724 }
725
726 for (const sp<WindowInfoHandle>& newWindow : newWindows) {
727 TouchedWindow touchedWindow;
728 touchedWindow.windowHandle = newWindow;
729 if (oldWindows.find(newWindow) == oldWindows.end()) {
730 // Any windows that have this pointer now, and didn't have it before, should get
731 // HOVER_ENTER
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +0000732 touchedWindow.dispatchMode = InputTarget::DispatchMode::HOVER_ENTER;
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +0000733 } else {
734 // This pointer was already sent to the window. Use ACTION_HOVER_MOVE.
Siarhei Vishniakouc2eb8502023-04-11 18:33:36 -0700735 if (CC_UNLIKELY(maskedAction != AMOTION_EVENT_ACTION_HOVER_MOVE)) {
Daniel Norman7487dfa2023-08-02 16:39:45 -0700736 android::base::LogSeverity severity = android::base::LogSeverity::FATAL;
Ameer Armalycff4fa52023-10-04 23:45:11 +0000737 if (!input_flags::a11y_crash_on_inconsistent_event_stream() &&
738 entry.flags & AMOTION_EVENT_FLAG_IS_ACCESSIBILITY_EVENT) {
Daniel Norman7487dfa2023-08-02 16:39:45 -0700739 // The Accessibility injected touch exploration event stream
740 // has known inconsistencies, so log ERROR instead of
741 // crashing the device with FATAL.
Daniel Norman7487dfa2023-08-02 16:39:45 -0700742 severity = android::base::LogSeverity::ERROR;
743 }
744 LOG(severity) << "Expected ACTION_HOVER_MOVE instead of " << entry.getDescription();
Siarhei Vishniakouc2eb8502023-04-11 18:33:36 -0700745 }
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +0000746 touchedWindow.dispatchMode = InputTarget::DispatchMode::AS_IS;
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +0000747 }
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -0800748 touchedWindow.addHoveringPointer(entry.deviceId, pointer);
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +0000749 if (canReceiveForegroundTouches(*newWindow->getInfo())) {
750 touchedWindow.targetFlags |= InputTarget::Flags::FOREGROUND;
751 }
752 out.push_back(touchedWindow);
753 }
754 return out;
755}
756
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -0800757template <typename T>
758std::vector<T>& operator+=(std::vector<T>& left, const std::vector<T>& right) {
759 left.insert(left.end(), right.begin(), right.end());
760 return left;
761}
762
Harry Cuttsb166c002023-05-09 13:06:05 +0000763// Filter windows in a TouchState and targets in a vector to remove untrusted windows/targets from
764// both.
765void filterUntrustedTargets(TouchState& touchState, std::vector<InputTarget>& targets) {
766 std::erase_if(touchState.windows, [&](const TouchedWindow& window) {
767 if (!window.windowHandle->getInfo()->inputConfig.test(
768 WindowInfo::InputConfig::TRUSTED_OVERLAY)) {
769 // In addition to TouchState, erase this window from the input targets! We don't have a
770 // good way to do this today except by adding a nested loop.
771 // TODO(b/282025641): simplify this code once InputTargets are being identified
772 // separately from TouchedWindows.
773 std::erase_if(targets, [&](const InputTarget& target) {
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -0800774 return target.connection->getToken() == window.windowHandle->getToken();
Harry Cuttsb166c002023-05-09 13:06:05 +0000775 });
776 return true;
777 }
778 return false;
779 });
780}
781
Siarhei Vishniakouce1fd472023-09-18 18:38:07 -0700782/**
783 * In general, touch should be always split between windows. Some exceptions:
784 * 1. Don't split touch if all of the below is true:
785 * (a) we have an active pointer down *and*
786 * (b) a new pointer is going down that's from the same device *and*
787 * (c) the window that's receiving the current pointer does not support split touch.
788 * 2. Don't split mouse events
789 */
790bool shouldSplitTouch(const TouchState& touchState, const MotionEntry& entry) {
791 if (isFromSource(entry.source, AINPUT_SOURCE_MOUSE)) {
792 // We should never split mouse events
793 return false;
794 }
795 for (const TouchedWindow& touchedWindow : touchState.windows) {
796 if (touchedWindow.windowHandle->getInfo()->isSpy()) {
797 // Spy windows should not affect whether or not touch is split.
798 continue;
799 }
800 if (touchedWindow.windowHandle->getInfo()->supportsSplitTouch()) {
801 continue;
802 }
803 if (touchedWindow.windowHandle->getInfo()->inputConfig.test(
804 gui::WindowInfo::InputConfig::IS_WALLPAPER)) {
805 // Wallpaper window should not affect whether or not touch is split
806 continue;
807 }
808
809 if (touchedWindow.hasTouchingPointers(entry.deviceId)) {
810 return false;
811 }
812 }
813 return true;
814}
815
Siarhei Vishniakouf77f60a2023-10-23 17:26:05 -0700816/**
817 * Return true if stylus is currently down anywhere on the specified display, and false otherwise.
818 */
819bool isStylusActiveInDisplay(
820 int32_t displayId,
821 const std::unordered_map<int32_t /*displayId*/, TouchState>& touchStatesByDisplay) {
822 const auto it = touchStatesByDisplay.find(displayId);
823 if (it == touchStatesByDisplay.end()) {
824 return false;
825 }
826 const TouchState& state = it->second;
827 return state.hasActiveStylus();
828}
829
Siarhei Vishniakouaeed0da2024-01-09 08:57:13 -0800830Result<void> validateWindowInfosUpdate(const gui::WindowInfosUpdate& update) {
831 struct HashFunction {
832 size_t operator()(const WindowInfo& info) const { return info.id; }
833 };
834
835 std::unordered_set<WindowInfo, HashFunction> windowSet;
836 for (const WindowInfo& info : update.windowInfos) {
837 const auto [_, inserted] = windowSet.insert(info);
838 if (!inserted) {
839 return Error() << "Duplicate entry for " << info;
840 }
841 }
842 return {};
843}
844
Yeabkal Wubshitb8aadfa2024-01-17 17:03:42 -0800845int32_t getUserActivityEventType(const EventEntry& eventEntry) {
846 switch (eventEntry.type) {
847 case EventEntry::Type::KEY: {
848 return USER_ACTIVITY_EVENT_BUTTON;
849 }
850 case EventEntry::Type::MOTION: {
851 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(eventEntry);
852 if (MotionEvent::isTouchEvent(motionEntry.source, motionEntry.action)) {
853 return USER_ACTIVITY_EVENT_TOUCH;
854 }
855 return USER_ACTIVITY_EVENT_OTHER;
856 }
857 default: {
858 LOG_ALWAYS_FATAL("%s events are not user activity",
859 ftl::enum_string(eventEntry.type).c_str());
860 }
861 }
862}
863
Prabir Pradhanbb3f1c02024-01-04 20:17:14 +0000864std::pair<bool /*cancelPointers*/, bool /*cancelNonPointers*/> expandCancellationMode(
865 CancelationOptions::Mode mode) {
866 switch (mode) {
867 case CancelationOptions::Mode::CANCEL_ALL_EVENTS:
868 return {true, true};
869 case CancelationOptions::Mode::CANCEL_POINTER_EVENTS:
870 return {true, false};
871 case CancelationOptions::Mode::CANCEL_NON_POINTER_EVENTS:
872 return {false, true};
873 case CancelationOptions::Mode::CANCEL_FALLBACK_EVENTS:
874 return {false, true};
875 }
876}
877
Prabir Pradhand6b2b052024-02-21 23:25:15 +0000878class ScopedSyntheticEventTracer {
879public:
880 ScopedSyntheticEventTracer(std::unique_ptr<trace::InputTracerInterface>& tracer)
881 : mTracer(tracer) {
882 if (mTracer) {
883 mEventTracker = mTracer->createTrackerForSyntheticEvent();
884 }
885 }
886
887 ~ScopedSyntheticEventTracer() {
888 if (mTracer) {
889 mTracer->eventProcessingComplete(*mEventTracker);
890 }
891 }
892
893 const std::unique_ptr<trace::EventTrackerInterface>& getTracker() const {
894 return mEventTracker;
895 }
896
897private:
898 std::unique_ptr<trace::InputTracerInterface>& mTracer;
899 std::unique_ptr<trace::EventTrackerInterface> mEventTracker;
900};
901
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000902} // namespace
903
Michael Wrightd02c5b62014-02-10 15:10:22 -0800904// --- InputDispatcher ---
905
Prabir Pradhana41d2442023-04-20 21:30:40 +0000906InputDispatcher::InputDispatcher(InputDispatcherPolicyInterface& policy)
Prabir Pradhanbf3c8322024-02-23 02:38:36 +0000907 : InputDispatcher(policy, createInputTracingBackendIfEnabled([&policy](std::string pkg) {
908 return policy.getPackageUid(pkg);
909 })) {}
Prabir Pradhanabcdf5c2023-12-15 07:30:22 +0000910
911InputDispatcher::InputDispatcher(InputDispatcherPolicyInterface& policy,
912 std::unique_ptr<trace::InputTracingBackendInterface> traceBackend)
Garfield Tan00f511d2019-06-12 16:55:40 -0700913 : mPolicy(policy),
914 mPendingEvent(nullptr),
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700915 mLastDropReason(DropReason::NOT_DROPPED),
Garfield Tanff1f1bb2020-01-28 13:24:04 -0800916 mIdGenerator(IdGenerator::Source::INPUT_DISPATCHER),
Yeabkal Wubshitb8aadfa2024-01-17 17:03:42 -0800917 mMinTimeBetweenUserActivityPokes(DEFAULT_USER_ACTIVITY_POKE_INTERVAL),
Garfield Tan00f511d2019-06-12 16:55:40 -0700918 mNextUnblockedEvent(nullptr),
Prabir Pradhan1376fcd2022-01-21 09:56:35 -0800919 mMonitorDispatchingTimeout(DEFAULT_INPUT_DISPATCHING_TIMEOUT),
Garfield Tan00f511d2019-06-12 16:55:40 -0700920 mDispatchEnabled(false),
921 mDispatchFrozen(false),
922 mInputFilterEnabled(false),
Bernardo Rufinoea97d182020-08-19 14:43:14 +0100923 mMaximumObscuringOpacityForTouch(1.0f),
Siarhei Vishniakou2508b872020-12-03 16:33:53 -1000924 mFocusedDisplayId(ADISPLAY_ID_DEFAULT),
Prabir Pradhan99987712020-11-10 18:43:05 -0800925 mWindowTokenWithPointerCapture(nullptr),
Siarhei Vishniakoua04181f2021-03-26 05:56:49 +0000926 mLatencyAggregator(),
Antonio Kantek15beb512022-06-13 22:35:41 +0000927 mLatencyTracker(&mLatencyAggregator) {
Siarhei Vishniakouaed7ad02022-08-03 15:04:33 -0700928 mLooper = sp<Looper>::make(false);
Prabir Pradhanf93562f2018-11-29 12:13:37 -0800929 mReporter = createInputReporter();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800930
Siarhei Vishniakouaed7ad02022-08-03 15:04:33 -0700931 mWindowInfoListener = sp<DispatcherWindowListener>::make(*this);
Siarhei Vishniakou31977182022-09-30 08:51:23 -0700932#if defined(__ANDROID__)
Siarhei Vishniakou18050092021-09-01 13:32:49 -0700933 SurfaceComposerClient::getDefault()->addWindowInfosListener(mWindowInfoListener);
Siarhei Vishniakou31977182022-09-30 08:51:23 -0700934#endif
Yi Kong9b14ac62018-07-17 13:48:38 -0700935 mKeyRepeatState.lastKeyEntry = nullptr;
Prabir Pradhanabcdf5c2023-12-15 07:30:22 +0000936
937 if (traceBackend) {
Prabir Pradhandae52792023-12-15 07:36:40 +0000938 mTracer = std::make_unique<trace::impl::InputTracer>(std::move(traceBackend));
Prabir Pradhanabcdf5c2023-12-15 07:30:22 +0000939 }
Yeabkal Wubshitb8aadfa2024-01-17 17:03:42 -0800940
941 mLastUserActivityTimes.fill(0);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800942}
943
944InputDispatcher::~InputDispatcher() {
Prabir Pradhancef936d2021-07-21 16:17:52 +0000945 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800946
Prabir Pradhancef936d2021-07-21 16:17:52 +0000947 resetKeyRepeatLocked();
948 releasePendingEventLocked();
949 drainInboundQueueLocked();
950 mCommandQueue.clear();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800951
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +0000952 while (!mConnectionsByToken.empty()) {
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -0700953 std::shared_ptr<Connection> connection = mConnectionsByToken.begin()->second;
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -0800954 removeInputChannelLocked(connection->getToken(), /*notify=*/false);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800955 }
956}
957
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700958status_t InputDispatcher::start() {
Prabir Pradhan5a57cff2019-10-31 18:40:33 -0700959 if (mThread) {
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700960 return ALREADY_EXISTS;
961 }
Prabir Pradhan5a57cff2019-10-31 18:40:33 -0700962 mThread = std::make_unique<InputThread>(
963 "InputDispatcher", [this]() { dispatchOnce(); }, [this]() { mLooper->wake(); });
964 return OK;
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700965}
966
967status_t InputDispatcher::stop() {
Prabir Pradhan5a57cff2019-10-31 18:40:33 -0700968 if (mThread && mThread->isCallingThread()) {
969 ALOGE("InputDispatcher cannot be stopped from its own thread!");
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700970 return INVALID_OPERATION;
971 }
Prabir Pradhan5a57cff2019-10-31 18:40:33 -0700972 mThread.reset();
973 return OK;
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700974}
975
Michael Wrightd02c5b62014-02-10 15:10:22 -0800976void InputDispatcher::dispatchOnce() {
Colin Cross5b799302022-10-18 21:52:41 -0700977 nsecs_t nextWakeupTime = LLONG_MAX;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800978 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -0800979 std::scoped_lock _l(mLock);
980 mDispatcherIsAlive.notify_all();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800981
982 // Run a dispatch loop if there are no pending commands.
983 // The dispatch loop might enqueue commands to run afterwards.
984 if (!haveCommandsLocked()) {
Siarhei Vishniakou69505962023-12-28 12:07:04 -0800985 dispatchOnceInnerLocked(/*byref*/ nextWakeupTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800986 }
987
988 // Run all pending commands if there are any.
989 // If any commands were run then force the next poll to wake up immediately.
Prabir Pradhancef936d2021-07-21 16:17:52 +0000990 if (runCommandsLockedInterruptable()) {
Colin Cross5b799302022-10-18 21:52:41 -0700991 nextWakeupTime = LLONG_MIN;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800992 }
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -0800993
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700994 // If we are still waiting for ack on some events,
995 // we might have to wake up earlier to check if an app is anr'ing.
996 const nsecs_t nextAnrCheck = processAnrsLocked();
997 nextWakeupTime = std::min(nextWakeupTime, nextAnrCheck);
998
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -0800999 // We are about to enter an infinitely long sleep, because we have no commands or
1000 // pending or queued events
Colin Cross5b799302022-10-18 21:52:41 -07001001 if (nextWakeupTime == LLONG_MAX) {
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -08001002 mDispatcherEnteredIdle.notify_all();
1003 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001004 } // release lock
1005
1006 // Wait for callback or timeout or wake. (make sure we round up, not down)
1007 nsecs_t currentTime = now();
1008 int timeoutMillis = toMillisecondTimeoutDelay(currentTime, nextWakeupTime);
1009 mLooper->pollOnce(timeoutMillis);
1010}
1011
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001012/**
Siarhei Vishniakouf56b2692020-09-08 19:43:33 -05001013 * Raise ANR if there is no focused window.
1014 * Before the ANR is raised, do a final state check:
1015 * 1. The currently focused application must be the same one we are waiting for.
1016 * 2. Ensure we still don't have a focused window.
1017 */
1018void InputDispatcher::processNoFocusedWindowAnrLocked() {
1019 // Check if the application that we are waiting for is still focused.
1020 std::shared_ptr<InputApplicationHandle> focusedApplication =
1021 getValueByKey(mFocusedApplicationHandlesByDisplay, mAwaitedApplicationDisplayId);
1022 if (focusedApplication == nullptr ||
1023 focusedApplication->getApplicationToken() !=
1024 mAwaitedFocusedApplication->getApplicationToken()) {
1025 // Unexpected because we should have reset the ANR timer when focused application changed
1026 ALOGE("Waited for a focused window, but focused application has already changed to %s",
1027 focusedApplication->getName().c_str());
1028 return; // The focused application has changed.
1029 }
1030
chaviw98318de2021-05-19 16:45:23 -05001031 const sp<WindowInfoHandle>& focusedWindowHandle =
Siarhei Vishniakouf56b2692020-09-08 19:43:33 -05001032 getFocusedWindowHandleLocked(mAwaitedApplicationDisplayId);
1033 if (focusedWindowHandle != nullptr) {
1034 return; // We now have a focused window. No need for ANR.
1035 }
1036 onAnrLocked(mAwaitedFocusedApplication);
1037}
1038
1039/**
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001040 * Check if any of the connections' wait queues have events that are too old.
1041 * If we waited for events to be ack'ed for more than the window timeout, raise an ANR.
1042 * Return the time at which we should wake up next.
1043 */
1044nsecs_t InputDispatcher::processAnrsLocked() {
1045 const nsecs_t currentTime = now();
Colin Cross5b799302022-10-18 21:52:41 -07001046 nsecs_t nextAnrCheck = LLONG_MAX;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001047 // Check if we are waiting for a focused window to appear. Raise ANR if waited too long
1048 if (mNoFocusedWindowTimeoutTime.has_value() && mAwaitedFocusedApplication != nullptr) {
1049 if (currentTime >= *mNoFocusedWindowTimeoutTime) {
Siarhei Vishniakouf56b2692020-09-08 19:43:33 -05001050 processNoFocusedWindowAnrLocked();
Chris Yea209fde2020-07-22 13:54:51 -07001051 mAwaitedFocusedApplication.reset();
Siarhei Vishniakouf56b2692020-09-08 19:43:33 -05001052 mNoFocusedWindowTimeoutTime = std::nullopt;
Colin Cross5b799302022-10-18 21:52:41 -07001053 return LLONG_MIN;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001054 } else {
Siarhei Vishniakou38a6d272020-10-20 20:29:33 -05001055 // Keep waiting. We will drop the event when mNoFocusedWindowTimeoutTime comes.
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001056 nextAnrCheck = *mNoFocusedWindowTimeoutTime;
1057 }
1058 }
1059
1060 // Check if any connection ANRs are due
1061 nextAnrCheck = std::min(nextAnrCheck, mAnrTracker.firstTimeout());
1062 if (currentTime < nextAnrCheck) { // most likely scenario
1063 return nextAnrCheck; // everything is normal. Let's check again at nextAnrCheck
1064 }
1065
1066 // If we reached here, we have an unresponsive connection.
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07001067 std::shared_ptr<Connection> connection = getConnectionLocked(mAnrTracker.firstToken());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001068 if (connection == nullptr) {
1069 ALOGE("Could not find connection for entry %" PRId64, mAnrTracker.firstTimeout());
1070 return nextAnrCheck;
1071 }
1072 connection->responsive = false;
1073 // Stop waking up for this unresponsive connection
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08001074 mAnrTracker.eraseToken(connection->getToken());
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00001075 onAnrLocked(connection);
Colin Cross5b799302022-10-18 21:52:41 -07001076 return LLONG_MIN;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001077}
1078
Prabir Pradhan1376fcd2022-01-21 09:56:35 -08001079std::chrono::nanoseconds InputDispatcher::getDispatchingTimeoutLocked(
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07001080 const std::shared_ptr<Connection>& connection) {
Prabir Pradhan1376fcd2022-01-21 09:56:35 -08001081 if (connection->monitor) {
1082 return mMonitorDispatchingTimeout;
1083 }
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08001084 const sp<WindowInfoHandle> window = getWindowHandleLocked(connection->getToken());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001085 if (window != nullptr) {
Siarhei Vishniakou70622952020-07-30 11:17:23 -05001086 return window->getDispatchingTimeout(DEFAULT_INPUT_DISPATCHING_TIMEOUT);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001087 }
Siarhei Vishniakou70622952020-07-30 11:17:23 -05001088 return DEFAULT_INPUT_DISPATCHING_TIMEOUT;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001089}
1090
Siarhei Vishniakou69505962023-12-28 12:07:04 -08001091void InputDispatcher::dispatchOnceInnerLocked(nsecs_t& nextWakeupTime) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001092 nsecs_t currentTime = now();
1093
Jeff Browndc5992e2014-04-11 01:27:26 -07001094 // Reset the key repeat timer whenever normal dispatch is suspended while the
1095 // device is in a non-interactive state. This is to ensure that we abort a key
1096 // repeat if the device is just coming out of sleep.
1097 if (!mDispatchEnabled) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001098 resetKeyRepeatLocked();
1099 }
1100
1101 // If dispatching is frozen, do not process timeouts or try to deliver any new events.
1102 if (mDispatchFrozen) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01001103 if (DEBUG_FOCUS) {
1104 ALOGD("Dispatch frozen. Waiting some more.");
1105 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001106 return;
1107 }
1108
Michael Wrightd02c5b62014-02-10 15:10:22 -08001109 // Ready to start a new event.
1110 // If we don't already have a pending event, go grab one.
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001111 if (!mPendingEvent) {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001112 if (mInboundQueue.empty()) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001113 // Synthesize a key repeat if appropriate.
1114 if (mKeyRepeatState.lastKeyEntry) {
1115 if (currentTime >= mKeyRepeatState.nextRepeatTime) {
1116 mPendingEvent = synthesizeKeyRepeatLocked(currentTime);
1117 } else {
Siarhei Vishniakou69505962023-12-28 12:07:04 -08001118 nextWakeupTime = std::min(nextWakeupTime, mKeyRepeatState.nextRepeatTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001119 }
1120 }
1121
1122 // Nothing to do if there is no pending event.
1123 if (!mPendingEvent) {
1124 return;
1125 }
1126 } else {
1127 // Inbound queue has at least one entry.
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001128 mPendingEvent = mInboundQueue.front();
1129 mInboundQueue.pop_front();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001130 traceInboundQueueLengthLocked();
1131 }
1132
1133 // Poke user activity for this event.
1134 if (mPendingEvent->policyFlags & POLICY_FLAG_PASS_TO_USER) {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001135 pokeUserActivityLocked(*mPendingEvent);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001136 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001137 }
1138
1139 // Now we have an event to dispatch.
1140 // All events are eventually dequeued and processed this way, even if we intend to drop them.
Yi Kong9b14ac62018-07-17 13:48:38 -07001141 ALOG_ASSERT(mPendingEvent != nullptr);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001142 bool done = false;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001143 DropReason dropReason = DropReason::NOT_DROPPED;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001144 if (!(mPendingEvent->policyFlags & POLICY_FLAG_PASS_TO_USER)) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001145 dropReason = DropReason::POLICY;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001146 } else if (!mDispatchEnabled) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001147 dropReason = DropReason::DISABLED;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001148 }
1149
1150 if (mNextUnblockedEvent == mPendingEvent) {
Yi Kong9b14ac62018-07-17 13:48:38 -07001151 mNextUnblockedEvent = nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001152 }
1153
1154 switch (mPendingEvent->type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001155 case EventEntry::Type::CONFIGURATION_CHANGED: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001156 const ConfigurationChangedEntry& typedEntry =
1157 static_cast<const ConfigurationChangedEntry&>(*mPendingEvent);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001158 done = dispatchConfigurationChangedLocked(currentTime, typedEntry);
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001159 dropReason = DropReason::NOT_DROPPED; // configuration changes are never dropped
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001160 break;
1161 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001162
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001163 case EventEntry::Type::DEVICE_RESET: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001164 const DeviceResetEntry& typedEntry =
1165 static_cast<const DeviceResetEntry&>(*mPendingEvent);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001166 done = dispatchDeviceResetLocked(currentTime, typedEntry);
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001167 dropReason = DropReason::NOT_DROPPED; // device resets are never dropped
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001168 break;
1169 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001170
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001171 case EventEntry::Type::FOCUS: {
Prabir Pradhan24047542023-11-02 17:14:59 +00001172 std::shared_ptr<const FocusEntry> typedEntry =
1173 std::static_pointer_cast<const FocusEntry>(mPendingEvent);
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001174 dispatchFocusLocked(currentTime, typedEntry);
1175 done = true;
1176 dropReason = DropReason::NOT_DROPPED; // focus events are never dropped
1177 break;
1178 }
1179
Antonio Kantek7242d8b2021-08-05 16:07:20 -07001180 case EventEntry::Type::TOUCH_MODE_CHANGED: {
Prabir Pradhan24047542023-11-02 17:14:59 +00001181 const auto typedEntry = std::static_pointer_cast<const TouchModeEntry>(mPendingEvent);
Antonio Kantek7242d8b2021-08-05 16:07:20 -07001182 dispatchTouchModeChangeLocked(currentTime, typedEntry);
1183 done = true;
1184 dropReason = DropReason::NOT_DROPPED; // touch mode events are never dropped
1185 break;
1186 }
1187
Prabir Pradhan99987712020-11-10 18:43:05 -08001188 case EventEntry::Type::POINTER_CAPTURE_CHANGED: {
1189 const auto typedEntry =
Prabir Pradhan24047542023-11-02 17:14:59 +00001190 std::static_pointer_cast<const PointerCaptureChangedEntry>(mPendingEvent);
Prabir Pradhan99987712020-11-10 18:43:05 -08001191 dispatchPointerCaptureChangedLocked(currentTime, typedEntry, dropReason);
1192 done = true;
1193 break;
1194 }
1195
arthurhungb89ccb02020-12-30 16:19:01 +08001196 case EventEntry::Type::DRAG: {
Prabir Pradhan24047542023-11-02 17:14:59 +00001197 std::shared_ptr<const DragEntry> typedEntry =
1198 std::static_pointer_cast<const DragEntry>(mPendingEvent);
arthurhungb89ccb02020-12-30 16:19:01 +08001199 dispatchDragLocked(currentTime, typedEntry);
1200 done = true;
1201 break;
1202 }
1203
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001204 case EventEntry::Type::KEY: {
Prabir Pradhan24047542023-11-02 17:14:59 +00001205 std::shared_ptr<const KeyEntry> keyEntry =
1206 std::static_pointer_cast<const KeyEntry>(mPendingEvent);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001207 if (dropReason == DropReason::NOT_DROPPED && isStaleEvent(currentTime, *keyEntry)) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001208 dropReason = DropReason::STALE;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001209 }
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001210 if (dropReason == DropReason::NOT_DROPPED && mNextUnblockedEvent) {
1211 dropReason = DropReason::BLOCKED;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001212 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001213 done = dispatchKeyLocked(currentTime, keyEntry, &dropReason, nextWakeupTime);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001214 break;
1215 }
1216
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001217 case EventEntry::Type::MOTION: {
Prabir Pradhan24047542023-11-02 17:14:59 +00001218 std::shared_ptr<const MotionEntry> motionEntry =
1219 std::static_pointer_cast<const MotionEntry>(mPendingEvent);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001220 if (dropReason == DropReason::NOT_DROPPED && isStaleEvent(currentTime, *motionEntry)) {
Siarhei Vishniakou6b71b632023-10-27 21:34:46 -07001221 // The event is stale. However, only drop stale events if there isn't an ongoing
1222 // gesture. That would allow us to complete the processing of the current stroke.
1223 const auto touchStateIt = mTouchStatesByDisplay.find(motionEntry->displayId);
1224 if (touchStateIt != mTouchStatesByDisplay.end()) {
1225 const TouchState& touchState = touchStateIt->second;
1226 if (!touchState.hasTouchingPointers(motionEntry->deviceId) &&
1227 !touchState.hasHoveringPointers(motionEntry->deviceId)) {
1228 dropReason = DropReason::STALE;
1229 }
1230 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001231 }
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001232 if (dropReason == DropReason::NOT_DROPPED && mNextUnblockedEvent) {
Siarhei Vishniakou99e407b2023-12-26 18:09:32 -08001233 if (!isFromSource(motionEntry->source, AINPUT_SOURCE_CLASS_POINTER)) {
1234 // Only drop events that are focus-dispatched.
1235 dropReason = DropReason::BLOCKED;
1236 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001237 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001238 done = dispatchMotionLocked(currentTime, motionEntry, &dropReason, nextWakeupTime);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001239 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001240 }
Chris Yef59a2f42020-10-16 12:55:26 -07001241
1242 case EventEntry::Type::SENSOR: {
Prabir Pradhan24047542023-11-02 17:14:59 +00001243 std::shared_ptr<const SensorEntry> sensorEntry =
1244 std::static_pointer_cast<const SensorEntry>(mPendingEvent);
Siarhei Vishniakoue2404a12024-01-16 18:38:39 -08001245
Chris Yef59a2f42020-10-16 12:55:26 -07001246 // Sensor timestamps use SYSTEM_TIME_BOOTTIME time base, so we can't use
1247 // 'currentTime' here, get SYSTEM_TIME_BOOTTIME instead.
1248 nsecs_t bootTime = systemTime(SYSTEM_TIME_BOOTTIME);
1249 if (dropReason == DropReason::NOT_DROPPED && isStaleEvent(bootTime, *sensorEntry)) {
1250 dropReason = DropReason::STALE;
1251 }
1252 dispatchSensorLocked(currentTime, sensorEntry, &dropReason, nextWakeupTime);
1253 done = true;
1254 break;
1255 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001256 }
1257
1258 if (done) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001259 if (dropReason != DropReason::NOT_DROPPED) {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001260 dropInboundEventLocked(*mPendingEvent, dropReason);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001261 }
Michael Wright3a981722015-06-10 15:26:13 +01001262 mLastDropReason = dropReason;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001263
Prabir Pradhan052fb0b2024-02-23 21:03:12 +00001264 if (mTracer) {
1265 if (auto& traceTracker = getTraceTracker(*mPendingEvent); traceTracker != nullptr) {
1266 mTracer->eventProcessingComplete(*traceTracker);
1267 }
1268 }
1269
Michael Wrightd02c5b62014-02-10 15:10:22 -08001270 releasePendingEventLocked();
Siarhei Vishniakou69505962023-12-28 12:07:04 -08001271 nextWakeupTime = LLONG_MIN; // force next poll to wake up immediately
Michael Wrightd02c5b62014-02-10 15:10:22 -08001272 }
1273}
1274
Siarhei Vishniakou289e9242022-02-15 14:50:16 -08001275bool InputDispatcher::isStaleEvent(nsecs_t currentTime, const EventEntry& entry) {
Siarhei Vishniakoua7333112023-10-27 13:33:29 -07001276 return mPolicy.isStaleEvent(currentTime, entry.eventTime);
Siarhei Vishniakou289e9242022-02-15 14:50:16 -08001277}
1278
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001279/**
1280 * Return true if the events preceding this incoming motion event should be dropped
1281 * Return false otherwise (the default behaviour)
1282 */
Siarhei Vishniakouef2b4502023-12-28 11:51:47 -08001283bool InputDispatcher::shouldPruneInboundQueueLocked(const MotionEntry& motionEntry) const {
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001284 const bool isPointerDownEvent = motionEntry.action == AMOTION_EVENT_ACTION_DOWN &&
Prabir Pradhanaa561d12021-09-24 06:57:33 -07001285 isFromSource(motionEntry.source, AINPUT_SOURCE_CLASS_POINTER);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001286
1287 // Optimize case where the current application is unresponsive and the user
1288 // decides to touch a window in a different application.
1289 // If the application takes too long to catch up then we drop all events preceding
1290 // the touch into the other window.
1291 if (isPointerDownEvent && mAwaitedFocusedApplication != nullptr) {
Siarhei Vishniakou9306c382022-09-30 15:30:31 -07001292 const int32_t displayId = motionEntry.displayId;
1293 const auto [x, y] = resolveTouchedPosition(motionEntry);
Harry Cutts33476232023-01-30 19:57:29 +00001294 const bool isStylus = isPointerFromStylus(motionEntry, /*pointerIndex=*/0);
Siarhei Vishniakou9306c382022-09-30 15:30:31 -07001295
Siarhei Vishniakoue1ada272022-11-03 10:47:08 -07001296 sp<WindowInfoHandle> touchedWindowHandle =
1297 findTouchedWindowAtLocked(displayId, x, y, isStylus);
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001298 if (touchedWindowHandle != nullptr &&
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001299 touchedWindowHandle->getApplicationToken() !=
1300 mAwaitedFocusedApplication->getApplicationToken()) {
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001301 // User touched a different application than the one we are waiting on.
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001302 ALOGI("Pruning input queue because user touched a different application while waiting "
1303 "for %s",
1304 mAwaitedFocusedApplication->getName().c_str());
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001305 return true;
1306 }
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001307
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08001308 // Alternatively, maybe there's a spy window that could handle this event.
1309 const std::vector<sp<WindowInfoHandle>> touchedSpies =
1310 findTouchedSpyWindowsAtLocked(displayId, x, y, isStylus);
1311 for (const auto& windowHandle : touchedSpies) {
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07001312 const std::shared_ptr<Connection> connection =
1313 getConnectionLocked(windowHandle->getToken());
Siarhei Vishniakou34ed4d42020-06-18 00:43:02 +00001314 if (connection != nullptr && connection->responsive) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08001315 // This spy window could take more input. Drop all events preceding this
1316 // event, so that the spy window can get a chance to receive the stream.
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001317 ALOGW("Pruning the input queue because %s is unresponsive, but we have a "
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08001318 "responsive spy window that may handle the event.",
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001319 mAwaitedFocusedApplication->getName().c_str());
1320 return true;
1321 }
1322 }
1323 }
1324
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001325 return false;
1326}
1327
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001328bool InputDispatcher::enqueueInboundEventLocked(std::unique_ptr<EventEntry> newEntry) {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001329 bool needWake = mInboundQueue.empty();
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001330 mInboundQueue.push_back(std::move(newEntry));
Prabir Pradhan24047542023-11-02 17:14:59 +00001331 const EventEntry& entry = *(mInboundQueue.back());
Michael Wrightd02c5b62014-02-10 15:10:22 -08001332 traceInboundQueueLengthLocked();
1333
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001334 switch (entry.type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001335 case EventEntry::Type::KEY: {
Prabir Pradhan5735a322022-04-11 17:23:34 +00001336 LOG_ALWAYS_FATAL_IF((entry.policyFlags & POLICY_FLAG_TRUSTED) == 0,
1337 "Unexpected untrusted event.");
Siarhei Vishniakoue2404a12024-01-16 18:38:39 -08001338
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001339 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(entry);
Prabir Pradhanabcdf5c2023-12-15 07:30:22 +00001340 if (mTracer) {
1341 ensureEventTraced(keyEntry);
1342 }
Siarhei Vishniakou6520a582023-10-27 21:53:45 -07001343
Arthur Hung2ee6d0b2022-03-03 20:19:38 +08001344 // If a new up event comes in, and the pending event with same key code has been asked
1345 // to try again later because of the policy. We have to reset the intercept key wake up
1346 // time for it may have been handled in the policy and could be dropped.
1347 if (keyEntry.action == AKEY_EVENT_ACTION_UP && mPendingEvent &&
1348 mPendingEvent->type == EventEntry::Type::KEY) {
Prabir Pradhan24047542023-11-02 17:14:59 +00001349 const KeyEntry& pendingKey = static_cast<const KeyEntry&>(*mPendingEvent);
Arthur Hung2ee6d0b2022-03-03 20:19:38 +08001350 if (pendingKey.keyCode == keyEntry.keyCode &&
1351 pendingKey.interceptKeyResult ==
Michael Wright5caf55a2022-11-24 22:31:42 +00001352 KeyEntry::InterceptKeyResult::TRY_AGAIN_LATER) {
1353 pendingKey.interceptKeyResult = KeyEntry::InterceptKeyResult::UNKNOWN;
Arthur Hung2ee6d0b2022-03-03 20:19:38 +08001354 pendingKey.interceptKeyWakeupTime = 0;
1355 needWake = true;
1356 }
1357 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001358 break;
1359 }
1360
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001361 case EventEntry::Type::MOTION: {
Prabir Pradhan5735a322022-04-11 17:23:34 +00001362 LOG_ALWAYS_FATAL_IF((entry.policyFlags & POLICY_FLAG_TRUSTED) == 0,
1363 "Unexpected untrusted event.");
Prabir Pradhanabcdf5c2023-12-15 07:30:22 +00001364 const auto& motionEntry = static_cast<const MotionEntry&>(entry);
1365 if (mTracer) {
1366 ensureEventTraced(motionEntry);
1367 }
1368 if (shouldPruneInboundQueueLocked(motionEntry)) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001369 mNextUnblockedEvent = mInboundQueue.back();
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001370 needWake = true;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001371 }
Siarhei Vishniakouef2b4502023-12-28 11:51:47 -08001372
1373 const bool isPointerDownEvent = motionEntry.action == AMOTION_EVENT_ACTION_DOWN &&
1374 isFromSource(motionEntry.source, AINPUT_SOURCE_CLASS_POINTER);
1375 if (isPointerDownEvent && mKeyIsWaitingForEventsTimeout) {
1376 // Prevent waiting too long for unprocessed events: if we have a pending key event,
1377 // and some other events have not yet been processed, the dispatcher will wait for
1378 // these events to be processed before dispatching the key event. This is because
1379 // the unprocessed events may cause the focus to change (for example, by launching a
1380 // new window or tapping a different window). To prevent waiting too long, we force
1381 // the key to be sent to the currently focused window when a new tap comes in.
1382 ALOGD("Received a new pointer down event, stop waiting for events to process and "
1383 "just send the pending key event to the currently focused window.");
1384 mKeyIsWaitingForEventsTimeout = now();
Linnan Li563916a2024-02-23 16:08:33 +00001385 needWake = true;
Siarhei Vishniakouef2b4502023-12-28 11:51:47 -08001386 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001387 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001388 }
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001389 case EventEntry::Type::FOCUS: {
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001390 LOG_ALWAYS_FATAL("Focus events should be inserted using enqueueFocusEventLocked");
1391 break;
1392 }
Antonio Kantek7242d8b2021-08-05 16:07:20 -07001393 case EventEntry::Type::TOUCH_MODE_CHANGED:
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001394 case EventEntry::Type::CONFIGURATION_CHANGED:
Prabir Pradhan99987712020-11-10 18:43:05 -08001395 case EventEntry::Type::DEVICE_RESET:
Chris Yef59a2f42020-10-16 12:55:26 -07001396 case EventEntry::Type::SENSOR:
arthurhungb89ccb02020-12-30 16:19:01 +08001397 case EventEntry::Type::POINTER_CAPTURE_CHANGED:
1398 case EventEntry::Type::DRAG: {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001399 // nothing to do
1400 break;
1401 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001402 }
1403
1404 return needWake;
1405}
1406
Prabir Pradhan24047542023-11-02 17:14:59 +00001407void InputDispatcher::addRecentEventLocked(std::shared_ptr<const EventEntry> entry) {
Chris Yef59a2f42020-10-16 12:55:26 -07001408 // Do not store sensor event in recent queue to avoid flooding the queue.
1409 if (entry->type != EventEntry::Type::SENSOR) {
1410 mRecentQueue.push_back(entry);
1411 }
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001412 if (mRecentQueue.size() > RECENT_QUEUE_MAX_SIZE) {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001413 mRecentQueue.pop_front();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001414 }
1415}
1416
Siarhei Vishniakoue1ada272022-11-03 10:47:08 -07001417sp<WindowInfoHandle> InputDispatcher::findTouchedWindowAtLocked(int32_t displayId, float x, float y,
1418 bool isStylus,
1419 bool ignoreDragWindow) const {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001420 // Traverse windows from front to back to find touched window.
Prabir Pradhan07e05b62021-11-19 03:57:24 -08001421 const auto& windowHandles = getWindowHandlesLocked(displayId);
chaviw98318de2021-05-19 16:45:23 -05001422 for (const sp<WindowInfoHandle>& windowHandle : windowHandles) {
arthurhung6d4bed92021-03-17 11:59:33 +08001423 if (ignoreDragWindow && haveSameToken(windowHandle, mDragState->dragWindow)) {
arthurhungb89ccb02020-12-30 16:19:01 +08001424 continue;
1425 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001426
Prabir Pradhan3f90d312021-11-19 03:57:24 -08001427 const WindowInfo& info = *windowHandle->getInfo();
Prabir Pradhan33e3baa2022-12-06 20:30:22 +00001428 if (!info.isSpy() &&
1429 windowAcceptsTouchAt(info, displayId, x, y, isStylus, getTransformLocked(displayId))) {
Siarhei Vishniakoue1ada272022-11-03 10:47:08 -07001430 return windowHandle;
1431 }
1432 }
1433 return nullptr;
1434}
1435
1436std::vector<InputTarget> InputDispatcher::findOutsideTargetsLocked(
Siarhei Vishniakou70f3d8c2023-09-19 15:36:52 -07001437 int32_t displayId, const sp<WindowInfoHandle>& touchedWindow, int32_t pointerId) const {
Siarhei Vishniakoue1ada272022-11-03 10:47:08 -07001438 if (touchedWindow == nullptr) {
1439 return {};
1440 }
1441 // Traverse windows from front to back until we encounter the touched window.
1442 std::vector<InputTarget> outsideTargets;
1443 const auto& windowHandles = getWindowHandlesLocked(displayId);
1444 for (const sp<WindowInfoHandle>& windowHandle : windowHandles) {
1445 if (windowHandle == touchedWindow) {
1446 // Stop iterating once we found a touched window. Any WATCH_OUTSIDE_TOUCH window
1447 // below the touched window will not get ACTION_OUTSIDE event.
1448 return outsideTargets;
Prabir Pradhan3f90d312021-11-19 03:57:24 -08001449 }
Tiger Huang85b8c5e2019-01-17 18:34:54 +08001450
Siarhei Vishniakoue1ada272022-11-03 10:47:08 -07001451 const WindowInfo& info = *windowHandle->getInfo();
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08001452 if (info.inputConfig.test(WindowInfo::InputConfig::WATCH_OUTSIDE_TOUCH)) {
Siarhei Vishniakou70f3d8c2023-09-19 15:36:52 -07001453 std::bitset<MAX_POINTER_ID + 1> pointerIds;
1454 pointerIds.set(pointerId);
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00001455 addPointerWindowTargetLocked(windowHandle, InputTarget::DispatchMode::OUTSIDE,
1456 ftl::Flags<InputTarget::Flags>(), pointerIds,
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07001457 /*firstDownTimeInTarget=*/std::nullopt, outsideTargets);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001458 }
1459 }
Siarhei Vishniakoue1ada272022-11-03 10:47:08 -07001460 return outsideTargets;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001461}
1462
Prabir Pradhand65552b2021-10-07 11:23:50 -07001463std::vector<sp<WindowInfoHandle>> InputDispatcher::findTouchedSpyWindowsAtLocked(
Prabir Pradhan82e081e2022-12-06 09:50:09 +00001464 int32_t displayId, float x, float y, bool isStylus) const {
Prabir Pradhan07e05b62021-11-19 03:57:24 -08001465 // Traverse windows from front to back and gather the touched spy windows.
1466 std::vector<sp<WindowInfoHandle>> spyWindows;
1467 const auto& windowHandles = getWindowHandlesLocked(displayId);
1468 for (const sp<WindowInfoHandle>& windowHandle : windowHandles) {
1469 const WindowInfo& info = *windowHandle->getInfo();
1470
Prabir Pradhan33e3baa2022-12-06 20:30:22 +00001471 if (!windowAcceptsTouchAt(info, displayId, x, y, isStylus, getTransformLocked(displayId))) {
Prabir Pradhan07e05b62021-11-19 03:57:24 -08001472 continue;
1473 }
1474 if (!info.isSpy()) {
1475 // The first touched non-spy window was found, so return the spy windows touched so far.
1476 return spyWindows;
1477 }
1478 spyWindows.push_back(windowHandle);
1479 }
1480 return spyWindows;
1481}
1482
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001483void InputDispatcher::dropInboundEventLocked(const EventEntry& entry, DropReason dropReason) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001484 const char* reason;
1485 switch (dropReason) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001486 case DropReason::POLICY:
Prabir Pradhan65613802023-02-22 23:36:58 +00001487 if (debugInboundEventDetails()) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001488 ALOGD("Dropped event because policy consumed it.");
1489 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001490 reason = "inbound event was dropped because the policy consumed it";
1491 break;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001492 case DropReason::DISABLED:
1493 if (mLastDropReason != DropReason::DISABLED) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001494 ALOGI("Dropped event because input dispatch is disabled.");
1495 }
1496 reason = "inbound event was dropped because input dispatch is disabled";
1497 break;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001498 case DropReason::BLOCKED:
Siarhei Vishniakou99e407b2023-12-26 18:09:32 -08001499 LOG(INFO) << "Dropping because the current application is not responding and the user "
1500 "has started interacting with a different application: "
1501 << entry.getDescription();
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001502 reason = "inbound event was dropped because the current application is not responding "
1503 "and the user has started interacting with a different application";
1504 break;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001505 case DropReason::STALE:
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001506 ALOGI("Dropped event because it is stale.");
1507 reason = "inbound event was dropped because it is stale";
1508 break;
Prabir Pradhan99987712020-11-10 18:43:05 -08001509 case DropReason::NO_POINTER_CAPTURE:
1510 ALOGI("Dropped event because there is no window with Pointer Capture.");
1511 reason = "inbound event was dropped because there is no window with Pointer Capture";
1512 break;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001513 case DropReason::NOT_DROPPED: {
1514 LOG_ALWAYS_FATAL("Should not be dropping a NOT_DROPPED event");
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001515 return;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001516 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001517 }
1518
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001519 switch (entry.type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001520 case EventEntry::Type::KEY: {
Hu Guo3cfa7382023-11-15 09:50:04 +00001521 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(entry);
Prabir Pradhand6b2b052024-02-21 23:25:15 +00001522 CancelationOptions options(CancelationOptions::Mode::CANCEL_NON_POINTER_EVENTS, reason,
1523 keyEntry.traceTracker);
Hu Guo3cfa7382023-11-15 09:50:04 +00001524 options.displayId = keyEntry.displayId;
1525 options.deviceId = keyEntry.deviceId;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001526 synthesizeCancelationEventsForAllConnectionsLocked(options);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001527 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001528 }
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001529 case EventEntry::Type::MOTION: {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001530 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(entry);
1531 if (motionEntry.source & AINPUT_SOURCE_CLASS_POINTER) {
Prabir Pradhand6b2b052024-02-21 23:25:15 +00001532 CancelationOptions options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS, reason,
1533 motionEntry.traceTracker);
Hu Guo3cfa7382023-11-15 09:50:04 +00001534 options.displayId = motionEntry.displayId;
1535 options.deviceId = motionEntry.deviceId;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001536 synthesizeCancelationEventsForAllConnectionsLocked(options);
1537 } else {
Michael Wrightfb04fd52022-11-24 22:31:11 +00001538 CancelationOptions options(CancelationOptions::Mode::CANCEL_NON_POINTER_EVENTS,
Prabir Pradhand6b2b052024-02-21 23:25:15 +00001539 reason, motionEntry.traceTracker);
Hu Guo3cfa7382023-11-15 09:50:04 +00001540 options.displayId = motionEntry.displayId;
1541 options.deviceId = motionEntry.deviceId;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001542 synthesizeCancelationEventsForAllConnectionsLocked(options);
1543 }
1544 break;
1545 }
Chris Yef59a2f42020-10-16 12:55:26 -07001546 case EventEntry::Type::SENSOR: {
1547 break;
1548 }
arthurhungb89ccb02020-12-30 16:19:01 +08001549 case EventEntry::Type::POINTER_CAPTURE_CHANGED:
1550 case EventEntry::Type::DRAG: {
Prabir Pradhan99987712020-11-10 18:43:05 -08001551 break;
1552 }
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001553 case EventEntry::Type::FOCUS:
Antonio Kantek7242d8b2021-08-05 16:07:20 -07001554 case EventEntry::Type::TOUCH_MODE_CHANGED:
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001555 case EventEntry::Type::CONFIGURATION_CHANGED:
1556 case EventEntry::Type::DEVICE_RESET: {
Dominik Laskowski75788452021-02-09 18:51:25 -08001557 LOG_ALWAYS_FATAL("Should not drop %s events", ftl::enum_string(entry.type).c_str());
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001558 break;
1559 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001560 }
1561}
1562
Michael Wrightd02c5b62014-02-10 15:10:22 -08001563bool InputDispatcher::haveCommandsLocked() const {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001564 return !mCommandQueue.empty();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001565}
1566
Prabir Pradhancef936d2021-07-21 16:17:52 +00001567bool InputDispatcher::runCommandsLockedInterruptable() {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001568 if (mCommandQueue.empty()) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001569 return false;
1570 }
1571
1572 do {
Prabir Pradhancef936d2021-07-21 16:17:52 +00001573 auto command = std::move(mCommandQueue.front());
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001574 mCommandQueue.pop_front();
Prabir Pradhancef936d2021-07-21 16:17:52 +00001575 // Commands are run with the lock held, but may release and re-acquire the lock from within.
1576 command();
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001577 } while (!mCommandQueue.empty());
Michael Wrightd02c5b62014-02-10 15:10:22 -08001578 return true;
1579}
1580
Prabir Pradhancef936d2021-07-21 16:17:52 +00001581void InputDispatcher::postCommandLocked(Command&& command) {
1582 mCommandQueue.push_back(command);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001583}
1584
1585void InputDispatcher::drainInboundQueueLocked() {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001586 while (!mInboundQueue.empty()) {
Prabir Pradhan24047542023-11-02 17:14:59 +00001587 std::shared_ptr<const EventEntry> entry = mInboundQueue.front();
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001588 mInboundQueue.pop_front();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001589 releaseInboundEventLocked(entry);
1590 }
1591 traceInboundQueueLengthLocked();
1592}
1593
1594void InputDispatcher::releasePendingEventLocked() {
1595 if (mPendingEvent) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001596 releaseInboundEventLocked(mPendingEvent);
Yi Kong9b14ac62018-07-17 13:48:38 -07001597 mPendingEvent = nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001598 }
1599}
1600
Prabir Pradhan24047542023-11-02 17:14:59 +00001601void InputDispatcher::releaseInboundEventLocked(std::shared_ptr<const EventEntry> entry) {
Prabir Pradhana8cdbe12023-11-01 21:30:02 +00001602 const std::shared_ptr<InjectionState>& injectionState = entry->injectionState;
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001603 if (injectionState && injectionState->injectionResult == InputEventInjectionResult::PENDING) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001604 if (DEBUG_DISPATCH_CYCLE) {
1605 ALOGD("Injected inbound event was dropped.");
1606 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001607 setInjectionResult(*entry, InputEventInjectionResult::FAILED);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001608 }
1609 if (entry == mNextUnblockedEvent) {
Yi Kong9b14ac62018-07-17 13:48:38 -07001610 mNextUnblockedEvent = nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001611 }
1612 addRecentEventLocked(entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001613}
1614
1615void InputDispatcher::resetKeyRepeatLocked() {
1616 if (mKeyRepeatState.lastKeyEntry) {
Yi Kong9b14ac62018-07-17 13:48:38 -07001617 mKeyRepeatState.lastKeyEntry = nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001618 }
1619}
1620
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001621std::shared_ptr<KeyEntry> InputDispatcher::synthesizeKeyRepeatLocked(nsecs_t currentTime) {
Prabir Pradhan24047542023-11-02 17:14:59 +00001622 std::shared_ptr<const KeyEntry> entry = mKeyRepeatState.lastKeyEntry;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001623
Michael Wright2e732952014-09-24 13:26:59 -07001624 uint32_t policyFlags = entry->policyFlags &
1625 (POLICY_FLAG_RAW_MASK | POLICY_FLAG_PASS_TO_USER | POLICY_FLAG_TRUSTED);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001626
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001627 std::shared_ptr<KeyEntry> newEntry =
Prabir Pradhana8cdbe12023-11-01 21:30:02 +00001628 std::make_unique<KeyEntry>(mIdGenerator.nextId(), /*injectionState=*/nullptr,
1629 currentTime, entry->deviceId, entry->source,
1630 entry->displayId, policyFlags, entry->action, entry->flags,
1631 entry->keyCode, entry->scanCode, entry->metaState,
1632 entry->repeatCount + 1, entry->downTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001633
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001634 newEntry->syntheticRepeat = true;
Prabir Pradhanabcdf5c2023-12-15 07:30:22 +00001635 if (mTracer) {
1636 newEntry->traceTracker = mTracer->traceInboundEvent(*newEntry);
1637 }
1638
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001639 mKeyRepeatState.lastKeyEntry = newEntry;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001640 mKeyRepeatState.nextRepeatTime = currentTime + mConfig.keyRepeatDelay;
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001641 return newEntry;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001642}
1643
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001644bool InputDispatcher::dispatchConfigurationChangedLocked(nsecs_t currentTime,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001645 const ConfigurationChangedEntry& entry) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001646 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
1647 ALOGD("dispatchConfigurationChanged - eventTime=%" PRId64, entry.eventTime);
1648 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001649
1650 // Reset key repeating in case a keyboard device was added or removed or something.
1651 resetKeyRepeatLocked();
1652
1653 // Enqueue a command to run outside the lock to tell the policy that the configuration changed.
Prabir Pradhancef936d2021-07-21 16:17:52 +00001654 auto command = [this, eventTime = entry.eventTime]() REQUIRES(mLock) {
1655 scoped_unlock unlock(mLock);
Prabir Pradhana41d2442023-04-20 21:30:40 +00001656 mPolicy.notifyConfigurationChanged(eventTime);
Prabir Pradhancef936d2021-07-21 16:17:52 +00001657 };
1658 postCommandLocked(std::move(command));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001659 return true;
1660}
1661
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001662bool InputDispatcher::dispatchDeviceResetLocked(nsecs_t currentTime,
1663 const DeviceResetEntry& entry) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001664 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
1665 ALOGD("dispatchDeviceReset - eventTime=%" PRId64 ", deviceId=%d", entry.eventTime,
1666 entry.deviceId);
1667 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001668
liushenxiang42232912021-05-21 20:24:09 +08001669 // Reset key repeating in case a keyboard device was disabled or enabled.
1670 if (mKeyRepeatState.lastKeyEntry && mKeyRepeatState.lastKeyEntry->deviceId == entry.deviceId) {
1671 resetKeyRepeatLocked();
1672 }
1673
Prabir Pradhand6b2b052024-02-21 23:25:15 +00001674 ScopedSyntheticEventTracer traceContext(mTracer);
1675 CancelationOptions options(CancelationOptions::Mode::CANCEL_ALL_EVENTS, "device was reset",
1676 traceContext.getTracker());
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001677 options.deviceId = entry.deviceId;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001678 synthesizeCancelationEventsForAllConnectionsLocked(options);
Siarhei Vishniakou0686f0c2023-05-02 11:56:15 -07001679
1680 // Remove all active pointers from this device
1681 for (auto& [_, touchState] : mTouchStatesByDisplay) {
1682 touchState.removeAllPointersForDevice(entry.deviceId);
1683 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001684 return true;
1685}
1686
Vishnu Nairad321cd2020-08-20 16:40:21 -07001687void InputDispatcher::enqueueFocusEventLocked(const sp<IBinder>& windowToken, bool hasFocus,
Vishnu Nairc519ff72021-01-21 08:23:08 -08001688 const std::string& reason) {
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001689 if (mPendingEvent != nullptr) {
1690 // Move the pending event to the front of the queue. This will give the chance
1691 // for the pending event to get dispatched to the newly focused window
1692 mInboundQueue.push_front(mPendingEvent);
1693 mPendingEvent = nullptr;
1694 }
1695
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001696 std::unique_ptr<FocusEntry> focusEntry =
1697 std::make_unique<FocusEntry>(mIdGenerator.nextId(), now(), windowToken, hasFocus,
1698 reason);
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001699
1700 // This event should go to the front of the queue, but behind all other focus events
1701 // Find the last focus event, and insert right after it
Prabir Pradhan24047542023-11-02 17:14:59 +00001702 auto it = std::find_if(mInboundQueue.rbegin(), mInboundQueue.rend(),
1703 [](const std::shared_ptr<const EventEntry>& event) {
1704 return event->type == EventEntry::Type::FOCUS;
1705 });
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001706
1707 // Maintain the order of focus events. Insert the entry after all other focus events.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001708 mInboundQueue.insert(it.base(), std::move(focusEntry));
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001709}
1710
Prabir Pradhan24047542023-11-02 17:14:59 +00001711void InputDispatcher::dispatchFocusLocked(nsecs_t currentTime,
1712 std::shared_ptr<const FocusEntry> entry) {
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08001713 std::shared_ptr<Connection> connection = getConnectionLocked(entry->connectionToken);
1714 if (connection == nullptr) {
1715 return; // Connection has gone away
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001716 }
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001717 entry->dispatchInProgress = true;
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00001718 std::string message = std::string("Focus ") + (entry->hasFocus ? "entering " : "leaving ") +
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08001719 connection->getInputChannelName();
Vishnu Nair7d3d00d2020-08-03 11:20:42 -07001720 std::string reason = std::string("reason=").append(entry->reason);
1721 android_log_event_list(LOGTAG_INPUT_FOCUS) << message << reason << LOG_ID_EVENTS;
Prabir Pradhanc32a4112024-01-23 23:20:37 +00001722 dispatchEventLocked(currentTime, entry, {{connection}});
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001723}
1724
Prabir Pradhan99987712020-11-10 18:43:05 -08001725void InputDispatcher::dispatchPointerCaptureChangedLocked(
Prabir Pradhan24047542023-11-02 17:14:59 +00001726 nsecs_t currentTime, const std::shared_ptr<const PointerCaptureChangedEntry>& entry,
Prabir Pradhan99987712020-11-10 18:43:05 -08001727 DropReason& dropReason) {
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001728 dropReason = DropReason::NOT_DROPPED;
1729
Prabir Pradhan99987712020-11-10 18:43:05 -08001730 const bool haveWindowWithPointerCapture = mWindowTokenWithPointerCapture != nullptr;
Prabir Pradhan99987712020-11-10 18:43:05 -08001731 sp<IBinder> token;
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001732
Hiroki Sato25040232024-02-22 17:21:22 +09001733 if (entry->pointerCaptureRequest.isEnable()) {
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001734 // Enable Pointer Capture.
1735 if (haveWindowWithPointerCapture &&
1736 (entry->pointerCaptureRequest == mCurrentPointerCaptureRequest)) {
Prabir Pradhan7092e262022-05-03 16:51:09 +00001737 // This can happen if pointer capture is disabled and re-enabled before we notify the
1738 // app of the state change, so there is no need to notify the app.
1739 ALOGI("Skipping dispatch of Pointer Capture being enabled: no state change.");
1740 return;
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001741 }
Hiroki Sato25040232024-02-22 17:21:22 +09001742 if (!mCurrentPointerCaptureRequest.isEnable()) {
Prabir Pradhan99987712020-11-10 18:43:05 -08001743 // This can happen if a window requests capture and immediately releases capture.
1744 ALOGW("No window requested Pointer Capture.");
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001745 dropReason = DropReason::NO_POINTER_CAPTURE;
Prabir Pradhan99987712020-11-10 18:43:05 -08001746 return;
1747 }
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001748 if (entry->pointerCaptureRequest.seq != mCurrentPointerCaptureRequest.seq) {
1749 ALOGI("Skipping dispatch of Pointer Capture being enabled: sequence number mismatch.");
1750 return;
1751 }
1752
Vishnu Nairc519ff72021-01-21 08:23:08 -08001753 token = mFocusResolver.getFocusedWindowToken(mFocusedDisplayId);
Prabir Pradhan99987712020-11-10 18:43:05 -08001754 LOG_ALWAYS_FATAL_IF(!token, "Cannot find focused window for Pointer Capture.");
Hiroki Sato25040232024-02-22 17:21:22 +09001755 LOG_ALWAYS_FATAL_IF(token != entry->pointerCaptureRequest.window,
1756 "Unexpected requested window for Pointer Capture.");
Prabir Pradhan99987712020-11-10 18:43:05 -08001757 mWindowTokenWithPointerCapture = token;
1758 } else {
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001759 // Disable Pointer Capture.
1760 // We do not check if the sequence number matches for requests to disable Pointer Capture
1761 // for two reasons:
1762 // 1. Pointer Capture can be disabled by a focus change, which means we can get two entries
1763 // to disable capture with the same sequence number: one generated by
1764 // disablePointerCaptureForcedLocked() and another as an acknowledgement of Pointer
1765 // Capture being disabled in InputReader.
1766 // 2. We respect any request to disable Pointer Capture generated by InputReader, since the
1767 // actual Pointer Capture state that affects events being generated by input devices is
1768 // in InputReader.
1769 if (!haveWindowWithPointerCapture) {
1770 // Pointer capture was already forcefully disabled because of focus change.
1771 dropReason = DropReason::NOT_DROPPED;
1772 return;
1773 }
Prabir Pradhan99987712020-11-10 18:43:05 -08001774 token = mWindowTokenWithPointerCapture;
1775 mWindowTokenWithPointerCapture = nullptr;
Hiroki Sato25040232024-02-22 17:21:22 +09001776 if (mCurrentPointerCaptureRequest.isEnable()) {
1777 setPointerCaptureLocked(nullptr);
Prabir Pradhan7d030382020-12-21 07:58:35 -08001778 }
Prabir Pradhan99987712020-11-10 18:43:05 -08001779 }
1780
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08001781 auto connection = getConnectionLocked(token);
1782 if (connection == nullptr) {
Prabir Pradhan99987712020-11-10 18:43:05 -08001783 // Window has gone away, clean up Pointer Capture state.
1784 mWindowTokenWithPointerCapture = nullptr;
Hiroki Sato25040232024-02-22 17:21:22 +09001785 if (mCurrentPointerCaptureRequest.isEnable()) {
1786 setPointerCaptureLocked(nullptr);
Prabir Pradhan7d030382020-12-21 07:58:35 -08001787 }
Prabir Pradhan99987712020-11-10 18:43:05 -08001788 return;
1789 }
Prabir Pradhan99987712020-11-10 18:43:05 -08001790 entry->dispatchInProgress = true;
Prabir Pradhanc32a4112024-01-23 23:20:37 +00001791 dispatchEventLocked(currentTime, entry, {{connection}});
Prabir Pradhan99987712020-11-10 18:43:05 -08001792
1793 dropReason = DropReason::NOT_DROPPED;
1794}
1795
Prabir Pradhan24047542023-11-02 17:14:59 +00001796void InputDispatcher::dispatchTouchModeChangeLocked(
1797 nsecs_t currentTime, const std::shared_ptr<const TouchModeEntry>& entry) {
Antonio Kantek7242d8b2021-08-05 16:07:20 -07001798 const std::vector<sp<WindowInfoHandle>>& windowHandles =
Antonio Kantek15beb512022-06-13 22:35:41 +00001799 getWindowHandlesLocked(entry->displayId);
Antonio Kantek7242d8b2021-08-05 16:07:20 -07001800 if (windowHandles.empty()) {
1801 return;
1802 }
1803 const std::vector<InputTarget> inputTargets =
1804 getInputTargetsFromWindowHandlesLocked(windowHandles);
1805 if (inputTargets.empty()) {
1806 return;
1807 }
1808 entry->dispatchInProgress = true;
1809 dispatchEventLocked(currentTime, entry, inputTargets);
1810}
1811
1812std::vector<InputTarget> InputDispatcher::getInputTargetsFromWindowHandlesLocked(
1813 const std::vector<sp<WindowInfoHandle>>& windowHandles) const {
1814 std::vector<InputTarget> inputTargets;
1815 for (const sp<WindowInfoHandle>& handle : windowHandles) {
Antonio Kantek7242d8b2021-08-05 16:07:20 -07001816 const sp<IBinder>& token = handle->getToken();
1817 if (token == nullptr) {
1818 continue;
1819 }
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08001820 std::shared_ptr<Connection> connection = getConnectionLocked(token);
1821 if (connection == nullptr) {
1822 continue; // Connection has gone away
Antonio Kantek7242d8b2021-08-05 16:07:20 -07001823 }
Prabir Pradhanc32a4112024-01-23 23:20:37 +00001824 inputTargets.emplace_back(connection);
Antonio Kantek7242d8b2021-08-05 16:07:20 -07001825 }
1826 return inputTargets;
1827}
1828
Prabir Pradhan24047542023-11-02 17:14:59 +00001829bool InputDispatcher::dispatchKeyLocked(nsecs_t currentTime, std::shared_ptr<const KeyEntry> entry,
Siarhei Vishniakou69505962023-12-28 12:07:04 -08001830 DropReason* dropReason, nsecs_t& nextWakeupTime) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001831 // Preprocessing.
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001832 if (!entry->dispatchInProgress) {
Hu Guofe3c8f12023-09-22 17:20:15 +08001833 if (!entry->syntheticRepeat && entry->action == AKEY_EVENT_ACTION_DOWN &&
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001834 (entry->policyFlags & POLICY_FLAG_TRUSTED) &&
1835 (!(entry->policyFlags & POLICY_FLAG_DISABLE_KEY_REPEAT))) {
1836 if (mKeyRepeatState.lastKeyEntry &&
Chris Ye2ad95392020-09-01 13:44:44 -07001837 mKeyRepeatState.lastKeyEntry->keyCode == entry->keyCode &&
Michael Wrightd02c5b62014-02-10 15:10:22 -08001838 // We have seen two identical key downs in a row which indicates that the device
1839 // driver is automatically generating key repeats itself. We take note of the
1840 // repeat here, but we disable our own next key repeat timer since it is clear that
1841 // we will not need to synthesize key repeats ourselves.
Chris Ye2ad95392020-09-01 13:44:44 -07001842 mKeyRepeatState.lastKeyEntry->deviceId == entry->deviceId) {
1843 // Make sure we don't get key down from a different device. If a different
1844 // device Id has same key pressed down, the new device Id will replace the
1845 // current one to hold the key repeat with repeat count reset.
1846 // In the future when got a KEY_UP on the device id, drop it and do not
1847 // stop the key repeat on current device.
Michael Wrightd02c5b62014-02-10 15:10:22 -08001848 entry->repeatCount = mKeyRepeatState.lastKeyEntry->repeatCount + 1;
1849 resetKeyRepeatLocked();
Colin Cross5b799302022-10-18 21:52:41 -07001850 mKeyRepeatState.nextRepeatTime = LLONG_MAX; // don't generate repeats ourselves
Michael Wrightd02c5b62014-02-10 15:10:22 -08001851 } else {
1852 // Not a repeat. Save key down state in case we do see a repeat later.
1853 resetKeyRepeatLocked();
1854 mKeyRepeatState.nextRepeatTime = entry->eventTime + mConfig.keyRepeatTimeout;
1855 }
1856 mKeyRepeatState.lastKeyEntry = entry;
Chris Ye2ad95392020-09-01 13:44:44 -07001857 } else if (entry->action == AKEY_EVENT_ACTION_UP && mKeyRepeatState.lastKeyEntry &&
1858 mKeyRepeatState.lastKeyEntry->deviceId != entry->deviceId) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001859 // The key on device 'deviceId' is still down, do not stop key repeat
Prabir Pradhan65613802023-02-22 23:36:58 +00001860 if (debugInboundEventDetails()) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001861 ALOGD("deviceId=%d got KEY_UP as stale", entry->deviceId);
1862 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001863 } else if (!entry->syntheticRepeat) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001864 resetKeyRepeatLocked();
1865 }
1866
1867 if (entry->repeatCount == 1) {
1868 entry->flags |= AKEY_EVENT_FLAG_LONG_PRESS;
1869 } else {
1870 entry->flags &= ~AKEY_EVENT_FLAG_LONG_PRESS;
1871 }
1872
1873 entry->dispatchInProgress = true;
1874
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001875 logOutboundKeyDetails("dispatchKey - ", *entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001876 }
1877
1878 // Handle case where the policy asked us to try again later last time.
Michael Wright5caf55a2022-11-24 22:31:42 +00001879 if (entry->interceptKeyResult == KeyEntry::InterceptKeyResult::TRY_AGAIN_LATER) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001880 if (currentTime < entry->interceptKeyWakeupTime) {
Siarhei Vishniakou69505962023-12-28 12:07:04 -08001881 nextWakeupTime = std::min(nextWakeupTime, entry->interceptKeyWakeupTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001882 return false; // wait until next wakeup
1883 }
Michael Wright5caf55a2022-11-24 22:31:42 +00001884 entry->interceptKeyResult = KeyEntry::InterceptKeyResult::UNKNOWN;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001885 entry->interceptKeyWakeupTime = 0;
1886 }
1887
1888 // Give the policy a chance to intercept the key.
Michael Wright5caf55a2022-11-24 22:31:42 +00001889 if (entry->interceptKeyResult == KeyEntry::InterceptKeyResult::UNKNOWN) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001890 if (entry->policyFlags & POLICY_FLAG_PASS_TO_USER) {
Vishnu Nairad321cd2020-08-20 16:40:21 -07001891 sp<IBinder> focusedWindowToken =
Vishnu Nairc519ff72021-01-21 08:23:08 -08001892 mFocusResolver.getFocusedWindowToken(getTargetDisplayId(*entry));
Prabir Pradhancef936d2021-07-21 16:17:52 +00001893
1894 auto command = [this, focusedWindowToken, entry]() REQUIRES(mLock) {
1895 doInterceptKeyBeforeDispatchingCommand(focusedWindowToken, *entry);
1896 };
1897 postCommandLocked(std::move(command));
Josep del Riob3981622023-04-18 15:49:45 +00001898 // Poke user activity for keys not passed to user
1899 pokeUserActivityLocked(*entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001900 return false; // wait for the command to run
1901 } else {
Michael Wright5caf55a2022-11-24 22:31:42 +00001902 entry->interceptKeyResult = KeyEntry::InterceptKeyResult::CONTINUE;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001903 }
Michael Wright5caf55a2022-11-24 22:31:42 +00001904 } else if (entry->interceptKeyResult == KeyEntry::InterceptKeyResult::SKIP) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001905 if (*dropReason == DropReason::NOT_DROPPED) {
1906 *dropReason = DropReason::POLICY;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001907 }
1908 }
1909
1910 // Clean up if dropping the event.
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001911 if (*dropReason != DropReason::NOT_DROPPED) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001912 setInjectionResult(*entry,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001913 *dropReason == DropReason::POLICY ? InputEventInjectionResult::SUCCEEDED
1914 : InputEventInjectionResult::FAILED);
Garfield Tan6a5a14e2020-01-28 13:24:04 -08001915 mReporter->reportDroppedKey(entry->id);
Josep del Riob3981622023-04-18 15:49:45 +00001916 // Poke user activity for undispatched keys
1917 pokeUserActivityLocked(*entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001918 return true;
1919 }
1920
1921 // Identify targets.
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07001922 InputEventInjectionResult injectionResult;
1923 sp<WindowInfoHandle> focusedWindow =
1924 findFocusedWindowTargetLocked(currentTime, *entry, nextWakeupTime,
1925 /*byref*/ injectionResult);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001926 if (injectionResult == InputEventInjectionResult::PENDING) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001927 return false;
1928 }
1929
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001930 setInjectionResult(*entry, injectionResult);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001931 if (injectionResult != InputEventInjectionResult::SUCCEEDED) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001932 return true;
1933 }
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07001934 LOG_ALWAYS_FATAL_IF(focusedWindow == nullptr);
1935
1936 std::vector<InputTarget> inputTargets;
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00001937 addWindowTargetLocked(focusedWindow, InputTarget::DispatchMode::AS_IS,
1938 InputTarget::Flags::FOREGROUND, getDownTime(*entry), inputTargets);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001939
Arthur Hung2fbf37f2018-09-13 18:16:41 +08001940 // Add monitor channels from event's or focused display.
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001941 addGlobalMonitoringTargetsLocked(inputTargets, getTargetDisplayId(*entry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001942
Prabir Pradhanabcdf5c2023-12-15 07:30:22 +00001943 if (mTracer) {
1944 ensureEventTraced(*entry);
1945 for (const auto& target : inputTargets) {
1946 mTracer->dispatchToTargetHint(*entry->traceTracker, target);
1947 }
1948 }
1949
Michael Wrightd02c5b62014-02-10 15:10:22 -08001950 // Dispatch the key.
1951 dispatchEventLocked(currentTime, entry, inputTargets);
1952 return true;
1953}
1954
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001955void InputDispatcher::logOutboundKeyDetails(const char* prefix, const KeyEntry& entry) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001956 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
1957 ALOGD("%seventTime=%" PRId64 ", deviceId=%d, source=0x%x, displayId=%" PRId32 ", "
1958 "policyFlags=0x%x, action=0x%x, flags=0x%x, keyCode=0x%x, scanCode=0x%x, "
1959 "metaState=0x%x, repeatCount=%d, downTime=%" PRId64,
1960 prefix, entry.eventTime, entry.deviceId, entry.source, entry.displayId,
1961 entry.policyFlags, entry.action, entry.flags, entry.keyCode, entry.scanCode,
1962 entry.metaState, entry.repeatCount, entry.downTime);
1963 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001964}
1965
Prabir Pradhancef936d2021-07-21 16:17:52 +00001966void InputDispatcher::dispatchSensorLocked(nsecs_t currentTime,
Prabir Pradhan24047542023-11-02 17:14:59 +00001967 const std::shared_ptr<const SensorEntry>& entry,
Siarhei Vishniakou69505962023-12-28 12:07:04 -08001968 DropReason* dropReason, nsecs_t& nextWakeupTime) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001969 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
1970 ALOGD("notifySensorEvent eventTime=%" PRId64 ", hwTimestamp=%" PRId64 ", deviceId=%d, "
1971 "source=0x%x, sensorType=%s",
1972 entry->eventTime, entry->hwTimestamp, entry->deviceId, entry->source,
Dominik Laskowski75788452021-02-09 18:51:25 -08001973 ftl::enum_string(entry->sensorType).c_str());
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001974 }
Prabir Pradhancef936d2021-07-21 16:17:52 +00001975 auto command = [this, entry]() REQUIRES(mLock) {
1976 scoped_unlock unlock(mLock);
1977
1978 if (entry->accuracyChanged) {
Prabir Pradhana41d2442023-04-20 21:30:40 +00001979 mPolicy.notifySensorAccuracy(entry->deviceId, entry->sensorType, entry->accuracy);
Prabir Pradhancef936d2021-07-21 16:17:52 +00001980 }
Prabir Pradhana41d2442023-04-20 21:30:40 +00001981 mPolicy.notifySensorEvent(entry->deviceId, entry->sensorType, entry->accuracy,
1982 entry->hwTimestamp, entry->values);
Prabir Pradhancef936d2021-07-21 16:17:52 +00001983 };
1984 postCommandLocked(std::move(command));
Chris Yef59a2f42020-10-16 12:55:26 -07001985}
1986
1987bool InputDispatcher::flushSensor(int deviceId, InputDeviceSensorType sensorType) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001988 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
1989 ALOGD("flushSensor deviceId=%d, sensorType=%s", deviceId,
Dominik Laskowski75788452021-02-09 18:51:25 -08001990 ftl::enum_string(sensorType).c_str());
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001991 }
Chris Yef59a2f42020-10-16 12:55:26 -07001992 { // acquire lock
1993 std::scoped_lock _l(mLock);
1994
1995 for (auto it = mInboundQueue.begin(); it != mInboundQueue.end(); it++) {
Prabir Pradhan24047542023-11-02 17:14:59 +00001996 std::shared_ptr<const EventEntry> entry = *it;
Chris Yef59a2f42020-10-16 12:55:26 -07001997 if (entry->type == EventEntry::Type::SENSOR) {
1998 it = mInboundQueue.erase(it);
1999 releaseInboundEventLocked(entry);
2000 }
2001 }
2002 }
2003 return true;
2004}
2005
Prabir Pradhan24047542023-11-02 17:14:59 +00002006bool InputDispatcher::dispatchMotionLocked(nsecs_t currentTime,
2007 std::shared_ptr<const MotionEntry> entry,
Siarhei Vishniakou69505962023-12-28 12:07:04 -08002008 DropReason* dropReason, nsecs_t& nextWakeupTime) {
Michael Wright3dd60e22019-03-27 22:06:44 +00002009 ATRACE_CALL();
Michael Wrightd02c5b62014-02-10 15:10:22 -08002010 // Preprocessing.
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002011 if (!entry->dispatchInProgress) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002012 entry->dispatchInProgress = true;
2013
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002014 logOutboundMotionDetails("dispatchMotion - ", *entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002015 }
2016
2017 // Clean up if dropping the event.
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07002018 if (*dropReason != DropReason::NOT_DROPPED) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07002019 setInjectionResult(*entry,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002020 *dropReason == DropReason::POLICY ? InputEventInjectionResult::SUCCEEDED
2021 : InputEventInjectionResult::FAILED);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002022 return true;
2023 }
2024
Prabir Pradhanaa561d12021-09-24 06:57:33 -07002025 const bool isPointerEvent = isFromSource(entry->source, AINPUT_SOURCE_CLASS_POINTER);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002026
2027 // Identify targets.
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08002028 std::vector<InputTarget> inputTargets;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002029
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002030 InputEventInjectionResult injectionResult;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002031 if (isPointerEvent) {
2032 // Pointer event. (eg. touchscreen)
Vaibhav Devmurari6abcf8f2022-06-06 10:08:05 +00002033
2034 if (mDragState &&
2035 (entry->action & AMOTION_EVENT_ACTION_MASK) == AMOTION_EVENT_ACTION_POINTER_DOWN) {
2036 // If drag and drop ongoing and pointer down occur: pilfer drag window pointers
2037 pilferPointersLocked(mDragState->dragWindow->getToken());
2038 }
2039
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002040 inputTargets =
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002041 findTouchedWindowTargetsLocked(currentTime, *entry, /*byref*/ injectionResult);
Siarhei Vishniakou8619eb32022-12-01 21:30:59 -08002042 LOG_ALWAYS_FATAL_IF(injectionResult != InputEventInjectionResult::SUCCEEDED &&
2043 !inputTargets.empty());
Michael Wrightd02c5b62014-02-10 15:10:22 -08002044 } else {
2045 // Non touch event. (eg. trackball)
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002046 sp<WindowInfoHandle> focusedWindow =
2047 findFocusedWindowTargetLocked(currentTime, *entry, nextWakeupTime, injectionResult);
2048 if (injectionResult == InputEventInjectionResult::SUCCEEDED) {
2049 LOG_ALWAYS_FATAL_IF(focusedWindow == nullptr);
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00002050 addWindowTargetLocked(focusedWindow, InputTarget::DispatchMode::AS_IS,
2051 InputTarget::Flags::FOREGROUND, getDownTime(*entry),
2052 inputTargets);
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002053 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002054 }
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002055 if (injectionResult == InputEventInjectionResult::PENDING) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002056 return false;
2057 }
2058
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07002059 setInjectionResult(*entry, injectionResult);
Prabir Pradhan5735a322022-04-11 17:23:34 +00002060 if (injectionResult == InputEventInjectionResult::TARGET_MISMATCH) {
Siarhei Vishniakou767917f2020-03-24 20:49:09 -07002061 return true;
2062 }
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002063 if (injectionResult != InputEventInjectionResult::SUCCEEDED) {
Michael Wrightfb04fd52022-11-24 22:31:11 +00002064 CancelationOptions::Mode mode(
2065 isPointerEvent ? CancelationOptions::Mode::CANCEL_POINTER_EVENTS
2066 : CancelationOptions::Mode::CANCEL_NON_POINTER_EVENTS);
Prabir Pradhand6b2b052024-02-21 23:25:15 +00002067 CancelationOptions options(mode, "input event injection failed", entry->traceTracker);
Linnan Lid8150952024-01-26 18:07:17 +00002068 options.displayId = entry->displayId;
Siarhei Vishniakou767917f2020-03-24 20:49:09 -07002069 synthesizeCancelationEventsForMonitorsLocked(options);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002070 return true;
2071 }
2072
Arthur Hung2fbf37f2018-09-13 18:16:41 +08002073 // Add monitor channels from event's or focused display.
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002074 addGlobalMonitoringTargetsLocked(inputTargets, getTargetDisplayId(*entry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08002075
Prabir Pradhanabcdf5c2023-12-15 07:30:22 +00002076 if (mTracer) {
2077 ensureEventTraced(*entry);
2078 for (const auto& target : inputTargets) {
2079 mTracer->dispatchToTargetHint(*entry->traceTracker, target);
2080 }
2081 }
2082
Michael Wrightd02c5b62014-02-10 15:10:22 -08002083 // Dispatch the motion.
Michael Wrightd02c5b62014-02-10 15:10:22 -08002084 dispatchEventLocked(currentTime, entry, inputTargets);
2085 return true;
2086}
2087
chaviw98318de2021-05-19 16:45:23 -05002088void InputDispatcher::enqueueDragEventLocked(const sp<WindowInfoHandle>& windowHandle,
Arthur Hung54745652022-04-20 07:17:41 +00002089 bool isExiting, const int32_t rawX,
2090 const int32_t rawY) {
2091 const vec2 xy = windowHandle->getInfo()->transform.transform(vec2(rawX, rawY));
arthurhungb89ccb02020-12-30 16:19:01 +08002092 std::unique_ptr<DragEntry> dragEntry =
Arthur Hung54745652022-04-20 07:17:41 +00002093 std::make_unique<DragEntry>(mIdGenerator.nextId(), now(), windowHandle->getToken(),
2094 isExiting, xy.x, xy.y);
arthurhungb89ccb02020-12-30 16:19:01 +08002095
2096 enqueueInboundEventLocked(std::move(dragEntry));
2097}
2098
Prabir Pradhan24047542023-11-02 17:14:59 +00002099void InputDispatcher::dispatchDragLocked(nsecs_t currentTime,
2100 std::shared_ptr<const DragEntry> entry) {
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08002101 std::shared_ptr<Connection> connection = getConnectionLocked(entry->connectionToken);
2102 if (connection == nullptr) {
2103 return; // Connection has gone away
arthurhungb89ccb02020-12-30 16:19:01 +08002104 }
arthurhungb89ccb02020-12-30 16:19:01 +08002105 entry->dispatchInProgress = true;
Prabir Pradhanc32a4112024-01-23 23:20:37 +00002106 dispatchEventLocked(currentTime, entry, {{connection}});
arthurhungb89ccb02020-12-30 16:19:01 +08002107}
2108
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002109void InputDispatcher::logOutboundMotionDetails(const char* prefix, const MotionEntry& entry) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00002110 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
Siarhei Vishniakou0b0374d2022-11-17 17:40:53 -08002111 ALOGD("%seventTime=%" PRId64 ", deviceId=%d, source=%s, displayId=%" PRId32
Prabir Pradhan61a5d242021-07-26 16:41:09 +00002112 ", policyFlags=0x%x, "
Siarhei Vishniakouca205502021-07-16 21:31:58 +00002113 "action=%s, actionButton=0x%x, flags=0x%x, "
Prabir Pradhan61a5d242021-07-26 16:41:09 +00002114 "metaState=0x%x, buttonState=0x%x,"
2115 "edgeFlags=0x%x, xPrecision=%f, yPrecision=%f, downTime=%" PRId64,
Siarhei Vishniakou0b0374d2022-11-17 17:40:53 -08002116 prefix, entry.eventTime, entry.deviceId,
2117 inputEventSourceToString(entry.source).c_str(), entry.displayId, entry.policyFlags,
2118 MotionEvent::actionToString(entry.action).c_str(), entry.actionButton, entry.flags,
2119 entry.metaState, entry.buttonState, entry.edgeFlags, entry.xPrecision,
2120 entry.yPrecision, entry.downTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002121
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07002122 for (uint32_t i = 0; i < entry.getPointerCount(); i++) {
Siarhei Vishniakou09a8fe42022-07-21 17:27:03 -07002123 ALOGD(" Pointer %d: id=%d, toolType=%s, "
Prabir Pradhan61a5d242021-07-26 16:41:09 +00002124 "x=%f, y=%f, pressure=%f, size=%f, "
2125 "touchMajor=%f, touchMinor=%f, toolMajor=%f, toolMinor=%f, "
2126 "orientation=%f",
Siarhei Vishniakou09a8fe42022-07-21 17:27:03 -07002127 i, entry.pointerProperties[i].id,
2128 ftl::enum_string(entry.pointerProperties[i].toolType).c_str(),
Prabir Pradhan61a5d242021-07-26 16:41:09 +00002129 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_X),
2130 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_Y),
2131 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_PRESSURE),
2132 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_SIZE),
2133 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR),
2134 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR),
2135 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR),
2136 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR),
2137 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION));
2138 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002139 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002140}
2141
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07002142void InputDispatcher::dispatchEventLocked(nsecs_t currentTime,
Prabir Pradhan24047542023-11-02 17:14:59 +00002143 std::shared_ptr<const EventEntry> eventEntry,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002144 const std::vector<InputTarget>& inputTargets) {
Michael Wright3dd60e22019-03-27 22:06:44 +00002145 ATRACE_CALL();
Prabir Pradhan61a5d242021-07-26 16:41:09 +00002146 if (DEBUG_DISPATCH_CYCLE) {
2147 ALOGD("dispatchEventToCurrentInputTargets");
2148 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002149
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00002150 processInteractionsLocked(*eventEntry, inputTargets);
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00002151
Michael Wrightd02c5b62014-02-10 15:10:22 -08002152 ALOG_ASSERT(eventEntry->dispatchInProgress); // should already have been set to true
2153
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002154 pokeUserActivityLocked(*eventEntry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002155
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08002156 for (const InputTarget& inputTarget : inputTargets) {
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08002157 std::shared_ptr<Connection> connection = inputTarget.connection;
2158 prepareDispatchCycleLocked(currentTime, connection, eventEntry, inputTarget);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002159 }
2160}
2161
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07002162void InputDispatcher::cancelEventsForAnrLocked(const std::shared_ptr<Connection>& connection) {
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002163 // We will not be breaking any connections here, even if the policy wants us to abort dispatch.
2164 // If the policy decides to close the app, we will get a channel removal event via
2165 // unregisterInputChannel, and will clean up the connection that way. We are already not
2166 // sending new pointers to the connection when it blocked, but focused events will continue to
2167 // pile up.
2168 ALOGW("Canceling events for %s because it is unresponsive",
Siarhei Vishniakou10bfdc92024-02-01 11:12:57 -08002169 connection->getInputChannelName().c_str());
Prabir Pradhanfc364722024-02-08 17:51:20 +00002170 if (connection->status != Connection::Status::NORMAL) {
2171 return;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002172 }
Prabir Pradhand6b2b052024-02-21 23:25:15 +00002173 ScopedSyntheticEventTracer traceContext(mTracer);
Prabir Pradhanfc364722024-02-08 17:51:20 +00002174 CancelationOptions options(CancelationOptions::Mode::CANCEL_ALL_EVENTS,
Prabir Pradhand6b2b052024-02-21 23:25:15 +00002175 "application not responding", traceContext.getTracker());
Prabir Pradhanfc364722024-02-08 17:51:20 +00002176
2177 sp<WindowInfoHandle> windowHandle;
2178 if (!connection->monitor) {
2179 windowHandle = getWindowHandleLocked(connection->getToken());
2180 if (windowHandle == nullptr) {
2181 // The window that is receiving this ANR was removed, so there is no need to generate
2182 // cancellations, because the cancellations would have already been generated when
2183 // the window was removed.
2184 return;
2185 }
2186 }
2187 synthesizeCancelationEventsForConnectionLocked(connection, options, windowHandle);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002188}
2189
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002190void InputDispatcher::resetNoFocusedWindowTimeoutLocked() {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01002191 if (DEBUG_FOCUS) {
2192 ALOGD("Resetting ANR timeouts.");
2193 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002194
2195 // Reset input target wait timeout.
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002196 mNoFocusedWindowTimeoutTime = std::nullopt;
Chris Yea209fde2020-07-22 13:54:51 -07002197 mAwaitedFocusedApplication.reset();
Michael Wrightd02c5b62014-02-10 15:10:22 -08002198}
2199
Tiger Huang721e26f2018-07-24 22:26:19 +08002200/**
2201 * Get the display id that the given event should go to. If this event specifies a valid display id,
2202 * then it should be dispatched to that display. Otherwise, the event goes to the focused display.
2203 * Focused display is the display that the user most recently interacted with.
2204 */
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002205int32_t InputDispatcher::getTargetDisplayId(const EventEntry& entry) {
Tiger Huang721e26f2018-07-24 22:26:19 +08002206 int32_t displayId;
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002207 switch (entry.type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07002208 case EventEntry::Type::KEY: {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002209 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(entry);
2210 displayId = keyEntry.displayId;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002211 break;
2212 }
Siarhei Vishniakou49483272019-10-22 13:13:47 -07002213 case EventEntry::Type::MOTION: {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002214 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(entry);
2215 displayId = motionEntry.displayId;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002216 break;
2217 }
Antonio Kantekf16f2832021-09-28 04:39:20 +00002218 case EventEntry::Type::TOUCH_MODE_CHANGED:
Prabir Pradhan99987712020-11-10 18:43:05 -08002219 case EventEntry::Type::POINTER_CAPTURE_CHANGED:
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01002220 case EventEntry::Type::FOCUS:
Siarhei Vishniakou49483272019-10-22 13:13:47 -07002221 case EventEntry::Type::CONFIGURATION_CHANGED:
Chris Yef59a2f42020-10-16 12:55:26 -07002222 case EventEntry::Type::DEVICE_RESET:
arthurhungb89ccb02020-12-30 16:19:01 +08002223 case EventEntry::Type::SENSOR:
2224 case EventEntry::Type::DRAG: {
Dominik Laskowski75788452021-02-09 18:51:25 -08002225 ALOGE("%s events do not have a target display", ftl::enum_string(entry.type).c_str());
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002226 return ADISPLAY_ID_NONE;
2227 }
Tiger Huang721e26f2018-07-24 22:26:19 +08002228 }
2229 return displayId == ADISPLAY_ID_NONE ? mFocusedDisplayId : displayId;
2230}
2231
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002232bool InputDispatcher::shouldWaitToSendKeyLocked(nsecs_t currentTime,
2233 const char* focusedWindowName) {
2234 if (mAnrTracker.empty()) {
2235 // already processed all events that we waited for
2236 mKeyIsWaitingForEventsTimeout = std::nullopt;
2237 return false;
2238 }
2239
2240 if (!mKeyIsWaitingForEventsTimeout.has_value()) {
2241 // Start the timer
Siarhei Vishniakoud706a282021-02-13 00:08:48 +00002242 // Wait to send key because there are unprocessed events that may cause focus to change
Siarhei Vishniakou70622952020-07-30 11:17:23 -05002243 mKeyIsWaitingForEventsTimeout = currentTime +
Siarhei Vishniakouef2b4502023-12-28 11:51:47 -08002244 std::chrono::duration_cast<std::chrono::nanoseconds>(
2245 mPolicy.getKeyWaitingForEventsTimeout())
Siarhei Vishniakou70622952020-07-30 11:17:23 -05002246 .count();
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002247 return true;
2248 }
2249
2250 // We still have pending events, and already started the timer
2251 if (currentTime < *mKeyIsWaitingForEventsTimeout) {
2252 return true; // Still waiting
2253 }
2254
2255 // Waited too long, and some connection still hasn't processed all motions
2256 // Just send the key to the focused window
2257 ALOGW("Dispatching key to %s even though there are other unprocessed events",
2258 focusedWindowName);
2259 mKeyIsWaitingForEventsTimeout = std::nullopt;
2260 return false;
2261}
2262
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002263sp<WindowInfoHandle> InputDispatcher::findFocusedWindowTargetLocked(
Siarhei Vishniakou69505962023-12-28 12:07:04 -08002264 nsecs_t currentTime, const EventEntry& entry, nsecs_t& nextWakeupTime,
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002265 InputEventInjectionResult& outInjectionResult) {
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002266 outInjectionResult = InputEventInjectionResult::FAILED; // Default result
Michael Wrightd02c5b62014-02-10 15:10:22 -08002267
Tiger Huang721e26f2018-07-24 22:26:19 +08002268 int32_t displayId = getTargetDisplayId(entry);
chaviw98318de2021-05-19 16:45:23 -05002269 sp<WindowInfoHandle> focusedWindowHandle = getFocusedWindowHandleLocked(displayId);
Chris Yea209fde2020-07-22 13:54:51 -07002270 std::shared_ptr<InputApplicationHandle> focusedApplicationHandle =
Tiger Huang721e26f2018-07-24 22:26:19 +08002271 getValueByKey(mFocusedApplicationHandlesByDisplay, displayId);
2272
Michael Wrightd02c5b62014-02-10 15:10:22 -08002273 // If there is no currently focused window and no focused application
2274 // then drop the event.
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002275 if (focusedWindowHandle == nullptr && focusedApplicationHandle == nullptr) {
2276 ALOGI("Dropping %s event because there is no focused window or focused application in "
2277 "display %" PRId32 ".",
Dominik Laskowski75788452021-02-09 18:51:25 -08002278 ftl::enum_string(entry.type).c_str(), displayId);
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002279 return nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002280 }
2281
Vishnu Nair062a8672021-09-03 16:07:44 -07002282 // Drop key events if requested by input feature
2283 if (focusedWindowHandle != nullptr && shouldDropInput(entry, focusedWindowHandle)) {
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002284 return nullptr;
Vishnu Nair062a8672021-09-03 16:07:44 -07002285 }
2286
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002287 // Compatibility behavior: raise ANR if there is a focused application, but no focused window.
2288 // Only start counting when we have a focused event to dispatch. The ANR is canceled if we
2289 // start interacting with another application via touch (app switch). This code can be removed
2290 // if the "no focused window ANR" is moved to the policy. Input doesn't know whether
2291 // an app is expected to have a focused window.
2292 if (focusedWindowHandle == nullptr && focusedApplicationHandle != nullptr) {
2293 if (!mNoFocusedWindowTimeoutTime.has_value()) {
2294 // We just discovered that there's no focused window. Start the ANR timer
Siarhei Vishniakouc1ae5562020-06-30 14:22:57 -05002295 std::chrono::nanoseconds timeout = focusedApplicationHandle->getDispatchingTimeout(
2296 DEFAULT_INPUT_DISPATCHING_TIMEOUT);
2297 mNoFocusedWindowTimeoutTime = currentTime + timeout.count();
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002298 mAwaitedFocusedApplication = focusedApplicationHandle;
Siarhei Vishniakouf56b2692020-09-08 19:43:33 -05002299 mAwaitedApplicationDisplayId = displayId;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002300 ALOGW("Waiting because no window has focus but %s may eventually add a "
2301 "window when it finishes starting up. Will wait for %" PRId64 "ms",
Siarhei Vishniakouc1ae5562020-06-30 14:22:57 -05002302 mAwaitedFocusedApplication->getName().c_str(), millis(timeout));
Siarhei Vishniakou69505962023-12-28 12:07:04 -08002303 nextWakeupTime = std::min(nextWakeupTime, *mNoFocusedWindowTimeoutTime);
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002304 outInjectionResult = InputEventInjectionResult::PENDING;
2305 return nullptr;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002306 } else if (currentTime > *mNoFocusedWindowTimeoutTime) {
2307 // Already raised ANR. Drop the event
2308 ALOGE("Dropping %s event because there is no focused window",
Dominik Laskowski75788452021-02-09 18:51:25 -08002309 ftl::enum_string(entry.type).c_str());
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002310 return nullptr;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002311 } else {
2312 // Still waiting for the focused window
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002313 outInjectionResult = InputEventInjectionResult::PENDING;
2314 return nullptr;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002315 }
2316 }
2317
2318 // we have a valid, non-null focused window
2319 resetNoFocusedWindowTimeoutLocked();
2320
Prabir Pradhan5735a322022-04-11 17:23:34 +00002321 // Verify targeted injection.
2322 if (const auto err = verifyTargetedInjection(focusedWindowHandle, entry); err) {
2323 ALOGW("Dropping injected event: %s", (*err).c_str());
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002324 outInjectionResult = InputEventInjectionResult::TARGET_MISMATCH;
2325 return nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002326 }
2327
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08002328 if (focusedWindowHandle->getInfo()->inputConfig.test(
2329 WindowInfo::InputConfig::PAUSE_DISPATCHING)) {
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002330 ALOGI("Waiting because %s is paused", focusedWindowHandle->getName().c_str());
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002331 outInjectionResult = InputEventInjectionResult::PENDING;
2332 return nullptr;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002333 }
2334
2335 // If the event is a key event, then we must wait for all previous events to
2336 // complete before delivering it because previous events may have the
2337 // side-effect of transferring focus to a different window and we want to
2338 // ensure that the following keys are sent to the new window.
2339 //
2340 // Suppose the user touches a button in a window then immediately presses "A".
2341 // If the button causes a pop-up window to appear then we want to ensure that
2342 // the "A" key is delivered to the new pop-up window. This is because users
2343 // often anticipate pending UI changes when typing on a keyboard.
2344 // To obtain this behavior, we must serialize key events with respect to all
2345 // prior input events.
2346 if (entry.type == EventEntry::Type::KEY) {
2347 if (shouldWaitToSendKeyLocked(currentTime, focusedWindowHandle->getName().c_str())) {
Siarhei Vishniakou69505962023-12-28 12:07:04 -08002348 nextWakeupTime = std::min(nextWakeupTime, *mKeyIsWaitingForEventsTimeout);
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002349 outInjectionResult = InputEventInjectionResult::PENDING;
2350 return nullptr;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002351 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002352 }
2353
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002354 outInjectionResult = InputEventInjectionResult::SUCCEEDED;
2355 return focusedWindowHandle;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002356}
2357
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002358/**
2359 * Given a list of monitors, remove the ones we cannot find a connection for, and the ones
2360 * that are currently unresponsive.
2361 */
Prabir Pradhan0a99c922021-09-03 08:27:53 -07002362std::vector<Monitor> InputDispatcher::selectResponsiveMonitorsLocked(
2363 const std::vector<Monitor>& monitors) const {
2364 std::vector<Monitor> responsiveMonitors;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002365 std::copy_if(monitors.begin(), monitors.end(), std::back_inserter(responsiveMonitors),
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08002366 [](const Monitor& monitor) REQUIRES(mLock) {
2367 std::shared_ptr<Connection> connection = monitor.connection;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002368 if (!connection->responsive) {
2369 ALOGW("Unresponsive monitor %s will not get the new gesture",
Siarhei Vishniakou10bfdc92024-02-01 11:12:57 -08002370 connection->getInputChannelName().c_str());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002371 return false;
2372 }
2373 return true;
2374 });
2375 return responsiveMonitors;
2376}
2377
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002378std::vector<InputTarget> InputDispatcher::findTouchedWindowTargetsLocked(
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002379 nsecs_t currentTime, const MotionEntry& entry,
Siarhei Vishniakou4fe57392022-10-25 13:44:30 -07002380 InputEventInjectionResult& outInjectionResult) {
Michael Wright3dd60e22019-03-27 22:06:44 +00002381 ATRACE_CALL();
Michael Wrightd02c5b62014-02-10 15:10:22 -08002382
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002383 std::vector<InputTarget> targets;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002384 // For security reasons, we defer updating the touch state until we are sure that
2385 // event injection will be allowed.
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002386 const int32_t displayId = entry.displayId;
2387 const int32_t action = entry.action;
Siarhei Vishniakoubf880522023-05-01 11:03:22 -07002388 const int32_t maskedAction = MotionEvent::getActionMasked(action);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002389
2390 // Update the touch state as needed based on the properties of the touch event.
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002391 outInjectionResult = InputEventInjectionResult::PENDING;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002392
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002393 // Copy current touch state into tempTouchState.
2394 // This state will be used to update mTouchStatesByDisplay at the end of this function.
2395 // If no state for the specified display exists, then our initial state will be empty.
Yi Kong9b14ac62018-07-17 13:48:38 -07002396 const TouchState* oldState = nullptr;
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002397 TouchState tempTouchState;
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002398 if (const auto it = mTouchStatesByDisplay.find(displayId); it != mTouchStatesByDisplay.end()) {
2399 oldState = &(it->second);
Prabir Pradhane680f9b2022-02-04 04:24:00 -08002400 tempTouchState = *oldState;
Jeff Brownf086ddb2014-02-11 14:28:48 -08002401 }
2402
Siarhei Vishniakou64a98532022-10-25 15:20:24 -07002403 bool isSplit = shouldSplitTouch(tempTouchState, entry);
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002404
2405 const bool isHoverAction = (maskedAction == AMOTION_EVENT_ACTION_HOVER_MOVE ||
2406 maskedAction == AMOTION_EVENT_ACTION_HOVER_ENTER ||
2407 maskedAction == AMOTION_EVENT_ACTION_HOVER_EXIT);
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002408 // A DOWN could be generated from POINTER_DOWN if the initial pointers did not land into any
2409 // touchable windows.
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002410 const bool wasDown = oldState != nullptr && oldState->isDown(entry.deviceId);
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002411 const bool isDown = (maskedAction == AMOTION_EVENT_ACTION_DOWN) ||
2412 (maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN && !wasDown);
Siarhei Vishniakoua235c042023-05-02 09:59:09 -07002413 const bool newGesture = isDown || maskedAction == AMOTION_EVENT_ACTION_SCROLL ||
2414 maskedAction == AMOTION_EVENT_ACTION_HOVER_ENTER ||
2415 maskedAction == AMOTION_EVENT_ACTION_HOVER_MOVE;
Prabir Pradhanaa561d12021-09-24 06:57:33 -07002416 const bool isFromMouse = isFromSource(entry.source, AINPUT_SOURCE_MOUSE);
Siarhei Vishniakou5cee1e32022-11-29 12:35:39 -08002417
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002418 if (newGesture) {
2419 isSplit = false;
Siarhei Vishniakouf372b812023-02-14 18:06:51 -08002420 }
2421
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002422 if (isDown && tempTouchState.hasHoveringPointers(entry.deviceId)) {
2423 // Compatibility behaviour: ACTION_DOWN causes HOVER_EXIT to get generated.
2424 tempTouchState.clearHoveringPointers(entry.deviceId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002425 }
2426
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +00002427 if (isHoverAction) {
Siarhei Vishniakou7be50c92023-11-17 17:09:08 -08002428 if (wasDown) {
2429 // Started hovering, but the device is already down: reject the hover event
2430 LOG(ERROR) << "Got hover event " << entry.getDescription()
2431 << " but the device is already down " << oldState->dump();
2432 outInjectionResult = InputEventInjectionResult::FAILED;
2433 return {};
2434 }
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +00002435 // For hover actions, we will treat 'tempTouchState' as a new state, so let's erase
2436 // all of the existing hovering pointers and recompute.
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002437 tempTouchState.clearHoveringPointers(entry.deviceId);
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +00002438 }
2439
Michael Wrightd02c5b62014-02-10 15:10:22 -08002440 if (newGesture || (isSplit && maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN)) {
2441 /* Case 1: New splittable pointer going down, or need target for hover or scroll. */
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07002442 const auto [x, y] = resolveTouchedPosition(entry);
Siarhei Vishniakou5b9766d2023-07-18 14:06:29 -07002443 const int32_t pointerIndex = MotionEvent::getActionIndex(action);
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -08002444 const PointerProperties& pointer = entry.pointerProperties[pointerIndex];
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002445 // Outside targets should be added upon first dispatched DOWN event. That means, this should
2446 // be a pointer that would generate ACTION_DOWN, *and* touch should not already be down.
Prabir Pradhand65552b2021-10-07 11:23:50 -07002447 const bool isStylus = isPointerFromStylus(entry, pointerIndex);
Siarhei Vishniakoue1ada272022-11-03 10:47:08 -07002448 sp<WindowInfoHandle> newTouchedWindowHandle =
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002449 findTouchedWindowAtLocked(displayId, x, y, isStylus);
Michael Wright3dd60e22019-03-27 22:06:44 +00002450
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002451 if (isDown) {
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -08002452 targets += findOutsideTargetsLocked(displayId, newTouchedWindowHandle, pointer.id);
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002453 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002454 // Handle the case where we did not find a window.
Yi Kong9b14ac62018-07-17 13:48:38 -07002455 if (newTouchedWindowHandle == nullptr) {
Prabir Pradhan82e081e2022-12-06 09:50:09 +00002456 ALOGD("No new touched window at (%.1f, %.1f) in display %" PRId32, x, y, displayId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002457 // Try to assign the pointer to the first foreground window we find, if there is one.
Linnan Liccf6ce32024-04-11 20:32:13 +08002458 newTouchedWindowHandle = tempTouchState.getFirstForegroundWindowHandle(entry.deviceId);
Michael Wright3dd60e22019-03-27 22:06:44 +00002459 }
2460
Prabir Pradhan5735a322022-04-11 17:23:34 +00002461 // Verify targeted injection.
2462 if (const auto err = verifyTargetedInjection(newTouchedWindowHandle, entry); err) {
2463 ALOGW("Dropping injected touch event: %s", (*err).c_str());
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002464 outInjectionResult = os::InputEventInjectionResult::TARGET_MISMATCH;
Prabir Pradhan5735a322022-04-11 17:23:34 +00002465 newTouchedWindowHandle = nullptr;
Siarhei Vishniakou8619eb32022-12-01 21:30:59 -08002466 return {};
Prabir Pradhan5735a322022-04-11 17:23:34 +00002467 }
2468
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002469 // Figure out whether splitting will be allowed for this window.
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002470 if (newTouchedWindowHandle != nullptr) {
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002471 if (newTouchedWindowHandle->getInfo()->supportsSplitTouch()) {
2472 // New window supports splitting, but we should never split mouse events.
2473 isSplit = !isFromMouse;
2474 } else if (isSplit) {
2475 // New window does not support splitting but we have already split events.
2476 // Ignore the new window.
Siarhei Vishniakou25537f82023-07-18 14:35:47 -07002477 LOG(INFO) << "Skipping " << newTouchedWindowHandle->getName()
2478 << " because it doesn't support split touch";
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002479 newTouchedWindowHandle = nullptr;
2480 }
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002481 } else {
2482 // No window is touched, so set split to true. This will allow the next pointer down to
Prabir Pradhan713bb3e2021-12-20 02:07:40 -08002483 // be delivered to a new window which supports split touch. Pointers from a mouse device
2484 // should never be split.
Siarhei Vishniakou64a98532022-10-25 15:20:24 -07002485 isSplit = !isFromMouse;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002486 }
2487
Prabir Pradhan07e05b62021-11-19 03:57:24 -08002488 std::vector<sp<WindowInfoHandle>> newTouchedWindows =
Prabir Pradhand65552b2021-10-07 11:23:50 -07002489 findTouchedSpyWindowsAtLocked(displayId, x, y, isStylus);
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002490 if (newTouchedWindowHandle != nullptr) {
Prabir Pradhan07e05b62021-11-19 03:57:24 -08002491 // Process the foreground window first so that it is the first to receive the event.
2492 newTouchedWindows.insert(newTouchedWindows.begin(), newTouchedWindowHandle);
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002493 }
2494
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002495 if (newTouchedWindows.empty()) {
Prabir Pradhan82e081e2022-12-06 09:50:09 +00002496 ALOGI("Dropping event because there is no touchable window at (%.1f, %.1f) on display "
2497 "%d.",
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002498 x, y, displayId);
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002499 outInjectionResult = InputEventInjectionResult::FAILED;
Siarhei Vishniakou8619eb32022-12-01 21:30:59 -08002500 return {};
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002501 }
2502
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002503 for (const sp<WindowInfoHandle>& windowHandle : newTouchedWindows) {
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07002504 if (!canWindowReceiveMotionLocked(windowHandle, entry)) {
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002505 continue;
2506 }
2507
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002508 if (isHoverAction) {
Siarhei Vishniakoub681c202023-05-01 11:22:33 -07002509 // The "windowHandle" is the target of this hovering pointer.
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -08002510 tempTouchState.addHoveringPointerToWindow(windowHandle, entry.deviceId, pointer);
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +00002511 }
2512
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002513 // Set target flags.
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00002514 ftl::Flags<InputTarget::Flags> targetFlags;
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002515
Prabir Pradhan6dfbf262022-03-14 15:24:30 +00002516 if (canReceiveForegroundTouches(*windowHandle->getInfo())) {
2517 // There should only be one touched window that can be "foreground" for the pointer.
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002518 targetFlags |= InputTarget::Flags::FOREGROUND;
Prabir Pradhan07e05b62021-11-19 03:57:24 -08002519 }
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002520
2521 if (isSplit) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002522 targetFlags |= InputTarget::Flags::SPLIT;
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002523 }
2524 if (isWindowObscuredAtPointLocked(windowHandle, x, y)) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002525 targetFlags |= InputTarget::Flags::WINDOW_IS_OBSCURED;
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002526 } else if (isWindowObscuredLocked(windowHandle)) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002527 targetFlags |= InputTarget::Flags::WINDOW_IS_PARTIALLY_OBSCURED;
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002528 }
Michael Wright3dd60e22019-03-27 22:06:44 +00002529
2530 // Update the temporary touch state.
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002531
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +00002532 if (!isHoverAction) {
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002533 const bool isDownOrPointerDown = maskedAction == AMOTION_EVENT_ACTION_DOWN ||
2534 maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN;
Siarhei Vishniakoue535f972024-03-29 14:55:21 -07002535 Result<void> addResult =
2536 tempTouchState.addOrUpdateWindow(windowHandle,
2537 InputTarget::DispatchMode::AS_IS,
2538 targetFlags, entry.deviceId, {pointer},
2539 isDownOrPointerDown
2540 ? std::make_optional(
2541 entry.eventTime)
2542 : std::nullopt);
2543 if (!addResult.ok()) {
2544 LOG(ERROR) << "Error while processing " << entry << " for "
2545 << windowHandle->getName();
2546 logDispatchStateLocked();
2547 }
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002548 // If this is the pointer going down and the touched window has a wallpaper
2549 // then also add the touched wallpaper windows so they are locked in for the
2550 // duration of the touch gesture. We do not collect wallpapers during HOVER_MOVE or
2551 // SCROLL because the wallpaper engine only supports touch events. We would need to
2552 // add a mechanism similar to View.onGenericMotionEvent to enable wallpapers to
2553 // handle these events.
2554 if (isDownOrPointerDown && targetFlags.test(InputTarget::Flags::FOREGROUND) &&
Arthur Hungc539dbb2022-12-08 07:45:36 +00002555 windowHandle->getInfo()->inputConfig.test(
2556 gui::WindowInfo::InputConfig::DUPLICATE_TOUCH_TO_WALLPAPER)) {
2557 sp<WindowInfoHandle> wallpaper = findWallpaperWindowBelow(windowHandle);
2558 if (wallpaper != nullptr) {
2559 ftl::Flags<InputTarget::Flags> wallpaperFlags =
2560 InputTarget::Flags::WINDOW_IS_OBSCURED |
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00002561 InputTarget::Flags::WINDOW_IS_PARTIALLY_OBSCURED;
Arthur Hungc539dbb2022-12-08 07:45:36 +00002562 if (isSplit) {
2563 wallpaperFlags |= InputTarget::Flags::SPLIT;
2564 }
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00002565 tempTouchState.addOrUpdateWindow(wallpaper,
2566 InputTarget::DispatchMode::AS_IS,
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -08002567 wallpaperFlags, entry.deviceId, {pointer},
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00002568 entry.eventTime);
Arthur Hungc539dbb2022-12-08 07:45:36 +00002569 }
2570 }
2571 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002572 }
Vaibhav Devmurariff798f32022-05-09 23:45:04 +00002573
Siarhei Vishniakou060f82b2023-01-27 06:39:14 -08002574 // If a window is already pilfering some pointers, give it this new pointer as well and
2575 // make it pilfering. This will prevent other non-spy windows from getting this pointer,
2576 // which is a specific behaviour that we want.
Siarhei Vishniakou060f82b2023-01-27 06:39:14 -08002577 for (TouchedWindow& touchedWindow : tempTouchState.windows) {
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -08002578 if (touchedWindow.hasTouchingPointer(entry.deviceId, pointer.id) &&
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07002579 touchedWindow.hasPilferingPointers(entry.deviceId)) {
Siarhei Vishniakou060f82b2023-01-27 06:39:14 -08002580 // This window is already pilfering some pointers, and this new pointer is also
2581 // going to it. Therefore, take over this pointer and don't give it to anyone
2582 // else.
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -08002583 touchedWindow.addPilferingPointer(entry.deviceId, pointer.id);
Vaibhav Devmurariff798f32022-05-09 23:45:04 +00002584 }
2585 }
Siarhei Vishniakou060f82b2023-01-27 06:39:14 -08002586
2587 // Restrict all pilfered pointers to the pilfering windows.
2588 tempTouchState.cancelPointersForNonPilferingWindows();
Michael Wrightd02c5b62014-02-10 15:10:22 -08002589 } else {
2590 /* Case 2: Pointer move, up, cancel or non-splittable pointer down. */
2591
2592 // If the pointer is not currently down, then ignore the event.
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002593 if (!tempTouchState.isDown(entry.deviceId) &&
2594 maskedAction != AMOTION_EVENT_ACTION_HOVER_EXIT) {
Siarhei Vishniakou31dd1552023-10-30 18:46:10 -07002595 if (DEBUG_DROPPED_EVENTS_VERBOSE) {
2596 LOG(INFO) << "Dropping event because the pointer for device " << entry.deviceId
2597 << " is not down or we previously dropped the pointer down event in "
2598 << "display " << displayId << ": " << entry.getDescription();
2599 }
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002600 outInjectionResult = InputEventInjectionResult::FAILED;
Siarhei Vishniakou8619eb32022-12-01 21:30:59 -08002601 return {};
Michael Wrightd02c5b62014-02-10 15:10:22 -08002602 }
2603
Siarhei Vishniakoua235c042023-05-02 09:59:09 -07002604 // If the pointer is not currently hovering, then ignore the event.
2605 if (maskedAction == AMOTION_EVENT_ACTION_HOVER_EXIT) {
2606 const int32_t pointerId = entry.pointerProperties[0].id;
2607 if (oldState == nullptr ||
2608 oldState->getWindowsWithHoveringPointer(entry.deviceId, pointerId).empty()) {
2609 LOG(INFO) << "Dropping event because the hovering pointer is not in any windows in "
2610 "display "
2611 << displayId << ": " << entry.getDescription();
2612 outInjectionResult = InputEventInjectionResult::FAILED;
2613 return {};
2614 }
2615 tempTouchState.removeHoveringPointer(entry.deviceId, pointerId);
2616 }
2617
arthurhung6d4bed92021-03-17 11:59:33 +08002618 addDragEventLocked(entry);
arthurhungb89ccb02020-12-30 16:19:01 +08002619
Michael Wrightd02c5b62014-02-10 15:10:22 -08002620 // Check whether touches should slip outside of the current foreground window.
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07002621 if (maskedAction == AMOTION_EVENT_ACTION_MOVE && entry.getPointerCount() == 1 &&
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002622 tempTouchState.isSlippery()) {
Siarhei Vishniakou9306c382022-09-30 15:30:31 -07002623 const auto [x, y] = resolveTouchedPosition(entry);
Harry Cutts33476232023-01-30 19:57:29 +00002624 const bool isStylus = isPointerFromStylus(entry, /*pointerIndex=*/0);
chaviw98318de2021-05-19 16:45:23 -05002625 sp<WindowInfoHandle> oldTouchedWindowHandle =
Linnan Liccf6ce32024-04-11 20:32:13 +08002626 tempTouchState.getFirstForegroundWindowHandle(entry.deviceId);
Siarhei Vishniakou0f6558d2023-04-21 12:05:13 -07002627 LOG_ALWAYS_FATAL_IF(oldTouchedWindowHandle == nullptr);
Siarhei Vishniakoue1ada272022-11-03 10:47:08 -07002628 sp<WindowInfoHandle> newTouchedWindowHandle =
2629 findTouchedWindowAtLocked(displayId, x, y, isStylus);
Vishnu Nair062a8672021-09-03 16:07:44 -07002630
Prabir Pradhan5735a322022-04-11 17:23:34 +00002631 // Verify targeted injection.
2632 if (const auto err = verifyTargetedInjection(newTouchedWindowHandle, entry); err) {
2633 ALOGW("Dropping injected event: %s", (*err).c_str());
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002634 outInjectionResult = os::InputEventInjectionResult::TARGET_MISMATCH;
Siarhei Vishniakou8619eb32022-12-01 21:30:59 -08002635 return {};
Prabir Pradhan5735a322022-04-11 17:23:34 +00002636 }
2637
Linnan Libf069a32024-02-29 17:22:59 +00002638 // Do not slide events to the window which can not receive motion event
Vishnu Nair062a8672021-09-03 16:07:44 -07002639 if (newTouchedWindowHandle != nullptr &&
Linnan Libf069a32024-02-29 17:22:59 +00002640 !canWindowReceiveMotionLocked(newTouchedWindowHandle, entry)) {
Vishnu Nair062a8672021-09-03 16:07:44 -07002641 newTouchedWindowHandle = nullptr;
2642 }
2643
Siarhei Vishniakouafa08cc2023-05-08 22:35:50 -07002644 if (newTouchedWindowHandle != nullptr &&
2645 !haveSameToken(oldTouchedWindowHandle, newTouchedWindowHandle)) {
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002646 ALOGI("Touch is slipping out of window %s into window %s in display %" PRId32,
Siarhei Vishniakou0f6558d2023-04-21 12:05:13 -07002647 oldTouchedWindowHandle->getName().c_str(),
2648 newTouchedWindowHandle->getName().c_str(), displayId);
2649
Michael Wrightd02c5b62014-02-10 15:10:22 -08002650 // Make a slippery exit from the old window.
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08002651 std::bitset<MAX_POINTER_ID + 1> pointerIds;
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -08002652 const PointerProperties& pointer = entry.pointerProperties[0];
2653 pointerIds.set(pointer.id);
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002654
2655 const TouchedWindow& touchedWindow =
2656 tempTouchState.getTouchedWindow(oldTouchedWindowHandle);
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002657 addPointerWindowTargetLocked(oldTouchedWindowHandle,
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00002658 InputTarget::DispatchMode::SLIPPERY_EXIT,
2659 ftl::Flags<InputTarget::Flags>(), pointerIds,
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002660 touchedWindow.getDownTimeInTarget(entry.deviceId),
2661 targets);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002662
2663 // Make a slippery entrance into the new window.
2664 if (newTouchedWindowHandle->getInfo()->supportsSplitTouch()) {
Prabir Pradhan713bb3e2021-12-20 02:07:40 -08002665 isSplit = !isFromMouse;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002666 }
2667
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00002668 ftl::Flags<InputTarget::Flags> targetFlags;
Prabir Pradhan6dfbf262022-03-14 15:24:30 +00002669 if (canReceiveForegroundTouches(*newTouchedWindowHandle->getInfo())) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002670 targetFlags |= InputTarget::Flags::FOREGROUND;
Prabir Pradhan6dfbf262022-03-14 15:24:30 +00002671 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002672 if (isSplit) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002673 targetFlags |= InputTarget::Flags::SPLIT;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002674 }
2675 if (isWindowObscuredAtPointLocked(newTouchedWindowHandle, x, y)) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002676 targetFlags |= InputTarget::Flags::WINDOW_IS_OBSCURED;
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10002677 } else if (isWindowObscuredLocked(newTouchedWindowHandle)) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002678 targetFlags |= InputTarget::Flags::WINDOW_IS_PARTIALLY_OBSCURED;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002679 }
2680
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00002681 tempTouchState.addOrUpdateWindow(newTouchedWindowHandle,
2682 InputTarget::DispatchMode::SLIPPERY_ENTER,
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -08002683 targetFlags, entry.deviceId, {pointer},
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00002684 entry.eventTime);
Arthur Hungc539dbb2022-12-08 07:45:36 +00002685
2686 // Check if the wallpaper window should deliver the corresponding event.
2687 slipWallpaperTouch(targetFlags, oldTouchedWindowHandle, newTouchedWindowHandle,
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -08002688 tempTouchState, entry.deviceId, pointer, targets);
2689 tempTouchState.removeTouchingPointerFromWindow(entry.deviceId, pointer.id,
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07002690 oldTouchedWindowHandle);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002691 }
2692 }
Arthur Hung96483742022-11-15 03:30:48 +00002693
2694 // Update the pointerIds for non-splittable when it received pointer down.
2695 if (!isSplit && maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN) {
2696 // If no split, we suppose all touched windows should receive pointer down.
Siarhei Vishniakou5b9766d2023-07-18 14:06:29 -07002697 const int32_t pointerIndex = MotionEvent::getActionIndex(action);
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -08002698 std::vector<PointerProperties> touchingPointers{entry.pointerProperties[pointerIndex]};
2699 for (TouchedWindow& touchedWindow : tempTouchState.windows) {
Arthur Hung96483742022-11-15 03:30:48 +00002700 // Ignore drag window for it should just track one pointer.
2701 if (mDragState && mDragState->dragWindow == touchedWindow.windowHandle) {
2702 continue;
2703 }
Siarhei Vishniakou5b9766d2023-07-18 14:06:29 -07002704 touchedWindow.addTouchingPointers(entry.deviceId, touchingPointers);
Arthur Hung96483742022-11-15 03:30:48 +00002705 }
2706 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002707 }
2708
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002709 // Update dispatching for hover enter and exit.
Sam Dubeyf886dec2023-01-27 13:28:19 +00002710 {
2711 std::vector<TouchedWindow> hoveringWindows =
2712 getHoveringWindowsLocked(oldState, tempTouchState, entry);
Linnan Li41859c42024-03-05 16:20:34 +00002713 // Hardcode to single hovering pointer for now.
2714 std::bitset<MAX_POINTER_ID + 1> pointerIds;
2715 pointerIds.set(entry.pointerProperties[0].id);
Sam Dubeyf886dec2023-01-27 13:28:19 +00002716 for (const TouchedWindow& touchedWindow : hoveringWindows) {
Linnan Li41859c42024-03-05 16:20:34 +00002717 addPointerWindowTargetLocked(touchedWindow.windowHandle, touchedWindow.dispatchMode,
2718 touchedWindow.targetFlags, pointerIds,
2719 touchedWindow.getDownTimeInTarget(entry.deviceId),
2720 targets);
Sam Dubeyf886dec2023-01-27 13:28:19 +00002721 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002722 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002723
Prabir Pradhan5735a322022-04-11 17:23:34 +00002724 // Ensure that all touched windows are valid for injection.
2725 if (entry.injectionState != nullptr) {
2726 std::string errs;
2727 for (const TouchedWindow& touchedWindow : tempTouchState.windows) {
Prabir Pradhan5735a322022-04-11 17:23:34 +00002728 const auto err = verifyTargetedInjection(touchedWindow.windowHandle, entry);
2729 if (err) errs += "\n - " + *err;
2730 }
2731 if (!errs.empty()) {
2732 ALOGW("Dropping targeted injection: At least one touched window is not owned by uid "
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00002733 "%s:%s",
2734 entry.injectionState->targetUid->toString().c_str(), errs.c_str());
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002735 outInjectionResult = InputEventInjectionResult::TARGET_MISMATCH;
Siarhei Vishniakou8619eb32022-12-01 21:30:59 -08002736 return {};
Prabir Pradhan5735a322022-04-11 17:23:34 +00002737 }
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002738 }
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002739
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002740 // Check whether windows listening for outside touches are owned by the same UID. If the owner
2741 // has a different UID, then we will not reveal coordinate information to this window.
Michael Wrightd02c5b62014-02-10 15:10:22 -08002742 if (maskedAction == AMOTION_EVENT_ACTION_DOWN) {
chaviw98318de2021-05-19 16:45:23 -05002743 sp<WindowInfoHandle> foregroundWindowHandle =
Linnan Liccf6ce32024-04-11 20:32:13 +08002744 tempTouchState.getFirstForegroundWindowHandle(entry.deviceId);
Michael Wright3dd60e22019-03-27 22:06:44 +00002745 if (foregroundWindowHandle) {
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00002746 const auto foregroundWindowUid = foregroundWindowHandle->getInfo()->ownerUid;
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002747 for (InputTarget& target : targets) {
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00002748 if (target.dispatchMode == InputTarget::DispatchMode::OUTSIDE) {
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002749 sp<WindowInfoHandle> targetWindow =
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08002750 getWindowHandleLocked(target.connection->getToken());
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002751 if (targetWindow->getInfo()->ownerUid != foregroundWindowUid) {
2752 target.flags |= InputTarget::Flags::ZERO_COORDS;
Michael Wright3dd60e22019-03-27 22:06:44 +00002753 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002754 }
2755 }
2756 }
2757 }
2758
Harry Cuttsb166c002023-05-09 13:06:05 +00002759 // If this is a touchpad navigation gesture, it needs to only be sent to trusted targets, as we
2760 // only want the system UI to handle these gestures.
2761 const bool isTouchpadNavGesture = isFromSource(entry.source, AINPUT_SOURCE_MOUSE) &&
2762 entry.classification == MotionClassification::MULTI_FINGER_SWIPE;
2763 if (isTouchpadNavGesture) {
2764 filterUntrustedTargets(/* byref */ tempTouchState, /* byref */ targets);
2765 }
2766
Siarhei Vishniakoua235c042023-05-02 09:59:09 -07002767 // Output targets from the touch state.
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002768 for (const TouchedWindow& touchedWindow : tempTouchState.windows) {
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -08002769 std::vector<PointerProperties> touchingPointers =
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002770 touchedWindow.getTouchingPointers(entry.deviceId);
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -08002771 if (touchingPointers.empty()) {
Siarhei Vishniakoue0431e42023-01-28 17:01:39 -08002772 continue;
2773 }
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00002774 addPointerWindowTargetLocked(touchedWindow.windowHandle, touchedWindow.dispatchMode,
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -08002775 touchedWindow.targetFlags, getPointerIds(touchingPointers),
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002776 touchedWindow.getDownTimeInTarget(entry.deviceId), targets);
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +00002777 }
Sam Dubey39d37cf2022-12-07 18:05:35 +00002778
Siarhei Vishniakou580fb3a2023-05-05 15:02:20 -07002779 // During targeted injection, only allow owned targets to receive events
2780 std::erase_if(targets, [&](const InputTarget& target) {
2781 LOG_ALWAYS_FATAL_IF(target.windowHandle == nullptr);
2782 const auto err = verifyTargetedInjection(target.windowHandle, entry);
2783 if (err) {
2784 LOG(WARNING) << "Dropping injected event from " << target.windowHandle->getName()
2785 << ": " << (*err);
2786 return true;
2787 }
2788 return false;
2789 });
2790
Siarhei Vishniakoua235c042023-05-02 09:59:09 -07002791 if (targets.empty()) {
2792 LOG(INFO) << "Dropping event because no targets were found: " << entry.getDescription();
2793 outInjectionResult = InputEventInjectionResult::FAILED;
2794 return {};
2795 }
2796
2797 // If we only have windows getting ACTION_OUTSIDE, then drop the event, because there is no
2798 // window that is actually receiving the entire gesture.
2799 if (std::all_of(targets.begin(), targets.end(), [](const InputTarget& target) {
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00002800 return target.dispatchMode == InputTarget::DispatchMode::OUTSIDE;
Siarhei Vishniakoua235c042023-05-02 09:59:09 -07002801 })) {
2802 LOG(INFO) << "Dropping event because all windows would just receive ACTION_OUTSIDE: "
2803 << entry.getDescription();
2804 outInjectionResult = InputEventInjectionResult::FAILED;
2805 return {};
2806 }
2807
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +00002808 outInjectionResult = InputEventInjectionResult::SUCCEEDED;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002809
Prabir Pradhan502a7252023-12-01 16:11:24 +00002810 // Now that we have generated all of the input targets for this event, reset the dispatch
2811 // mode for all touched window to AS_IS.
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002812 for (TouchedWindow& touchedWindow : tempTouchState.windows) {
Prabir Pradhan502a7252023-12-01 16:11:24 +00002813 touchedWindow.dispatchMode = InputTarget::DispatchMode::AS_IS;
Siarhei Vishniakou79c32662022-10-25 17:56:25 -07002814 }
2815
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002816 // Update final pieces of touch state if the injector had permission.
Siarhei Vishniakou7be50c92023-11-17 17:09:08 -08002817 if (maskedAction == AMOTION_EVENT_ACTION_UP) {
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +00002818 // Pointer went up.
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07002819 tempTouchState.removeTouchingPointer(entry.deviceId, entry.pointerProperties[0].id);
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +00002820 } else if (maskedAction == AMOTION_EVENT_ACTION_CANCEL) {
Siarhei Vishniakou79c32662022-10-25 17:56:25 -07002821 // All pointers up or canceled.
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002822 tempTouchState.removeAllPointersForDevice(entry.deviceId);
Siarhei Vishniakou79c32662022-10-25 17:56:25 -07002823 } else if (maskedAction == AMOTION_EVENT_ACTION_POINTER_UP) {
2824 // One pointer went up.
Siarhei Vishniakou5b9766d2023-07-18 14:06:29 -07002825 const int32_t pointerIndex = MotionEvent::getActionIndex(action);
2826 const uint32_t pointerId = entry.pointerProperties[pointerIndex].id;
2827 tempTouchState.removeTouchingPointer(entry.deviceId, pointerId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002828 }
2829
Siarhei Vishniakou79c32662022-10-25 17:56:25 -07002830 // Save changes unless the action was scroll in which case the temporary touch
2831 // state was only valid for this one action.
2832 if (maskedAction != AMOTION_EVENT_ACTION_SCROLL) {
Siarhei Vishniakou40b8fbd2022-11-04 10:50:26 -07002833 if (displayId >= 0) {
Siarhei Vishniakouf372b812023-02-14 18:06:51 -08002834 tempTouchState.clearWindowsWithoutPointers();
Siarhei Vishniakou79c32662022-10-25 17:56:25 -07002835 mTouchStatesByDisplay[displayId] = tempTouchState;
2836 } else {
2837 mTouchStatesByDisplay.erase(displayId);
2838 }
2839 }
2840
Siarhei Vishniakou0b0374d2022-11-17 17:40:53 -08002841 if (tempTouchState.windows.empty()) {
2842 mTouchStatesByDisplay.erase(displayId);
2843 }
2844
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002845 return targets;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002846}
2847
arthurhung6d4bed92021-03-17 11:59:33 +08002848void InputDispatcher::finishDragAndDrop(int32_t displayId, float x, float y) {
Prabir Pradhand65552b2021-10-07 11:23:50 -07002849 // Prevent stylus interceptor windows from affecting drag and drop behavior for now, until we
2850 // have an explicit reason to support it.
2851 constexpr bool isStylus = false;
2852
Siarhei Vishniakoue1ada272022-11-03 10:47:08 -07002853 sp<WindowInfoHandle> dropWindow =
Harry Cutts33476232023-01-30 19:57:29 +00002854 findTouchedWindowAtLocked(displayId, x, y, isStylus, /*ignoreDragWindow=*/true);
arthurhung6d4bed92021-03-17 11:59:33 +08002855 if (dropWindow) {
2856 vec2 local = dropWindow->getInfo()->transform.transform(x, y);
Prabir Pradhancef936d2021-07-21 16:17:52 +00002857 sendDropWindowCommandLocked(dropWindow->getToken(), local.x, local.y);
Arthur Hung6d0571e2021-04-09 20:18:16 +08002858 } else {
Arthur Hung54745652022-04-20 07:17:41 +00002859 ALOGW("No window found when drop.");
Prabir Pradhancef936d2021-07-21 16:17:52 +00002860 sendDropWindowCommandLocked(nullptr, 0, 0);
arthurhung6d4bed92021-03-17 11:59:33 +08002861 }
2862 mDragState.reset();
2863}
2864
2865void InputDispatcher::addDragEventLocked(const MotionEntry& entry) {
Arthur Hung3915c1f2022-05-31 07:17:17 +00002866 if (!mDragState || mDragState->dragWindow->getInfo()->displayId != entry.displayId) {
arthurhungb89ccb02020-12-30 16:19:01 +08002867 return;
2868 }
2869
arthurhung6d4bed92021-03-17 11:59:33 +08002870 if (!mDragState->isStartDrag) {
2871 mDragState->isStartDrag = true;
2872 mDragState->isStylusButtonDownAtStart =
2873 (entry.buttonState & AMOTION_EVENT_BUTTON_STYLUS_PRIMARY) != 0;
2874 }
2875
Arthur Hung54745652022-04-20 07:17:41 +00002876 // Find the pointer index by id.
2877 int32_t pointerIndex = 0;
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07002878 for (; static_cast<uint32_t>(pointerIndex) < entry.getPointerCount(); pointerIndex++) {
Arthur Hung54745652022-04-20 07:17:41 +00002879 const PointerProperties& pointerProperties = entry.pointerProperties[pointerIndex];
2880 if (pointerProperties.id == mDragState->pointerId) {
2881 break;
arthurhung6d4bed92021-03-17 11:59:33 +08002882 }
Arthur Hung54745652022-04-20 07:17:41 +00002883 }
arthurhung6d4bed92021-03-17 11:59:33 +08002884
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07002885 if (uint32_t(pointerIndex) == entry.getPointerCount()) {
Arthur Hung54745652022-04-20 07:17:41 +00002886 LOG_ALWAYS_FATAL("Should find a valid pointer index by id %d", mDragState->pointerId);
Arthur Hung54745652022-04-20 07:17:41 +00002887 }
2888
2889 const int32_t maskedAction = entry.action & AMOTION_EVENT_ACTION_MASK;
2890 const int32_t x = entry.pointerCoords[pointerIndex].getX();
2891 const int32_t y = entry.pointerCoords[pointerIndex].getY();
2892
2893 switch (maskedAction) {
2894 case AMOTION_EVENT_ACTION_MOVE: {
2895 // Handle the special case : stylus button no longer pressed.
2896 bool isStylusButtonDown =
2897 (entry.buttonState & AMOTION_EVENT_BUTTON_STYLUS_PRIMARY) != 0;
2898 if (mDragState->isStylusButtonDownAtStart && !isStylusButtonDown) {
2899 finishDragAndDrop(entry.displayId, x, y);
2900 return;
2901 }
2902
2903 // Prevent stylus interceptor windows from affecting drag and drop behavior for now,
2904 // until we have an explicit reason to support it.
2905 constexpr bool isStylus = false;
2906
Siarhei Vishniakoue1ada272022-11-03 10:47:08 -07002907 sp<WindowInfoHandle> hoverWindowHandle =
2908 findTouchedWindowAtLocked(entry.displayId, x, y, isStylus,
2909 /*ignoreDragWindow=*/true);
Arthur Hung54745652022-04-20 07:17:41 +00002910 // enqueue drag exit if needed.
2911 if (hoverWindowHandle != mDragState->dragHoverWindowHandle &&
2912 !haveSameToken(hoverWindowHandle, mDragState->dragHoverWindowHandle)) {
2913 if (mDragState->dragHoverWindowHandle != nullptr) {
Harry Cutts33476232023-01-30 19:57:29 +00002914 enqueueDragEventLocked(mDragState->dragHoverWindowHandle, /*isExiting=*/true, x,
Arthur Hung54745652022-04-20 07:17:41 +00002915 y);
2916 }
2917 mDragState->dragHoverWindowHandle = hoverWindowHandle;
2918 }
2919 // enqueue drag location if needed.
2920 if (hoverWindowHandle != nullptr) {
Harry Cutts33476232023-01-30 19:57:29 +00002921 enqueueDragEventLocked(hoverWindowHandle, /*isExiting=*/false, x, y);
Arthur Hung54745652022-04-20 07:17:41 +00002922 }
2923 break;
2924 }
2925
2926 case AMOTION_EVENT_ACTION_POINTER_UP:
Siarhei Vishniakou5b9766d2023-07-18 14:06:29 -07002927 if (MotionEvent::getActionIndex(entry.action) != pointerIndex) {
Arthur Hung54745652022-04-20 07:17:41 +00002928 break;
2929 }
2930 // The drag pointer is up.
2931 [[fallthrough]];
2932 case AMOTION_EVENT_ACTION_UP:
2933 finishDragAndDrop(entry.displayId, x, y);
2934 break;
2935 case AMOTION_EVENT_ACTION_CANCEL: {
2936 ALOGD("Receiving cancel when drag and drop.");
2937 sendDropWindowCommandLocked(nullptr, 0, 0);
2938 mDragState.reset();
2939 break;
2940 }
arthurhungb89ccb02020-12-30 16:19:01 +08002941 }
2942}
2943
Siarhei Vishniakou6c377b32023-05-15 17:03:39 -07002944std::optional<InputTarget> InputDispatcher::createInputTargetLocked(
2945 const sp<android::gui::WindowInfoHandle>& windowHandle,
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00002946 InputTarget::DispatchMode dispatchMode, ftl::Flags<InputTarget::Flags> targetFlags,
Siarhei Vishniakou6c377b32023-05-15 17:03:39 -07002947 std::optional<nsecs_t> firstDownTimeInTarget) const {
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08002948 std::shared_ptr<Connection> connection = getConnectionLocked(windowHandle->getToken());
2949 if (connection == nullptr) {
Siarhei Vishniakou6c377b32023-05-15 17:03:39 -07002950 ALOGW("Not creating InputTarget for %s, no input channel", windowHandle->getName().c_str());
2951 return {};
2952 }
Prabir Pradhanc32a4112024-01-23 23:20:37 +00002953 InputTarget inputTarget{connection};
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00002954 inputTarget.windowHandle = windowHandle;
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00002955 inputTarget.dispatchMode = dispatchMode;
Siarhei Vishniakou6c377b32023-05-15 17:03:39 -07002956 inputTarget.flags = targetFlags;
2957 inputTarget.globalScaleFactor = windowHandle->getInfo()->globalScaleFactor;
2958 inputTarget.firstDownTimeInTarget = firstDownTimeInTarget;
2959 const auto& displayInfoIt = mDisplayInfos.find(windowHandle->getInfo()->displayId);
2960 if (displayInfoIt != mDisplayInfos.end()) {
2961 inputTarget.displayTransform = displayInfoIt->second.transform;
2962 } else {
Siarhei Vishniakou580fb3a2023-05-05 15:02:20 -07002963 // DisplayInfo not found for this window on display windowHandle->getInfo()->displayId.
Siarhei Vishniakou6c377b32023-05-15 17:03:39 -07002964 // TODO(b/198444055): Make this an error message after 'setInputWindows' API is removed.
2965 }
2966 return inputTarget;
2967}
2968
chaviw98318de2021-05-19 16:45:23 -05002969void InputDispatcher::addWindowTargetLocked(const sp<WindowInfoHandle>& windowHandle,
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00002970 InputTarget::DispatchMode dispatchMode,
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002971 ftl::Flags<InputTarget::Flags> targetFlags,
Vaibhav Devmurari882bd9b2022-06-23 14:54:54 +00002972 std::optional<nsecs_t> firstDownTimeInTarget,
Siarhei Vishniakouf75cddb2022-10-25 10:42:16 -07002973 std::vector<InputTarget>& inputTargets) const {
Chavi Weingarten65f98b82020-01-16 18:56:50 +00002974 std::vector<InputTarget>::iterator it =
2975 std::find_if(inputTargets.begin(), inputTargets.end(),
2976 [&windowHandle](const InputTarget& inputTarget) {
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08002977 return inputTarget.connection->getToken() == windowHandle->getToken();
Chavi Weingarten65f98b82020-01-16 18:56:50 +00002978 });
Chavi Weingarten97b8eec2020-01-09 18:09:08 +00002979
chaviw98318de2021-05-19 16:45:23 -05002980 const WindowInfo* windowInfo = windowHandle->getInfo();
Chavi Weingarten65f98b82020-01-16 18:56:50 +00002981
2982 if (it == inputTargets.end()) {
Siarhei Vishniakou6c377b32023-05-15 17:03:39 -07002983 std::optional<InputTarget> target =
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00002984 createInputTargetLocked(windowHandle, dispatchMode, targetFlags,
2985 firstDownTimeInTarget);
Siarhei Vishniakou6c377b32023-05-15 17:03:39 -07002986 if (!target) {
Chavi Weingarten65f98b82020-01-16 18:56:50 +00002987 return;
2988 }
Siarhei Vishniakou6c377b32023-05-15 17:03:39 -07002989 inputTargets.push_back(*target);
Chavi Weingarten65f98b82020-01-16 18:56:50 +00002990 it = inputTargets.end() - 1;
2991 }
2992
Siarhei Vishniakou23d73fb2023-10-29 13:27:46 -07002993 if (it->flags != targetFlags) {
2994 LOG(ERROR) << "Flags don't match! targetFlags=" << targetFlags.string() << ", it=" << *it;
2995 }
2996 if (it->globalScaleFactor != windowInfo->globalScaleFactor) {
2997 LOG(ERROR) << "Mismatch! it->globalScaleFactor=" << it->globalScaleFactor
2998 << ", windowInfo->globalScaleFactor=" << windowInfo->globalScaleFactor;
2999 }
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07003000}
3001
3002void InputDispatcher::addPointerWindowTargetLocked(
3003 const sp<android::gui::WindowInfoHandle>& windowHandle,
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00003004 InputTarget::DispatchMode dispatchMode, ftl::Flags<InputTarget::Flags> targetFlags,
3005 std::bitset<MAX_POINTER_ID + 1> pointerIds, std::optional<nsecs_t> firstDownTimeInTarget,
3006 std::vector<InputTarget>& inputTargets) const REQUIRES(mLock) {
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07003007 if (pointerIds.none()) {
3008 for (const auto& target : inputTargets) {
3009 LOG(INFO) << "Target: " << target;
3010 }
3011 LOG(FATAL) << "No pointers specified for " << windowHandle->getName();
3012 return;
3013 }
3014 std::vector<InputTarget>::iterator it =
3015 std::find_if(inputTargets.begin(), inputTargets.end(),
3016 [&windowHandle](const InputTarget& inputTarget) {
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08003017 return inputTarget.connection->getToken() == windowHandle->getToken();
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07003018 });
3019
3020 // This is a hack, because the actual entry could potentially be an ACTION_DOWN event that
3021 // causes a HOVER_EXIT to be generated. That means that the same entry of ACTION_DOWN would
3022 // have DISPATCH_AS_HOVER_EXIT and DISPATCH_AS_IS. And therefore, we have to create separate
3023 // input targets for hovering pointers and for touching pointers.
3024 // If we picked an existing input target above, but it's for HOVER_EXIT - let's use a new
3025 // target instead.
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00003026 if (it != inputTargets.end() && it->dispatchMode == InputTarget::DispatchMode::HOVER_EXIT) {
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07003027 // Force the code below to create a new input target
3028 it = inputTargets.end();
3029 }
3030
3031 const WindowInfo* windowInfo = windowHandle->getInfo();
3032
3033 if (it == inputTargets.end()) {
3034 std::optional<InputTarget> target =
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00003035 createInputTargetLocked(windowHandle, dispatchMode, targetFlags,
3036 firstDownTimeInTarget);
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07003037 if (!target) {
3038 return;
3039 }
3040 inputTargets.push_back(*target);
3041 it = inputTargets.end() - 1;
3042 }
3043
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00003044 if (it->dispatchMode != dispatchMode) {
3045 LOG(ERROR) << __func__ << ": DispatchMode doesn't match! ignoring new mode="
3046 << ftl::enum_string(dispatchMode) << ", it=" << *it;
3047 }
Siarhei Vishniakou4bd0b7c2023-10-27 00:51:14 -07003048 if (it->flags != targetFlags) {
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00003049 LOG(ERROR) << __func__ << ": Flags don't match! new targetFlags=" << targetFlags.string()
3050 << ", it=" << *it;
Siarhei Vishniakou4bd0b7c2023-10-27 00:51:14 -07003051 }
Siarhei Vishniakou23d73fb2023-10-29 13:27:46 -07003052 if (it->globalScaleFactor != windowInfo->globalScaleFactor) {
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00003053 LOG(ERROR) << __func__ << ": Mismatch! it->globalScaleFactor=" << it->globalScaleFactor
Siarhei Vishniakou23d73fb2023-10-29 13:27:46 -07003054 << ", windowInfo->globalScaleFactor=" << windowInfo->globalScaleFactor;
3055 }
Chavi Weingarten65f98b82020-01-16 18:56:50 +00003056
Siarhei Vishniakou59967592024-04-01 16:17:46 -07003057 Result<void> result = it->addPointers(pointerIds, windowInfo->transform);
3058 if (!result.ok()) {
3059 logDispatchStateLocked();
3060 LOG(FATAL) << result.error().message();
3061 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003062}
3063
Michael Wright3dd60e22019-03-27 22:06:44 +00003064void InputDispatcher::addGlobalMonitoringTargetsLocked(std::vector<InputTarget>& inputTargets,
Prabir Pradhan0a99c922021-09-03 08:27:53 -07003065 int32_t displayId) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08003066 auto monitorsIt = mGlobalMonitorsByDisplay.find(displayId);
3067 if (monitorsIt == mGlobalMonitorsByDisplay.end()) return;
Michael Wright3dd60e22019-03-27 22:06:44 +00003068
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08003069 for (const Monitor& monitor : selectResponsiveMonitorsLocked(monitorsIt->second)) {
Prabir Pradhanc32a4112024-01-23 23:20:37 +00003070 InputTarget target{monitor.connection};
Vaibhav Devmurari882bd9b2022-06-23 14:54:54 +00003071 // target.firstDownTimeInTarget is not set for global monitors. It is only required in split
3072 // touch and global monitoring works as intended even without setting firstDownTimeInTarget
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08003073 if (const auto& it = mDisplayInfos.find(displayId); it != mDisplayInfos.end()) {
3074 target.displayTransform = it->second.transform;
Arthur Hung2fbf37f2018-09-13 18:16:41 +08003075 }
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08003076 target.setDefaultPointerTransform(target.displayTransform);
3077 inputTargets.push_back(target);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003078 }
3079}
3080
Robert Carrc9bf1d32020-04-13 17:21:08 -07003081/**
3082 * Indicate whether one window handle should be considered as obscuring
3083 * another window handle. We only check a few preconditions. Actually
3084 * checking the bounds is left to the caller.
3085 */
chaviw98318de2021-05-19 16:45:23 -05003086static bool canBeObscuredBy(const sp<WindowInfoHandle>& windowHandle,
3087 const sp<WindowInfoHandle>& otherHandle) {
Robert Carrc9bf1d32020-04-13 17:21:08 -07003088 // Compare by token so cloned layers aren't counted
3089 if (haveSameToken(windowHandle, otherHandle)) {
3090 return false;
3091 }
3092 auto info = windowHandle->getInfo();
3093 auto otherInfo = otherHandle->getInfo();
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08003094 if (otherInfo->inputConfig.test(WindowInfo::InputConfig::NOT_VISIBLE)) {
Robert Carrc9bf1d32020-04-13 17:21:08 -07003095 return false;
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08003096 } else if (otherInfo->alpha == 0 &&
3097 otherInfo->inputConfig.test(WindowInfo::InputConfig::NOT_TOUCHABLE)) {
Bernardo Rufino653d2e02020-10-20 17:32:40 +00003098 // Those act as if they were invisible, so we don't need to flag them.
3099 // We do want to potentially flag touchable windows even if they have 0
3100 // opacity, since they can consume touches and alter the effects of the
3101 // user interaction (eg. apps that rely on
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003102 // Flags::WINDOW_IS_PARTIALLY_OBSCURED should still be told about those
Bernardo Rufino653d2e02020-10-20 17:32:40 +00003103 // windows), hence we also check for FLAG_NOT_TOUCHABLE.
3104 return false;
Bernardo Rufino8007daf2020-09-22 09:40:01 +00003105 } else if (info->ownerUid == otherInfo->ownerUid) {
3106 // If ownerUid is the same we don't generate occlusion events as there
3107 // is no security boundary within an uid.
Robert Carrc9bf1d32020-04-13 17:21:08 -07003108 return false;
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08003109 } else if (otherInfo->inputConfig.test(gui::WindowInfo::InputConfig::TRUSTED_OVERLAY)) {
Robert Carrc9bf1d32020-04-13 17:21:08 -07003110 return false;
3111 } else if (otherInfo->displayId != info->displayId) {
3112 return false;
3113 }
3114 return true;
3115}
3116
Bernardo Rufinoea97d182020-08-19 14:43:14 +01003117/**
3118 * Returns touch occlusion information in the form of TouchOcclusionInfo. To check if the touch is
3119 * untrusted, one should check:
3120 *
3121 * 1. If result.hasBlockingOcclusion is true.
3122 * If it's, it means the touch should be blocked due to a window with occlusion mode of
3123 * BLOCK_UNTRUSTED.
3124 *
3125 * 2. If result.obscuringOpacity > mMaximumObscuringOpacityForTouch.
3126 * If it is (and 1 is false), then the touch should be blocked because a stack of windows
3127 * (possibly only one) with occlusion mode of USE_OPACITY from one UID resulted in a composed
3128 * obscuring opacity above the threshold. Note that if there was no window of occlusion mode
3129 * USE_OPACITY, result.obscuringOpacity would've been 0 and since
3130 * mMaximumObscuringOpacityForTouch >= 0, the condition above would never be true.
3131 *
3132 * If neither of those is true, then it means the touch can be allowed.
3133 */
3134InputDispatcher::TouchOcclusionInfo InputDispatcher::computeTouchOcclusionInfoLocked(
Linnan Li5e5645e2024-03-05 14:43:05 +00003135 const sp<WindowInfoHandle>& windowHandle, float x, float y) const {
chaviw98318de2021-05-19 16:45:23 -05003136 const WindowInfo* windowInfo = windowHandle->getInfo();
Bernardo Rufino4bae0ac2020-10-14 18:33:46 +00003137 int32_t displayId = windowInfo->displayId;
chaviw98318de2021-05-19 16:45:23 -05003138 const std::vector<sp<WindowInfoHandle>>& windowHandles = getWindowHandlesLocked(displayId);
Bernardo Rufinoea97d182020-08-19 14:43:14 +01003139 TouchOcclusionInfo info;
3140 info.hasBlockingOcclusion = false;
3141 info.obscuringOpacity = 0;
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00003142 info.obscuringUid = gui::Uid::INVALID;
3143 std::map<gui::Uid, float> opacityByUid;
chaviw98318de2021-05-19 16:45:23 -05003144 for (const sp<WindowInfoHandle>& otherHandle : windowHandles) {
Bernardo Rufinoea97d182020-08-19 14:43:14 +01003145 if (windowHandle == otherHandle) {
3146 break; // All future windows are below us. Exit early.
3147 }
chaviw98318de2021-05-19 16:45:23 -05003148 const WindowInfo* otherInfo = otherHandle->getInfo();
Linnan Li5e5645e2024-03-05 14:43:05 +00003149 if (canBeObscuredBy(windowHandle, otherHandle) &&
3150 windowOccludesTouchAt(*otherInfo, displayId, x, y, getTransformLocked(displayId)) &&
Bernardo Rufino1ff9d592021-01-18 16:58:57 +00003151 !haveSameApplicationToken(windowInfo, otherInfo)) {
Bernardo Rufino4bae0ac2020-10-14 18:33:46 +00003152 if (DEBUG_TOUCH_OCCLUSION) {
3153 info.debugInfo.push_back(
Harry Cutts101ee9b2023-07-06 18:04:14 +00003154 dumpWindowForTouchOcclusion(otherInfo, /*isTouchedWindow=*/false));
Bernardo Rufino4bae0ac2020-10-14 18:33:46 +00003155 }
Bernardo Rufinoea97d182020-08-19 14:43:14 +01003156 // canBeObscuredBy() has returned true above, which means this window is untrusted, so
3157 // we perform the checks below to see if the touch can be propagated or not based on the
3158 // window's touch occlusion mode
3159 if (otherInfo->touchOcclusionMode == TouchOcclusionMode::BLOCK_UNTRUSTED) {
3160 info.hasBlockingOcclusion = true;
3161 info.obscuringUid = otherInfo->ownerUid;
3162 info.obscuringPackage = otherInfo->packageName;
3163 break;
3164 }
3165 if (otherInfo->touchOcclusionMode == TouchOcclusionMode::USE_OPACITY) {
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00003166 const auto uid = otherInfo->ownerUid;
Bernardo Rufinoea97d182020-08-19 14:43:14 +01003167 float opacity =
3168 (opacityByUid.find(uid) == opacityByUid.end()) ? 0 : opacityByUid[uid];
3169 // Given windows A and B:
3170 // opacity(A, B) = 1 - [1 - opacity(A)] * [1 - opacity(B)]
3171 opacity = 1 - (1 - opacity) * (1 - otherInfo->alpha);
3172 opacityByUid[uid] = opacity;
3173 if (opacity > info.obscuringOpacity) {
3174 info.obscuringOpacity = opacity;
3175 info.obscuringUid = uid;
3176 info.obscuringPackage = otherInfo->packageName;
3177 }
3178 }
3179 }
3180 }
Bernardo Rufino4bae0ac2020-10-14 18:33:46 +00003181 if (DEBUG_TOUCH_OCCLUSION) {
Harry Cutts101ee9b2023-07-06 18:04:14 +00003182 info.debugInfo.push_back(dumpWindowForTouchOcclusion(windowInfo, /*isTouchedWindow=*/true));
Bernardo Rufino4bae0ac2020-10-14 18:33:46 +00003183 }
Bernardo Rufinoea97d182020-08-19 14:43:14 +01003184 return info;
3185}
3186
chaviw98318de2021-05-19 16:45:23 -05003187std::string InputDispatcher::dumpWindowForTouchOcclusion(const WindowInfo* info,
Bernardo Rufino4bae0ac2020-10-14 18:33:46 +00003188 bool isTouchedWindow) const {
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00003189 return StringPrintf(INDENT2 "* %spackage=%s/%s, id=%" PRId32 ", mode=%s, alpha=%.2f, "
Prabir Pradhan51e7db02022-02-07 06:02:57 -08003190 "frame=[%" PRId32 ",%" PRId32 "][%" PRId32 ",%" PRId32
3191 "], touchableRegion=%s, window={%s}, inputConfig={%s}, "
3192 "hasToken=%s, applicationInfo.name=%s, applicationInfo.token=%s\n",
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08003193 isTouchedWindow ? "[TOUCHED] " : "", info->packageName.c_str(),
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00003194 info->ownerUid.toString().c_str(), info->id,
Chavi Weingarten7f019192023-08-08 20:39:01 +00003195 toString(info->touchOcclusionMode).c_str(), info->alpha, info->frame.left,
3196 info->frame.top, info->frame.right, info->frame.bottom,
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00003197 dumpRegion(info->touchableRegion).c_str(), info->name.c_str(),
3198 info->inputConfig.string().c_str(), toString(info->token != nullptr),
3199 info->applicationInfo.name.c_str(),
Siarhei Vishniakou63b63612023-04-12 11:00:23 -07003200 binderToString(info->applicationInfo.token).c_str());
Bernardo Rufino4bae0ac2020-10-14 18:33:46 +00003201}
3202
Bernardo Rufinoea97d182020-08-19 14:43:14 +01003203bool InputDispatcher::isTouchTrustedLocked(const TouchOcclusionInfo& occlusionInfo) const {
3204 if (occlusionInfo.hasBlockingOcclusion) {
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00003205 ALOGW("Untrusted touch due to occlusion by %s/%s", occlusionInfo.obscuringPackage.c_str(),
3206 occlusionInfo.obscuringUid.toString().c_str());
Bernardo Rufinoea97d182020-08-19 14:43:14 +01003207 return false;
3208 }
3209 if (occlusionInfo.obscuringOpacity > mMaximumObscuringOpacityForTouch) {
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00003210 ALOGW("Untrusted touch due to occlusion by %s/%s (obscuring opacity = "
Bernardo Rufinoea97d182020-08-19 14:43:14 +01003211 "%.2f, maximum allowed = %.2f)",
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00003212 occlusionInfo.obscuringPackage.c_str(), occlusionInfo.obscuringUid.toString().c_str(),
Bernardo Rufinoea97d182020-08-19 14:43:14 +01003213 occlusionInfo.obscuringOpacity, mMaximumObscuringOpacityForTouch);
3214 return false;
3215 }
3216 return true;
3217}
3218
chaviw98318de2021-05-19 16:45:23 -05003219bool InputDispatcher::isWindowObscuredAtPointLocked(const sp<WindowInfoHandle>& windowHandle,
Linnan Li5e5645e2024-03-05 14:43:05 +00003220 float x, float y) const {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003221 int32_t displayId = windowHandle->getInfo()->displayId;
chaviw98318de2021-05-19 16:45:23 -05003222 const std::vector<sp<WindowInfoHandle>>& windowHandles = getWindowHandlesLocked(displayId);
3223 for (const sp<WindowInfoHandle>& otherHandle : windowHandles) {
Robert Carrc9bf1d32020-04-13 17:21:08 -07003224 if (windowHandle == otherHandle) {
3225 break; // All future windows are below us. Exit early.
Michael Wrightd02c5b62014-02-10 15:10:22 -08003226 }
chaviw98318de2021-05-19 16:45:23 -05003227 const WindowInfo* otherInfo = otherHandle->getInfo();
Robert Carrc9bf1d32020-04-13 17:21:08 -07003228 if (canBeObscuredBy(windowHandle, otherHandle) &&
Linnan Li5e5645e2024-03-05 14:43:05 +00003229 windowOccludesTouchAt(*otherInfo, displayId, x, y, getTransformLocked(displayId))) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003230 return true;
3231 }
3232 }
3233 return false;
3234}
3235
chaviw98318de2021-05-19 16:45:23 -05003236bool InputDispatcher::isWindowObscuredLocked(const sp<WindowInfoHandle>& windowHandle) const {
Michael Wrightcdcd8f22016-03-22 16:52:13 -07003237 int32_t displayId = windowHandle->getInfo()->displayId;
chaviw98318de2021-05-19 16:45:23 -05003238 const std::vector<sp<WindowInfoHandle>>& windowHandles = getWindowHandlesLocked(displayId);
3239 const WindowInfo* windowInfo = windowHandle->getInfo();
3240 for (const sp<WindowInfoHandle>& otherHandle : windowHandles) {
Robert Carrc9bf1d32020-04-13 17:21:08 -07003241 if (windowHandle == otherHandle) {
3242 break; // All future windows are below us. Exit early.
Michael Wrightcdcd8f22016-03-22 16:52:13 -07003243 }
chaviw98318de2021-05-19 16:45:23 -05003244 const WindowInfo* otherInfo = otherHandle->getInfo();
Robert Carrc9bf1d32020-04-13 17:21:08 -07003245 if (canBeObscuredBy(windowHandle, otherHandle) &&
minchelif28cc4e2020-03-19 11:18:11 +08003246 otherInfo->overlaps(windowInfo)) {
Michael Wrightcdcd8f22016-03-22 16:52:13 -07003247 return true;
3248 }
3249 }
3250 return false;
3251}
3252
Siarhei Vishniakou61291d42019-02-11 18:13:20 -08003253std::string InputDispatcher::getApplicationWindowLabel(
chaviw98318de2021-05-19 16:45:23 -05003254 const InputApplicationHandle* applicationHandle, const sp<WindowInfoHandle>& windowHandle) {
Yi Kong9b14ac62018-07-17 13:48:38 -07003255 if (applicationHandle != nullptr) {
3256 if (windowHandle != nullptr) {
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07003257 return applicationHandle->getName() + " - " + windowHandle->getName();
Michael Wrightd02c5b62014-02-10 15:10:22 -08003258 } else {
3259 return applicationHandle->getName();
3260 }
Yi Kong9b14ac62018-07-17 13:48:38 -07003261 } else if (windowHandle != nullptr) {
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07003262 return windowHandle->getInfo()->applicationInfo.name + " - " + windowHandle->getName();
Michael Wrightd02c5b62014-02-10 15:10:22 -08003263 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08003264 return "<unknown application or window>";
Michael Wrightd02c5b62014-02-10 15:10:22 -08003265 }
3266}
3267
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003268void InputDispatcher::pokeUserActivityLocked(const EventEntry& eventEntry) {
Antonio Kantekf16f2832021-09-28 04:39:20 +00003269 if (!isUserActivityEvent(eventEntry)) {
3270 // Not poking user activity if the event type does not represent a user activity
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01003271 return;
3272 }
Yeabkal Wubshitb8aadfa2024-01-17 17:03:42 -08003273
3274 const int32_t eventType = getUserActivityEventType(eventEntry);
3275 if (input_flags::rate_limit_user_activity_poke_in_dispatcher()) {
3276 // Note that we're directly getting the time diff between the current event and the previous
3277 // event. This is assuming that the first user event always happens at a timestamp that is
3278 // greater than `mMinTimeBetweenUserActivityPokes` (otherwise, the first user event will
3279 // wrongly be dropped). In real life, `mMinTimeBetweenUserActivityPokes` is a much smaller
3280 // value than the potential first user activity event time, so this is ok.
3281 std::chrono::nanoseconds timeSinceLastEvent =
3282 std::chrono::nanoseconds(eventEntry.eventTime - mLastUserActivityTimes[eventType]);
3283 if (timeSinceLastEvent < mMinTimeBetweenUserActivityPokes) {
3284 return;
3285 }
3286 }
3287
Tiger Huang721e26f2018-07-24 22:26:19 +08003288 int32_t displayId = getTargetDisplayId(eventEntry);
chaviw98318de2021-05-19 16:45:23 -05003289 sp<WindowInfoHandle> focusedWindowHandle = getFocusedWindowHandleLocked(displayId);
Josep del Riob3981622023-04-18 15:49:45 +00003290 const WindowInfo* windowDisablingUserActivityInfo = nullptr;
Tiger Huang721e26f2018-07-24 22:26:19 +08003291 if (focusedWindowHandle != nullptr) {
chaviw98318de2021-05-19 16:45:23 -05003292 const WindowInfo* info = focusedWindowHandle->getInfo();
Prabir Pradhan51e7db02022-02-07 06:02:57 -08003293 if (info->inputConfig.test(WindowInfo::InputConfig::DISABLE_USER_ACTIVITY)) {
Josep del Riob3981622023-04-18 15:49:45 +00003294 windowDisablingUserActivityInfo = info;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003295 }
3296 }
3297
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003298 switch (eventEntry.type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003299 case EventEntry::Type::MOTION: {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003300 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(eventEntry);
3301 if (motionEntry.action == AMOTION_EVENT_ACTION_CANCEL) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003302 return;
3303 }
Josep del Riob3981622023-04-18 15:49:45 +00003304 if (windowDisablingUserActivityInfo != nullptr) {
3305 if (DEBUG_DISPATCH_CYCLE) {
3306 ALOGD("Not poking user activity: disabled by window '%s'.",
3307 windowDisablingUserActivityInfo->name.c_str());
3308 }
3309 return;
3310 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003311 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003312 }
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003313 case EventEntry::Type::KEY: {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003314 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(eventEntry);
3315 if (keyEntry.flags & AKEY_EVENT_FLAG_CANCELED) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003316 return;
3317 }
Josep del Riob3981622023-04-18 15:49:45 +00003318 // If the key code is unknown, we don't consider it user activity
3319 if (keyEntry.keyCode == AKEYCODE_UNKNOWN) {
3320 return;
3321 }
3322 // Don't inhibit events that were intercepted or are not passed to
3323 // the apps, like system shortcuts
3324 if (windowDisablingUserActivityInfo != nullptr &&
3325 keyEntry.interceptKeyResult != KeyEntry::InterceptKeyResult::SKIP &&
3326 keyEntry.policyFlags & POLICY_FLAG_PASS_TO_USER) {
3327 if (DEBUG_DISPATCH_CYCLE) {
3328 ALOGD("Not poking user activity: disabled by window '%s'.",
3329 windowDisablingUserActivityInfo->name.c_str());
3330 }
3331 return;
3332 }
3333
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003334 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003335 }
Antonio Kantekf16f2832021-09-28 04:39:20 +00003336 default: {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003337 LOG_ALWAYS_FATAL("%s events are not user activity",
Dominik Laskowski75788452021-02-09 18:51:25 -08003338 ftl::enum_string(eventEntry.type).c_str());
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003339 break;
3340 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003341 }
3342
Yeabkal Wubshitb8aadfa2024-01-17 17:03:42 -08003343 mLastUserActivityTimes[eventType] = eventEntry.eventTime;
Prabir Pradhancef936d2021-07-21 16:17:52 +00003344 auto command = [this, eventTime = eventEntry.eventTime, eventType, displayId]()
3345 REQUIRES(mLock) {
3346 scoped_unlock unlock(mLock);
Prabir Pradhana41d2442023-04-20 21:30:40 +00003347 mPolicy.pokeUserActivity(eventTime, eventType, displayId);
Prabir Pradhancef936d2021-07-21 16:17:52 +00003348 };
3349 postCommandLocked(std::move(command));
Michael Wrightd02c5b62014-02-10 15:10:22 -08003350}
3351
3352void InputDispatcher::prepareDispatchCycleLocked(nsecs_t currentTime,
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003353 const std::shared_ptr<Connection>& connection,
Prabir Pradhan24047542023-11-02 17:14:59 +00003354 std::shared_ptr<const EventEntry> eventEntry,
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08003355 const InputTarget& inputTarget) {
Prabir Pradhan2dac8b82023-09-06 01:11:51 +00003356 ATRACE_NAME_IF(ATRACE_ENABLED(),
3357 StringPrintf("prepareDispatchCycleLocked(inputChannel=%s, id=0x%" PRIx32 ")",
3358 connection->getInputChannelName().c_str(), eventEntry->id));
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003359 if (DEBUG_DISPATCH_CYCLE) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003360 ALOGD("channel '%s' ~ prepareDispatchCycle - flags=%s, "
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08003361 "globalScaleFactor=%f, pointerIds=%s %s",
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003362 connection->getInputChannelName().c_str(), inputTarget.flags.string().c_str(),
Prabir Pradhanc32a4112024-01-23 23:20:37 +00003363 inputTarget.globalScaleFactor, bitsetToString(inputTarget.getPointerIds()).c_str(),
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003364 inputTarget.getPointerInfoString().c_str());
3365 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003366
3367 // Skip this event if the connection status is not normal.
3368 // We don't want to enqueue additional outbound events if the connection is broken.
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08003369 if (connection->status != Connection::Status::NORMAL) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003370 if (DEBUG_DISPATCH_CYCLE) {
3371 ALOGD("channel '%s' ~ Dropping event because the channel status is %s",
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08003372 connection->getInputChannelName().c_str(),
3373 ftl::enum_string(connection->status).c_str());
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003374 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003375 return;
3376 }
3377
3378 // Split a motion event if needed.
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003379 if (inputTarget.flags.test(InputTarget::Flags::SPLIT)) {
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08003380 LOG_ALWAYS_FATAL_IF(eventEntry->type != EventEntry::Type::MOTION,
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003381 "Entry type %s should not have Flags::SPLIT",
Dominik Laskowski75788452021-02-09 18:51:25 -08003382 ftl::enum_string(eventEntry->type).c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08003383
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003384 const MotionEntry& originalMotionEntry = static_cast<const MotionEntry&>(*eventEntry);
Prabir Pradhanc32a4112024-01-23 23:20:37 +00003385 if (inputTarget.getPointerIds().count() != originalMotionEntry.getPointerCount()) {
Siarhei Vishniakou16e4fa02023-02-16 17:48:56 -08003386 if (!inputTarget.firstDownTimeInTarget.has_value()) {
3387 logDispatchStateLocked();
3388 LOG(FATAL) << "Splitting motion events requires a down time to be set for the "
3389 "target on connection "
3390 << connection->getInputChannelName() << " for "
3391 << originalMotionEntry.getDescription();
3392 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003393 std::unique_ptr<MotionEntry> splitMotionEntry =
Prabir Pradhanc32a4112024-01-23 23:20:37 +00003394 splitMotionEvent(originalMotionEntry, inputTarget.getPointerIds(),
Vaibhav Devmurari882bd9b2022-06-23 14:54:54 +00003395 inputTarget.firstDownTimeInTarget.value());
Michael Wrightd02c5b62014-02-10 15:10:22 -08003396 if (!splitMotionEntry) {
3397 return; // split event was dropped
3398 }
Arthur Hungb3307ee2021-10-14 10:57:37 +00003399 if (splitMotionEntry->action == AMOTION_EVENT_ACTION_CANCEL) {
3400 std::string reason = std::string("reason=pointer cancel on split window");
3401 android_log_event_list(LOGTAG_INPUT_CANCEL)
3402 << connection->getInputChannelName().c_str() << reason << LOG_ID_EVENTS;
3403 }
Siarhei Vishniakou86587282019-09-09 18:20:15 +01003404 if (DEBUG_FOCUS) {
3405 ALOGD("channel '%s' ~ Split motion event.",
3406 connection->getInputChannelName().c_str());
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003407 logOutboundMotionDetails(" ", *splitMotionEntry);
Siarhei Vishniakou86587282019-09-09 18:20:15 +01003408 }
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00003409 enqueueDispatchEntryAndStartDispatchCycleLocked(currentTime, connection,
3410 std::move(splitMotionEntry),
3411 inputTarget);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003412 return;
3413 }
3414 }
3415
3416 // Not splitting. Enqueue dispatch entries for the event as is.
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00003417 enqueueDispatchEntryAndStartDispatchCycleLocked(currentTime, connection, eventEntry,
3418 inputTarget);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003419}
3420
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00003421void InputDispatcher::enqueueDispatchEntryAndStartDispatchCycleLocked(
3422 nsecs_t currentTime, const std::shared_ptr<Connection>& connection,
3423 std::shared_ptr<const EventEntry> eventEntry, const InputTarget& inputTarget) {
Prabir Pradhan2dac8b82023-09-06 01:11:51 +00003424 ATRACE_NAME_IF(ATRACE_ENABLED(),
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00003425 StringPrintf("enqueueDispatchEntryAndStartDispatchCycleLocked(inputChannel=%s, "
3426 "id=0x%" PRIx32 ")",
Prabir Pradhan2dac8b82023-09-06 01:11:51 +00003427 connection->getInputChannelName().c_str(), eventEntry->id));
Michael Wright3dd60e22019-03-27 22:06:44 +00003428
hongzuo liu95785e22022-09-06 02:51:35 +00003429 const bool wasEmpty = connection->outboundQueue.empty();
Michael Wrightd02c5b62014-02-10 15:10:22 -08003430
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00003431 enqueueDispatchEntryLocked(connection, eventEntry, inputTarget);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003432
3433 // If the outbound queue was previously empty, start the dispatch cycle going.
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07003434 if (wasEmpty && !connection->outboundQueue.empty()) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003435 startDispatchCycleLocked(currentTime, connection);
3436 }
3437}
3438
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003439void InputDispatcher::enqueueDispatchEntryLocked(const std::shared_ptr<Connection>& connection,
Prabir Pradhan24047542023-11-02 17:14:59 +00003440 std::shared_ptr<const EventEntry> eventEntry,
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00003441 const InputTarget& inputTarget) {
Prabir Pradhanbb3f1c02024-01-04 20:17:14 +00003442 const bool isKeyOrMotion = eventEntry->type == EventEntry::Type::KEY ||
3443 eventEntry->type == EventEntry::Type::MOTION;
3444 if (isKeyOrMotion && !inputTarget.windowHandle && !connection->monitor) {
3445 LOG(FATAL) << "All InputTargets for non-monitors must be associated with a window; target: "
3446 << inputTarget << " connection: " << connection->getInputChannelName()
3447 << " entry: " << eventEntry->getDescription();
3448 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003449 // This is a new event.
3450 // Enqueue a new dispatch entry onto the outbound queue for this connection.
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08003451 std::unique_ptr<DispatchEntry> dispatchEntry =
Prabir Pradhanc88b1fa2024-01-23 21:48:03 +00003452 createDispatchEntry(mIdGenerator, inputTarget, eventEntry, inputTarget.flags,
Prabir Pradhana67623c2024-02-21 06:57:36 +00003453 mWindowInfosVsyncId, mTracer.get());
Michael Wrightd02c5b62014-02-10 15:10:22 -08003454
Chavi Weingarten65f98b82020-01-16 18:56:50 +00003455 // Use the eventEntry from dispatchEntry since the entry may have changed and can now be a
3456 // different EventEntry than what was passed in.
Prabir Pradhan2a2da1d2023-11-03 02:16:20 +00003457 eventEntry = dispatchEntry->eventEntry;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003458 // Apply target flags and update the connection's input state.
Prabir Pradhan2a2da1d2023-11-03 02:16:20 +00003459 switch (eventEntry->type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003460 case EventEntry::Type::KEY: {
Prabir Pradhan2a2da1d2023-11-03 02:16:20 +00003461 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(*eventEntry);
3462 if (!connection->inputState.trackKey(keyEntry, keyEntry.flags)) {
Siarhei Vishniakouc94dafe2023-05-26 10:24:19 -07003463 LOG(WARNING) << "channel " << connection->getInputChannelName()
3464 << "~ dropping inconsistent event: " << *dispatchEntry;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003465 return; // skip the inconsistent event
3466 }
3467 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003468 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003469
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003470 case EventEntry::Type::MOTION: {
Prabir Pradhan2a2da1d2023-11-03 02:16:20 +00003471 std::shared_ptr<const MotionEntry> resolvedMotion =
3472 std::static_pointer_cast<const MotionEntry>(eventEntry);
3473 {
3474 // Determine the resolved motion entry.
3475 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(*eventEntry);
3476 int32_t resolvedAction = motionEntry.action;
3477 int32_t resolvedFlags = motionEntry.flags;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003478
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00003479 if (inputTarget.dispatchMode == InputTarget::DispatchMode::OUTSIDE) {
Prabir Pradhan2a2da1d2023-11-03 02:16:20 +00003480 resolvedAction = AMOTION_EVENT_ACTION_OUTSIDE;
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00003481 } else if (inputTarget.dispatchMode == InputTarget::DispatchMode::HOVER_EXIT) {
Prabir Pradhan2a2da1d2023-11-03 02:16:20 +00003482 resolvedAction = AMOTION_EVENT_ACTION_HOVER_EXIT;
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00003483 } else if (inputTarget.dispatchMode == InputTarget::DispatchMode::HOVER_ENTER) {
Prabir Pradhan2a2da1d2023-11-03 02:16:20 +00003484 resolvedAction = AMOTION_EVENT_ACTION_HOVER_ENTER;
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00003485 } else if (inputTarget.dispatchMode == InputTarget::DispatchMode::SLIPPERY_EXIT) {
Prabir Pradhan2a2da1d2023-11-03 02:16:20 +00003486 resolvedAction = AMOTION_EVENT_ACTION_CANCEL;
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00003487 } else if (inputTarget.dispatchMode == InputTarget::DispatchMode::SLIPPERY_ENTER) {
Prabir Pradhan2a2da1d2023-11-03 02:16:20 +00003488 resolvedAction = AMOTION_EVENT_ACTION_DOWN;
3489 }
3490 if (resolvedAction == AMOTION_EVENT_ACTION_HOVER_MOVE &&
3491 !connection->inputState.isHovering(motionEntry.deviceId, motionEntry.source,
3492 motionEntry.displayId)) {
3493 if (DEBUG_DISPATCH_CYCLE) {
3494 LOG(DEBUG) << "channel '" << connection->getInputChannelName().c_str()
3495 << "' ~ enqueueDispatchEntryLocked: filling in missing hover "
3496 "enter event";
3497 }
3498 resolvedAction = AMOTION_EVENT_ACTION_HOVER_ENTER;
3499 }
3500
3501 if (resolvedAction == AMOTION_EVENT_ACTION_CANCEL) {
3502 resolvedFlags |= AMOTION_EVENT_FLAG_CANCELED;
3503 }
3504 if (dispatchEntry->targetFlags.test(InputTarget::Flags::WINDOW_IS_OBSCURED)) {
3505 resolvedFlags |= AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED;
3506 }
3507 if (dispatchEntry->targetFlags.test(
3508 InputTarget::Flags::WINDOW_IS_PARTIALLY_OBSCURED)) {
3509 resolvedFlags |= AMOTION_EVENT_FLAG_WINDOW_IS_PARTIALLY_OBSCURED;
3510 }
Prabir Pradhan65455c72024-02-13 21:46:41 +00003511 if (dispatchEntry->targetFlags.test(InputTarget::Flags::NO_FOCUS_CHANGE)) {
3512 resolvedFlags |= AMOTION_EVENT_FLAG_NO_FOCUS_CHANGE;
3513 }
Prabir Pradhan2a2da1d2023-11-03 02:16:20 +00003514
3515 dispatchEntry->resolvedFlags = resolvedFlags;
3516 if (resolvedAction != motionEntry.action) {
Siarhei Vishniakoue9ef6bc2023-12-21 19:47:20 -08003517 std::optional<std::vector<PointerProperties>> usingProperties;
3518 std::optional<std::vector<PointerCoords>> usingCoords;
3519 if (resolvedAction == AMOTION_EVENT_ACTION_HOVER_EXIT ||
3520 resolvedAction == AMOTION_EVENT_ACTION_CANCEL) {
3521 // This is a HOVER_EXIT or an ACTION_CANCEL event that was synthesized by
3522 // the dispatcher, and therefore the coordinates of this event are currently
3523 // incorrect. These events should use the coordinates of the last dispatched
3524 // ACTION_MOVE or HOVER_MOVE. We need to query InputState to get this data.
3525 const bool hovering = resolvedAction == AMOTION_EVENT_ACTION_HOVER_EXIT;
3526 std::optional<std::pair<std::vector<PointerProperties>,
3527 std::vector<PointerCoords>>>
3528 pointerInfo =
3529 connection->inputState.getPointersOfLastEvent(motionEntry,
3530 hovering);
3531 if (pointerInfo) {
3532 usingProperties = pointerInfo->first;
3533 usingCoords = pointerInfo->second;
3534 }
3535 }
Prabir Pradhana67623c2024-02-21 06:57:36 +00003536 {
3537 // Generate a new MotionEntry with a new eventId using the resolved action
3538 // and flags, and set it as the resolved entry.
3539 auto newEntry = std::make_shared<
3540 MotionEntry>(mIdGenerator.nextId(), motionEntry.injectionState,
3541 motionEntry.eventTime, motionEntry.deviceId,
3542 motionEntry.source, motionEntry.displayId,
3543 motionEntry.policyFlags, resolvedAction,
3544 motionEntry.actionButton, resolvedFlags,
3545 motionEntry.metaState, motionEntry.buttonState,
3546 motionEntry.classification, motionEntry.edgeFlags,
3547 motionEntry.xPrecision, motionEntry.yPrecision,
3548 motionEntry.xCursorPosition,
3549 motionEntry.yCursorPosition, motionEntry.downTime,
3550 usingProperties.value_or(
3551 motionEntry.pointerProperties),
3552 usingCoords.value_or(motionEntry.pointerCoords));
3553 if (mTracer) {
3554 ensureEventTraced(motionEntry);
3555 newEntry->traceTracker =
3556 mTracer->traceDerivedEvent(*newEntry,
3557 *motionEntry.traceTracker);
3558 }
3559 resolvedMotion = newEntry;
3560 }
Prabir Pradhan2a2da1d2023-11-03 02:16:20 +00003561 if (ATRACE_ENABLED()) {
3562 std::string message = StringPrintf("Transmute MotionEvent(id=0x%" PRIx32
3563 ") to MotionEvent(id=0x%" PRIx32 ").",
3564 motionEntry.id, resolvedMotion->id);
3565 ATRACE_NAME(message.c_str());
3566 }
3567
3568 // Set the resolved motion entry in the DispatchEntry.
3569 dispatchEntry->eventEntry = resolvedMotion;
3570 eventEntry = resolvedMotion;
3571 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003572 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003573
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07003574 // Check if we need to cancel any of the ongoing gestures. We don't support multiple
3575 // devices being active at the same time in the same window, so if a new device is
3576 // active, cancel the gesture from the old device.
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07003577 std::unique_ptr<EventEntry> cancelEvent =
Prabir Pradhan2a2da1d2023-11-03 02:16:20 +00003578 connection->inputState.cancelConflictingInputStream(*resolvedMotion);
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07003579 if (cancelEvent != nullptr) {
Prabir Pradhan2a2da1d2023-11-03 02:16:20 +00003580 LOG(INFO) << "Canceling pointers for device " << resolvedMotion->deviceId << " in "
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07003581 << connection->getInputChannelName() << " with event "
3582 << cancelEvent->getDescription();
Prabir Pradhand6b2b052024-02-21 23:25:15 +00003583 if (mTracer) {
3584 static_cast<MotionEntry&>(*cancelEvent).traceTracker =
3585 mTracer->traceDerivedEvent(*cancelEvent, *resolvedMotion->traceTracker);
3586 }
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07003587 std::unique_ptr<DispatchEntry> cancelDispatchEntry =
Prabir Pradhanc88b1fa2024-01-23 21:48:03 +00003588 createDispatchEntry(mIdGenerator, inputTarget, std::move(cancelEvent),
Prabir Pradhana67623c2024-02-21 06:57:36 +00003589 ftl::Flags<InputTarget::Flags>(), mWindowInfosVsyncId,
3590 mTracer.get());
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07003591
3592 // Send these cancel events to the queue before sending the event from the new
3593 // device.
3594 connection->outboundQueue.emplace_back(std::move(cancelDispatchEntry));
3595 }
3596
Prabir Pradhan2a2da1d2023-11-03 02:16:20 +00003597 if (!connection->inputState.trackMotion(*resolvedMotion,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003598 dispatchEntry->resolvedFlags)) {
Siarhei Vishniakouc94dafe2023-05-26 10:24:19 -07003599 LOG(WARNING) << "channel " << connection->getInputChannelName()
3600 << "~ dropping inconsistent event: " << *dispatchEntry;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003601 return; // skip the inconsistent event
3602 }
Prabir Pradhan65455c72024-02-13 21:46:41 +00003603 if ((dispatchEntry->resolvedFlags & AMOTION_EVENT_FLAG_NO_FOCUS_CHANGE) &&
Prabir Pradhan2a2da1d2023-11-03 02:16:20 +00003604 (resolvedMotion->policyFlags & POLICY_FLAG_TRUSTED)) {
Prabir Pradhan47cf0a02021-03-11 20:30:57 -08003605 // Skip reporting pointer down outside focus to the policy.
3606 break;
3607 }
3608
Prabir Pradhan2a2da1d2023-11-03 02:16:20 +00003609 dispatchPointerDownOutsideFocus(resolvedMotion->source, resolvedMotion->action,
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08003610 inputTarget.connection->getToken());
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003611
3612 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003613 }
Prabir Pradhan99987712020-11-10 18:43:05 -08003614 case EventEntry::Type::FOCUS:
Antonio Kantek7242d8b2021-08-05 16:07:20 -07003615 case EventEntry::Type::TOUCH_MODE_CHANGED:
arthurhungb89ccb02020-12-30 16:19:01 +08003616 case EventEntry::Type::POINTER_CAPTURE_CHANGED:
3617 case EventEntry::Type::DRAG: {
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01003618 break;
3619 }
Chris Yef59a2f42020-10-16 12:55:26 -07003620 case EventEntry::Type::SENSOR: {
3621 LOG_ALWAYS_FATAL("SENSOR events should not go to apps via input channel");
3622 break;
3623 }
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003624 case EventEntry::Type::CONFIGURATION_CHANGED:
3625 case EventEntry::Type::DEVICE_RESET: {
3626 LOG_ALWAYS_FATAL("%s events should not go to apps",
Prabir Pradhan2a2da1d2023-11-03 02:16:20 +00003627 ftl::enum_string(eventEntry->type).c_str());
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003628 break;
3629 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003630 }
3631
3632 // Remember that we are waiting for this dispatch to complete.
3633 if (dispatchEntry->hasForegroundTarget()) {
Prabir Pradhan2a2da1d2023-11-03 02:16:20 +00003634 incrementPendingForegroundDispatches(*eventEntry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003635 }
3636
3637 // Enqueue the dispatch entry.
Prabir Pradhan8c90d782023-09-15 21:16:44 +00003638 connection->outboundQueue.emplace_back(std::move(dispatchEntry));
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00003639 traceOutboundQueueLength(*connection);
chaviw8c9cf542019-03-25 13:02:48 -07003640}
3641
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003642/**
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00003643 * This function is for debugging and metrics collection. It has two roles.
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003644 *
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00003645 * The first role is to log input interaction with windows, which helps determine what the user was
3646 * interacting with. For example, if user is touching launcher, we will see an input_interaction log
3647 * that user started interacting with launcher window, as well as any other window that received
3648 * that gesture, such as the wallpaper or other spy windows. A new input_interaction is only logged
3649 * when the set of tokens that received the event changes. It is not logged again as long as the
3650 * user is interacting with the same windows.
3651 *
3652 * The second role is to track input device activity for metrics collection. For each input event,
3653 * we report the set of UIDs that the input device interacted with to the policy. Unlike for the
3654 * input_interaction logs, the device interaction is reported even when the set of interaction
3655 * tokens do not change.
3656 *
3657 * For these purposes, we do not count ACTION_OUTSIDE, ACTION_UP and ACTION_CANCEL actions as
3658 * interaction. This includes up and cancel events for both keys and motions.
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003659 */
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00003660void InputDispatcher::processInteractionsLocked(const EventEntry& entry,
3661 const std::vector<InputTarget>& targets) {
3662 int32_t deviceId;
3663 nsecs_t eventTime;
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003664 // Skip ACTION_UP events, and all events other than keys and motions
3665 if (entry.type == EventEntry::Type::KEY) {
3666 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(entry);
3667 if (keyEntry.action == AKEY_EVENT_ACTION_UP) {
3668 return;
3669 }
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00003670 deviceId = keyEntry.deviceId;
3671 eventTime = keyEntry.eventTime;
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003672 } else if (entry.type == EventEntry::Type::MOTION) {
3673 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(entry);
3674 if (motionEntry.action == AMOTION_EVENT_ACTION_UP ||
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00003675 motionEntry.action == AMOTION_EVENT_ACTION_CANCEL ||
3676 MotionEvent::getActionMasked(motionEntry.action) == AMOTION_EVENT_ACTION_POINTER_UP) {
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003677 return;
3678 }
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00003679 deviceId = motionEntry.deviceId;
3680 eventTime = motionEntry.eventTime;
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003681 } else {
3682 return; // Not a key or a motion
3683 }
3684
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00003685 std::set<gui::Uid> interactionUids;
Prabir Pradhan6a9a8312021-04-23 11:59:31 -07003686 std::unordered_set<sp<IBinder>, StrongPointerHash<IBinder>> newConnectionTokens;
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003687 std::vector<std::shared_ptr<Connection>> newConnections;
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003688 for (const InputTarget& target : targets) {
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00003689 if (target.dispatchMode == InputTarget::DispatchMode::OUTSIDE) {
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003690 continue; // Skip windows that receive ACTION_OUTSIDE
3691 }
3692
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08003693 sp<IBinder> token = target.connection->getToken();
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003694 newConnectionTokens.insert(std::move(token));
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08003695 newConnections.emplace_back(target.connection);
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00003696 if (target.windowHandle) {
3697 interactionUids.emplace(target.windowHandle->getInfo()->ownerUid);
3698 }
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003699 }
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00003700
3701 auto command = [this, deviceId, eventTime, uids = std::move(interactionUids)]()
3702 REQUIRES(mLock) {
3703 scoped_unlock unlock(mLock);
3704 mPolicy.notifyDeviceInteraction(deviceId, eventTime, uids);
3705 };
3706 postCommandLocked(std::move(command));
3707
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003708 if (newConnectionTokens == mInteractionConnectionTokens) {
3709 return; // no change
3710 }
3711 mInteractionConnectionTokens = newConnectionTokens;
3712
Siarhei Vishniakoud706a282021-02-13 00:08:48 +00003713 std::string targetList;
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003714 for (const std::shared_ptr<Connection>& connection : newConnections) {
Siarhei Vishniakou10bfdc92024-02-01 11:12:57 -08003715 targetList += connection->getInputChannelName() + ", ";
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003716 }
Siarhei Vishniakoud706a282021-02-13 00:08:48 +00003717 std::string message = "Interaction with: " + targetList;
3718 if (targetList.empty()) {
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003719 message += "<none>";
3720 }
3721 android_log_event_list(LOGTAG_INPUT_INTERACTION) << message << LOG_ID_EVENTS;
3722}
3723
chaviwfd6d3512019-03-25 13:23:49 -07003724void InputDispatcher::dispatchPointerDownOutsideFocus(uint32_t source, int32_t action,
Vishnu Nairad321cd2020-08-20 16:40:21 -07003725 const sp<IBinder>& token) {
chaviw8c9cf542019-03-25 13:02:48 -07003726 int32_t maskedAction = action & AMOTION_EVENT_ACTION_MASK;
chaviwfd6d3512019-03-25 13:23:49 -07003727 uint32_t maskedSource = source & AINPUT_SOURCE_CLASS_MASK;
3728 if (maskedSource != AINPUT_SOURCE_CLASS_POINTER || maskedAction != AMOTION_EVENT_ACTION_DOWN) {
chaviw8c9cf542019-03-25 13:02:48 -07003729 return;
3730 }
3731
Vishnu Nairc519ff72021-01-21 08:23:08 -08003732 sp<IBinder> focusedToken = mFocusResolver.getFocusedWindowToken(mFocusedDisplayId);
Vishnu Nairad321cd2020-08-20 16:40:21 -07003733 if (focusedToken == token) {
3734 // ignore since token is focused
chaviw8c9cf542019-03-25 13:02:48 -07003735 return;
3736 }
3737
Prabir Pradhancef936d2021-07-21 16:17:52 +00003738 auto command = [this, token]() REQUIRES(mLock) {
3739 scoped_unlock unlock(mLock);
Prabir Pradhana41d2442023-04-20 21:30:40 +00003740 mPolicy.onPointerDownOutsideFocus(token);
Prabir Pradhancef936d2021-07-21 16:17:52 +00003741 };
3742 postCommandLocked(std::move(command));
Michael Wrightd02c5b62014-02-10 15:10:22 -08003743}
3744
Siarhei Vishniakoucce7e112022-10-25 13:31:17 -07003745status_t InputDispatcher::publishMotionEvent(Connection& connection,
3746 DispatchEntry& dispatchEntry) const {
3747 const EventEntry& eventEntry = *(dispatchEntry.eventEntry);
3748 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(eventEntry);
3749
3750 PointerCoords scaledCoords[MAX_POINTERS];
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07003751 const PointerCoords* usingCoords = motionEntry.pointerCoords.data();
Siarhei Vishniakoucce7e112022-10-25 13:31:17 -07003752
Prabir Pradhanabcdf5c2023-12-15 07:30:22 +00003753 // TODO(b/316355518): Do not modify coords before dispatch.
Siarhei Vishniakoucce7e112022-10-25 13:31:17 -07003754 // Set the X and Y offset and X and Y scale depending on the input source.
3755 if ((motionEntry.source & AINPUT_SOURCE_CLASS_POINTER) &&
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003756 !(dispatchEntry.targetFlags.test(InputTarget::Flags::ZERO_COORDS))) {
Siarhei Vishniakoucce7e112022-10-25 13:31:17 -07003757 float globalScaleFactor = dispatchEntry.globalScaleFactor;
3758 if (globalScaleFactor != 1.0f) {
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07003759 for (uint32_t i = 0; i < motionEntry.getPointerCount(); i++) {
Siarhei Vishniakoucce7e112022-10-25 13:31:17 -07003760 scaledCoords[i] = motionEntry.pointerCoords[i];
3761 // Don't apply window scale here since we don't want scale to affect raw
3762 // coordinates. The scale will be sent back to the client and applied
3763 // later when requesting relative coordinates.
Harry Cutts33476232023-01-30 19:57:29 +00003764 scaledCoords[i].scale(globalScaleFactor, /*windowXScale=*/1, /*windowYScale=*/1);
Siarhei Vishniakoucce7e112022-10-25 13:31:17 -07003765 }
3766 usingCoords = scaledCoords;
3767 }
Siarhei Vishniakoucce7e112022-10-25 13:31:17 -07003768 }
3769
3770 std::array<uint8_t, 32> hmac = getSignature(motionEntry, dispatchEntry);
3771
3772 // Publish the motion event.
3773 return connection.inputPublisher
Prabir Pradhan2a2da1d2023-11-03 02:16:20 +00003774 .publishMotionEvent(dispatchEntry.seq, motionEntry.id, motionEntry.deviceId,
3775 motionEntry.source, motionEntry.displayId, std::move(hmac),
3776 motionEntry.action, motionEntry.actionButton,
3777 dispatchEntry.resolvedFlags, motionEntry.edgeFlags,
3778 motionEntry.metaState, motionEntry.buttonState,
3779 motionEntry.classification, dispatchEntry.transform,
3780 motionEntry.xPrecision, motionEntry.yPrecision,
3781 motionEntry.xCursorPosition, motionEntry.yCursorPosition,
3782 dispatchEntry.rawTransform, motionEntry.downTime,
3783 motionEntry.eventTime, motionEntry.getPointerCount(),
3784 motionEntry.pointerProperties.data(), usingCoords);
Siarhei Vishniakoucce7e112022-10-25 13:31:17 -07003785}
3786
Michael Wrightd02c5b62014-02-10 15:10:22 -08003787void InputDispatcher::startDispatchCycleLocked(nsecs_t currentTime,
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003788 const std::shared_ptr<Connection>& connection) {
Prabir Pradhan2dac8b82023-09-06 01:11:51 +00003789 ATRACE_NAME_IF(ATRACE_ENABLED(),
3790 StringPrintf("startDispatchCycleLocked(inputChannel=%s)",
3791 connection->getInputChannelName().c_str()));
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003792 if (DEBUG_DISPATCH_CYCLE) {
3793 ALOGD("channel '%s' ~ startDispatchCycle", connection->getInputChannelName().c_str());
3794 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003795
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08003796 while (connection->status == Connection::Status::NORMAL && !connection->outboundQueue.empty()) {
Prabir Pradhan8c90d782023-09-15 21:16:44 +00003797 std::unique_ptr<DispatchEntry>& dispatchEntry = connection->outboundQueue.front();
Michael Wrightd02c5b62014-02-10 15:10:22 -08003798 dispatchEntry->deliveryTime = currentTime;
Prabir Pradhan1376fcd2022-01-21 09:56:35 -08003799 const std::chrono::nanoseconds timeout = getDispatchingTimeoutLocked(connection);
Siarhei Vishniakou70622952020-07-30 11:17:23 -05003800 dispatchEntry->timeoutTime = currentTime + timeout.count();
Michael Wrightd02c5b62014-02-10 15:10:22 -08003801
3802 // Publish the event.
3803 status_t status;
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003804 const EventEntry& eventEntry = *(dispatchEntry->eventEntry);
3805 switch (eventEntry.type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003806 case EventEntry::Type::KEY: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003807 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(eventEntry);
3808 std::array<uint8_t, 32> hmac = getSignature(keyEntry, *dispatchEntry);
Siarhei Vishniakoud010b012023-01-18 15:00:53 -08003809 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
Siarhei Vishniakou827d1ac2023-07-21 16:37:51 -07003810 LOG(INFO) << "Publishing " << *dispatchEntry << " to "
3811 << connection->getInputChannelName();
Siarhei Vishniakoud010b012023-01-18 15:00:53 -08003812 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003813
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003814 // Publish the key event.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003815 status = connection->inputPublisher
Prabir Pradhan2a2da1d2023-11-03 02:16:20 +00003816 .publishKeyEvent(dispatchEntry->seq, keyEntry.id,
3817 keyEntry.deviceId, keyEntry.source,
3818 keyEntry.displayId, std::move(hmac),
3819 keyEntry.action, dispatchEntry->resolvedFlags,
3820 keyEntry.keyCode, keyEntry.scanCode,
3821 keyEntry.metaState, keyEntry.repeatCount,
3822 keyEntry.downTime, keyEntry.eventTime);
Prabir Pradhanabcdf5c2023-12-15 07:30:22 +00003823 if (mTracer) {
Prabir Pradhand6b2b052024-02-21 23:25:15 +00003824 ensureEventTraced(keyEntry);
3825 mTracer->traceEventDispatch(*dispatchEntry, *keyEntry.traceTracker);
Prabir Pradhanabcdf5c2023-12-15 07:30:22 +00003826 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003827 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003828 }
3829
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003830 case EventEntry::Type::MOTION: {
Siarhei Vishniakoud010b012023-01-18 15:00:53 -08003831 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
Siarhei Vishniakou827d1ac2023-07-21 16:37:51 -07003832 LOG(INFO) << "Publishing " << *dispatchEntry << " to "
3833 << connection->getInputChannelName();
Siarhei Vishniakoud010b012023-01-18 15:00:53 -08003834 }
Prabir Pradhanabcdf5c2023-12-15 07:30:22 +00003835 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(eventEntry);
Siarhei Vishniakoucce7e112022-10-25 13:31:17 -07003836 status = publishMotionEvent(*connection, *dispatchEntry);
Prabir Pradhanabcdf5c2023-12-15 07:30:22 +00003837 if (mTracer) {
Prabir Pradhand6b2b052024-02-21 23:25:15 +00003838 ensureEventTraced(motionEntry);
3839 mTracer->traceEventDispatch(*dispatchEntry, *motionEntry.traceTracker);
Prabir Pradhanabcdf5c2023-12-15 07:30:22 +00003840 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003841 break;
3842 }
Prabir Pradhan99987712020-11-10 18:43:05 -08003843
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01003844 case EventEntry::Type::FOCUS: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003845 const FocusEntry& focusEntry = static_cast<const FocusEntry&>(eventEntry);
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01003846 status = connection->inputPublisher.publishFocusEvent(dispatchEntry->seq,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003847 focusEntry.id,
Antonio Kantek3cfec7b2021-11-05 18:26:17 -07003848 focusEntry.hasFocus);
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01003849 break;
3850 }
3851
Antonio Kantek7242d8b2021-08-05 16:07:20 -07003852 case EventEntry::Type::TOUCH_MODE_CHANGED: {
3853 const TouchModeEntry& touchModeEntry =
3854 static_cast<const TouchModeEntry&>(eventEntry);
3855 status = connection->inputPublisher
3856 .publishTouchModeEvent(dispatchEntry->seq, touchModeEntry.id,
3857 touchModeEntry.inTouchMode);
3858
3859 break;
3860 }
3861
Prabir Pradhan99987712020-11-10 18:43:05 -08003862 case EventEntry::Type::POINTER_CAPTURE_CHANGED: {
3863 const auto& captureEntry =
3864 static_cast<const PointerCaptureChangedEntry&>(eventEntry);
Hiroki Sato25040232024-02-22 17:21:22 +09003865 status =
3866 connection->inputPublisher
3867 .publishCaptureEvent(dispatchEntry->seq, captureEntry.id,
3868 captureEntry.pointerCaptureRequest.isEnable());
Prabir Pradhan99987712020-11-10 18:43:05 -08003869 break;
3870 }
3871
arthurhungb89ccb02020-12-30 16:19:01 +08003872 case EventEntry::Type::DRAG: {
3873 const DragEntry& dragEntry = static_cast<const DragEntry&>(eventEntry);
3874 status = connection->inputPublisher.publishDragEvent(dispatchEntry->seq,
3875 dragEntry.id, dragEntry.x,
3876 dragEntry.y,
3877 dragEntry.isExiting);
3878 break;
3879 }
3880
Siarhei Vishniakou3b37f9a2019-11-23 13:42:41 -08003881 case EventEntry::Type::CONFIGURATION_CHANGED:
Chris Yef59a2f42020-10-16 12:55:26 -07003882 case EventEntry::Type::DEVICE_RESET:
3883 case EventEntry::Type::SENSOR: {
Siarhei Vishniakou3b37f9a2019-11-23 13:42:41 -08003884 LOG_ALWAYS_FATAL("Should never start dispatch cycles for %s events",
Dominik Laskowski75788452021-02-09 18:51:25 -08003885 ftl::enum_string(eventEntry.type).c_str());
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003886 return;
Siarhei Vishniakou3b37f9a2019-11-23 13:42:41 -08003887 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003888 }
3889
3890 // Check the result.
3891 if (status) {
3892 if (status == WOULD_BLOCK) {
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07003893 if (connection->waitQueue.empty()) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003894 ALOGE("channel '%s' ~ Could not publish event because the pipe is full. "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003895 "This is unexpected because the wait queue is empty, so the pipe "
3896 "should be empty and we shouldn't have any problems writing an "
Siarhei Vishniakou09b02ac2021-04-14 22:24:04 +00003897 "event to it, status=%s(%d)",
3898 connection->getInputChannelName().c_str(), statusToString(status).c_str(),
3899 status);
Harry Cutts33476232023-01-30 19:57:29 +00003900 abortBrokenDispatchCycleLocked(currentTime, connection, /*notify=*/true);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003901 } else {
3902 // Pipe is full and we are waiting for the app to finish process some events
3903 // before sending more events to it.
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003904 if (DEBUG_DISPATCH_CYCLE) {
3905 ALOGD("channel '%s' ~ Could not publish event because the pipe is full, "
3906 "waiting for the application to catch up",
3907 connection->getInputChannelName().c_str());
3908 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003909 }
3910 } else {
3911 ALOGE("channel '%s' ~ Could not publish event due to an unexpected error, "
Siarhei Vishniakou09b02ac2021-04-14 22:24:04 +00003912 "status=%s(%d)",
3913 connection->getInputChannelName().c_str(), statusToString(status).c_str(),
3914 status);
Harry Cutts33476232023-01-30 19:57:29 +00003915 abortBrokenDispatchCycleLocked(currentTime, connection, /*notify=*/true);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003916 }
3917 return;
3918 }
3919
3920 // Re-enqueue the event on the wait queue.
Prabir Pradhan8c90d782023-09-15 21:16:44 +00003921 const nsecs_t timeoutTime = dispatchEntry->timeoutTime;
3922 connection->waitQueue.emplace_back(std::move(dispatchEntry));
3923 connection->outboundQueue.erase(connection->outboundQueue.begin());
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00003924 traceOutboundQueueLength(*connection);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003925 if (connection->responsive) {
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08003926 mAnrTracker.insert(timeoutTime, connection->getToken());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003927 }
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00003928 traceWaitQueueLength(*connection);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003929 }
3930}
3931
chaviw09c8d2d2020-08-24 15:48:26 -07003932std::array<uint8_t, 32> InputDispatcher::sign(const VerifiedInputEvent& event) const {
3933 size_t size;
3934 switch (event.type) {
3935 case VerifiedInputEvent::Type::KEY: {
3936 size = sizeof(VerifiedKeyEvent);
3937 break;
3938 }
3939 case VerifiedInputEvent::Type::MOTION: {
3940 size = sizeof(VerifiedMotionEvent);
3941 break;
3942 }
3943 }
3944 const uint8_t* start = reinterpret_cast<const uint8_t*>(&event);
3945 return mHmacKeyManager.sign(start, size);
3946}
3947
Edgar Arriagac6ae4bb2020-04-16 18:46:48 -07003948const std::array<uint8_t, 32> InputDispatcher::getSignature(
3949 const MotionEntry& motionEntry, const DispatchEntry& dispatchEntry) const {
Prabir Pradhan2a2da1d2023-11-03 02:16:20 +00003950 const int32_t actionMasked = MotionEvent::getActionMasked(motionEntry.action);
Prabir Pradhanb5cb9572021-09-24 06:35:16 -07003951 if (actionMasked != AMOTION_EVENT_ACTION_UP && actionMasked != AMOTION_EVENT_ACTION_DOWN) {
Edgar Arriagac6ae4bb2020-04-16 18:46:48 -07003952 // Only sign events up and down events as the purely move events
3953 // are tied to their up/down counterparts so signing would be redundant.
Prabir Pradhanb5cb9572021-09-24 06:35:16 -07003954 return INVALID_HMAC;
Edgar Arriagac6ae4bb2020-04-16 18:46:48 -07003955 }
Prabir Pradhanb5cb9572021-09-24 06:35:16 -07003956
3957 VerifiedMotionEvent verifiedEvent =
3958 verifiedMotionEventFromMotionEntry(motionEntry, dispatchEntry.rawTransform);
3959 verifiedEvent.actionMasked = actionMasked;
3960 verifiedEvent.flags = dispatchEntry.resolvedFlags & VERIFIED_MOTION_EVENT_FLAGS;
3961 return sign(verifiedEvent);
Edgar Arriagac6ae4bb2020-04-16 18:46:48 -07003962}
3963
3964const std::array<uint8_t, 32> InputDispatcher::getSignature(
3965 const KeyEntry& keyEntry, const DispatchEntry& dispatchEntry) const {
3966 VerifiedKeyEvent verifiedEvent = verifiedKeyEventFromKeyEntry(keyEntry);
3967 verifiedEvent.flags = dispatchEntry.resolvedFlags & VERIFIED_KEY_EVENT_FLAGS;
chaviw09c8d2d2020-08-24 15:48:26 -07003968 return sign(verifiedEvent);
Edgar Arriagac6ae4bb2020-04-16 18:46:48 -07003969}
3970
Michael Wrightd02c5b62014-02-10 15:10:22 -08003971void InputDispatcher::finishDispatchCycleLocked(nsecs_t currentTime,
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003972 const std::shared_ptr<Connection>& connection,
3973 uint32_t seq, bool handled, nsecs_t consumeTime) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003974 if (DEBUG_DISPATCH_CYCLE) {
3975 ALOGD("channel '%s' ~ finishDispatchCycle - seq=%u, handled=%s",
3976 connection->getInputChannelName().c_str(), seq, toString(handled));
3977 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003978
Prabir Pradhan98ca4a22024-01-09 23:51:50 +00003979 if (connection->status != Connection::Status::NORMAL) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003980 return;
3981 }
3982
3983 // Notify other system components and prepare to start the next dispatch cycle.
Prabir Pradhancef936d2021-07-21 16:17:52 +00003984 auto command = [this, currentTime, connection, seq, handled, consumeTime]() REQUIRES(mLock) {
3985 doDispatchCycleFinishedCommand(currentTime, connection, seq, handled, consumeTime);
3986 };
3987 postCommandLocked(std::move(command));
Michael Wrightd02c5b62014-02-10 15:10:22 -08003988}
3989
3990void InputDispatcher::abortBrokenDispatchCycleLocked(nsecs_t currentTime,
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003991 const std::shared_ptr<Connection>& connection,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003992 bool notify) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003993 if (DEBUG_DISPATCH_CYCLE) {
Siarhei Vishniakou827d1ac2023-07-21 16:37:51 -07003994 LOG(INFO) << "channel '" << connection->getInputChannelName() << "'~ " << __func__
3995 << " - notify=" << toString(notify);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003996 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003997
3998 // Clear the dispatch queues.
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07003999 drainDispatchQueue(connection->outboundQueue);
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00004000 traceOutboundQueueLength(*connection);
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07004001 drainDispatchQueue(connection->waitQueue);
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00004002 traceWaitQueueLength(*connection);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004003
4004 // The connection appears to be unrecoverably broken.
4005 // Ignore already broken or zombie connections.
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08004006 if (connection->status == Connection::Status::NORMAL) {
4007 connection->status = Connection::Status::BROKEN;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004008
4009 if (notify) {
4010 // Notify other system components.
Prabir Pradhancef936d2021-07-21 16:17:52 +00004011 ALOGE("channel '%s' ~ Channel is unrecoverably broken and will be disposed!",
4012 connection->getInputChannelName().c_str());
4013
4014 auto command = [this, connection]() REQUIRES(mLock) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00004015 scoped_unlock unlock(mLock);
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08004016 mPolicy.notifyInputChannelBroken(connection->getToken());
Prabir Pradhancef936d2021-07-21 16:17:52 +00004017 };
4018 postCommandLocked(std::move(command));
Michael Wrightd02c5b62014-02-10 15:10:22 -08004019 }
4020 }
4021}
4022
Prabir Pradhan8c90d782023-09-15 21:16:44 +00004023void InputDispatcher::drainDispatchQueue(std::deque<std::unique_ptr<DispatchEntry>>& queue) {
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07004024 while (!queue.empty()) {
Prabir Pradhan8c90d782023-09-15 21:16:44 +00004025 releaseDispatchEntry(std::move(queue.front()));
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07004026 queue.pop_front();
Michael Wrightd02c5b62014-02-10 15:10:22 -08004027 }
4028}
4029
Prabir Pradhan8c90d782023-09-15 21:16:44 +00004030void InputDispatcher::releaseDispatchEntry(std::unique_ptr<DispatchEntry> dispatchEntry) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004031 if (dispatchEntry->hasForegroundTarget()) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004032 decrementPendingForegroundDispatches(*(dispatchEntry->eventEntry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08004033 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004034}
4035
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00004036int InputDispatcher::handleReceiveCallback(int events, sp<IBinder> connectionToken) {
4037 std::scoped_lock _l(mLock);
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07004038 std::shared_ptr<Connection> connection = getConnectionLocked(connectionToken);
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00004039 if (connection == nullptr) {
4040 ALOGW("Received looper callback for unknown input channel token %p. events=0x%x",
4041 connectionToken.get(), events);
4042 return 0; // remove the callback
4043 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004044
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00004045 bool notify;
4046 if (!(events & (ALOOPER_EVENT_ERROR | ALOOPER_EVENT_HANGUP))) {
4047 if (!(events & ALOOPER_EVENT_INPUT)) {
4048 ALOGW("channel '%s' ~ Received spurious callback for unhandled poll event. "
4049 "events=0x%x",
4050 connection->getInputChannelName().c_str(), events);
4051 return 1;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004052 }
4053
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00004054 nsecs_t currentTime = now();
4055 bool gotOne = false;
4056 status_t status = OK;
4057 for (;;) {
4058 Result<InputPublisher::ConsumerResponse> result =
4059 connection->inputPublisher.receiveConsumerResponse();
4060 if (!result.ok()) {
4061 status = result.error().code();
4062 break;
4063 }
4064
4065 if (std::holds_alternative<InputPublisher::Finished>(*result)) {
4066 const InputPublisher::Finished& finish =
4067 std::get<InputPublisher::Finished>(*result);
4068 finishDispatchCycleLocked(currentTime, connection, finish.seq, finish.handled,
4069 finish.consumeTime);
4070 } else if (std::holds_alternative<InputPublisher::Timeline>(*result)) {
Siarhei Vishniakouf2652122021-03-05 21:39:46 +00004071 if (shouldReportMetricsForConnection(*connection)) {
4072 const InputPublisher::Timeline& timeline =
4073 std::get<InputPublisher::Timeline>(*result);
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08004074 mLatencyTracker.trackGraphicsLatency(timeline.inputEventId,
4075 connection->getToken(),
4076 std::move(timeline.graphicsTimeline));
Siarhei Vishniakouf2652122021-03-05 21:39:46 +00004077 }
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00004078 }
4079 gotOne = true;
4080 }
4081 if (gotOne) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00004082 runCommandsLockedInterruptable();
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00004083 if (status == WOULD_BLOCK) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004084 return 1;
4085 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004086 }
4087
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00004088 notify = status != DEAD_OBJECT || !connection->monitor;
4089 if (notify) {
4090 ALOGE("channel '%s' ~ Failed to receive finished signal. status=%s(%d)",
4091 connection->getInputChannelName().c_str(), statusToString(status).c_str(),
4092 status);
4093 }
4094 } else {
4095 // Monitor channels are never explicitly unregistered.
4096 // We do it automatically when the remote endpoint is closed so don't warn about them.
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08004097 const bool stillHaveWindowHandle = getWindowHandleLocked(connection->getToken()) != nullptr;
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00004098 notify = !connection->monitor && stillHaveWindowHandle;
4099 if (notify) {
4100 ALOGW("channel '%s' ~ Consumer closed input channel or an error occurred. events=0x%x",
4101 connection->getInputChannelName().c_str(), events);
4102 }
4103 }
4104
4105 // Remove the channel.
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08004106 removeInputChannelLocked(connection->getToken(), notify);
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00004107 return 0; // remove the callback
Michael Wrightd02c5b62014-02-10 15:10:22 -08004108}
4109
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004110void InputDispatcher::synthesizeCancelationEventsForAllConnectionsLocked(
Michael Wrightd02c5b62014-02-10 15:10:22 -08004111 const CancelationOptions& options) {
Prabir Pradhanbb3f1c02024-01-04 20:17:14 +00004112 // Cancel windows (i.e. non-monitors).
4113 // A channel must have at least one window to receive any input. If a window was removed, the
4114 // event streams directed to the window will already have been canceled during window removal.
4115 // So there is no need to generate cancellations for connections without any windows.
4116 const auto [cancelPointers, cancelNonPointers] = expandCancellationMode(options.mode);
4117 // Generate cancellations for touched windows first. This is to avoid generating cancellations
4118 // through a non-touched window if there are more than one window for an input channel.
4119 if (cancelPointers) {
4120 for (const auto& [displayId, touchState] : mTouchStatesByDisplay) {
4121 if (options.displayId.has_value() && options.displayId != displayId) {
4122 continue;
4123 }
4124 for (const auto& touchedWindow : touchState.windows) {
4125 synthesizeCancelationEventsForWindowLocked(touchedWindow.windowHandle, options);
4126 }
4127 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004128 }
Prabir Pradhanbb3f1c02024-01-04 20:17:14 +00004129 // Follow up by generating cancellations for all windows, because we don't explicitly track
4130 // the windows that have an ongoing focus event stream.
4131 if (cancelNonPointers) {
4132 for (const auto& [_, handles] : mWindowHandlesByDisplay) {
4133 for (const auto& windowHandle : handles) {
4134 synthesizeCancelationEventsForWindowLocked(windowHandle, options);
4135 }
4136 }
4137 }
4138
4139 // Cancel monitors.
4140 synthesizeCancelationEventsForMonitorsLocked(options);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004141}
4142
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004143void InputDispatcher::synthesizeCancelationEventsForMonitorsLocked(
Michael Wrightfa13dcf2015-06-12 13:25:11 +01004144 const CancelationOptions& options) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08004145 for (const auto& [_, monitors] : mGlobalMonitorsByDisplay) {
Michael Wright3dd60e22019-03-27 22:06:44 +00004146 for (const Monitor& monitor : monitors) {
Prabir Pradhanbb3f1c02024-01-04 20:17:14 +00004147 synthesizeCancelationEventsForConnectionLocked(monitor.connection, options,
4148 /*window=*/nullptr);
Arthur Hung2fbf37f2018-09-13 18:16:41 +08004149 }
Michael Wrightfa13dcf2015-06-12 13:25:11 +01004150 }
4151}
4152
Prabir Pradhanbb3f1c02024-01-04 20:17:14 +00004153void InputDispatcher::synthesizeCancelationEventsForWindowLocked(
4154 const sp<WindowInfoHandle>& windowHandle, const CancelationOptions& options,
4155 const std::shared_ptr<Connection>& connection) {
4156 if (windowHandle == nullptr) {
4157 LOG(FATAL) << __func__ << ": Window handle must not be null";
4158 }
4159 if (connection) {
4160 // The connection can be optionally provided to avoid multiple lookups.
4161 if (windowHandle->getToken() != connection->getToken()) {
4162 LOG(FATAL) << __func__
4163 << ": Wrong connection provided for window: " << windowHandle->getName();
4164 }
4165 }
4166
4167 std::shared_ptr<Connection> resolvedConnection =
4168 connection ? connection : getConnectionLocked(windowHandle->getToken());
4169 if (!resolvedConnection) {
4170 LOG(DEBUG) << __func__ << "No connection found for window: " << windowHandle->getName();
4171 return;
4172 }
4173 synthesizeCancelationEventsForConnectionLocked(resolvedConnection, options, windowHandle);
4174}
4175
Michael Wrightd02c5b62014-02-10 15:10:22 -08004176void InputDispatcher::synthesizeCancelationEventsForConnectionLocked(
Prabir Pradhanbb3f1c02024-01-04 20:17:14 +00004177 const std::shared_ptr<Connection>& connection, const CancelationOptions& options,
4178 const sp<WindowInfoHandle>& window) {
4179 if (!connection->monitor && window == nullptr) {
4180 LOG(FATAL) << __func__
4181 << ": Cannot send event to non-monitor channel without a window - channel: "
4182 << connection->getInputChannelName();
4183 }
Prabir Pradhanb13da8f2024-01-09 23:10:13 +00004184 if (connection->status != Connection::Status::NORMAL) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004185 return;
4186 }
4187
4188 nsecs_t currentTime = now();
4189
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004190 std::vector<std::unique_ptr<EventEntry>> cancelationEvents =
Siarhei Vishniakou00fca7c2019-10-29 13:05:57 -07004191 connection->inputState.synthesizeCancelationEvents(currentTime, options);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004192
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08004193 if (cancelationEvents.empty()) {
4194 return;
4195 }
Vaibhav Devmurari110ba322023-11-17 10:47:16 +00004196
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004197 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
4198 ALOGD("channel '%s' ~ Synthesized %zu cancelation events to bring channel back in sync "
Siarhei Vishniakou2e3e4432023-02-09 18:34:11 -08004199 "with reality: %s, mode=%s.",
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004200 connection->getInputChannelName().c_str(), cancelationEvents.size(), options.reason,
Siarhei Vishniakou2e3e4432023-02-09 18:34:11 -08004201 ftl::enum_string(options.mode).c_str());
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004202 }
Svet Ganov5d3bc372020-01-26 23:11:07 -08004203
Arthur Hungb3307ee2021-10-14 10:57:37 +00004204 std::string reason = std::string("reason=").append(options.reason);
4205 android_log_event_list(LOGTAG_INPUT_CANCEL)
4206 << connection->getInputChannelName().c_str() << reason << LOG_ID_EVENTS;
4207
hongzuo liu95785e22022-09-06 02:51:35 +00004208 const bool wasEmpty = connection->outboundQueue.empty();
Prabir Pradhan16463382023-10-12 23:03:19 +00004209 // The target to use if we don't find a window associated with the channel.
Prabir Pradhanc32a4112024-01-23 23:20:37 +00004210 const InputTarget fallbackTarget{connection};
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08004211 const auto& token = connection->getToken();
hongzuo liu95785e22022-09-06 02:51:35 +00004212
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08004213 for (size_t i = 0; i < cancelationEvents.size(); i++) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004214 std::unique_ptr<EventEntry> cancelationEventEntry = std::move(cancelationEvents[i]);
Prabir Pradhan112b1ad2023-09-21 09:53:53 +00004215 std::vector<InputTarget> targets{};
Prabir Pradhan112b1ad2023-09-21 09:53:53 +00004216
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08004217 switch (cancelationEventEntry->type) {
4218 case EventEntry::Type::KEY: {
Prabir Pradhand6b2b052024-02-21 23:25:15 +00004219 if (mTracer) {
4220 static_cast<KeyEntry&>(*cancelationEventEntry).traceTracker =
4221 mTracer->traceDerivedEvent(*cancelationEventEntry,
4222 *options.traceTracker);
4223 }
Prabir Pradhan112b1ad2023-09-21 09:53:53 +00004224 const auto& keyEntry = static_cast<const KeyEntry&>(*cancelationEventEntry);
Prabir Pradhanbb3f1c02024-01-04 20:17:14 +00004225 if (window) {
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00004226 addWindowTargetLocked(window, InputTarget::DispatchMode::AS_IS,
4227 /*targetFlags=*/{}, keyEntry.downTime, targets);
Prabir Pradhan112b1ad2023-09-21 09:53:53 +00004228 } else {
4229 targets.emplace_back(fallbackTarget);
4230 }
4231 logOutboundKeyDetails("cancel - ", keyEntry);
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08004232 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004233 }
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08004234 case EventEntry::Type::MOTION: {
Prabir Pradhand6b2b052024-02-21 23:25:15 +00004235 if (mTracer) {
4236 static_cast<MotionEntry&>(*cancelationEventEntry).traceTracker =
4237 mTracer->traceDerivedEvent(*cancelationEventEntry,
4238 *options.traceTracker);
4239 }
Prabir Pradhan112b1ad2023-09-21 09:53:53 +00004240 const auto& motionEntry = static_cast<const MotionEntry&>(*cancelationEventEntry);
Prabir Pradhanbb3f1c02024-01-04 20:17:14 +00004241 if (window) {
Prabir Pradhan112b1ad2023-09-21 09:53:53 +00004242 std::bitset<MAX_POINTER_ID + 1> pointerIds;
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07004243 for (uint32_t pointerIndex = 0; pointerIndex < motionEntry.getPointerCount();
Prabir Pradhan112b1ad2023-09-21 09:53:53 +00004244 pointerIndex++) {
4245 pointerIds.set(motionEntry.pointerProperties[pointerIndex].id);
4246 }
Vaibhav Devmurari110ba322023-11-17 10:47:16 +00004247 if (mDragState && mDragState->dragWindow->getToken() == token &&
4248 pointerIds.test(mDragState->pointerId)) {
4249 LOG(INFO) << __func__
4250 << ": Canceling drag and drop because the pointers for the drag "
4251 "window are being canceled.";
4252 sendDropWindowCommandLocked(nullptr, /*x=*/0, /*y=*/0);
4253 mDragState.reset();
4254 }
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00004255 addPointerWindowTargetLocked(window, InputTarget::DispatchMode::AS_IS,
4256 ftl::Flags<InputTarget::Flags>(), pointerIds,
4257 motionEntry.downTime, targets);
Prabir Pradhan112b1ad2023-09-21 09:53:53 +00004258 } else {
4259 targets.emplace_back(fallbackTarget);
4260 const auto it = mDisplayInfos.find(motionEntry.displayId);
4261 if (it != mDisplayInfos.end()) {
4262 targets.back().displayTransform = it->second.transform;
4263 targets.back().setDefaultPointerTransform(it->second.transform);
4264 }
4265 }
4266 logOutboundMotionDetails("cancel - ", motionEntry);
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08004267 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004268 }
Prabir Pradhan99987712020-11-10 18:43:05 -08004269 case EventEntry::Type::FOCUS:
Antonio Kantek7242d8b2021-08-05 16:07:20 -07004270 case EventEntry::Type::TOUCH_MODE_CHANGED:
arthurhungb89ccb02020-12-30 16:19:01 +08004271 case EventEntry::Type::POINTER_CAPTURE_CHANGED:
4272 case EventEntry::Type::DRAG: {
Prabir Pradhan99987712020-11-10 18:43:05 -08004273 LOG_ALWAYS_FATAL("Canceling %s events is not supported",
Dominik Laskowski75788452021-02-09 18:51:25 -08004274 ftl::enum_string(cancelationEventEntry->type).c_str());
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08004275 break;
4276 }
4277 case EventEntry::Type::CONFIGURATION_CHANGED:
Chris Yef59a2f42020-10-16 12:55:26 -07004278 case EventEntry::Type::DEVICE_RESET:
4279 case EventEntry::Type::SENSOR: {
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08004280 LOG_ALWAYS_FATAL("%s event should not be found inside Connections's queue",
Dominik Laskowski75788452021-02-09 18:51:25 -08004281 ftl::enum_string(cancelationEventEntry->type).c_str());
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08004282 break;
4283 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004284 }
4285
Prabir Pradhan112b1ad2023-09-21 09:53:53 +00004286 if (targets.size() != 1) LOG(FATAL) << __func__ << ": InputTarget not created";
Prabir Pradhand6b2b052024-02-21 23:25:15 +00004287 if (mTracer) {
4288 mTracer->dispatchToTargetHint(*options.traceTracker, targets[0]);
4289 }
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00004290 enqueueDispatchEntryLocked(connection, std::move(cancelationEventEntry), targets[0]);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004291 }
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08004292
hongzuo liu95785e22022-09-06 02:51:35 +00004293 // If the outbound queue was previously empty, start the dispatch cycle going.
4294 if (wasEmpty && !connection->outboundQueue.empty()) {
4295 startDispatchCycleLocked(currentTime, connection);
4296 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004297}
4298
Svet Ganov5d3bc372020-01-26 23:11:07 -08004299void InputDispatcher::synthesizePointerDownEventsForConnectionLocked(
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07004300 const nsecs_t downTime, const std::shared_ptr<Connection>& connection,
Prabir Pradhand6b2b052024-02-21 23:25:15 +00004301 ftl::Flags<InputTarget::Flags> targetFlags,
4302 const std::unique_ptr<trace::EventTrackerInterface>& traceTracker) {
Prabir Pradhan98ca4a22024-01-09 23:51:50 +00004303 if (connection->status != Connection::Status::NORMAL) {
Svet Ganov5d3bc372020-01-26 23:11:07 -08004304 return;
4305 }
4306
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004307 std::vector<std::unique_ptr<EventEntry>> downEvents =
Vaibhav Devmurari882bd9b2022-06-23 14:54:54 +00004308 connection->inputState.synthesizePointerDownEvents(downTime);
Svet Ganov5d3bc372020-01-26 23:11:07 -08004309
4310 if (downEvents.empty()) {
4311 return;
4312 }
4313
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004314 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
Svet Ganov5d3bc372020-01-26 23:11:07 -08004315 ALOGD("channel '%s' ~ Synthesized %zu down events to ensure consistent event stream.",
4316 connection->getInputChannelName().c_str(), downEvents.size());
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004317 }
Svet Ganov5d3bc372020-01-26 23:11:07 -08004318
Prabir Pradhanfeca0572024-02-06 00:43:11 +00004319 const auto [_, touchedWindowState, displayId] =
4320 findTouchStateWindowAndDisplayLocked(connection->getToken());
4321 if (touchedWindowState == nullptr) {
4322 LOG(FATAL) << __func__ << ": Touch state is out of sync: No touched window for token";
4323 }
4324 const auto& windowHandle = touchedWindowState->windowHandle;
Svet Ganov5d3bc372020-01-26 23:11:07 -08004325
hongzuo liu95785e22022-09-06 02:51:35 +00004326 const bool wasEmpty = connection->outboundQueue.empty();
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004327 for (std::unique_ptr<EventEntry>& downEventEntry : downEvents) {
Prabir Pradhan1c29a092023-09-21 10:29:29 +00004328 std::vector<InputTarget> targets{};
Svet Ganov5d3bc372020-01-26 23:11:07 -08004329 switch (downEventEntry->type) {
4330 case EventEntry::Type::MOTION: {
Prabir Pradhand6b2b052024-02-21 23:25:15 +00004331 if (mTracer) {
4332 static_cast<MotionEntry&>(*downEventEntry).traceTracker =
4333 mTracer->traceDerivedEvent(*downEventEntry, *traceTracker);
4334 }
Prabir Pradhan1c29a092023-09-21 10:29:29 +00004335 const auto& motionEntry = static_cast<const MotionEntry&>(*downEventEntry);
4336 if (windowHandle != nullptr) {
4337 std::bitset<MAX_POINTER_ID + 1> pointerIds;
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07004338 for (uint32_t pointerIndex = 0; pointerIndex < motionEntry.getPointerCount();
Prabir Pradhan1c29a092023-09-21 10:29:29 +00004339 pointerIndex++) {
4340 pointerIds.set(motionEntry.pointerProperties[pointerIndex].id);
4341 }
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00004342 addPointerWindowTargetLocked(windowHandle, InputTarget::DispatchMode::AS_IS,
4343 targetFlags, pointerIds, motionEntry.downTime,
4344 targets);
Prabir Pradhan1c29a092023-09-21 10:29:29 +00004345 } else {
Prabir Pradhanc32a4112024-01-23 23:20:37 +00004346 targets.emplace_back(connection, targetFlags);
Prabir Pradhan1c29a092023-09-21 10:29:29 +00004347 const auto it = mDisplayInfos.find(motionEntry.displayId);
4348 if (it != mDisplayInfos.end()) {
4349 targets.back().displayTransform = it->second.transform;
4350 targets.back().setDefaultPointerTransform(it->second.transform);
4351 }
4352 }
4353 logOutboundMotionDetails("down - ", motionEntry);
Svet Ganov5d3bc372020-01-26 23:11:07 -08004354 break;
4355 }
4356
4357 case EventEntry::Type::KEY:
4358 case EventEntry::Type::FOCUS:
Antonio Kantek7242d8b2021-08-05 16:07:20 -07004359 case EventEntry::Type::TOUCH_MODE_CHANGED:
Svet Ganov5d3bc372020-01-26 23:11:07 -08004360 case EventEntry::Type::CONFIGURATION_CHANGED:
Prabir Pradhan99987712020-11-10 18:43:05 -08004361 case EventEntry::Type::DEVICE_RESET:
Chris Yef59a2f42020-10-16 12:55:26 -07004362 case EventEntry::Type::POINTER_CAPTURE_CHANGED:
arthurhungb89ccb02020-12-30 16:19:01 +08004363 case EventEntry::Type::SENSOR:
4364 case EventEntry::Type::DRAG: {
Svet Ganov5d3bc372020-01-26 23:11:07 -08004365 LOG_ALWAYS_FATAL("%s event should not be found inside Connections's queue",
Dominik Laskowski75788452021-02-09 18:51:25 -08004366 ftl::enum_string(downEventEntry->type).c_str());
Svet Ganov5d3bc372020-01-26 23:11:07 -08004367 break;
4368 }
4369 }
4370
Prabir Pradhan1c29a092023-09-21 10:29:29 +00004371 if (targets.size() != 1) LOG(FATAL) << __func__ << ": InputTarget not created";
Prabir Pradhand6b2b052024-02-21 23:25:15 +00004372 if (mTracer) {
4373 mTracer->dispatchToTargetHint(*traceTracker, targets[0]);
4374 }
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00004375 enqueueDispatchEntryLocked(connection, std::move(downEventEntry), targets[0]);
Svet Ganov5d3bc372020-01-26 23:11:07 -08004376 }
4377
hongzuo liu95785e22022-09-06 02:51:35 +00004378 // If the outbound queue was previously empty, start the dispatch cycle going.
4379 if (wasEmpty && !connection->outboundQueue.empty()) {
4380 startDispatchCycleLocked(downTime, connection);
4381 }
Svet Ganov5d3bc372020-01-26 23:11:07 -08004382}
4383
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004384std::unique_ptr<MotionEntry> InputDispatcher::splitMotionEvent(
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08004385 const MotionEntry& originalMotionEntry, std::bitset<MAX_POINTER_ID + 1> pointerIds,
4386 nsecs_t splitDownTime) {
Prabir Pradhanbf9b0a82024-02-29 02:23:50 +00004387 const auto& [action, pointerProperties, pointerCoords] =
4388 MotionEvent::split(originalMotionEntry.action, originalMotionEntry.flags,
4389 /*historySize=*/0, originalMotionEntry.pointerProperties,
4390 originalMotionEntry.pointerCoords, pointerIds);
Prabir Pradhan1a41fe02024-03-11 18:38:40 +00004391 if (pointerIds.count() != pointerCoords.size()) {
4392 // TODO(b/329107108): Determine why some IDs in pointerIds were not in originalMotionEntry.
4393 // This is bad. We are missing some of the pointers that we expected to deliver.
4394 // Most likely this indicates that we received an ACTION_MOVE events that has
4395 // different pointer ids than we expected based on the previous ACTION_DOWN
4396 // or ACTION_POINTER_DOWN events that caused us to decide to split the pointers
4397 // in this way.
Siarhei Vishniakoued89cbb2023-10-13 10:42:44 -07004398 ALOGW("Dropping split motion event because the pointer count is %zu but "
Prabir Pradhan1a41fe02024-03-11 18:38:40 +00004399 "we expected there to be %zu pointers. This probably means we received "
4400 "a broken sequence of pointer ids from the input device: %s",
4401 pointerCoords.size(), pointerIds.count(),
4402 originalMotionEntry.getDescription().c_str());
4403 return nullptr;
4404 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004405
Prabir Pradhanbf9b0a82024-02-29 02:23:50 +00004406 // TODO(b/327503168): Move this check inside MotionEvent::split once all callers handle it
4407 // correctly.
Siarhei Vishniakou59e302b2023-06-05 08:04:53 -07004408 if (action == AMOTION_EVENT_ACTION_DOWN && splitDownTime != originalMotionEntry.eventTime) {
4409 logDispatchStateLocked();
4410 LOG_ALWAYS_FATAL("Split motion event has mismatching downTime and eventTime for "
4411 "ACTION_DOWN, motionEntry=%s, splitDownTime=%" PRId64,
4412 originalMotionEntry.getDescription().c_str(), splitDownTime);
Vaibhav Devmurari882bd9b2022-06-23 14:54:54 +00004413 }
4414
Garfield Tanff1f1bb2020-01-28 13:24:04 -08004415 int32_t newId = mIdGenerator.nextId();
Prabir Pradhan2dac8b82023-09-06 01:11:51 +00004416 ATRACE_NAME_IF(ATRACE_ENABLED(),
4417 StringPrintf("Split MotionEvent(id=0x%" PRIx32 ") to MotionEvent(id=0x%" PRIx32
4418 ").",
4419 originalMotionEntry.id, newId));
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004420 std::unique_ptr<MotionEntry> splitMotionEntry =
Prabir Pradhana8cdbe12023-11-01 21:30:02 +00004421 std::make_unique<MotionEntry>(newId, originalMotionEntry.injectionState,
4422 originalMotionEntry.eventTime,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004423 originalMotionEntry.deviceId, originalMotionEntry.source,
4424 originalMotionEntry.displayId,
4425 originalMotionEntry.policyFlags, action,
4426 originalMotionEntry.actionButton,
4427 originalMotionEntry.flags, originalMotionEntry.metaState,
4428 originalMotionEntry.buttonState,
4429 originalMotionEntry.classification,
4430 originalMotionEntry.edgeFlags,
4431 originalMotionEntry.xPrecision,
4432 originalMotionEntry.yPrecision,
4433 originalMotionEntry.xCursorPosition,
Vaibhav Devmurari882bd9b2022-06-23 14:54:54 +00004434 originalMotionEntry.yCursorPosition, splitDownTime,
Prabir Pradhanbf9b0a82024-02-29 02:23:50 +00004435 pointerProperties, pointerCoords);
Prabir Pradhana67623c2024-02-21 06:57:36 +00004436 if (mTracer) {
4437 splitMotionEntry->traceTracker =
4438 mTracer->traceDerivedEvent(*splitMotionEntry, *originalMotionEntry.traceTracker);
4439 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004440
Michael Wrightd02c5b62014-02-10 15:10:22 -08004441 return splitMotionEntry;
4442}
4443
Asmita Poddardd9a6cd2023-09-26 15:35:12 +00004444void InputDispatcher::notifyInputDevicesChanged(const NotifyInputDevicesChangedArgs& args) {
4445 std::scoped_lock _l(mLock);
4446 mLatencyTracker.setInputDevices(args.inputDeviceInfos);
4447}
4448
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004449void InputDispatcher::notifyConfigurationChanged(const NotifyConfigurationChangedArgs& args) {
Prabir Pradhan65613802023-02-22 23:36:58 +00004450 if (debugInboundEventDetails()) {
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004451 ALOGD("notifyConfigurationChanged - eventTime=%" PRId64, args.eventTime);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004452 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004453
Antonio Kantekf16f2832021-09-28 04:39:20 +00004454 bool needWake = false;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004455 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004456 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004457
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004458 std::unique_ptr<ConfigurationChangedEntry> newEntry =
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004459 std::make_unique<ConfigurationChangedEntry>(args.id, args.eventTime);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004460 needWake = enqueueInboundEventLocked(std::move(newEntry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08004461 } // release lock
4462
4463 if (needWake) {
4464 mLooper->wake();
4465 }
4466}
4467
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004468void InputDispatcher::notifyKey(const NotifyKeyArgs& args) {
Prabir Pradhan96282b02023-02-24 22:36:17 +00004469 ALOGD_IF(debugInboundEventDetails(),
4470 "notifyKey - id=%" PRIx32 ", eventTime=%" PRId64
4471 ", deviceId=%d, source=%s, displayId=%" PRId32
4472 "policyFlags=0x%x, action=%s, flags=0x%x, keyCode=%s, scanCode=0x%x, metaState=0x%x, "
4473 "downTime=%" PRId64,
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004474 args.id, args.eventTime, args.deviceId, inputEventSourceToString(args.source).c_str(),
4475 args.displayId, args.policyFlags, KeyEvent::actionToString(args.action), args.flags,
4476 KeyEvent::getLabel(args.keyCode), args.scanCode, args.metaState, args.downTime);
Siarhei Vishniakou23740b92023-04-21 11:30:20 -07004477 Result<void> keyCheck = validateKeyEvent(args.action);
4478 if (!keyCheck.ok()) {
4479 LOG(ERROR) << "invalid key event: " << keyCheck.error();
Michael Wrightd02c5b62014-02-10 15:10:22 -08004480 return;
4481 }
4482
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004483 uint32_t policyFlags = args.policyFlags;
4484 int32_t flags = args.flags;
4485 int32_t metaState = args.metaState;
Siarhei Vishniakou622bd322018-10-29 18:02:27 -07004486 // InputDispatcher tracks and generates key repeats on behalf of
4487 // whatever notifies it, so repeatCount should always be set to 0
4488 constexpr int32_t repeatCount = 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004489 if ((policyFlags & POLICY_FLAG_VIRTUAL) || (flags & AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY)) {
4490 policyFlags |= POLICY_FLAG_VIRTUAL;
4491 flags |= AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY;
4492 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004493 if (policyFlags & POLICY_FLAG_FUNCTION) {
4494 metaState |= AMETA_FUNCTION_ON;
4495 }
4496
4497 policyFlags |= POLICY_FLAG_TRUSTED;
4498
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004499 int32_t keyCode = args.keyCode;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004500 KeyEvent event;
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004501 event.initialize(args.id, args.deviceId, args.source, args.displayId, INVALID_HMAC, args.action,
4502 flags, keyCode, args.scanCode, metaState, repeatCount, args.downTime,
4503 args.eventTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004504
Michael Wright2b3c3302018-03-02 17:19:13 +00004505 android::base::Timer t;
Prabir Pradhana41d2442023-04-20 21:30:40 +00004506 mPolicy.interceptKeyBeforeQueueing(event, /*byref*/ policyFlags);
Michael Wright2b3c3302018-03-02 17:19:13 +00004507 if (t.duration() > SLOW_INTERCEPTION_THRESHOLD) {
4508 ALOGW("Excessive delay in interceptKeyBeforeQueueing; took %s ms",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004509 std::to_string(t.duration().count()).c_str());
Michael Wright2b3c3302018-03-02 17:19:13 +00004510 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004511
Antonio Kantekf16f2832021-09-28 04:39:20 +00004512 bool needWake = false;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004513 { // acquire lock
4514 mLock.lock();
4515
4516 if (shouldSendKeyToInputFilterLocked(args)) {
4517 mLock.unlock();
4518
Siarhei Vishniakouf00a4ec2021-06-16 03:55:32 +00004519 policyFlags |= POLICY_FLAG_FILTERED;
Prabir Pradhana41d2442023-04-20 21:30:40 +00004520 if (!mPolicy.filterInputEvent(event, policyFlags)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004521 return; // event was consumed by the filter
4522 }
4523
4524 mLock.lock();
4525 }
4526
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004527 std::unique_ptr<KeyEntry> newEntry =
Prabir Pradhana8cdbe12023-11-01 21:30:02 +00004528 std::make_unique<KeyEntry>(args.id, /*injectionState=*/nullptr, args.eventTime,
4529 args.deviceId, args.source, args.displayId, policyFlags,
4530 args.action, flags, keyCode, args.scanCode, metaState,
4531 repeatCount, args.downTime);
Prabir Pradhanabcdf5c2023-12-15 07:30:22 +00004532 if (mTracer) {
4533 newEntry->traceTracker = mTracer->traceInboundEvent(*newEntry);
4534 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004535
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004536 needWake = enqueueInboundEventLocked(std::move(newEntry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08004537 mLock.unlock();
4538 } // release lock
4539
4540 if (needWake) {
4541 mLooper->wake();
4542 }
4543}
4544
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004545bool InputDispatcher::shouldSendKeyToInputFilterLocked(const NotifyKeyArgs& args) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004546 return mInputFilterEnabled;
4547}
4548
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004549void InputDispatcher::notifyMotion(const NotifyMotionArgs& args) {
Prabir Pradhan65613802023-02-22 23:36:58 +00004550 if (debugInboundEventDetails()) {
Prabir Pradhan96282b02023-02-24 22:36:17 +00004551 ALOGD("notifyMotion - id=%" PRIx32 " eventTime=%" PRId64 ", deviceId=%d, source=%s, "
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004552 "displayId=%" PRId32 ", policyFlags=0x%x, "
Siarhei Vishniakou6ebd0692022-10-20 15:05:45 -07004553 "action=%s, actionButton=0x%x, flags=0x%x, metaState=0x%x, buttonState=0x%x, "
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004554 "edgeFlags=0x%x, xPrecision=%f, yPrecision=%f, xCursorPosition=%f, "
4555 "yCursorPosition=%f, downTime=%" PRId64,
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004556 args.id, args.eventTime, args.deviceId, inputEventSourceToString(args.source).c_str(),
4557 args.displayId, args.policyFlags, MotionEvent::actionToString(args.action).c_str(),
4558 args.actionButton, args.flags, args.metaState, args.buttonState, args.edgeFlags,
4559 args.xPrecision, args.yPrecision, args.xCursorPosition, args.yCursorPosition,
4560 args.downTime);
Siarhei Vishniakou3218fc02023-06-15 20:41:02 -07004561 for (uint32_t i = 0; i < args.getPointerCount(); i++) {
Prabir Pradhan96282b02023-02-24 22:36:17 +00004562 ALOGD(" Pointer %d: id=%d, toolType=%s, x=%f, y=%f, pressure=%f, size=%f, "
4563 "touchMajor=%f, touchMinor=%f, toolMajor=%f, toolMinor=%f, orientation=%f",
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004564 i, args.pointerProperties[i].id,
4565 ftl::enum_string(args.pointerProperties[i].toolType).c_str(),
4566 args.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_X),
4567 args.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_Y),
4568 args.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_PRESSURE),
4569 args.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_SIZE),
4570 args.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR),
4571 args.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR),
4572 args.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR),
4573 args.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR),
4574 args.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION));
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004575 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004576 }
Siarhei Vishniakou23740b92023-04-21 11:30:20 -07004577
Siarhei Vishniakou3218fc02023-06-15 20:41:02 -07004578 Result<void> motionCheck =
4579 validateMotionEvent(args.action, args.actionButton, args.getPointerCount(),
4580 args.pointerProperties.data());
Siarhei Vishniakou23740b92023-04-21 11:30:20 -07004581 if (!motionCheck.ok()) {
4582 LOG(FATAL) << "Invalid event: " << args.dump() << "; reason: " << motionCheck.error();
4583 return;
4584 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004585
Siarhei Vishniakou5c02a712023-05-15 15:45:02 -07004586 if (DEBUG_VERIFY_EVENTS) {
4587 auto [it, _] =
4588 mVerifiersByDisplay.try_emplace(args.displayId,
4589 StringPrintf("display %" PRId32, args.displayId));
4590 Result<void> result =
Siarhei Vishniakou2d151ac2023-09-19 13:30:24 -07004591 it->second.processMovement(args.deviceId, args.source, args.action,
4592 args.getPointerCount(), args.pointerProperties.data(),
4593 args.pointerCoords.data(), args.flags);
Siarhei Vishniakou5c02a712023-05-15 15:45:02 -07004594 if (!result.ok()) {
4595 LOG(FATAL) << "Bad stream: " << result.error() << " caused by " << args.dump();
4596 }
4597 }
4598
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004599 uint32_t policyFlags = args.policyFlags;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004600 policyFlags |= POLICY_FLAG_TRUSTED;
Michael Wright2b3c3302018-03-02 17:19:13 +00004601
4602 android::base::Timer t;
Yeabkal Wubshit88a90412023-12-21 18:23:04 -08004603 mPolicy.interceptMotionBeforeQueueing(args.displayId, args.source, args.action, args.eventTime,
4604 policyFlags);
Michael Wright2b3c3302018-03-02 17:19:13 +00004605 if (t.duration() > SLOW_INTERCEPTION_THRESHOLD) {
4606 ALOGW("Excessive delay in interceptMotionBeforeQueueing; took %s ms",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004607 std::to_string(t.duration().count()).c_str());
Michael Wright2b3c3302018-03-02 17:19:13 +00004608 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004609
Antonio Kantekf16f2832021-09-28 04:39:20 +00004610 bool needWake = false;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004611 { // acquire lock
4612 mLock.lock();
Siarhei Vishniakou5bf25d92023-02-08 15:43:38 -08004613 if (!(policyFlags & POLICY_FLAG_PASS_TO_USER)) {
4614 // Set the flag anyway if we already have an ongoing gesture. That would allow us to
4615 // complete the processing of the current stroke.
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004616 const auto touchStateIt = mTouchStatesByDisplay.find(args.displayId);
Siarhei Vishniakou5bf25d92023-02-08 15:43:38 -08004617 if (touchStateIt != mTouchStatesByDisplay.end()) {
4618 const TouchState& touchState = touchStateIt->second;
Linnan Li907ae732023-09-05 17:14:21 +08004619 if (touchState.hasTouchingPointers(args.deviceId) ||
4620 touchState.hasHoveringPointers(args.deviceId)) {
Siarhei Vishniakou5bf25d92023-02-08 15:43:38 -08004621 policyFlags |= POLICY_FLAG_PASS_TO_USER;
4622 }
4623 }
4624 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004625
4626 if (shouldSendMotionToInputFilterLocked(args)) {
Prabir Pradhan81420cc2021-09-06 10:28:50 -07004627 ui::Transform displayTransform;
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004628 if (const auto it = mDisplayInfos.find(args.displayId); it != mDisplayInfos.end()) {
Prabir Pradhan81420cc2021-09-06 10:28:50 -07004629 displayTransform = it->second.transform;
4630 }
4631
Michael Wrightd02c5b62014-02-10 15:10:22 -08004632 mLock.unlock();
4633
4634 MotionEvent event;
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004635 event.initialize(args.id, args.deviceId, args.source, args.displayId, INVALID_HMAC,
4636 args.action, args.actionButton, args.flags, args.edgeFlags,
4637 args.metaState, args.buttonState, args.classification,
4638 displayTransform, args.xPrecision, args.yPrecision,
4639 args.xCursorPosition, args.yCursorPosition, displayTransform,
Siarhei Vishniakou3218fc02023-06-15 20:41:02 -07004640 args.downTime, args.eventTime, args.getPointerCount(),
4641 args.pointerProperties.data(), args.pointerCoords.data());
Michael Wrightd02c5b62014-02-10 15:10:22 -08004642
4643 policyFlags |= POLICY_FLAG_FILTERED;
Prabir Pradhana41d2442023-04-20 21:30:40 +00004644 if (!mPolicy.filterInputEvent(event, policyFlags)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004645 return; // event was consumed by the filter
4646 }
4647
4648 mLock.lock();
4649 }
4650
4651 // Just enqueue a new motion event.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004652 std::unique_ptr<MotionEntry> newEntry =
Prabir Pradhana8cdbe12023-11-01 21:30:02 +00004653 std::make_unique<MotionEntry>(args.id, /*injectionState=*/nullptr, args.eventTime,
4654 args.deviceId, args.source, args.displayId,
4655 policyFlags, args.action, args.actionButton,
4656 args.flags, args.metaState, args.buttonState,
4657 args.classification, args.edgeFlags, args.xPrecision,
4658 args.yPrecision, args.xCursorPosition,
4659 args.yCursorPosition, args.downTime,
4660 args.pointerProperties, args.pointerCoords);
Prabir Pradhanabcdf5c2023-12-15 07:30:22 +00004661 if (mTracer) {
4662 newEntry->traceTracker = mTracer->traceInboundEvent(*newEntry);
4663 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004664
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004665 if (args.id != android::os::IInputConstants::INVALID_INPUT_EVENT_ID &&
4666 IdGenerator::getSource(args.id) == IdGenerator::Source::INPUT_READER &&
Siarhei Vishniakou363e7292021-07-09 03:22:42 +00004667 !mInputFilterEnabled) {
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004668 const bool isDown = args.action == AMOTION_EVENT_ACTION_DOWN;
Asmita Poddardd9a6cd2023-09-26 15:35:12 +00004669 std::set<InputDeviceUsageSource> sources = getUsageSourcesForMotionArgs(args);
4670 mLatencyTracker.trackListener(args.id, isDown, args.eventTime, args.readTime,
4671 args.deviceId, sources);
Siarhei Vishniakou363e7292021-07-09 03:22:42 +00004672 }
4673
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004674 needWake = enqueueInboundEventLocked(std::move(newEntry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08004675 mLock.unlock();
4676 } // release lock
4677
4678 if (needWake) {
4679 mLooper->wake();
4680 }
4681}
4682
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004683void InputDispatcher::notifySensor(const NotifySensorArgs& args) {
Prabir Pradhan65613802023-02-22 23:36:58 +00004684 if (debugInboundEventDetails()) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004685 ALOGD("notifySensor - id=%" PRIx32 " eventTime=%" PRId64 ", deviceId=%d, source=0x%x, "
4686 " sensorType=%s",
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004687 args.id, args.eventTime, args.deviceId, args.source,
4688 ftl::enum_string(args.sensorType).c_str());
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004689 }
Chris Yef59a2f42020-10-16 12:55:26 -07004690
Antonio Kantekf16f2832021-09-28 04:39:20 +00004691 bool needWake = false;
Chris Yef59a2f42020-10-16 12:55:26 -07004692 { // acquire lock
4693 mLock.lock();
4694
4695 // Just enqueue a new sensor event.
4696 std::unique_ptr<SensorEntry> newEntry =
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004697 std::make_unique<SensorEntry>(args.id, args.eventTime, args.deviceId, args.source,
4698 /* policyFlags=*/0, args.hwTimestamp, args.sensorType,
4699 args.accuracy, args.accuracyChanged, args.values);
Chris Yef59a2f42020-10-16 12:55:26 -07004700
4701 needWake = enqueueInboundEventLocked(std::move(newEntry));
4702 mLock.unlock();
4703 } // release lock
4704
4705 if (needWake) {
4706 mLooper->wake();
4707 }
4708}
4709
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004710void InputDispatcher::notifyVibratorState(const NotifyVibratorStateArgs& args) {
Prabir Pradhan65613802023-02-22 23:36:58 +00004711 if (debugInboundEventDetails()) {
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004712 ALOGD("notifyVibratorState - eventTime=%" PRId64 ", device=%d, isOn=%d", args.eventTime,
4713 args.deviceId, args.isOn);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004714 }
Prabir Pradhana41d2442023-04-20 21:30:40 +00004715 mPolicy.notifyVibratorState(args.deviceId, args.isOn);
Chris Yefb552902021-02-03 17:18:37 -08004716}
4717
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004718bool InputDispatcher::shouldSendMotionToInputFilterLocked(const NotifyMotionArgs& args) {
Jackal Guof9696682018-10-05 12:23:23 +08004719 return mInputFilterEnabled;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004720}
4721
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004722void InputDispatcher::notifySwitch(const NotifySwitchArgs& args) {
Prabir Pradhan65613802023-02-22 23:36:58 +00004723 if (debugInboundEventDetails()) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004724 ALOGD("notifySwitch - eventTime=%" PRId64 ", policyFlags=0x%x, switchValues=0x%08x, "
4725 "switchMask=0x%08x",
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004726 args.eventTime, args.policyFlags, args.switchValues, args.switchMask);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004727 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004728
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004729 uint32_t policyFlags = args.policyFlags;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004730 policyFlags |= POLICY_FLAG_TRUSTED;
Prabir Pradhana41d2442023-04-20 21:30:40 +00004731 mPolicy.notifySwitch(args.eventTime, args.switchValues, args.switchMask, policyFlags);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004732}
4733
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004734void InputDispatcher::notifyDeviceReset(const NotifyDeviceResetArgs& args) {
Siarhei Vishniakou527a4cf2024-04-19 17:31:01 +00004735 // TODO(b/308677868) Remove device reset from the InputListener interface
Prabir Pradhan65613802023-02-22 23:36:58 +00004736 if (debugInboundEventDetails()) {
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004737 ALOGD("notifyDeviceReset - eventTime=%" PRId64 ", deviceId=%d", args.eventTime,
4738 args.deviceId);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004739 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004740
Antonio Kantekf16f2832021-09-28 04:39:20 +00004741 bool needWake = false;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004742 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004743 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004744
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004745 std::unique_ptr<DeviceResetEntry> newEntry =
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004746 std::make_unique<DeviceResetEntry>(args.id, args.eventTime, args.deviceId);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004747 needWake = enqueueInboundEventLocked(std::move(newEntry));
Siarhei Vishniakou1160ecd2023-06-28 15:57:47 -07004748
4749 for (auto& [_, verifier] : mVerifiersByDisplay) {
4750 verifier.resetDevice(args.deviceId);
4751 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004752 } // release lock
4753
4754 if (needWake) {
4755 mLooper->wake();
4756 }
4757}
4758
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004759void InputDispatcher::notifyPointerCaptureChanged(const NotifyPointerCaptureChangedArgs& args) {
Prabir Pradhan65613802023-02-22 23:36:58 +00004760 if (debugInboundEventDetails()) {
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004761 ALOGD("notifyPointerCaptureChanged - eventTime=%" PRId64 ", enabled=%s", args.eventTime,
Hiroki Sato25040232024-02-22 17:21:22 +09004762 args.request.isEnable() ? "true" : "false");
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004763 }
Prabir Pradhan7e186182020-11-10 13:56:45 -08004764
Antonio Kantekf16f2832021-09-28 04:39:20 +00004765 bool needWake = false;
Prabir Pradhan99987712020-11-10 18:43:05 -08004766 { // acquire lock
4767 std::scoped_lock _l(mLock);
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004768 auto entry =
4769 std::make_unique<PointerCaptureChangedEntry>(args.id, args.eventTime, args.request);
Prabir Pradhan99987712020-11-10 18:43:05 -08004770 needWake = enqueueInboundEventLocked(std::move(entry));
4771 } // release lock
4772
4773 if (needWake) {
4774 mLooper->wake();
4775 }
Prabir Pradhan7e186182020-11-10 13:56:45 -08004776}
4777
Prabir Pradhan5735a322022-04-11 17:23:34 +00004778InputEventInjectionResult InputDispatcher::injectInputEvent(const InputEvent* event,
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00004779 std::optional<gui::Uid> targetUid,
Prabir Pradhan5735a322022-04-11 17:23:34 +00004780 InputEventInjectionSync syncMode,
4781 std::chrono::milliseconds timeout,
4782 uint32_t policyFlags) {
Siarhei Vishniakou23740b92023-04-21 11:30:20 -07004783 Result<void> eventValidation = validateInputEvent(*event);
4784 if (!eventValidation.ok()) {
4785 LOG(INFO) << "Injection failed: invalid event: " << eventValidation.error();
4786 return InputEventInjectionResult::FAILED;
4787 }
4788
Prabir Pradhan65613802023-02-22 23:36:58 +00004789 if (debugInboundEventDetails()) {
Siarhei Vishniakou827d1ac2023-07-21 16:37:51 -07004790 LOG(INFO) << __func__ << ": targetUid=" << toString(targetUid, &uidString)
4791 << ", syncMode=" << ftl::enum_string(syncMode) << ", timeout=" << timeout.count()
4792 << "ms, policyFlags=0x" << std::hex << policyFlags << std::dec
4793 << ", event=" << *event;
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004794 }
Siarhei Vishniakou097c3db2020-05-06 14:18:38 -07004795 nsecs_t endTime = now() + std::chrono::duration_cast<std::chrono::nanoseconds>(timeout).count();
Michael Wrightd02c5b62014-02-10 15:10:22 -08004796
Prabir Pradhan5735a322022-04-11 17:23:34 +00004797 policyFlags |= POLICY_FLAG_INJECTED | POLICY_FLAG_TRUSTED;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004798
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004799 // For all injected events, set device id = VIRTUAL_KEYBOARD_ID. The only exception is events
Siarhei Vishniakouf00a4ec2021-06-16 03:55:32 +00004800 // that have gone through the InputFilter. If the event passed through the InputFilter, assign
4801 // the provided device id. If the InputFilter is accessibility, and it modifies or synthesizes
4802 // the injected event, it is responsible for setting POLICY_FLAG_INJECTED_FROM_ACCESSIBILITY.
4803 // For those events, we will set FLAG_IS_ACCESSIBILITY_EVENT to allow apps to distinguish them
4804 // from events that originate from actual hardware.
Siarhei Vishniakouf4043212023-09-18 19:33:03 -07004805 DeviceId resolvedDeviceId = VIRTUAL_KEYBOARD_ID;
Siarhei Vishniakouf00a4ec2021-06-16 03:55:32 +00004806 if (policyFlags & POLICY_FLAG_FILTERED) {
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004807 resolvedDeviceId = event->getDeviceId();
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004808 }
4809
Prabir Pradhana8cdbe12023-11-01 21:30:02 +00004810 const bool isAsync = syncMode == InputEventInjectionSync::NONE;
4811 auto injectionState = std::make_shared<InjectionState>(targetUid, isAsync);
4812
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004813 std::queue<std::unique_ptr<EventEntry>> injectedEntries;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004814 switch (event->getType()) {
Siarhei Vishniakou63b63612023-04-12 11:00:23 -07004815 case InputEventType::KEY: {
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -08004816 const KeyEvent& incomingKey = static_cast<const KeyEvent&>(*event);
Siarhei Vishniakou23740b92023-04-21 11:30:20 -07004817 const int32_t action = incomingKey.getAction();
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -08004818 int32_t flags = incomingKey.getFlags();
Siarhei Vishniakouf00a4ec2021-06-16 03:55:32 +00004819 if (policyFlags & POLICY_FLAG_INJECTED_FROM_ACCESSIBILITY) {
4820 flags |= AKEY_EVENT_FLAG_IS_ACCESSIBILITY_EVENT;
4821 }
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -08004822 int32_t keyCode = incomingKey.getKeyCode();
4823 int32_t metaState = incomingKey.getMetaState();
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -08004824 KeyEvent keyEvent;
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004825 keyEvent.initialize(incomingKey.getId(), resolvedDeviceId, incomingKey.getSource(),
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -08004826 incomingKey.getDisplayId(), INVALID_HMAC, action, flags, keyCode,
4827 incomingKey.getScanCode(), metaState, incomingKey.getRepeatCount(),
4828 incomingKey.getDownTime(), incomingKey.getEventTime());
Michael Wrightd02c5b62014-02-10 15:10:22 -08004829
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004830 if (flags & AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY) {
4831 policyFlags |= POLICY_FLAG_VIRTUAL;
Michael Wright2b3c3302018-03-02 17:19:13 +00004832 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004833
4834 if (!(policyFlags & POLICY_FLAG_FILTERED)) {
4835 android::base::Timer t;
Prabir Pradhana41d2442023-04-20 21:30:40 +00004836 mPolicy.interceptKeyBeforeQueueing(keyEvent, /*byref*/ policyFlags);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004837 if (t.duration() > SLOW_INTERCEPTION_THRESHOLD) {
4838 ALOGW("Excessive delay in interceptKeyBeforeQueueing; took %s ms",
4839 std::to_string(t.duration().count()).c_str());
4840 }
4841 }
4842
4843 mLock.lock();
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004844 std::unique_ptr<KeyEntry> injectedEntry =
Prabir Pradhana8cdbe12023-11-01 21:30:02 +00004845 std::make_unique<KeyEntry>(incomingKey.getId(), injectionState,
4846 incomingKey.getEventTime(), resolvedDeviceId,
4847 incomingKey.getSource(), incomingKey.getDisplayId(),
4848 policyFlags, action, flags, keyCode,
4849 incomingKey.getScanCode(), metaState,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004850 incomingKey.getRepeatCount(),
4851 incomingKey.getDownTime());
Prabir Pradhanabcdf5c2023-12-15 07:30:22 +00004852 if (mTracer) {
4853 injectedEntry->traceTracker = mTracer->traceInboundEvent(*injectedEntry);
4854 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004855 injectedEntries.push(std::move(injectedEntry));
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004856 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004857 }
4858
Siarhei Vishniakou63b63612023-04-12 11:00:23 -07004859 case InputEventType::MOTION: {
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004860 const MotionEvent& motionEvent = static_cast<const MotionEvent&>(*event);
Prabir Pradhanaa561d12021-09-24 06:57:33 -07004861 const bool isPointerEvent =
4862 isFromSource(event->getSource(), AINPUT_SOURCE_CLASS_POINTER);
4863 // If a pointer event has no displayId specified, inject it to the default display.
Linnan Li43654e72024-03-28 11:07:13 +00004864 const int32_t displayId = isPointerEvent && (event->getDisplayId() == ADISPLAY_ID_NONE)
Prabir Pradhanaa561d12021-09-24 06:57:33 -07004865 ? ADISPLAY_ID_DEFAULT
4866 : event->getDisplayId();
Siarhei Vishniakouf00a4ec2021-06-16 03:55:32 +00004867 int32_t flags = motionEvent.getFlags();
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004868
4869 if (!(policyFlags & POLICY_FLAG_FILTERED)) {
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004870 nsecs_t eventTime = motionEvent.getEventTime();
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004871 android::base::Timer t;
Yeabkal Wubshit88a90412023-12-21 18:23:04 -08004872 mPolicy.interceptMotionBeforeQueueing(displayId, motionEvent.getSource(),
4873 motionEvent.getAction(), eventTime,
4874 /*byref*/ policyFlags);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004875 if (t.duration() > SLOW_INTERCEPTION_THRESHOLD) {
4876 ALOGW("Excessive delay in interceptMotionBeforeQueueing; took %s ms",
4877 std::to_string(t.duration().count()).c_str());
4878 }
4879 }
4880
Siarhei Vishniakouf00a4ec2021-06-16 03:55:32 +00004881 if (policyFlags & POLICY_FLAG_INJECTED_FROM_ACCESSIBILITY) {
4882 flags |= AMOTION_EVENT_FLAG_IS_ACCESSIBILITY_EVENT;
4883 }
4884
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004885 mLock.lock();
Siarhei Vishniakou527a4cf2024-04-19 17:31:01 +00004886
4887 if (policyFlags & POLICY_FLAG_FILTERED) {
4888 // The events from InputFilter impersonate real hardware devices. Check these
4889 // events for consistency and print an error. An inconsistent event sent from
4890 // InputFilter could cause a crash in the later stages of dispatching pipeline.
4891 auto [it, _] =
4892 mInputFilterVerifiersByDisplay
4893 .try_emplace(displayId,
4894 StringPrintf("Injection on %" PRId32, displayId));
4895 InputVerifier& verifier = it->second;
4896
4897 Result<void> result =
4898 verifier.processMovement(resolvedDeviceId, motionEvent.getSource(),
4899 motionEvent.getAction(),
4900 motionEvent.getPointerCount(),
4901 motionEvent.getPointerProperties(),
4902 motionEvent.getSamplePointerCoords(), flags);
4903 if (!result.ok()) {
4904 logDispatchStateLocked();
4905 LOG(ERROR) << "Inconsistent event: " << motionEvent
4906 << ", reason: " << result.error();
4907 }
4908 }
4909
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004910 const nsecs_t* sampleEventTimes = motionEvent.getSampleEventTimes();
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07004911 const size_t pointerCount = motionEvent.getPointerCount();
4912 const std::vector<PointerProperties>
4913 pointerProperties(motionEvent.getPointerProperties(),
4914 motionEvent.getPointerProperties() + pointerCount);
4915
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004916 const PointerCoords* samplePointerCoords = motionEvent.getSamplePointerCoords();
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004917 std::unique_ptr<MotionEntry> injectedEntry =
Prabir Pradhana8cdbe12023-11-01 21:30:02 +00004918 std::make_unique<MotionEntry>(motionEvent.getId(), injectionState,
4919 *sampleEventTimes, resolvedDeviceId,
4920 motionEvent.getSource(), displayId, policyFlags,
4921 motionEvent.getAction(),
Siarhei Vishniakou23740b92023-04-21 11:30:20 -07004922 motionEvent.getActionButton(), flags,
4923 motionEvent.getMetaState(),
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004924 motionEvent.getButtonState(),
4925 motionEvent.getClassification(),
4926 motionEvent.getEdgeFlags(),
4927 motionEvent.getXPrecision(),
4928 motionEvent.getYPrecision(),
4929 motionEvent.getRawXCursorPosition(),
4930 motionEvent.getRawYCursorPosition(),
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07004931 motionEvent.getDownTime(), pointerProperties,
4932 std::vector<PointerCoords>(samplePointerCoords,
4933 samplePointerCoords +
4934 pointerCount));
Prabir Pradhandaa2f142021-12-10 09:30:08 +00004935 transformMotionEntryForInjectionLocked(*injectedEntry, motionEvent.getTransform());
Prabir Pradhanabcdf5c2023-12-15 07:30:22 +00004936 if (mTracer) {
4937 injectedEntry->traceTracker = mTracer->traceInboundEvent(*injectedEntry);
4938 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004939 injectedEntries.push(std::move(injectedEntry));
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004940 for (size_t i = motionEvent.getHistorySize(); i > 0; i--) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004941 sampleEventTimes += 1;
Siarhei Vishniakou23740b92023-04-21 11:30:20 -07004942 samplePointerCoords += motionEvent.getPointerCount();
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07004943 std::unique_ptr<MotionEntry> nextInjectedEntry = std::make_unique<
Prabir Pradhana8cdbe12023-11-01 21:30:02 +00004944 MotionEntry>(motionEvent.getId(), injectionState, *sampleEventTimes,
4945 resolvedDeviceId, motionEvent.getSource(), displayId,
4946 policyFlags, motionEvent.getAction(),
4947 motionEvent.getActionButton(), flags,
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07004948 motionEvent.getMetaState(), motionEvent.getButtonState(),
4949 motionEvent.getClassification(), motionEvent.getEdgeFlags(),
4950 motionEvent.getXPrecision(), motionEvent.getYPrecision(),
4951 motionEvent.getRawXCursorPosition(),
4952 motionEvent.getRawYCursorPosition(), motionEvent.getDownTime(),
4953 pointerProperties,
4954 std::vector<PointerCoords>(samplePointerCoords,
4955 samplePointerCoords +
4956 pointerCount));
Prabir Pradhandaa2f142021-12-10 09:30:08 +00004957 transformMotionEntryForInjectionLocked(*nextInjectedEntry,
4958 motionEvent.getTransform());
Prabir Pradhan2b2d1bf2024-03-05 16:27:56 +00004959 if (mTracer) {
4960 nextInjectedEntry->traceTracker =
4961 mTracer->traceInboundEvent(*nextInjectedEntry);
4962 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004963 injectedEntries.push(std::move(nextInjectedEntry));
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004964 }
4965 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004966 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004967
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004968 default:
Siarhei Vishniakou63b63612023-04-12 11:00:23 -07004969 LOG(WARNING) << "Cannot inject " << ftl::enum_string(event->getType()) << " events";
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004970 return InputEventInjectionResult::FAILED;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004971 }
4972
Michael Wrightd02c5b62014-02-10 15:10:22 -08004973 bool needWake = false;
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07004974 while (!injectedEntries.empty()) {
Siarhei Vishniakoud010b012023-01-18 15:00:53 -08004975 if (DEBUG_INJECTION) {
Siarhei Vishniakou827d1ac2023-07-21 16:37:51 -07004976 LOG(INFO) << "Injecting " << injectedEntries.front()->getDescription();
Siarhei Vishniakoud010b012023-01-18 15:00:53 -08004977 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004978 needWake |= enqueueInboundEventLocked(std::move(injectedEntries.front()));
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07004979 injectedEntries.pop();
Michael Wrightd02c5b62014-02-10 15:10:22 -08004980 }
4981
4982 mLock.unlock();
4983
4984 if (needWake) {
4985 mLooper->wake();
4986 }
4987
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004988 InputEventInjectionResult injectionResult;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004989 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004990 std::unique_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004991
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004992 if (syncMode == InputEventInjectionSync::NONE) {
4993 injectionResult = InputEventInjectionResult::SUCCEEDED;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004994 } else {
4995 for (;;) {
4996 injectionResult = injectionState->injectionResult;
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004997 if (injectionResult != InputEventInjectionResult::PENDING) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004998 break;
4999 }
5000
5001 nsecs_t remainingTimeout = endTime - now();
5002 if (remainingTimeout <= 0) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00005003 if (DEBUG_INJECTION) {
5004 ALOGD("injectInputEvent - Timed out waiting for injection result "
5005 "to become available.");
5006 }
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08005007 injectionResult = InputEventInjectionResult::TIMED_OUT;
Michael Wrightd02c5b62014-02-10 15:10:22 -08005008 break;
5009 }
5010
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08005011 mInjectionResultAvailable.wait_for(_l, std::chrono::nanoseconds(remainingTimeout));
Michael Wrightd02c5b62014-02-10 15:10:22 -08005012 }
5013
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08005014 if (injectionResult == InputEventInjectionResult::SUCCEEDED &&
5015 syncMode == InputEventInjectionSync::WAIT_FOR_FINISHED) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08005016 while (injectionState->pendingForegroundDispatches != 0) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00005017 if (DEBUG_INJECTION) {
5018 ALOGD("injectInputEvent - Waiting for %d pending foreground dispatches.",
5019 injectionState->pendingForegroundDispatches);
5020 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005021 nsecs_t remainingTimeout = endTime - now();
5022 if (remainingTimeout <= 0) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00005023 if (DEBUG_INJECTION) {
5024 ALOGD("injectInputEvent - Timed out waiting for pending foreground "
5025 "dispatches to finish.");
5026 }
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08005027 injectionResult = InputEventInjectionResult::TIMED_OUT;
Michael Wrightd02c5b62014-02-10 15:10:22 -08005028 break;
5029 }
5030
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08005031 mInjectionSyncFinished.wait_for(_l, std::chrono::nanoseconds(remainingTimeout));
Michael Wrightd02c5b62014-02-10 15:10:22 -08005032 }
5033 }
5034 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005035 } // release lock
5036
Prabir Pradhan61a5d242021-07-26 16:41:09 +00005037 if (DEBUG_INJECTION) {
Siarhei Vishniakou827d1ac2023-07-21 16:37:51 -07005038 LOG(INFO) << "injectInputEvent - Finished with result "
5039 << ftl::enum_string(injectionResult);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00005040 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005041
5042 return injectionResult;
5043}
5044
Siarhei Vishniakou54d3e182020-01-15 17:38:38 -08005045std::unique_ptr<VerifiedInputEvent> InputDispatcher::verifyInputEvent(const InputEvent& event) {
Gang Wange9087892020-01-07 12:17:14 -05005046 std::array<uint8_t, 32> calculatedHmac;
5047 std::unique_ptr<VerifiedInputEvent> result;
5048 switch (event.getType()) {
Siarhei Vishniakou63b63612023-04-12 11:00:23 -07005049 case InputEventType::KEY: {
Gang Wange9087892020-01-07 12:17:14 -05005050 const KeyEvent& keyEvent = static_cast<const KeyEvent&>(event);
5051 VerifiedKeyEvent verifiedKeyEvent = verifiedKeyEventFromKeyEvent(keyEvent);
5052 result = std::make_unique<VerifiedKeyEvent>(verifiedKeyEvent);
chaviw09c8d2d2020-08-24 15:48:26 -07005053 calculatedHmac = sign(verifiedKeyEvent);
Gang Wange9087892020-01-07 12:17:14 -05005054 break;
5055 }
Siarhei Vishniakou63b63612023-04-12 11:00:23 -07005056 case InputEventType::MOTION: {
Gang Wange9087892020-01-07 12:17:14 -05005057 const MotionEvent& motionEvent = static_cast<const MotionEvent&>(event);
5058 VerifiedMotionEvent verifiedMotionEvent =
5059 verifiedMotionEventFromMotionEvent(motionEvent);
5060 result = std::make_unique<VerifiedMotionEvent>(verifiedMotionEvent);
chaviw09c8d2d2020-08-24 15:48:26 -07005061 calculatedHmac = sign(verifiedMotionEvent);
Gang Wange9087892020-01-07 12:17:14 -05005062 break;
5063 }
5064 default: {
Siarhei Vishniakouef2b4502023-12-28 11:51:47 -08005065 LOG(ERROR) << "Cannot verify events of type " << ftl::enum_string(event.getType());
Gang Wange9087892020-01-07 12:17:14 -05005066 return nullptr;
5067 }
5068 }
5069 if (calculatedHmac == INVALID_HMAC) {
5070 return nullptr;
5071 }
tyiu1573a672023-02-21 22:38:32 +00005072 if (0 != CRYPTO_memcmp(calculatedHmac.data(), event.getHmac().data(), calculatedHmac.size())) {
Gang Wange9087892020-01-07 12:17:14 -05005073 return nullptr;
5074 }
5075 return result;
Siarhei Vishniakou54d3e182020-01-15 17:38:38 -08005076}
5077
Prabir Pradhan24047542023-11-02 17:14:59 +00005078void InputDispatcher::setInjectionResult(const EventEntry& entry,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08005079 InputEventInjectionResult injectionResult) {
Prabir Pradhana8cdbe12023-11-01 21:30:02 +00005080 if (!entry.injectionState) {
5081 // Not an injected event.
5082 return;
Michael Wrightd02c5b62014-02-10 15:10:22 -08005083 }
Prabir Pradhana8cdbe12023-11-01 21:30:02 +00005084
5085 InjectionState& injectionState = *entry.injectionState;
5086 if (DEBUG_INJECTION) {
5087 LOG(INFO) << "Setting input event injection result to "
5088 << ftl::enum_string(injectionResult);
5089 }
5090
5091 if (injectionState.injectionIsAsync && !(entry.policyFlags & POLICY_FLAG_FILTERED)) {
5092 // Log the outcome since the injector did not wait for the injection result.
5093 switch (injectionResult) {
5094 case InputEventInjectionResult::SUCCEEDED:
5095 ALOGV("Asynchronous input event injection succeeded.");
5096 break;
5097 case InputEventInjectionResult::TARGET_MISMATCH:
5098 ALOGV("Asynchronous input event injection target mismatch.");
5099 break;
5100 case InputEventInjectionResult::FAILED:
5101 ALOGW("Asynchronous input event injection failed.");
5102 break;
5103 case InputEventInjectionResult::TIMED_OUT:
5104 ALOGW("Asynchronous input event injection timed out.");
5105 break;
5106 case InputEventInjectionResult::PENDING:
5107 ALOGE("Setting result to 'PENDING' for asynchronous injection");
5108 break;
5109 }
5110 }
5111
5112 injectionState.injectionResult = injectionResult;
5113 mInjectionResultAvailable.notify_all();
Michael Wrightd02c5b62014-02-10 15:10:22 -08005114}
5115
Prabir Pradhandaa2f142021-12-10 09:30:08 +00005116void InputDispatcher::transformMotionEntryForInjectionLocked(
5117 MotionEntry& entry, const ui::Transform& injectedTransform) const {
Prabir Pradhan81420cc2021-09-06 10:28:50 -07005118 // Input injection works in the logical display coordinate space, but the input pipeline works
5119 // display space, so we need to transform the injected events accordingly.
5120 const auto it = mDisplayInfos.find(entry.displayId);
5121 if (it == mDisplayInfos.end()) return;
Prabir Pradhandaa2f142021-12-10 09:30:08 +00005122 const auto& transformToDisplay = it->second.transform.inverse() * injectedTransform;
Prabir Pradhan81420cc2021-09-06 10:28:50 -07005123
Prabir Pradhand9a2ebe2022-07-20 19:25:13 +00005124 if (entry.xCursorPosition != AMOTION_EVENT_INVALID_CURSOR_POSITION &&
5125 entry.yCursorPosition != AMOTION_EVENT_INVALID_CURSOR_POSITION) {
5126 const vec2 cursor =
5127 MotionEvent::calculateTransformedXY(entry.source, transformToDisplay,
5128 {entry.xCursorPosition, entry.yCursorPosition});
5129 entry.xCursorPosition = cursor.x;
5130 entry.yCursorPosition = cursor.y;
5131 }
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07005132 for (uint32_t i = 0; i < entry.getPointerCount(); i++) {
Prabir Pradhan8e6ce222022-02-24 09:08:54 -08005133 entry.pointerCoords[i] =
5134 MotionEvent::calculateTransformedCoords(entry.source, transformToDisplay,
5135 entry.pointerCoords[i]);
Prabir Pradhan81420cc2021-09-06 10:28:50 -07005136 }
5137}
5138
Prabir Pradhan24047542023-11-02 17:14:59 +00005139void InputDispatcher::incrementPendingForegroundDispatches(const EventEntry& entry) {
Prabir Pradhana8cdbe12023-11-01 21:30:02 +00005140 if (entry.injectionState) {
5141 entry.injectionState->pendingForegroundDispatches += 1;
Michael Wrightd02c5b62014-02-10 15:10:22 -08005142 }
5143}
5144
Prabir Pradhan24047542023-11-02 17:14:59 +00005145void InputDispatcher::decrementPendingForegroundDispatches(const EventEntry& entry) {
Prabir Pradhana8cdbe12023-11-01 21:30:02 +00005146 if (entry.injectionState) {
5147 entry.injectionState->pendingForegroundDispatches -= 1;
Michael Wrightd02c5b62014-02-10 15:10:22 -08005148
Prabir Pradhana8cdbe12023-11-01 21:30:02 +00005149 if (entry.injectionState->pendingForegroundDispatches == 0) {
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08005150 mInjectionSyncFinished.notify_all();
Michael Wrightd02c5b62014-02-10 15:10:22 -08005151 }
5152 }
5153}
5154
chaviw98318de2021-05-19 16:45:23 -05005155const std::vector<sp<WindowInfoHandle>>& InputDispatcher::getWindowHandlesLocked(
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08005156 int32_t displayId) const {
chaviw98318de2021-05-19 16:45:23 -05005157 static const std::vector<sp<WindowInfoHandle>> EMPTY_WINDOW_HANDLES;
Vishnu Nairad321cd2020-08-20 16:40:21 -07005158 auto it = mWindowHandlesByDisplay.find(displayId);
5159 return it != mWindowHandlesByDisplay.end() ? it->second : EMPTY_WINDOW_HANDLES;
Arthur Hungb92218b2018-08-14 12:00:21 +08005160}
5161
chaviw98318de2021-05-19 16:45:23 -05005162sp<WindowInfoHandle> InputDispatcher::getWindowHandleLocked(
Prabir Pradhan16463382023-10-12 23:03:19 +00005163 const sp<IBinder>& windowHandleToken, std::optional<int32_t> displayId) const {
arthurhungbe737672020-06-24 12:29:21 +08005164 if (windowHandleToken == nullptr) {
5165 return nullptr;
5166 }
5167
Prabir Pradhan16463382023-10-12 23:03:19 +00005168 if (!displayId) {
5169 // Look through all displays.
5170 for (auto& it : mWindowHandlesByDisplay) {
5171 const std::vector<sp<WindowInfoHandle>>& windowHandles = it.second;
5172 for (const sp<WindowInfoHandle>& windowHandle : windowHandles) {
5173 if (windowHandle->getToken() == windowHandleToken) {
5174 return windowHandle;
5175 }
Arthur Hungb92218b2018-08-14 12:00:21 +08005176 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005177 }
Vishnu Nairad321cd2020-08-20 16:40:21 -07005178 return nullptr;
5179 }
5180
Prabir Pradhan16463382023-10-12 23:03:19 +00005181 // Only look through the requested display.
5182 for (const sp<WindowInfoHandle>& windowHandle : getWindowHandlesLocked(*displayId)) {
Vishnu Nairad321cd2020-08-20 16:40:21 -07005183 if (windowHandle->getToken() == windowHandleToken) {
5184 return windowHandle;
5185 }
5186 }
5187 return nullptr;
5188}
5189
chaviw98318de2021-05-19 16:45:23 -05005190sp<WindowInfoHandle> InputDispatcher::getWindowHandleLocked(
5191 const sp<WindowInfoHandle>& windowHandle) const {
Mady Mellor017bcd12020-06-23 19:12:00 +00005192 for (auto& it : mWindowHandlesByDisplay) {
chaviw98318de2021-05-19 16:45:23 -05005193 const std::vector<sp<WindowInfoHandle>>& windowHandles = it.second;
5194 for (const sp<WindowInfoHandle>& handle : windowHandles) {
arthurhungbe737672020-06-24 12:29:21 +08005195 if (handle->getId() == windowHandle->getId() &&
5196 handle->getToken() == windowHandle->getToken()) {
Mady Mellor017bcd12020-06-23 19:12:00 +00005197 if (windowHandle->getInfo()->displayId != it.first) {
5198 ALOGE("Found window %s in display %" PRId32
5199 ", but it should belong to display %" PRId32,
5200 windowHandle->getName().c_str(), it.first,
5201 windowHandle->getInfo()->displayId);
5202 }
Prabir Pradhan6a9a8312021-04-23 11:59:31 -07005203 return handle;
Arthur Hungb92218b2018-08-14 12:00:21 +08005204 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005205 }
5206 }
Prabir Pradhan6a9a8312021-04-23 11:59:31 -07005207 return nullptr;
5208}
5209
chaviw98318de2021-05-19 16:45:23 -05005210sp<WindowInfoHandle> InputDispatcher::getFocusedWindowHandleLocked(int displayId) const {
Prabir Pradhan6a9a8312021-04-23 11:59:31 -07005211 sp<IBinder> focusedToken = mFocusResolver.getFocusedWindowToken(displayId);
5212 return getWindowHandleLocked(focusedToken, displayId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005213}
5214
Prabir Pradhan33e3baa2022-12-06 20:30:22 +00005215ui::Transform InputDispatcher::getTransformLocked(int32_t displayId) const {
5216 auto displayInfoIt = mDisplayInfos.find(displayId);
5217 return displayInfoIt != mDisplayInfos.end() ? displayInfoIt->second.transform
5218 : kIdentityTransform;
5219}
5220
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07005221bool InputDispatcher::canWindowReceiveMotionLocked(const sp<WindowInfoHandle>& window,
5222 const MotionEntry& motionEntry) const {
5223 const WindowInfo& info = *window->getInfo();
5224
5225 // Skip spy window targets that are not valid for targeted injection.
5226 if (const auto err = verifyTargetedInjection(window, motionEntry); err) {
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05005227 return false;
5228 }
5229
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07005230 if (info.inputConfig.test(WindowInfo::InputConfig::PAUSE_DISPATCHING)) {
5231 ALOGI("Not sending touch event to %s because it is paused", window->getName().c_str());
5232 return false;
5233 }
5234
5235 if (info.inputConfig.test(WindowInfo::InputConfig::NO_INPUT_CHANNEL)) {
5236 ALOGW("Not sending touch gesture to %s because it has config NO_INPUT_CHANNEL",
5237 window->getName().c_str());
5238 return false;
5239 }
5240
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07005241 std::shared_ptr<Connection> connection = getConnectionLocked(window->getToken());
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05005242 if (connection == nullptr) {
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07005243 ALOGW("Not sending touch to %s because there's no corresponding connection",
5244 window->getName().c_str());
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05005245 return false;
5246 }
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07005247
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05005248 if (!connection->responsive) {
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07005249 ALOGW("Not sending touch to %s because it is not responsive", window->getName().c_str());
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05005250 return false;
5251 }
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07005252
5253 // Drop events that can't be trusted due to occlusion
5254 const auto [x, y] = resolveTouchedPosition(motionEntry);
5255 TouchOcclusionInfo occlusionInfo = computeTouchOcclusionInfoLocked(window, x, y);
5256 if (!isTouchTrustedLocked(occlusionInfo)) {
5257 if (DEBUG_TOUCH_OCCLUSION) {
Prabir Pradhan82e081e2022-12-06 09:50:09 +00005258 ALOGD("Stack of obscuring windows during untrusted touch (%.1f, %.1f):", x, y);
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07005259 for (const auto& log : occlusionInfo.debugInfo) {
5260 ALOGD("%s", log.c_str());
5261 }
5262 }
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00005263 ALOGW("Dropping untrusted touch event due to %s/%s", occlusionInfo.obscuringPackage.c_str(),
5264 occlusionInfo.obscuringUid.toString().c_str());
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07005265 return false;
5266 }
5267
5268 // Drop touch events if requested by input feature
5269 if (shouldDropInput(motionEntry, window)) {
5270 return false;
5271 }
5272
Siarhei Vishniakouf77f60a2023-10-23 17:26:05 -07005273 // Ignore touches if stylus is down anywhere on screen
5274 if (info.inputConfig.test(WindowInfo::InputConfig::GLOBAL_STYLUS_BLOCKS_TOUCH) &&
5275 isStylusActiveInDisplay(info.displayId, mTouchStatesByDisplay)) {
5276 LOG(INFO) << "Dropping touch from " << window->getName() << " because stylus is active";
5277 return false;
5278 }
5279
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05005280 return true;
5281}
5282
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005283void InputDispatcher::updateWindowHandlesForDisplayLocked(
chaviw98318de2021-05-19 16:45:23 -05005284 const std::vector<sp<WindowInfoHandle>>& windowInfoHandles, int32_t displayId) {
5285 if (windowInfoHandles.empty()) {
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005286 // Remove all handles on a display if there are no windows left.
5287 mWindowHandlesByDisplay.erase(displayId);
5288 return;
5289 }
5290
5291 // Since we compare the pointer of input window handles across window updates, we need
5292 // to make sure the handle object for the same window stays unchanged across updates.
chaviw98318de2021-05-19 16:45:23 -05005293 const std::vector<sp<WindowInfoHandle>>& oldHandles = getWindowHandlesLocked(displayId);
5294 std::unordered_map<int32_t /*id*/, sp<WindowInfoHandle>> oldHandlesById;
5295 for (const sp<WindowInfoHandle>& handle : oldHandles) {
chaviwaf87b3e2019-10-01 16:59:28 -07005296 oldHandlesById[handle->getId()] = handle;
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005297 }
5298
chaviw98318de2021-05-19 16:45:23 -05005299 std::vector<sp<WindowInfoHandle>> newHandles;
5300 for (const sp<WindowInfoHandle>& handle : windowInfoHandles) {
chaviw98318de2021-05-19 16:45:23 -05005301 const WindowInfo* info = handle->getInfo();
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08005302 if (getConnectionLocked(handle->getToken()) == nullptr) {
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005303 const bool noInputChannel =
Prabir Pradhan51e7db02022-02-07 06:02:57 -08005304 info->inputConfig.test(WindowInfo::InputConfig::NO_INPUT_CHANNEL);
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08005305 const bool canReceiveInput =
5306 !info->inputConfig.test(WindowInfo::InputConfig::NOT_TOUCHABLE) ||
5307 !info->inputConfig.test(WindowInfo::InputConfig::NOT_FOCUSABLE);
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005308 if (canReceiveInput && !noInputChannel) {
John Recke0710582019-09-26 13:46:12 -07005309 ALOGV("Window handle %s has no registered input channel",
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005310 handle->getName().c_str());
Robert Carr2984b7a2020-04-13 17:06:45 -07005311 continue;
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005312 }
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005313 }
5314
5315 if (info->displayId != displayId) {
5316 ALOGE("Window %s updated by wrong display %d, should belong to display %d",
5317 handle->getName().c_str(), displayId, info->displayId);
5318 continue;
5319 }
5320
Robert Carredd13602020-04-13 17:24:34 -07005321 if ((oldHandlesById.find(handle->getId()) != oldHandlesById.end()) &&
5322 (oldHandlesById.at(handle->getId())->getToken() == handle->getToken())) {
chaviw98318de2021-05-19 16:45:23 -05005323 const sp<WindowInfoHandle>& oldHandle = oldHandlesById.at(handle->getId());
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005324 oldHandle->updateFrom(handle);
5325 newHandles.push_back(oldHandle);
5326 } else {
5327 newHandles.push_back(handle);
5328 }
5329 }
5330
5331 // Insert or replace
5332 mWindowHandlesByDisplay[displayId] = newHandles;
5333}
5334
Arthur Hungb92218b2018-08-14 12:00:21 +08005335/**
5336 * Called from InputManagerService, update window handle list by displayId that can receive input.
5337 * A window handle contains information about InputChannel, Touch Region, Types, Focused,...
5338 * If set an empty list, remove all handles from the specific display.
5339 * For focused handle, check if need to change and send a cancel event to previous one.
5340 * For removed handle, check if need to send a cancel event if already in touch.
5341 */
Arthur Hung72d8dc32020-03-28 00:48:39 +00005342void InputDispatcher::setInputWindowsLocked(
chaviw98318de2021-05-19 16:45:23 -05005343 const std::vector<sp<WindowInfoHandle>>& windowInfoHandles, int32_t displayId) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005344 if (DEBUG_FOCUS) {
5345 std::string windowList;
chaviw98318de2021-05-19 16:45:23 -05005346 for (const sp<WindowInfoHandle>& iwh : windowInfoHandles) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005347 windowList += iwh->getName() + " ";
5348 }
Siarhei Vishniakou366fb5b2023-12-06 11:23:41 -08005349 LOG(INFO) << "setInputWindows displayId=" << displayId << " " << windowList;
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005350 }
Prabir Pradhand6b2b052024-02-21 23:25:15 +00005351 ScopedSyntheticEventTracer traceContext(mTracer);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005352
Prabir Pradhand65552b2021-10-07 11:23:50 -07005353 // Check preconditions for new input windows
chaviw98318de2021-05-19 16:45:23 -05005354 for (const sp<WindowInfoHandle>& window : windowInfoHandles) {
Prabir Pradhand65552b2021-10-07 11:23:50 -07005355 const WindowInfo& info = *window->getInfo();
5356
5357 // Ensure all tokens are null if the window has feature NO_INPUT_CHANNEL
Prabir Pradhan51e7db02022-02-07 06:02:57 -08005358 const bool noInputWindow = info.inputConfig.test(WindowInfo::InputConfig::NO_INPUT_CHANNEL);
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05005359 if (noInputWindow && window->getToken() != nullptr) {
5360 ALOGE("%s has feature NO_INPUT_WINDOW, but a non-null token. Clearing",
5361 window->getName().c_str());
5362 window->releaseChannel();
5363 }
Prabir Pradhand65552b2021-10-07 11:23:50 -07005364
Prabir Pradhan5c85e052021-12-22 02:27:12 -08005365 // Ensure all spy windows are trusted overlays
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08005366 LOG_ALWAYS_FATAL_IF(info.isSpy() &&
5367 !info.inputConfig.test(
5368 WindowInfo::InputConfig::TRUSTED_OVERLAY),
Prabir Pradhan5c85e052021-12-22 02:27:12 -08005369 "%s has feature SPY, but is not a trusted overlay.",
5370 window->getName().c_str());
5371
Prabir Pradhand65552b2021-10-07 11:23:50 -07005372 // Ensure all stylus interceptors are trusted overlays
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08005373 LOG_ALWAYS_FATAL_IF(info.interceptsStylus() &&
5374 !info.inputConfig.test(
5375 WindowInfo::InputConfig::TRUSTED_OVERLAY),
Prabir Pradhand65552b2021-10-07 11:23:50 -07005376 "%s has feature INTERCEPTS_STYLUS, but is not a trusted overlay.",
5377 window->getName().c_str());
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05005378 }
5379
Arthur Hung72d8dc32020-03-28 00:48:39 +00005380 // Copy old handles for release if they are no longer present.
chaviw98318de2021-05-19 16:45:23 -05005381 const std::vector<sp<WindowInfoHandle>> oldWindowHandles = getWindowHandlesLocked(displayId);
Prabir Pradhan4b9b1a12024-02-02 00:16:17 +00005382 const sp<WindowInfoHandle> removedFocusedWindowHandle = getFocusedWindowHandleLocked(displayId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005383
chaviw98318de2021-05-19 16:45:23 -05005384 updateWindowHandlesForDisplayLocked(windowInfoHandles, displayId);
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005385
chaviw98318de2021-05-19 16:45:23 -05005386 const std::vector<sp<WindowInfoHandle>>& windowHandles = getWindowHandlesLocked(displayId);
Arthur Hung72d8dc32020-03-28 00:48:39 +00005387
Vishnu Nairc519ff72021-01-21 08:23:08 -08005388 std::optional<FocusResolver::FocusChanges> changes =
5389 mFocusResolver.setInputWindows(displayId, windowHandles);
5390 if (changes) {
Prabir Pradhand6b2b052024-02-21 23:25:15 +00005391 onFocusChangedLocked(*changes, traceContext.getTracker(), removedFocusedWindowHandle);
Arthur Hung72d8dc32020-03-28 00:48:39 +00005392 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005393
Siarhei Vishniakou4700f822020-03-24 19:05:54 -07005394 std::unordered_map<int32_t, TouchState>::iterator stateIt =
5395 mTouchStatesByDisplay.find(displayId);
5396 if (stateIt != mTouchStatesByDisplay.end()) {
5397 TouchState& state = stateIt->second;
Arthur Hung72d8dc32020-03-28 00:48:39 +00005398 for (size_t i = 0; i < state.windows.size();) {
5399 TouchedWindow& touchedWindow = state.windows[i];
Prabir Pradhan6a9a8312021-04-23 11:59:31 -07005400 if (getWindowHandleLocked(touchedWindow.windowHandle) == nullptr) {
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07005401 LOG(INFO) << "Touched window was removed: " << touchedWindow.windowHandle->getName()
5402 << " in display %" << displayId;
Prabir Pradhanbb3f1c02024-01-04 20:17:14 +00005403 CancelationOptions options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS,
Prabir Pradhand6b2b052024-02-21 23:25:15 +00005404 "touched window was removed", traceContext.getTracker());
Prabir Pradhanbb3f1c02024-01-04 20:17:14 +00005405 synthesizeCancelationEventsForWindowLocked(touchedWindow.windowHandle, options);
5406 // Since we are about to drop the touch, cancel the events for the wallpaper as
5407 // well.
5408 if (touchedWindow.targetFlags.test(InputTarget::Flags::FOREGROUND) &&
5409 touchedWindow.windowHandle->getInfo()->inputConfig.test(
5410 gui::WindowInfo::InputConfig::DUPLICATE_TOUCH_TO_WALLPAPER)) {
5411 if (const auto& ww = state.getWallpaperWindow(); ww) {
5412 synthesizeCancelationEventsForWindowLocked(ww, options);
Siarhei Vishniakouca205502021-07-16 21:31:58 +00005413 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005414 }
Arthur Hung72d8dc32020-03-28 00:48:39 +00005415 state.windows.erase(state.windows.begin() + i);
5416 } else {
5417 ++i;
Michael Wrightd02c5b62014-02-10 15:10:22 -08005418 }
5419 }
arthurhungb89ccb02020-12-30 16:19:01 +08005420
arthurhung6d4bed92021-03-17 11:59:33 +08005421 // If drag window is gone, it would receive a cancel event and broadcast the DRAG_END. We
arthurhungb89ccb02020-12-30 16:19:01 +08005422 // could just clear the state here.
Arthur Hung3915c1f2022-05-31 07:17:17 +00005423 if (mDragState && mDragState->dragWindow->getInfo()->displayId == displayId &&
arthurhung6d4bed92021-03-17 11:59:33 +08005424 std::find(windowHandles.begin(), windowHandles.end(), mDragState->dragWindow) ==
arthurhungb89ccb02020-12-30 16:19:01 +08005425 windowHandles.end()) {
Arthur Hung3915c1f2022-05-31 07:17:17 +00005426 ALOGI("Drag window went away: %s", mDragState->dragWindow->getName().c_str());
5427 sendDropWindowCommandLocked(nullptr, 0, 0);
arthurhung6d4bed92021-03-17 11:59:33 +08005428 mDragState.reset();
arthurhungb89ccb02020-12-30 16:19:01 +08005429 }
Arthur Hung72d8dc32020-03-28 00:48:39 +00005430 }
Arthur Hung25e2af12020-03-26 12:58:37 +00005431
Arthur Hung72d8dc32020-03-28 00:48:39 +00005432 // Release information for windows that are no longer present.
5433 // This ensures that unused input channels are released promptly.
5434 // Otherwise, they might stick around until the window handle is destroyed
5435 // which might not happen until the next GC.
chaviw98318de2021-05-19 16:45:23 -05005436 for (const sp<WindowInfoHandle>& oldWindowHandle : oldWindowHandles) {
Prabir Pradhan6a9a8312021-04-23 11:59:31 -07005437 if (getWindowHandleLocked(oldWindowHandle) == nullptr) {
Arthur Hung72d8dc32020-03-28 00:48:39 +00005438 if (DEBUG_FOCUS) {
5439 ALOGD("Window went away: %s", oldWindowHandle->getName().c_str());
Arthur Hung25e2af12020-03-26 12:58:37 +00005440 }
Arthur Hung72d8dc32020-03-28 00:48:39 +00005441 oldWindowHandle->releaseChannel();
Arthur Hung25e2af12020-03-26 12:58:37 +00005442 }
chaviw291d88a2019-02-14 10:33:58 -08005443 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005444}
5445
5446void InputDispatcher::setFocusedApplication(
Chris Yea209fde2020-07-22 13:54:51 -07005447 int32_t displayId, const std::shared_ptr<InputApplicationHandle>& inputApplicationHandle) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005448 if (DEBUG_FOCUS) {
5449 ALOGD("setFocusedApplication displayId=%" PRId32 " %s", displayId,
5450 inputApplicationHandle ? inputApplicationHandle->getName().c_str() : "<nullptr>");
5451 }
Siarhei Vishniakoue41c4512020-09-08 19:35:58 -05005452 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08005453 std::scoped_lock _l(mLock);
Vishnu Nair599f1412021-06-21 10:39:58 -07005454 setFocusedApplicationLocked(displayId, inputApplicationHandle);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005455 } // release lock
5456
5457 // Wake up poll loop since it may need to make new input dispatching choices.
5458 mLooper->wake();
5459}
5460
Vishnu Nair599f1412021-06-21 10:39:58 -07005461void InputDispatcher::setFocusedApplicationLocked(
5462 int32_t displayId, const std::shared_ptr<InputApplicationHandle>& inputApplicationHandle) {
5463 std::shared_ptr<InputApplicationHandle> oldFocusedApplicationHandle =
5464 getValueByKey(mFocusedApplicationHandlesByDisplay, displayId);
5465
5466 if (sharedPointersEqual(oldFocusedApplicationHandle, inputApplicationHandle)) {
5467 return; // This application is already focused. No need to wake up or change anything.
5468 }
5469
5470 // Set the new application handle.
5471 if (inputApplicationHandle != nullptr) {
5472 mFocusedApplicationHandlesByDisplay[displayId] = inputApplicationHandle;
5473 } else {
5474 mFocusedApplicationHandlesByDisplay.erase(displayId);
5475 }
5476
5477 // No matter what the old focused application was, stop waiting on it because it is
5478 // no longer focused.
5479 resetNoFocusedWindowTimeoutLocked();
5480}
5481
Yeabkal Wubshitb8aadfa2024-01-17 17:03:42 -08005482void InputDispatcher::setMinTimeBetweenUserActivityPokes(std::chrono::milliseconds interval) {
5483 if (interval.count() < 0) {
5484 LOG_ALWAYS_FATAL("Minimum time between user activity pokes should be >= 0");
5485 }
5486 std::scoped_lock _l(mLock);
5487 mMinTimeBetweenUserActivityPokes = interval;
5488}
5489
Tiger Huang721e26f2018-07-24 22:26:19 +08005490/**
5491 * Sets the focused display, which is responsible for receiving focus-dispatched input events where
5492 * the display not specified.
5493 *
5494 * We track any unreleased events for each window. If a window loses the ability to receive the
5495 * released event, we will send a cancel event to it. So when the focused display is changed, we
5496 * cancel all the unreleased display-unspecified events for the focused window on the old focused
5497 * display. The display-specified events won't be affected.
5498 */
5499void InputDispatcher::setFocusedDisplay(int32_t displayId) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005500 if (DEBUG_FOCUS) {
5501 ALOGD("setFocusedDisplay displayId=%" PRId32, displayId);
5502 }
Tiger Huang721e26f2018-07-24 22:26:19 +08005503 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08005504 std::scoped_lock _l(mLock);
Prabir Pradhand6b2b052024-02-21 23:25:15 +00005505 ScopedSyntheticEventTracer traceContext(mTracer);
Tiger Huang721e26f2018-07-24 22:26:19 +08005506
5507 if (mFocusedDisplayId != displayId) {
Vishnu Nairad321cd2020-08-20 16:40:21 -07005508 sp<IBinder> oldFocusedWindowToken =
Vishnu Nairc519ff72021-01-21 08:23:08 -08005509 mFocusResolver.getFocusedWindowToken(mFocusedDisplayId);
Vishnu Nairad321cd2020-08-20 16:40:21 -07005510 if (oldFocusedWindowToken != nullptr) {
Prabir Pradhan4b9b1a12024-02-02 00:16:17 +00005511 const auto windowHandle =
5512 getWindowHandleLocked(oldFocusedWindowToken, mFocusedDisplayId);
5513 if (windowHandle == nullptr) {
5514 LOG(FATAL) << __func__ << ": Previously focused token did not have a window";
Tiger Huang721e26f2018-07-24 22:26:19 +08005515 }
Prabir Pradhan4b9b1a12024-02-02 00:16:17 +00005516 CancelationOptions
5517 options(CancelationOptions::Mode::CANCEL_NON_POINTER_EVENTS,
Prabir Pradhand6b2b052024-02-21 23:25:15 +00005518 "The display which contains this window no longer has focus.",
5519 traceContext.getTracker());
Prabir Pradhan4b9b1a12024-02-02 00:16:17 +00005520 options.displayId = ADISPLAY_ID_NONE;
5521 synthesizeCancelationEventsForWindowLocked(windowHandle, options);
Tiger Huang721e26f2018-07-24 22:26:19 +08005522 }
5523 mFocusedDisplayId = displayId;
5524
Chris Ye3c2d6f52020-08-09 10:39:48 -07005525 // Find new focused window and validate
Vishnu Nairc519ff72021-01-21 08:23:08 -08005526 sp<IBinder> newFocusedWindowToken = mFocusResolver.getFocusedWindowToken(displayId);
Prabir Pradhancef936d2021-07-21 16:17:52 +00005527 sendFocusChangedCommandLocked(oldFocusedWindowToken, newFocusedWindowToken);
Robert Carrf759f162018-11-13 12:57:11 -08005528
Vishnu Nairad321cd2020-08-20 16:40:21 -07005529 if (newFocusedWindowToken == nullptr) {
Tiger Huang721e26f2018-07-24 22:26:19 +08005530 ALOGW("Focused display #%" PRId32 " does not have a focused window.", displayId);
Vishnu Nairc519ff72021-01-21 08:23:08 -08005531 if (mFocusResolver.hasFocusedWindowTokens()) {
Vishnu Nairad321cd2020-08-20 16:40:21 -07005532 ALOGE("But another display has a focused window\n%s",
Vishnu Nairc519ff72021-01-21 08:23:08 -08005533 mFocusResolver.dumpFocusedWindows().c_str());
Tiger Huang721e26f2018-07-24 22:26:19 +08005534 }
5535 }
5536 }
Tiger Huang721e26f2018-07-24 22:26:19 +08005537 } // release lock
5538
5539 // Wake up poll loop since it may need to make new input dispatching choices.
5540 mLooper->wake();
5541}
5542
Michael Wrightd02c5b62014-02-10 15:10:22 -08005543void InputDispatcher::setInputDispatchMode(bool enabled, bool frozen) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005544 if (DEBUG_FOCUS) {
5545 ALOGD("setInputDispatchMode: enabled=%d, frozen=%d", enabled, frozen);
5546 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005547
5548 bool changed;
5549 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08005550 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005551
5552 if (mDispatchEnabled != enabled || mDispatchFrozen != frozen) {
5553 if (mDispatchFrozen && !frozen) {
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005554 resetNoFocusedWindowTimeoutLocked();
Michael Wrightd02c5b62014-02-10 15:10:22 -08005555 }
5556
5557 if (mDispatchEnabled && !enabled) {
5558 resetAndDropEverythingLocked("dispatcher is being disabled");
5559 }
5560
5561 mDispatchEnabled = enabled;
5562 mDispatchFrozen = frozen;
5563 changed = true;
5564 } else {
5565 changed = false;
5566 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005567 } // release lock
5568
5569 if (changed) {
5570 // Wake up poll loop since it may need to make new input dispatching choices.
5571 mLooper->wake();
5572 }
5573}
5574
5575void InputDispatcher::setInputFilterEnabled(bool enabled) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005576 if (DEBUG_FOCUS) {
5577 ALOGD("setInputFilterEnabled: enabled=%d", enabled);
5578 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005579
5580 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08005581 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005582
5583 if (mInputFilterEnabled == enabled) {
5584 return;
5585 }
5586
5587 mInputFilterEnabled = enabled;
5588 resetAndDropEverythingLocked("input filter is being enabled or disabled");
5589 } // release lock
5590
5591 // Wake up poll loop since there might be work to do to drop everything.
5592 mLooper->wake();
5593}
5594
Prabir Pradhanaeebeb42023-06-13 19:53:03 +00005595bool InputDispatcher::setInTouchMode(bool inTouchMode, gui::Pid pid, gui::Uid uid,
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00005596 bool hasPermission, int32_t displayId) {
Antonio Kantekf16f2832021-09-28 04:39:20 +00005597 bool needWake = false;
5598 {
5599 std::scoped_lock lock(mLock);
Antonio Kantek15beb512022-06-13 22:35:41 +00005600 ALOGD_IF(DEBUG_TOUCH_MODE,
Prabir Pradhanaeebeb42023-06-13 19:53:03 +00005601 "Request to change touch mode to %s (calling pid=%s, uid=%s, "
Antonio Kantek15beb512022-06-13 22:35:41 +00005602 "hasPermission=%s, target displayId=%d, mTouchModePerDisplay[displayId]=%s)",
Prabir Pradhanaeebeb42023-06-13 19:53:03 +00005603 toString(inTouchMode), pid.toString().c_str(), uid.toString().c_str(),
5604 toString(hasPermission), displayId,
Antonio Kantek15beb512022-06-13 22:35:41 +00005605 mTouchModePerDisplay.count(displayId) == 0
5606 ? "not set"
5607 : std::to_string(mTouchModePerDisplay[displayId]).c_str());
5608
Antonio Kantek15beb512022-06-13 22:35:41 +00005609 auto touchModeIt = mTouchModePerDisplay.find(displayId);
5610 if (touchModeIt != mTouchModePerDisplay.end() && touchModeIt->second == inTouchMode) {
Antonio Kantekea47acb2021-12-23 12:41:25 -08005611 return false;
Antonio Kantekf16f2832021-09-28 04:39:20 +00005612 }
Antonio Kantekea47acb2021-12-23 12:41:25 -08005613 if (!hasPermission) {
Antonio Kantek48710e42022-03-24 14:19:30 -07005614 if (!focusedWindowIsOwnedByLocked(pid, uid) &&
5615 !recentWindowsAreOwnedByLocked(pid, uid)) {
Prabir Pradhanaeebeb42023-06-13 19:53:03 +00005616 ALOGD("Touch mode switch rejected, caller (pid=%s, uid=%s) doesn't own the focused "
Antonio Kantek48710e42022-03-24 14:19:30 -07005617 "window nor none of the previously interacted window",
Prabir Pradhanaeebeb42023-06-13 19:53:03 +00005618 pid.toString().c_str(), uid.toString().c_str());
Antonio Kantekea47acb2021-12-23 12:41:25 -08005619 return false;
5620 }
Antonio Kantekf16f2832021-09-28 04:39:20 +00005621 }
Antonio Kantek15beb512022-06-13 22:35:41 +00005622 mTouchModePerDisplay[displayId] = inTouchMode;
5623 auto entry = std::make_unique<TouchModeEntry>(mIdGenerator.nextId(), now(), inTouchMode,
5624 displayId);
Antonio Kantekf16f2832021-09-28 04:39:20 +00005625 needWake = enqueueInboundEventLocked(std::move(entry));
5626 } // release lock
5627
5628 if (needWake) {
5629 mLooper->wake();
5630 }
Antonio Kantekea47acb2021-12-23 12:41:25 -08005631 return true;
Siarhei Vishniakouf3bc1aa2019-11-25 13:48:53 -08005632}
5633
Prabir Pradhanaeebeb42023-06-13 19:53:03 +00005634bool InputDispatcher::focusedWindowIsOwnedByLocked(gui::Pid pid, gui::Uid uid) {
Antonio Kantek48710e42022-03-24 14:19:30 -07005635 const sp<IBinder> focusedToken = mFocusResolver.getFocusedWindowToken(mFocusedDisplayId);
5636 if (focusedToken == nullptr) {
5637 return false;
5638 }
5639 sp<WindowInfoHandle> windowHandle = getWindowHandleLocked(focusedToken);
5640 return isWindowOwnedBy(windowHandle, pid, uid);
5641}
5642
Prabir Pradhanaeebeb42023-06-13 19:53:03 +00005643bool InputDispatcher::recentWindowsAreOwnedByLocked(gui::Pid pid, gui::Uid uid) {
Antonio Kantek48710e42022-03-24 14:19:30 -07005644 return std::find_if(mInteractionConnectionTokens.begin(), mInteractionConnectionTokens.end(),
5645 [&](const sp<IBinder>& connectionToken) REQUIRES(mLock) {
5646 const sp<WindowInfoHandle> windowHandle =
5647 getWindowHandleLocked(connectionToken);
5648 return isWindowOwnedBy(windowHandle, pid, uid);
5649 }) != mInteractionConnectionTokens.end();
5650}
5651
Bernardo Rufinoea97d182020-08-19 14:43:14 +01005652void InputDispatcher::setMaximumObscuringOpacityForTouch(float opacity) {
5653 if (opacity < 0 || opacity > 1) {
5654 LOG_ALWAYS_FATAL("Maximum obscuring opacity for touch should be >= 0 and <= 1");
5655 return;
5656 }
5657
5658 std::scoped_lock lock(mLock);
5659 mMaximumObscuringOpacityForTouch = opacity;
5660}
5661
Siarhei Vishniakou40b8fbd2022-11-04 10:50:26 -07005662std::tuple<TouchState*, TouchedWindow*, int32_t /*displayId*/>
5663InputDispatcher::findTouchStateWindowAndDisplayLocked(const sp<IBinder>& token) {
Arthur Hungabbb9d82021-09-01 14:52:30 +00005664 for (auto& [displayId, state] : mTouchStatesByDisplay) {
5665 for (TouchedWindow& w : state.windows) {
5666 if (w.windowHandle->getToken() == token) {
Siarhei Vishniakou40b8fbd2022-11-04 10:50:26 -07005667 return std::make_tuple(&state, &w, displayId);
Arthur Hungabbb9d82021-09-01 14:52:30 +00005668 }
5669 }
5670 }
Siarhei Vishniakou40b8fbd2022-11-04 10:50:26 -07005671 return std::make_tuple(nullptr, nullptr, ADISPLAY_ID_DEFAULT);
Arthur Hungabbb9d82021-09-01 14:52:30 +00005672}
5673
Prabir Pradhan367f3432024-02-13 23:05:58 +00005674bool InputDispatcher::transferTouchGesture(const sp<IBinder>& fromToken, const sp<IBinder>& toToken,
5675 bool isDragDrop) {
chaviwfbe5d9c2018-12-26 12:23:37 -08005676 if (fromToken == toToken) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005677 if (DEBUG_FOCUS) {
5678 ALOGD("Trivial transfer to same window.");
5679 }
chaviwfbe5d9c2018-12-26 12:23:37 -08005680 return true;
5681 }
5682
Michael Wrightd02c5b62014-02-10 15:10:22 -08005683 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08005684 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005685
Arthur Hungabbb9d82021-09-01 14:52:30 +00005686 // Find the target touch state and touched window by fromToken.
Siarhei Vishniakou40b8fbd2022-11-04 10:50:26 -07005687 auto [state, touchedWindow, displayId] = findTouchStateWindowAndDisplayLocked(fromToken);
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07005688
Arthur Hungabbb9d82021-09-01 14:52:30 +00005689 if (state == nullptr || touchedWindow == nullptr) {
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07005690 ALOGD("Touch transfer failed because from window is not being touched.");
Michael Wrightd02c5b62014-02-10 15:10:22 -08005691 return false;
5692 }
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07005693 std::set<int32_t> deviceIds = touchedWindow->getTouchingDeviceIds();
5694 if (deviceIds.size() != 1) {
Siarhei Vishniakou827d1ac2023-07-21 16:37:51 -07005695 LOG(INFO) << "Can't transfer touch. Currently touching devices: " << dumpSet(deviceIds)
5696 << " for window: " << touchedWindow->dump();
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07005697 return false;
5698 }
5699 const int32_t deviceId = *deviceIds.begin();
Arthur Hungabbb9d82021-09-01 14:52:30 +00005700
Prabir Pradhanbb3f1c02024-01-04 20:17:14 +00005701 const sp<WindowInfoHandle> fromWindowHandle = touchedWindow->windowHandle;
5702 const sp<WindowInfoHandle> toWindowHandle = getWindowHandleLocked(toToken, displayId);
5703 if (!toWindowHandle) {
5704 ALOGW("Cannot transfer touch because the transfer target window was not found.");
Arthur Hungabbb9d82021-09-01 14:52:30 +00005705 return false;
5706 }
5707
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005708 if (DEBUG_FOCUS) {
Prabir Pradhan367f3432024-02-13 23:05:58 +00005709 ALOGD("%s: fromWindowHandle=%s, toWindowHandle=%s", __func__,
Arthur Hungabbb9d82021-09-01 14:52:30 +00005710 touchedWindow->windowHandle->getName().c_str(),
5711 toWindowHandle->getName().c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08005712 }
5713
Arthur Hungabbb9d82021-09-01 14:52:30 +00005714 // Erase old window.
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08005715 ftl::Flags<InputTarget::Flags> oldTargetFlags = touchedWindow->targetFlags;
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -08005716 std::vector<PointerProperties> pointers = touchedWindow->getTouchingPointers(deviceId);
Arthur Hungabbb9d82021-09-01 14:52:30 +00005717 state->removeWindowByToken(fromToken);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005718
Arthur Hungabbb9d82021-09-01 14:52:30 +00005719 // Add new window.
Vaibhav Devmurari882bd9b2022-06-23 14:54:54 +00005720 nsecs_t downTimeInTarget = now();
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08005721 ftl::Flags<InputTarget::Flags> newTargetFlags =
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00005722 oldTargetFlags & (InputTarget::Flags::SPLIT);
Prabir Pradhan6dfbf262022-03-14 15:24:30 +00005723 if (canReceiveForegroundTouches(*toWindowHandle->getInfo())) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08005724 newTargetFlags |= InputTarget::Flags::FOREGROUND;
Prabir Pradhan6dfbf262022-03-14 15:24:30 +00005725 }
Prabir Pradhan65455c72024-02-13 21:46:41 +00005726 // Transferring touch focus using this API should not effect the focused window.
5727 newTargetFlags |= InputTarget::Flags::NO_FOCUS_CHANGE;
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00005728 state->addOrUpdateWindow(toWindowHandle, InputTarget::DispatchMode::AS_IS, newTargetFlags,
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -08005729 deviceId, pointers, downTimeInTarget);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005730
Arthur Hungabbb9d82021-09-01 14:52:30 +00005731 // Store the dragging window.
5732 if (isDragDrop) {
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -08005733 if (pointers.size() != 1) {
Arthur Hungb75c2aa2022-07-15 09:35:36 +00005734 ALOGW("The drag and drop cannot be started when there is no pointer or more than 1"
5735 " pointer on the window.");
Arthur Hung54745652022-04-20 07:17:41 +00005736 return false;
5737 }
Arthur Hungb75c2aa2022-07-15 09:35:36 +00005738 // Track the pointer id for drag window and generate the drag state.
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -08005739 const size_t id = pointers.begin()->id;
Arthur Hung54745652022-04-20 07:17:41 +00005740 mDragState = std::make_unique<DragState>(toWindowHandle, id);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005741 }
5742
Arthur Hungabbb9d82021-09-01 14:52:30 +00005743 // Synthesize cancel for old window and down for new window.
Prabir Pradhand6b2b052024-02-21 23:25:15 +00005744 ScopedSyntheticEventTracer traceContext(mTracer);
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07005745 std::shared_ptr<Connection> fromConnection = getConnectionLocked(fromToken);
5746 std::shared_ptr<Connection> toConnection = getConnectionLocked(toToken);
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07005747 if (fromConnection != nullptr && toConnection != nullptr) {
Svet Ganov5d3bc372020-01-26 23:11:07 -08005748 fromConnection->inputState.mergePointerStateTo(toConnection->inputState);
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07005749 CancelationOptions options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS,
Prabir Pradhand6b2b052024-02-21 23:25:15 +00005750 "transferring touch from this window to another window",
5751 traceContext.getTracker());
Prabir Pradhanbb3f1c02024-01-04 20:17:14 +00005752 synthesizeCancelationEventsForWindowLocked(fromWindowHandle, options, fromConnection);
Arthur Hungc539dbb2022-12-08 07:45:36 +00005753 synthesizePointerDownEventsForConnectionLocked(downTimeInTarget, toConnection,
Prabir Pradhand6b2b052024-02-21 23:25:15 +00005754 newTargetFlags,
5755 traceContext.getTracker());
Arthur Hungc539dbb2022-12-08 07:45:36 +00005756
5757 // Check if the wallpaper window should deliver the corresponding event.
5758 transferWallpaperTouch(oldTargetFlags, newTargetFlags, fromWindowHandle, toWindowHandle,
Prabir Pradhand6b2b052024-02-21 23:25:15 +00005759 *state, deviceId, pointers, traceContext.getTracker());
Michael Wrightd02c5b62014-02-10 15:10:22 -08005760 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005761 } // release lock
5762
5763 // Wake up poll loop since it may need to make new input dispatching choices.
5764 mLooper->wake();
5765 return true;
5766}
5767
Siarhei Vishniakou7ae7afd2022-03-31 15:26:13 -07005768/**
5769 * Get the touched foreground window on the given display.
5770 * Return null if there are no windows touched on that display, or if more than one foreground
5771 * window is being touched.
5772 */
5773sp<WindowInfoHandle> InputDispatcher::findTouchedForegroundWindowLocked(int32_t displayId) const {
5774 auto stateIt = mTouchStatesByDisplay.find(displayId);
5775 if (stateIt == mTouchStatesByDisplay.end()) {
5776 ALOGI("No touch state on display %" PRId32, displayId);
5777 return nullptr;
5778 }
5779
5780 const TouchState& state = stateIt->second;
5781 sp<WindowInfoHandle> touchedForegroundWindow;
5782 // If multiple foreground windows are touched, return nullptr
5783 for (const TouchedWindow& window : state.windows) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08005784 if (window.targetFlags.test(InputTarget::Flags::FOREGROUND)) {
Siarhei Vishniakou7ae7afd2022-03-31 15:26:13 -07005785 if (touchedForegroundWindow != nullptr) {
5786 ALOGI("Two or more foreground windows: %s and %s",
5787 touchedForegroundWindow->getName().c_str(),
5788 window.windowHandle->getName().c_str());
5789 return nullptr;
5790 }
5791 touchedForegroundWindow = window.windowHandle;
5792 }
5793 }
5794 return touchedForegroundWindow;
5795}
5796
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +00005797// Binder call
Prabir Pradhan367f3432024-02-13 23:05:58 +00005798bool InputDispatcher::transferTouchOnDisplay(const sp<IBinder>& destChannelToken,
5799 int32_t displayId) {
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +00005800 sp<IBinder> fromToken;
5801 { // acquire lock
5802 std::scoped_lock _l(mLock);
Arthur Hungabbb9d82021-09-01 14:52:30 +00005803 sp<WindowInfoHandle> toWindowHandle = getWindowHandleLocked(destChannelToken, displayId);
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +00005804 if (toWindowHandle == nullptr) {
Siarhei Vishniakou7ae7afd2022-03-31 15:26:13 -07005805 ALOGW("Could not find window associated with token=%p on display %" PRId32,
5806 destChannelToken.get(), displayId);
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +00005807 return false;
5808 }
5809
Siarhei Vishniakou7ae7afd2022-03-31 15:26:13 -07005810 sp<WindowInfoHandle> from = findTouchedForegroundWindowLocked(displayId);
5811 if (from == nullptr) {
5812 ALOGE("Could not find a source window in %s for %p", __func__, destChannelToken.get());
5813 return false;
5814 }
5815
5816 fromToken = from->getToken();
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +00005817 } // release lock
5818
Prabir Pradhan367f3432024-02-13 23:05:58 +00005819 return transferTouchGesture(fromToken, destChannelToken);
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +00005820}
5821
Michael Wrightd02c5b62014-02-10 15:10:22 -08005822void InputDispatcher::resetAndDropEverythingLocked(const char* reason) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005823 if (DEBUG_FOCUS) {
5824 ALOGD("Resetting and dropping all events (%s).", reason);
5825 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005826
Prabir Pradhand6b2b052024-02-21 23:25:15 +00005827 ScopedSyntheticEventTracer traceContext(mTracer);
5828 CancelationOptions options(CancelationOptions::Mode::CANCEL_ALL_EVENTS, reason,
5829 traceContext.getTracker());
Michael Wrightd02c5b62014-02-10 15:10:22 -08005830 synthesizeCancelationEventsForAllConnectionsLocked(options);
5831
5832 resetKeyRepeatLocked();
5833 releasePendingEventLocked();
5834 drainInboundQueueLocked();
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005835 resetNoFocusedWindowTimeoutLocked();
Michael Wrightd02c5b62014-02-10 15:10:22 -08005836
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005837 mAnrTracker.clear();
Jeff Brownf086ddb2014-02-11 14:28:48 -08005838 mTouchStatesByDisplay.clear();
Michael Wrightd02c5b62014-02-10 15:10:22 -08005839}
5840
Siarhei Vishniakou4c9d6ff2023-04-18 11:23:20 -07005841void InputDispatcher::logDispatchStateLocked() const {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005842 std::string dump;
Michael Wrightd02c5b62014-02-10 15:10:22 -08005843 dumpDispatchStateLocked(dump);
5844
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005845 std::istringstream stream(dump);
5846 std::string line;
5847
5848 while (std::getline(stream, line, '\n')) {
Siarhei Vishniakoua235c042023-05-02 09:59:09 -07005849 ALOGI("%s", line.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08005850 }
5851}
5852
Siarhei Vishniakou4c9d6ff2023-04-18 11:23:20 -07005853std::string InputDispatcher::dumpPointerCaptureStateLocked() const {
Prabir Pradhan99987712020-11-10 18:43:05 -08005854 std::string dump;
5855
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00005856 dump += StringPrintf(INDENT "Pointer Capture Requested: %s\n",
Hiroki Sato25040232024-02-22 17:21:22 +09005857 toString(mCurrentPointerCaptureRequest.isEnable()));
Prabir Pradhan99987712020-11-10 18:43:05 -08005858
5859 std::string windowName = "None";
5860 if (mWindowTokenWithPointerCapture) {
chaviw98318de2021-05-19 16:45:23 -05005861 const sp<WindowInfoHandle> captureWindowHandle =
Prabir Pradhan99987712020-11-10 18:43:05 -08005862 getWindowHandleLocked(mWindowTokenWithPointerCapture);
5863 windowName = captureWindowHandle ? captureWindowHandle->getName().c_str()
5864 : "token has capture without window";
5865 }
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00005866 dump += StringPrintf(INDENT "Current Window with Pointer Capture: %s\n", windowName.c_str());
Prabir Pradhan99987712020-11-10 18:43:05 -08005867
5868 return dump;
5869}
5870
Siarhei Vishniakou4c9d6ff2023-04-18 11:23:20 -07005871void InputDispatcher::dumpDispatchStateLocked(std::string& dump) const {
Siarhei Vishniakou043a3ec2019-05-01 11:30:46 -07005872 dump += StringPrintf(INDENT "DispatchEnabled: %s\n", toString(mDispatchEnabled));
5873 dump += StringPrintf(INDENT "DispatchFrozen: %s\n", toString(mDispatchFrozen));
5874 dump += StringPrintf(INDENT "InputFilterEnabled: %s\n", toString(mInputFilterEnabled));
Tiger Huang721e26f2018-07-24 22:26:19 +08005875 dump += StringPrintf(INDENT "FocusedDisplayId: %" PRId32 "\n", mFocusedDisplayId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005876
Tiger Huang721e26f2018-07-24 22:26:19 +08005877 if (!mFocusedApplicationHandlesByDisplay.empty()) {
5878 dump += StringPrintf(INDENT "FocusedApplications:\n");
5879 for (auto& it : mFocusedApplicationHandlesByDisplay) {
5880 const int32_t displayId = it.first;
Chris Yea209fde2020-07-22 13:54:51 -07005881 const std::shared_ptr<InputApplicationHandle>& applicationHandle = it.second;
Siarhei Vishniakou70622952020-07-30 11:17:23 -05005882 const std::chrono::duration timeout =
5883 applicationHandle->getDispatchingTimeout(DEFAULT_INPUT_DISPATCHING_TIMEOUT);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07005884 dump += StringPrintf(INDENT2 "displayId=%" PRId32
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07005885 ", name='%s', dispatchingTimeout=%" PRId64 "ms\n",
Siarhei Vishniakou70622952020-07-30 11:17:23 -05005886 displayId, applicationHandle->getName().c_str(), millis(timeout));
Tiger Huang721e26f2018-07-24 22:26:19 +08005887 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005888 } else {
Tiger Huang721e26f2018-07-24 22:26:19 +08005889 dump += StringPrintf(INDENT "FocusedApplications: <none>\n");
Michael Wrightd02c5b62014-02-10 15:10:22 -08005890 }
Tiger Huang721e26f2018-07-24 22:26:19 +08005891
Vishnu Nairc519ff72021-01-21 08:23:08 -08005892 dump += mFocusResolver.dump();
Prabir Pradhan99987712020-11-10 18:43:05 -08005893 dump += dumpPointerCaptureStateLocked();
Michael Wrightd02c5b62014-02-10 15:10:22 -08005894
Siarhei Vishniakou4700f822020-03-24 19:05:54 -07005895 if (!mTouchStatesByDisplay.empty()) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005896 dump += StringPrintf(INDENT "TouchStatesByDisplay:\n");
Siarhei Vishniakou40b8fbd2022-11-04 10:50:26 -07005897 for (const auto& [displayId, state] : mTouchStatesByDisplay) {
Siarhei Vishniakou6e1e9872022-11-08 17:51:35 -08005898 std::string touchStateDump = addLinePrefix(state.dump(), INDENT2);
5899 dump += INDENT2 + std::to_string(displayId) + " : " + touchStateDump;
Michael Wrightd02c5b62014-02-10 15:10:22 -08005900 }
5901 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005902 dump += INDENT "TouchStates: <no displays touched>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005903 }
5904
arthurhung6d4bed92021-03-17 11:59:33 +08005905 if (mDragState) {
5906 dump += StringPrintf(INDENT "DragState:\n");
5907 mDragState->dump(dump, INDENT2);
5908 }
5909
Arthur Hungb92218b2018-08-14 12:00:21 +08005910 if (!mWindowHandlesByDisplay.empty()) {
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07005911 for (const auto& [displayId, windowHandles] : mWindowHandlesByDisplay) {
5912 dump += StringPrintf(INDENT "Display: %" PRId32 "\n", displayId);
5913 if (const auto& it = mDisplayInfos.find(displayId); it != mDisplayInfos.end()) {
5914 const auto& displayInfo = it->second;
5915 dump += StringPrintf(INDENT2 "logicalSize=%dx%d\n", displayInfo.logicalWidth,
5916 displayInfo.logicalHeight);
5917 displayInfo.transform.dump(dump, "transform", INDENT4);
5918 } else {
5919 dump += INDENT2 "No DisplayInfo found!\n";
5920 }
5921
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08005922 if (!windowHandles.empty()) {
Arthur Hungb92218b2018-08-14 12:00:21 +08005923 dump += INDENT2 "Windows:\n";
5924 for (size_t i = 0; i < windowHandles.size(); i++) {
Siarhei Vishniakou366fb5b2023-12-06 11:23:41 -08005925 dump += StringPrintf(INDENT3 "%zu: %s", i,
5926 streamableToString(*windowHandles[i]).c_str());
Arthur Hungb92218b2018-08-14 12:00:21 +08005927 }
5928 } else {
5929 dump += INDENT2 "Windows: <none>\n";
5930 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005931 }
5932 } else {
Arthur Hungb92218b2018-08-14 12:00:21 +08005933 dump += INDENT "Displays: <none>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005934 }
5935
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08005936 if (!mGlobalMonitorsByDisplay.empty()) {
5937 for (const auto& [displayId, monitors] : mGlobalMonitorsByDisplay) {
5938 dump += StringPrintf(INDENT "Global monitors on display %d:\n", displayId);
Michael Wright3dd60e22019-03-27 22:06:44 +00005939 dumpMonitors(dump, monitors);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07005940 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005941 } else {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08005942 dump += INDENT "Global Monitors: <none>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005943 }
5944
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08005945 const nsecs_t currentTime = now();
Michael Wrightd02c5b62014-02-10 15:10:22 -08005946
5947 // Dump recently dispatched or dropped events from oldest to newest.
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07005948 if (!mRecentQueue.empty()) {
5949 dump += StringPrintf(INDENT "RecentQueue: length=%zu\n", mRecentQueue.size());
Prabir Pradhan24047542023-11-02 17:14:59 +00005950 for (const std::shared_ptr<const EventEntry>& entry : mRecentQueue) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005951 dump += INDENT2;
Siarhei Vishniakou14411c92020-09-18 21:15:05 -05005952 dump += entry->getDescription();
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07005953 dump += StringPrintf(", age=%" PRId64 "ms\n", ns2ms(currentTime - entry->eventTime));
Michael Wrightd02c5b62014-02-10 15:10:22 -08005954 }
5955 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005956 dump += INDENT "RecentQueue: <empty>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005957 }
5958
5959 // Dump event currently being dispatched.
5960 if (mPendingEvent) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005961 dump += INDENT "PendingEvent:\n";
5962 dump += INDENT2;
Siarhei Vishniakou14411c92020-09-18 21:15:05 -05005963 dump += mPendingEvent->getDescription();
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07005964 dump += StringPrintf(", age=%" PRId64 "ms\n",
5965 ns2ms(currentTime - mPendingEvent->eventTime));
Michael Wrightd02c5b62014-02-10 15:10:22 -08005966 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005967 dump += INDENT "PendingEvent: <none>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005968 }
5969
5970 // Dump inbound events from oldest to newest.
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07005971 if (!mInboundQueue.empty()) {
5972 dump += StringPrintf(INDENT "InboundQueue: length=%zu\n", mInboundQueue.size());
Prabir Pradhan24047542023-11-02 17:14:59 +00005973 for (const std::shared_ptr<const EventEntry>& entry : mInboundQueue) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005974 dump += INDENT2;
Siarhei Vishniakou14411c92020-09-18 21:15:05 -05005975 dump += entry->getDescription();
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07005976 dump += StringPrintf(", age=%" PRId64 "ms\n", ns2ms(currentTime - entry->eventTime));
Michael Wrightd02c5b62014-02-10 15:10:22 -08005977 }
5978 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005979 dump += INDENT "InboundQueue: <empty>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005980 }
5981
Prabir Pradhancef936d2021-07-21 16:17:52 +00005982 if (!mCommandQueue.empty()) {
5983 dump += StringPrintf(INDENT "CommandQueue: size=%zu\n", mCommandQueue.size());
5984 } else {
5985 dump += INDENT "CommandQueue: <empty>\n";
5986 }
5987
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005988 if (!mConnectionsByToken.empty()) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005989 dump += INDENT "Connections:\n";
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005990 for (const auto& [token, connection] : mConnectionsByToken) {
Siarhei Vishniakou10bfdc92024-02-01 11:12:57 -08005991 dump += StringPrintf(INDENT2 "%i: channelName='%s', "
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005992 "status=%s, monitor=%s, responsive=%s\n",
Siarhei Vishniakou7b9f4f52024-02-02 13:07:16 -08005993 connection->inputPublisher.getChannel().getFd(),
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005994 connection->getInputChannelName().c_str(),
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08005995 ftl::enum_string(connection->status).c_str(),
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005996 toString(connection->monitor), toString(connection->responsive));
Michael Wrightd02c5b62014-02-10 15:10:22 -08005997
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07005998 if (!connection->outboundQueue.empty()) {
5999 dump += StringPrintf(INDENT3 "OutboundQueue: length=%zu\n",
6000 connection->outboundQueue.size());
Siarhei Vishniakou14411c92020-09-18 21:15:05 -05006001 dump += dumpQueue(connection->outboundQueue, currentTime);
6002
Michael Wrightd02c5b62014-02-10 15:10:22 -08006003 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08006004 dump += INDENT3 "OutboundQueue: <empty>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08006005 }
6006
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07006007 if (!connection->waitQueue.empty()) {
6008 dump += StringPrintf(INDENT3 "WaitQueue: length=%zu\n",
6009 connection->waitQueue.size());
Siarhei Vishniakou14411c92020-09-18 21:15:05 -05006010 dump += dumpQueue(connection->waitQueue, currentTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006011 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08006012 dump += INDENT3 "WaitQueue: <empty>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08006013 }
Siarhei Vishniakou366fb5b2023-12-06 11:23:41 -08006014 std::string inputStateDump = streamableToString(connection->inputState);
6015 if (!inputStateDump.empty()) {
Siarhei Vishniakoud38a1e02023-07-18 11:55:17 -07006016 dump += INDENT3 "InputState: ";
Siarhei Vishniakou366fb5b2023-12-06 11:23:41 -08006017 dump += inputStateDump + "\n";
Siarhei Vishniakoud38a1e02023-07-18 11:55:17 -07006018 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08006019 }
6020 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08006021 dump += INDENT "Connections: <none>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08006022 }
6023
Antonio Kantek15beb512022-06-13 22:35:41 +00006024 if (!mTouchModePerDisplay.empty()) {
6025 dump += INDENT "TouchModePerDisplay:\n";
6026 for (const auto& [displayId, touchMode] : mTouchModePerDisplay) {
6027 dump += StringPrintf(INDENT2 "Display: %" PRId32 " TouchMode: %s\n", displayId,
6028 std::to_string(touchMode).c_str());
6029 }
6030 } else {
6031 dump += INDENT "TouchModePerDisplay: <none>\n";
6032 }
6033
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08006034 dump += INDENT "Configuration:\n";
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07006035 dump += StringPrintf(INDENT2 "KeyRepeatDelay: %" PRId64 "ms\n", ns2ms(mConfig.keyRepeatDelay));
6036 dump += StringPrintf(INDENT2 "KeyRepeatTimeout: %" PRId64 "ms\n",
6037 ns2ms(mConfig.keyRepeatTimeout));
Siarhei Vishniakouf2652122021-03-05 21:39:46 +00006038 dump += mLatencyTracker.dump(INDENT2);
Siarhei Vishniakoua04181f2021-03-26 05:56:49 +00006039 dump += mLatencyAggregator.dump(INDENT2);
Prabir Pradhanabcdf5c2023-12-15 07:30:22 +00006040 dump += INDENT "InputTracer: ";
6041 dump += mTracer == nullptr ? "Disabled" : "Enabled";
Michael Wrightd02c5b62014-02-10 15:10:22 -08006042}
6043
Siarhei Vishniakou4c9d6ff2023-04-18 11:23:20 -07006044void InputDispatcher::dumpMonitors(std::string& dump, const std::vector<Monitor>& monitors) const {
Michael Wright3dd60e22019-03-27 22:06:44 +00006045 const size_t numMonitors = monitors.size();
6046 for (size_t i = 0; i < numMonitors; i++) {
6047 const Monitor& monitor = monitors[i];
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08006048 const std::shared_ptr<Connection>& connection = monitor.connection;
6049 dump += StringPrintf(INDENT2 "%zu: '%s', ", i, connection->getInputChannelName().c_str());
Michael Wright3dd60e22019-03-27 22:06:44 +00006050 dump += "\n";
6051 }
6052}
6053
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00006054class LooperEventCallback : public LooperCallback {
6055public:
6056 LooperEventCallback(std::function<int(int events)> callback) : mCallback(callback) {}
6057 int handleEvent(int /*fd*/, int events, void* /*data*/) override { return mCallback(events); }
6058
6059private:
6060 std::function<int(int events)> mCallback;
6061};
6062
Siarhei Vishniakoueedd0fc2021-03-12 09:50:36 +00006063Result<std::unique_ptr<InputChannel>> InputDispatcher::createInputChannel(const std::string& name) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006064 if (DEBUG_CHANNEL_CREATION) {
6065 ALOGD("channel '%s' ~ createInputChannel", name.c_str());
6066 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08006067
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00006068 std::unique_ptr<InputChannel> serverChannel;
Garfield Tan15601662020-09-22 15:32:38 -07006069 std::unique_ptr<InputChannel> clientChannel;
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00006070 status_t result = InputChannel::openInputChannelPair(name, serverChannel, clientChannel);
Garfield Tan15601662020-09-22 15:32:38 -07006071
6072 if (result) {
6073 return base::Error(result) << "Failed to open input channel pair with name " << name;
6074 }
6075
Michael Wrightd02c5b62014-02-10 15:10:22 -08006076 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08006077 std::scoped_lock _l(mLock);
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00006078 const sp<IBinder>& token = serverChannel->getConnectionToken();
Siarhei Vishniakou8d660132024-01-11 16:48:44 -08006079 const int fd = serverChannel->getFd();
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07006080 std::shared_ptr<Connection> connection =
6081 std::make_shared<Connection>(std::move(serverChannel), /*monitor=*/false,
6082 mIdGenerator);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006083
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08006084 auto [_, inserted] = mConnectionsByToken.try_emplace(token, connection);
6085 if (!inserted) {
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00006086 ALOGE("Created a new connection, but the token %p is already known", token.get());
6087 }
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00006088
6089 std::function<int(int events)> callback = std::bind(&InputDispatcher::handleReceiveCallback,
6090 this, std::placeholders::_1, token);
6091
Siarhei Vishniakou8d660132024-01-11 16:48:44 -08006092 mLooper->addFd(fd, 0, ALOOPER_EVENT_INPUT, sp<LooperEventCallback>::make(callback),
Siarhei Vishniakouaed7ad02022-08-03 15:04:33 -07006093 nullptr);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006094 } // release lock
6095
6096 // Wake the looper because some connections have changed.
6097 mLooper->wake();
Garfield Tan15601662020-09-22 15:32:38 -07006098 return clientChannel;
Michael Wrightd02c5b62014-02-10 15:10:22 -08006099}
6100
Siarhei Vishniakoueedd0fc2021-03-12 09:50:36 +00006101Result<std::unique_ptr<InputChannel>> InputDispatcher::createInputMonitor(int32_t displayId,
Siarhei Vishniakoueedd0fc2021-03-12 09:50:36 +00006102 const std::string& name,
Prabir Pradhanaeebeb42023-06-13 19:53:03 +00006103 gui::Pid pid) {
Siarhei Vishniakou7b9f4f52024-02-02 13:07:16 -08006104 std::unique_ptr<InputChannel> serverChannel;
Garfield Tan15601662020-09-22 15:32:38 -07006105 std::unique_ptr<InputChannel> clientChannel;
Siarhei Vishniakou7b9f4f52024-02-02 13:07:16 -08006106 status_t result = InputChannel::openInputChannelPair(name, serverChannel, clientChannel);
Garfield Tan15601662020-09-22 15:32:38 -07006107 if (result) {
6108 return base::Error(result) << "Failed to open input channel pair with name " << name;
6109 }
6110
Michael Wright3dd60e22019-03-27 22:06:44 +00006111 { // acquire lock
6112 std::scoped_lock _l(mLock);
6113
6114 if (displayId < 0) {
Garfield Tan15601662020-09-22 15:32:38 -07006115 return base::Error(BAD_VALUE) << "Attempted to create input monitor with name " << name
6116 << " without a specified display.";
Michael Wright3dd60e22019-03-27 22:06:44 +00006117 }
6118
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00006119 const sp<IBinder>& token = serverChannel->getConnectionToken();
Siarhei Vishniakou8d660132024-01-11 16:48:44 -08006120 const int fd = serverChannel->getFd();
Siarhei Vishniakou7b9f4f52024-02-02 13:07:16 -08006121 std::shared_ptr<Connection> connection =
6122 std::make_shared<Connection>(std::move(serverChannel), /*monitor=*/true,
6123 mIdGenerator);
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00006124
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08006125 auto [_, inserted] = mConnectionsByToken.emplace(token, connection);
6126 if (!inserted) {
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00006127 ALOGE("Created a new connection, but the token %p is already known", token.get());
6128 }
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08006129
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00006130 std::function<int(int events)> callback = std::bind(&InputDispatcher::handleReceiveCallback,
6131 this, std::placeholders::_1, token);
Michael Wright3dd60e22019-03-27 22:06:44 +00006132
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08006133 mGlobalMonitorsByDisplay[displayId].emplace_back(connection, pid);
Michael Wright3dd60e22019-03-27 22:06:44 +00006134
Siarhei Vishniakou8d660132024-01-11 16:48:44 -08006135 mLooper->addFd(fd, 0, ALOOPER_EVENT_INPUT, sp<LooperEventCallback>::make(callback),
Siarhei Vishniakouaed7ad02022-08-03 15:04:33 -07006136 nullptr);
Michael Wright3dd60e22019-03-27 22:06:44 +00006137 }
Garfield Tan15601662020-09-22 15:32:38 -07006138
Michael Wright3dd60e22019-03-27 22:06:44 +00006139 // Wake the looper because some connections have changed.
6140 mLooper->wake();
Garfield Tan15601662020-09-22 15:32:38 -07006141 return clientChannel;
Michael Wright3dd60e22019-03-27 22:06:44 +00006142}
6143
Garfield Tan15601662020-09-22 15:32:38 -07006144status_t InputDispatcher::removeInputChannel(const sp<IBinder>& connectionToken) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08006145 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08006146 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006147
Harry Cutts33476232023-01-30 19:57:29 +00006148 status_t status = removeInputChannelLocked(connectionToken, /*notify=*/false);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006149 if (status) {
6150 return status;
6151 }
6152 } // release lock
6153
6154 // Wake the poll loop because removing the connection may have changed the current
6155 // synchronization state.
6156 mLooper->wake();
6157 return OK;
6158}
6159
Garfield Tan15601662020-09-22 15:32:38 -07006160status_t InputDispatcher::removeInputChannelLocked(const sp<IBinder>& connectionToken,
6161 bool notify) {
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07006162 std::shared_ptr<Connection> connection = getConnectionLocked(connectionToken);
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07006163 if (connection == nullptr) {
Siarhei Vishniakoud706a282021-02-13 00:08:48 +00006164 // Connection can be removed via socket hang up or an explicit call to 'removeInputChannel'
Michael Wrightd02c5b62014-02-10 15:10:22 -08006165 return BAD_VALUE;
6166 }
6167
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07006168 removeConnectionLocked(connection);
Robert Carr5c8a0262018-10-03 16:30:44 -07006169
Michael Wrightd02c5b62014-02-10 15:10:22 -08006170 if (connection->monitor) {
Siarhei Vishniakouadefc3e2020-09-02 22:28:29 -05006171 removeMonitorChannelLocked(connectionToken);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006172 }
6173
Siarhei Vishniakou7b9f4f52024-02-02 13:07:16 -08006174 mLooper->removeFd(connection->inputPublisher.getChannel().getFd());
Michael Wrightd02c5b62014-02-10 15:10:22 -08006175
6176 nsecs_t currentTime = now();
6177 abortBrokenDispatchCycleLocked(currentTime, connection, notify);
6178
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08006179 connection->status = Connection::Status::ZOMBIE;
Michael Wrightd02c5b62014-02-10 15:10:22 -08006180 return OK;
6181}
6182
Siarhei Vishniakouadefc3e2020-09-02 22:28:29 -05006183void InputDispatcher::removeMonitorChannelLocked(const sp<IBinder>& connectionToken) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006184 for (auto it = mGlobalMonitorsByDisplay.begin(); it != mGlobalMonitorsByDisplay.end();) {
6185 auto& [displayId, monitors] = *it;
6186 std::erase_if(monitors, [connectionToken](const Monitor& monitor) {
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08006187 return monitor.connection->getToken() == connectionToken;
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006188 });
Michael Wright3dd60e22019-03-27 22:06:44 +00006189
Michael Wright3dd60e22019-03-27 22:06:44 +00006190 if (monitors.empty()) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006191 it = mGlobalMonitorsByDisplay.erase(it);
Arthur Hung2fbf37f2018-09-13 18:16:41 +08006192 } else {
6193 ++it;
6194 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08006195 }
6196}
6197
Michael Wright3dd60e22019-03-27 22:06:44 +00006198status_t InputDispatcher::pilferPointers(const sp<IBinder>& token) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006199 std::scoped_lock _l(mLock);
Vaibhav Devmurari6abcf8f2022-06-06 10:08:05 +00006200 return pilferPointersLocked(token);
6201}
Michael Wright3dd60e22019-03-27 22:06:44 +00006202
Vaibhav Devmurari6abcf8f2022-06-06 10:08:05 +00006203status_t InputDispatcher::pilferPointersLocked(const sp<IBinder>& token) {
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08006204 const std::shared_ptr<Connection> requestingConnection = getConnectionLocked(token);
6205 if (!requestingConnection) {
Siarhei Vishniakou8384e0d2023-09-18 18:48:27 -07006206 LOG(WARNING)
6207 << "Attempted to pilfer pointers from an un-registered channel or invalid token";
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006208 return BAD_VALUE;
Michael Wright3dd60e22019-03-27 22:06:44 +00006209 }
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006210
Siarhei Vishniakou40b8fbd2022-11-04 10:50:26 -07006211 auto [statePtr, windowPtr, displayId] = findTouchStateWindowAndDisplayLocked(token);
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07006212 if (statePtr == nullptr || windowPtr == nullptr) {
Siarhei Vishniakou8384e0d2023-09-18 18:48:27 -07006213 LOG(WARNING)
6214 << "Attempted to pilfer points from a channel without any on-going pointer streams."
6215 " Ignoring.";
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006216 return BAD_VALUE;
6217 }
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07006218 std::set<int32_t> deviceIds = windowPtr->getTouchingDeviceIds();
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07006219 if (deviceIds.empty()) {
6220 LOG(WARNING) << "Can't pilfer: no touching devices in window: " << windowPtr->dump();
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07006221 return BAD_VALUE;
6222 }
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006223
Prabir Pradhand6b2b052024-02-21 23:25:15 +00006224 ScopedSyntheticEventTracer traceContext(mTracer);
Siarhei Vishniakou8384e0d2023-09-18 18:48:27 -07006225 for (const DeviceId deviceId : deviceIds) {
6226 TouchState& state = *statePtr;
6227 TouchedWindow& window = *windowPtr;
6228 // Send cancel events to all the input channels we're stealing from.
6229 CancelationOptions options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS,
Prabir Pradhand6b2b052024-02-21 23:25:15 +00006230 "input channel stole pointer stream", traceContext.getTracker());
Siarhei Vishniakou8384e0d2023-09-18 18:48:27 -07006231 options.deviceId = deviceId;
6232 options.displayId = displayId;
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -08006233 std::vector<PointerProperties> pointers = window.getTouchingPointers(deviceId);
6234 std::bitset<MAX_POINTER_ID + 1> pointerIds = getPointerIds(pointers);
Siarhei Vishniakou8384e0d2023-09-18 18:48:27 -07006235 options.pointerIds = pointerIds;
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -08006236
Siarhei Vishniakou8384e0d2023-09-18 18:48:27 -07006237 std::string canceledWindows;
6238 for (const TouchedWindow& w : state.windows) {
Prabir Pradhanbb3f1c02024-01-04 20:17:14 +00006239 if (w.windowHandle->getToken() != token) {
6240 synthesizeCancelationEventsForWindowLocked(w.windowHandle, options);
Siarhei Vishniakou8384e0d2023-09-18 18:48:27 -07006241 canceledWindows += canceledWindows.empty() ? "[" : ", ";
Prabir Pradhanbb3f1c02024-01-04 20:17:14 +00006242 canceledWindows += w.windowHandle->getName();
Siarhei Vishniakou8384e0d2023-09-18 18:48:27 -07006243 }
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006244 }
Siarhei Vishniakou8384e0d2023-09-18 18:48:27 -07006245 canceledWindows += canceledWindows.empty() ? "[]" : "]";
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08006246 LOG(INFO) << "Channel " << requestingConnection->getInputChannelName()
Siarhei Vishniakou8384e0d2023-09-18 18:48:27 -07006247 << " is stealing input gesture for device " << deviceId << " from "
6248 << canceledWindows;
6249
6250 // Prevent the gesture from being sent to any other windows.
6251 // This only blocks relevant pointers to be sent to other windows
6252 window.addPilferingPointers(deviceId, pointerIds);
6253
6254 state.cancelPointersForWindowsExcept(deviceId, pointerIds, token);
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006255 }
Michael Wright3dd60e22019-03-27 22:06:44 +00006256 return OK;
6257}
6258
Prabir Pradhan99987712020-11-10 18:43:05 -08006259void InputDispatcher::requestPointerCapture(const sp<IBinder>& windowToken, bool enabled) {
6260 { // acquire lock
6261 std::scoped_lock _l(mLock);
6262 if (DEBUG_FOCUS) {
chaviw98318de2021-05-19 16:45:23 -05006263 const sp<WindowInfoHandle> windowHandle = getWindowHandleLocked(windowToken);
Prabir Pradhan99987712020-11-10 18:43:05 -08006264 ALOGI("Request to %s Pointer Capture from: %s.", enabled ? "enable" : "disable",
6265 windowHandle != nullptr ? windowHandle->getName().c_str()
6266 : "token without window");
6267 }
6268
Vishnu Nairc519ff72021-01-21 08:23:08 -08006269 const sp<IBinder> focusedToken = mFocusResolver.getFocusedWindowToken(mFocusedDisplayId);
Prabir Pradhan99987712020-11-10 18:43:05 -08006270 if (focusedToken != windowToken) {
6271 ALOGW("Ignoring request to %s Pointer Capture: window does not have focus.",
6272 enabled ? "enable" : "disable");
6273 return;
6274 }
6275
Hiroki Sato25040232024-02-22 17:21:22 +09006276 if (enabled == mCurrentPointerCaptureRequest.isEnable()) {
Prabir Pradhan99987712020-11-10 18:43:05 -08006277 ALOGW("Ignoring request to %s Pointer Capture: "
6278 "window has %s requested pointer capture.",
6279 enabled ? "enable" : "disable", enabled ? "already" : "not");
6280 return;
6281 }
6282
Christine Franksb768bb42021-11-29 12:11:31 -08006283 if (enabled) {
6284 if (std::find(mIneligibleDisplaysForPointerCapture.begin(),
6285 mIneligibleDisplaysForPointerCapture.end(),
6286 mFocusedDisplayId) != mIneligibleDisplaysForPointerCapture.end()) {
6287 ALOGW("Ignoring request to enable Pointer Capture: display is not eligible");
6288 return;
6289 }
6290 }
6291
Hiroki Sato25040232024-02-22 17:21:22 +09006292 setPointerCaptureLocked(enabled ? windowToken : nullptr);
Prabir Pradhan99987712020-11-10 18:43:05 -08006293 } // release lock
6294
6295 // Wake the thread to process command entries.
6296 mLooper->wake();
6297}
6298
Christine Franksb768bb42021-11-29 12:11:31 -08006299void InputDispatcher::setDisplayEligibilityForPointerCapture(int32_t displayId, bool isEligible) {
6300 { // acquire lock
6301 std::scoped_lock _l(mLock);
6302 std::erase(mIneligibleDisplaysForPointerCapture, displayId);
6303 if (!isEligible) {
6304 mIneligibleDisplaysForPointerCapture.push_back(displayId);
6305 }
6306 } // release lock
6307}
6308
Prabir Pradhanaeebeb42023-06-13 19:53:03 +00006309std::optional<gui::Pid> InputDispatcher::findMonitorPidByTokenLocked(const sp<IBinder>& token) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006310 for (const auto& [_, monitors] : mGlobalMonitorsByDisplay) {
Michael Wright3dd60e22019-03-27 22:06:44 +00006311 for (const Monitor& monitor : monitors) {
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08006312 if (monitor.connection->getToken() == token) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006313 return monitor.pid;
Michael Wright3dd60e22019-03-27 22:06:44 +00006314 }
6315 }
6316 }
6317 return std::nullopt;
6318}
6319
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07006320std::shared_ptr<Connection> InputDispatcher::getConnectionLocked(
6321 const sp<IBinder>& inputConnectionToken) const {
Siarhei Vishniakoud0d71b62019-10-14 14:50:45 -07006322 if (inputConnectionToken == nullptr) {
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07006323 return nullptr;
Arthur Hung3b413f22018-10-26 18:05:34 +08006324 }
6325
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00006326 for (const auto& [token, connection] : mConnectionsByToken) {
6327 if (token == inputConnectionToken) {
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07006328 return connection;
Michael Wrightd02c5b62014-02-10 15:10:22 -08006329 }
6330 }
Robert Carr4e670e52018-08-15 13:26:12 -07006331
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07006332 return nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08006333}
6334
Siarhei Vishniakouad991402020-10-28 11:40:09 -05006335std::string InputDispatcher::getConnectionNameLocked(const sp<IBinder>& connectionToken) const {
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07006336 std::shared_ptr<Connection> connection = getConnectionLocked(connectionToken);
Siarhei Vishniakouad991402020-10-28 11:40:09 -05006337 if (connection == nullptr) {
6338 return "<nullptr>";
6339 }
6340 return connection->getInputChannelName();
6341}
6342
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07006343void InputDispatcher::removeConnectionLocked(const std::shared_ptr<Connection>& connection) {
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08006344 mAnrTracker.eraseToken(connection->getToken());
6345 mConnectionsByToken.erase(connection->getToken());
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07006346}
6347
Prabir Pradhancef936d2021-07-21 16:17:52 +00006348void InputDispatcher::doDispatchCycleFinishedCommand(nsecs_t finishTime,
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07006349 const std::shared_ptr<Connection>& connection,
6350 uint32_t seq, bool handled,
6351 nsecs_t consumeTime) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00006352 // Handle post-event policy actions.
Prabir Pradhan24047542023-11-02 17:14:59 +00006353 std::unique_ptr<const KeyEntry> fallbackKeyEntry;
Prabir Pradhan8c90d782023-09-15 21:16:44 +00006354
6355 { // Start critical section
6356 auto dispatchEntryIt =
6357 std::find_if(connection->waitQueue.begin(), connection->waitQueue.end(),
6358 [seq](auto& e) { return e->seq == seq; });
6359 if (dispatchEntryIt == connection->waitQueue.end()) {
6360 return;
6361 }
6362
6363 DispatchEntry& dispatchEntry = **dispatchEntryIt;
6364
6365 const nsecs_t eventDuration = finishTime - dispatchEntry.deliveryTime;
6366 if (eventDuration > SLOW_EVENT_PROCESSING_WARNING_TIMEOUT) {
Siarhei Vishniakou10bfdc92024-02-01 11:12:57 -08006367 ALOGI("%s spent %" PRId64 "ms processing %s", connection->getInputChannelName().c_str(),
Prabir Pradhan8c90d782023-09-15 21:16:44 +00006368 ns2ms(eventDuration), dispatchEntry.eventEntry->getDescription().c_str());
6369 }
6370 if (shouldReportFinishedEvent(dispatchEntry, *connection)) {
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08006371 mLatencyTracker.trackFinishedEvent(dispatchEntry.eventEntry->id, connection->getToken(),
Prabir Pradhan8c90d782023-09-15 21:16:44 +00006372 dispatchEntry.deliveryTime, consumeTime, finishTime);
6373 }
6374
6375 if (dispatchEntry.eventEntry->type == EventEntry::Type::KEY) {
Prabir Pradhanb9dd1642023-11-02 18:05:36 +00006376 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(*(dispatchEntry.eventEntry));
6377 fallbackKeyEntry =
Prabir Pradhan8c90d782023-09-15 21:16:44 +00006378 afterKeyEventLockedInterruptable(connection, dispatchEntry, keyEntry, handled);
Prabir Pradhan8c90d782023-09-15 21:16:44 +00006379 }
6380 } // End critical section: The -LockedInterruptable methods may have released the lock.
Prabir Pradhancef936d2021-07-21 16:17:52 +00006381
6382 // Dequeue the event and start the next cycle.
6383 // Because the lock might have been released, it is possible that the
6384 // contents of the wait queue to have been drained, so we need to double-check
6385 // a few things.
Prabir Pradhan8c90d782023-09-15 21:16:44 +00006386 auto entryIt = std::find_if(connection->waitQueue.begin(), connection->waitQueue.end(),
6387 [seq](auto& e) { return e->seq == seq; });
6388 if (entryIt != connection->waitQueue.end()) {
6389 std::unique_ptr<DispatchEntry> dispatchEntry = std::move(*entryIt);
6390 connection->waitQueue.erase(entryIt);
6391
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08006392 const sp<IBinder>& connectionToken = connection->getToken();
Prabir Pradhancef936d2021-07-21 16:17:52 +00006393 mAnrTracker.erase(dispatchEntry->timeoutTime, connectionToken);
6394 if (!connection->responsive) {
6395 connection->responsive = isConnectionResponsive(*connection);
6396 if (connection->responsive) {
6397 // The connection was unresponsive, and now it's responsive.
6398 processConnectionResponsiveLocked(*connection);
6399 }
6400 }
6401 traceWaitQueueLength(*connection);
Prabir Pradhanb9dd1642023-11-02 18:05:36 +00006402 if (fallbackKeyEntry && connection->status == Connection::Status::NORMAL) {
Prabir Pradhanfa2c69f2024-02-01 20:31:34 +00006403 const auto windowHandle = getWindowHandleLocked(connection->getToken());
6404 // Only dispatch fallbacks if there is a window for the connection.
6405 if (windowHandle != nullptr) {
6406 const auto inputTarget =
6407 createInputTargetLocked(windowHandle, InputTarget::DispatchMode::AS_IS,
6408 dispatchEntry->targetFlags,
6409 fallbackKeyEntry->downTime);
6410 if (inputTarget.has_value()) {
6411 enqueueDispatchEntryLocked(connection, std::move(fallbackKeyEntry),
6412 *inputTarget);
6413 }
6414 }
Prabir Pradhancef936d2021-07-21 16:17:52 +00006415 }
Prabir Pradhanb9dd1642023-11-02 18:05:36 +00006416 releaseDispatchEntry(std::move(dispatchEntry));
Prabir Pradhancef936d2021-07-21 16:17:52 +00006417 }
6418
6419 // Start the next dispatch cycle for this connection.
6420 startDispatchCycleLocked(now(), connection);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006421}
6422
Prabir Pradhancef936d2021-07-21 16:17:52 +00006423void InputDispatcher::sendFocusChangedCommandLocked(const sp<IBinder>& oldToken,
6424 const sp<IBinder>& newToken) {
6425 auto command = [this, oldToken, newToken]() REQUIRES(mLock) {
6426 scoped_unlock unlock(mLock);
Prabir Pradhana41d2442023-04-20 21:30:40 +00006427 mPolicy.notifyFocusChanged(oldToken, newToken);
Prabir Pradhancef936d2021-07-21 16:17:52 +00006428 };
6429 postCommandLocked(std::move(command));
Michael Wrightd02c5b62014-02-10 15:10:22 -08006430}
6431
Prabir Pradhancef936d2021-07-21 16:17:52 +00006432void InputDispatcher::sendDropWindowCommandLocked(const sp<IBinder>& token, float x, float y) {
6433 auto command = [this, token, x, y]() REQUIRES(mLock) {
6434 scoped_unlock unlock(mLock);
Prabir Pradhana41d2442023-04-20 21:30:40 +00006435 mPolicy.notifyDropWindow(token, x, y);
Prabir Pradhancef936d2021-07-21 16:17:52 +00006436 };
6437 postCommandLocked(std::move(command));
Robert Carrf759f162018-11-13 12:57:11 -08006438}
6439
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07006440void InputDispatcher::onAnrLocked(const std::shared_ptr<Connection>& connection) {
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006441 if (connection == nullptr) {
6442 LOG_ALWAYS_FATAL("Caller must check for nullness");
6443 }
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006444 // Since we are allowing the policy to extend the timeout, maybe the waitQueue
6445 // is already healthy again. Don't raise ANR in this situation
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006446 if (connection->waitQueue.empty()) {
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006447 ALOGI("Not raising ANR because the connection %s has recovered",
Siarhei Vishniakou10bfdc92024-02-01 11:12:57 -08006448 connection->getInputChannelName().c_str());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006449 return;
6450 }
6451 /**
6452 * The "oldestEntry" is the entry that was first sent to the application. That entry, however,
6453 * may not be the one that caused the timeout to occur. One possibility is that window timeout
6454 * has changed. This could cause newer entries to time out before the already dispatched
6455 * entries. In that situation, the newest entries caused ANR. But in all likelihood, the app
6456 * processes the events linearly. So providing information about the oldest entry seems to be
6457 * most useful.
6458 */
Prabir Pradhan8c90d782023-09-15 21:16:44 +00006459 DispatchEntry& oldestEntry = *connection->waitQueue.front();
6460 const nsecs_t currentWait = now() - oldestEntry.deliveryTime;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006461 std::string reason =
6462 android::base::StringPrintf("%s is not responding. Waited %" PRId64 "ms for %s",
Siarhei Vishniakou10bfdc92024-02-01 11:12:57 -08006463 connection->getInputChannelName().c_str(),
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006464 ns2ms(currentWait),
Prabir Pradhan8c90d782023-09-15 21:16:44 +00006465 oldestEntry.eventEntry->getDescription().c_str());
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08006466 sp<IBinder> connectionToken = connection->getToken();
Siarhei Vishniakou2b4782c2020-11-07 01:51:18 -06006467 updateLastAnrStateLocked(getWindowHandleLocked(connectionToken), reason);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006468
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006469 processConnectionUnresponsiveLocked(*connection, std::move(reason));
6470
6471 // Stop waking up for events on this connection, it is already unresponsive
6472 cancelEventsForAnrLocked(connection);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006473}
6474
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05006475void InputDispatcher::onAnrLocked(std::shared_ptr<InputApplicationHandle> application) {
6476 std::string reason =
6477 StringPrintf("%s does not have a focused window", application->getName().c_str());
6478 updateLastAnrStateLocked(*application, reason);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006479
Yabin Cui8eb9c552023-06-08 18:05:07 +00006480 auto command = [this, app = std::move(application)]() REQUIRES(mLock) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00006481 scoped_unlock unlock(mLock);
Yabin Cuiced952f2023-06-09 21:12:51 +00006482 mPolicy.notifyNoFocusedWindowAnr(app);
Prabir Pradhancef936d2021-07-21 16:17:52 +00006483 };
6484 postCommandLocked(std::move(command));
Bernardo Rufino2e1f6512020-10-08 13:42:07 +00006485}
6486
chaviw98318de2021-05-19 16:45:23 -05006487void InputDispatcher::updateLastAnrStateLocked(const sp<WindowInfoHandle>& window,
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006488 const std::string& reason) {
6489 const std::string windowLabel = getApplicationWindowLabel(nullptr, window);
6490 updateLastAnrStateLocked(windowLabel, reason);
6491}
6492
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05006493void InputDispatcher::updateLastAnrStateLocked(const InputApplicationHandle& application,
6494 const std::string& reason) {
6495 const std::string windowLabel = getApplicationWindowLabel(&application, nullptr);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006496 updateLastAnrStateLocked(windowLabel, reason);
6497}
6498
6499void InputDispatcher::updateLastAnrStateLocked(const std::string& windowLabel,
6500 const std::string& reason) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08006501 // Capture a record of the InputDispatcher state at the time of the ANR.
Yi Kong9b14ac62018-07-17 13:48:38 -07006502 time_t t = time(nullptr);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006503 struct tm tm;
6504 localtime_r(&t, &tm);
6505 char timestr[64];
6506 strftime(timestr, sizeof(timestr), "%F %T", &tm);
Siarhei Vishniakoub1a16272020-05-06 16:09:19 -07006507 mLastAnrState.clear();
6508 mLastAnrState += INDENT "ANR:\n";
6509 mLastAnrState += StringPrintf(INDENT2 "Time: %s\n", timestr);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006510 mLastAnrState += StringPrintf(INDENT2 "Reason: %s\n", reason.c_str());
6511 mLastAnrState += StringPrintf(INDENT2 "Window: %s\n", windowLabel.c_str());
Siarhei Vishniakoub1a16272020-05-06 16:09:19 -07006512 dumpDispatchStateLocked(mLastAnrState);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006513}
6514
Prabir Pradhancef936d2021-07-21 16:17:52 +00006515void InputDispatcher::doInterceptKeyBeforeDispatchingCommand(const sp<IBinder>& focusedWindowToken,
Prabir Pradhan24047542023-11-02 17:14:59 +00006516 const KeyEntry& entry) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00006517 const KeyEvent event = createKeyEvent(entry);
6518 nsecs_t delay = 0;
6519 { // release lock
6520 scoped_unlock unlock(mLock);
6521 android::base::Timer t;
Prabir Pradhana41d2442023-04-20 21:30:40 +00006522 delay = mPolicy.interceptKeyBeforeDispatching(focusedWindowToken, event, entry.policyFlags);
Prabir Pradhancef936d2021-07-21 16:17:52 +00006523 if (t.duration() > SLOW_INTERCEPTION_THRESHOLD) {
6524 ALOGW("Excessive delay in interceptKeyBeforeDispatching; took %s ms",
6525 std::to_string(t.duration().count()).c_str());
6526 }
6527 } // acquire lock
Michael Wrightd02c5b62014-02-10 15:10:22 -08006528
6529 if (delay < 0) {
Michael Wright5caf55a2022-11-24 22:31:42 +00006530 entry.interceptKeyResult = KeyEntry::InterceptKeyResult::SKIP;
Prabir Pradhancef936d2021-07-21 16:17:52 +00006531 } else if (delay == 0) {
Michael Wright5caf55a2022-11-24 22:31:42 +00006532 entry.interceptKeyResult = KeyEntry::InterceptKeyResult::CONTINUE;
Michael Wrightd02c5b62014-02-10 15:10:22 -08006533 } else {
Michael Wright5caf55a2022-11-24 22:31:42 +00006534 entry.interceptKeyResult = KeyEntry::InterceptKeyResult::TRY_AGAIN_LATER;
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006535 entry.interceptKeyWakeupTime = now() + delay;
Michael Wrightd02c5b62014-02-10 15:10:22 -08006536 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08006537}
6538
Prabir Pradhancef936d2021-07-21 16:17:52 +00006539void InputDispatcher::sendWindowUnresponsiveCommandLocked(const sp<IBinder>& token,
Prabir Pradhanaeebeb42023-06-13 19:53:03 +00006540 std::optional<gui::Pid> pid,
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006541 std::string reason) {
Yabin Cui8eb9c552023-06-08 18:05:07 +00006542 auto command = [this, token, pid, r = std::move(reason)]() REQUIRES(mLock) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00006543 scoped_unlock unlock(mLock);
Yabin Cuiced952f2023-06-09 21:12:51 +00006544 mPolicy.notifyWindowUnresponsive(token, pid, r);
Prabir Pradhancef936d2021-07-21 16:17:52 +00006545 };
6546 postCommandLocked(std::move(command));
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006547}
6548
Prabir Pradhanedd96402022-02-15 01:46:16 -08006549void InputDispatcher::sendWindowResponsiveCommandLocked(const sp<IBinder>& token,
Prabir Pradhanaeebeb42023-06-13 19:53:03 +00006550 std::optional<gui::Pid> pid) {
Prabir Pradhanedd96402022-02-15 01:46:16 -08006551 auto command = [this, token, pid]() REQUIRES(mLock) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00006552 scoped_unlock unlock(mLock);
Prabir Pradhana41d2442023-04-20 21:30:40 +00006553 mPolicy.notifyWindowResponsive(token, pid);
Prabir Pradhancef936d2021-07-21 16:17:52 +00006554 };
6555 postCommandLocked(std::move(command));
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006556}
6557
6558/**
6559 * Tell the policy that a connection has become unresponsive so that it can start ANR.
6560 * Check whether the connection of interest is a monitor or a window, and add the corresponding
6561 * command entry to the command queue.
6562 */
6563void InputDispatcher::processConnectionUnresponsiveLocked(const Connection& connection,
6564 std::string reason) {
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08006565 const sp<IBinder>& connectionToken = connection.getToken();
Prabir Pradhanaeebeb42023-06-13 19:53:03 +00006566 std::optional<gui::Pid> pid;
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006567 if (connection.monitor) {
Siarhei Vishniakou10bfdc92024-02-01 11:12:57 -08006568 ALOGW("Monitor %s is unresponsive: %s", connection.getInputChannelName().c_str(),
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006569 reason.c_str());
Prabir Pradhanedd96402022-02-15 01:46:16 -08006570 pid = findMonitorPidByTokenLocked(connectionToken);
6571 } else {
6572 // The connection is a window
Siarhei Vishniakou10bfdc92024-02-01 11:12:57 -08006573 ALOGW("Window %s is unresponsive: %s", connection.getInputChannelName().c_str(),
Prabir Pradhanedd96402022-02-15 01:46:16 -08006574 reason.c_str());
6575 const sp<WindowInfoHandle> handle = getWindowHandleLocked(connectionToken);
6576 if (handle != nullptr) {
6577 pid = handle->getInfo()->ownerPid;
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006578 }
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006579 }
Prabir Pradhanedd96402022-02-15 01:46:16 -08006580 sendWindowUnresponsiveCommandLocked(connectionToken, pid, std::move(reason));
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006581}
6582
6583/**
6584 * Tell the policy that a connection has become responsive so that it can stop ANR.
6585 */
6586void InputDispatcher::processConnectionResponsiveLocked(const Connection& connection) {
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08006587 const sp<IBinder>& connectionToken = connection.getToken();
Prabir Pradhanaeebeb42023-06-13 19:53:03 +00006588 std::optional<gui::Pid> pid;
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006589 if (connection.monitor) {
Prabir Pradhanedd96402022-02-15 01:46:16 -08006590 pid = findMonitorPidByTokenLocked(connectionToken);
6591 } else {
6592 // The connection is a window
6593 const sp<WindowInfoHandle> handle = getWindowHandleLocked(connectionToken);
6594 if (handle != nullptr) {
6595 pid = handle->getInfo()->ownerPid;
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006596 }
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006597 }
Prabir Pradhanedd96402022-02-15 01:46:16 -08006598 sendWindowResponsiveCommandLocked(connectionToken, pid);
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006599}
6600
Prabir Pradhan24047542023-11-02 17:14:59 +00006601std::unique_ptr<const KeyEntry> InputDispatcher::afterKeyEventLockedInterruptable(
Prabir Pradhan8c90d782023-09-15 21:16:44 +00006602 const std::shared_ptr<Connection>& connection, DispatchEntry& dispatchEntry,
Prabir Pradhanb9dd1642023-11-02 18:05:36 +00006603 const KeyEntry& keyEntry, bool handled) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006604 if (keyEntry.flags & AKEY_EVENT_FLAG_FALLBACK) {
Prabir Pradhanf93562f2018-11-29 12:13:37 -08006605 if (!handled) {
6606 // Report the key as unhandled, since the fallback was not handled.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006607 mReporter->reportUnhandledKey(keyEntry.id);
Prabir Pradhanf93562f2018-11-29 12:13:37 -08006608 }
Prabir Pradhanb9dd1642023-11-02 18:05:36 +00006609 return {};
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006610 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08006611
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006612 // Get the fallback key state.
6613 // Clear it out after dispatching the UP.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006614 int32_t originalKeyCode = keyEntry.keyCode;
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006615 std::optional<int32_t> fallbackKeyCode = connection->inputState.getFallbackKey(originalKeyCode);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006616 if (keyEntry.action == AKEY_EVENT_ACTION_UP) {
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006617 connection->inputState.removeFallbackKey(originalKeyCode);
6618 }
6619
Prabir Pradhan8c90d782023-09-15 21:16:44 +00006620 if (handled || !dispatchEntry.hasForegroundTarget()) {
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006621 // If the application handles the original key for which we previously
6622 // generated a fallback or if the window is not a foreground window,
6623 // then cancel the associated fallback key, if any.
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006624 if (fallbackKeyCode) {
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006625 // Dispatch the unhandled key to the policy with the cancel flag.
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006626 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
6627 ALOGD("Unhandled key event: Asking policy to cancel fallback action. "
6628 "keyCode=%d, action=%d, repeatCount=%d, policyFlags=0x%08x",
6629 keyEntry.keyCode, keyEntry.action, keyEntry.repeatCount,
6630 keyEntry.policyFlags);
6631 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006632 KeyEvent event = createKeyEvent(keyEntry);
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006633 event.setFlags(event.getFlags() | AKEY_EVENT_FLAG_CANCELED);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006634
6635 mLock.unlock();
6636
Prabir Pradhana41d2442023-04-20 21:30:40 +00006637 if (const auto unhandledKeyFallback =
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08006638 mPolicy.dispatchUnhandledKey(connection->getToken(), event,
6639 keyEntry.policyFlags);
Prabir Pradhana41d2442023-04-20 21:30:40 +00006640 unhandledKeyFallback) {
6641 event = *unhandledKeyFallback;
6642 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08006643
6644 mLock.lock();
6645
Prabir Pradhanfa2c69f2024-02-01 20:31:34 +00006646 // Cancel the fallback key, but only if we still have a window for the channel.
6647 // It could have been removed during the policy call.
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006648 if (*fallbackKeyCode != AKEYCODE_UNKNOWN) {
Prabir Pradhanfa2c69f2024-02-01 20:31:34 +00006649 const auto windowHandle = getWindowHandleLocked(connection->getToken());
6650 if (windowHandle != nullptr) {
6651 CancelationOptions options(CancelationOptions::Mode::CANCEL_FALLBACK_EVENTS,
6652 "application handled the original non-fallback key "
6653 "or is no longer a foreground target, "
Prabir Pradhand6b2b052024-02-21 23:25:15 +00006654 "canceling previously dispatched fallback key",
6655 keyEntry.traceTracker);
Prabir Pradhanfa2c69f2024-02-01 20:31:34 +00006656 options.keyCode = *fallbackKeyCode;
Prabir Pradhanbb3f1c02024-01-04 20:17:14 +00006657 synthesizeCancelationEventsForWindowLocked(windowHandle, options, connection);
Prabir Pradhanfa2c69f2024-02-01 20:31:34 +00006658 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08006659 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006660 connection->inputState.removeFallbackKey(originalKeyCode);
6661 }
6662 } else {
6663 // If the application did not handle a non-fallback key, first check
6664 // that we are in a good state to perform unhandled key event processing
6665 // Then ask the policy what to do with it.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006666 bool initialDown = keyEntry.action == AKEY_EVENT_ACTION_DOWN && keyEntry.repeatCount == 0;
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006667 if (!fallbackKeyCode && !initialDown) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006668 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
6669 ALOGD("Unhandled key event: Skipping unhandled key event processing "
6670 "since this is not an initial down. "
6671 "keyCode=%d, action=%d, repeatCount=%d, policyFlags=0x%08x",
6672 originalKeyCode, keyEntry.action, keyEntry.repeatCount, keyEntry.policyFlags);
6673 }
Prabir Pradhanb9dd1642023-11-02 18:05:36 +00006674 return {};
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006675 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08006676
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006677 // Dispatch the unhandled key to the policy.
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006678 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
6679 ALOGD("Unhandled key event: Asking policy to perform fallback action. "
6680 "keyCode=%d, action=%d, repeatCount=%d, policyFlags=0x%08x",
6681 keyEntry.keyCode, keyEntry.action, keyEntry.repeatCount, keyEntry.policyFlags);
6682 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006683 KeyEvent event = createKeyEvent(keyEntry);
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006684
6685 mLock.unlock();
6686
Prabir Pradhana41d2442023-04-20 21:30:40 +00006687 bool fallback = false;
Siarhei Vishniakou18cbdb82024-01-31 17:58:13 -08006688 if (auto fb = mPolicy.dispatchUnhandledKey(connection->getToken(), event,
6689 keyEntry.policyFlags);
Prabir Pradhana41d2442023-04-20 21:30:40 +00006690 fb) {
6691 fallback = true;
6692 event = *fb;
6693 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006694
6695 mLock.lock();
6696
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08006697 if (connection->status != Connection::Status::NORMAL) {
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006698 connection->inputState.removeFallbackKey(originalKeyCode);
Prabir Pradhanb9dd1642023-11-02 18:05:36 +00006699 return {};
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006700 }
6701
6702 // Latch the fallback keycode for this key on an initial down.
6703 // The fallback keycode cannot change at any other point in the lifecycle.
6704 if (initialDown) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08006705 if (fallback) {
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006706 *fallbackKeyCode = event.getKeyCode();
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006707 } else {
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006708 *fallbackKeyCode = AKEYCODE_UNKNOWN;
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006709 }
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006710 connection->inputState.setFallbackKey(originalKeyCode, *fallbackKeyCode);
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006711 }
6712
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006713 ALOG_ASSERT(fallbackKeyCode);
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006714
6715 // Cancel the fallback key if the policy decides not to send it anymore.
6716 // We will continue to dispatch the key to the policy but we will no
6717 // longer dispatch a fallback key to the application.
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006718 if (*fallbackKeyCode != AKEYCODE_UNKNOWN &&
6719 (!fallback || *fallbackKeyCode != event.getKeyCode())) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006720 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
6721 if (fallback) {
6722 ALOGD("Unhandled key event: Policy requested to send key %d"
6723 "as a fallback for %d, but on the DOWN it had requested "
6724 "to send %d instead. Fallback canceled.",
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006725 event.getKeyCode(), originalKeyCode, *fallbackKeyCode);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006726 } else {
6727 ALOGD("Unhandled key event: Policy did not request fallback for %d, "
6728 "but on the DOWN it had requested to send %d. "
6729 "Fallback canceled.",
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006730 originalKeyCode, *fallbackKeyCode);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006731 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006732 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006733
Prabir Pradhanfa2c69f2024-02-01 20:31:34 +00006734 const auto windowHandle = getWindowHandleLocked(connection->getToken());
6735 if (windowHandle != nullptr) {
6736 CancelationOptions options(CancelationOptions::Mode::CANCEL_FALLBACK_EVENTS,
Prabir Pradhand6b2b052024-02-21 23:25:15 +00006737 "canceling fallback, policy no longer desires it",
6738 keyEntry.traceTracker);
Prabir Pradhanfa2c69f2024-02-01 20:31:34 +00006739 options.keyCode = *fallbackKeyCode;
Prabir Pradhanbb3f1c02024-01-04 20:17:14 +00006740 synthesizeCancelationEventsForWindowLocked(windowHandle, options, connection);
Prabir Pradhanfa2c69f2024-02-01 20:31:34 +00006741 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006742
6743 fallback = false;
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006744 *fallbackKeyCode = AKEYCODE_UNKNOWN;
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006745 if (keyEntry.action != AKEY_EVENT_ACTION_UP) {
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006746 connection->inputState.setFallbackKey(originalKeyCode, *fallbackKeyCode);
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006747 }
6748 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08006749
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006750 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
6751 {
6752 std::string msg;
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006753 const std::map<int32_t, int32_t>& fallbackKeys =
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006754 connection->inputState.getFallbackKeys();
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006755 for (const auto& [key, value] : fallbackKeys) {
6756 msg += StringPrintf(", %d->%d", key, value);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006757 }
6758 ALOGD("Unhandled key event: %zu currently tracked fallback keys%s.",
6759 fallbackKeys.size(), msg.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08006760 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006761 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006762
6763 if (fallback) {
Prabir Pradhanb9dd1642023-11-02 18:05:36 +00006764 // Return the fallback key that we want dispatched to the channel.
6765 std::unique_ptr<KeyEntry> newEntry =
6766 std::make_unique<KeyEntry>(mIdGenerator.nextId(), keyEntry.injectionState,
6767 event.getEventTime(), event.getDeviceId(),
6768 event.getSource(), event.getDisplayId(),
6769 keyEntry.policyFlags, keyEntry.action,
6770 event.getFlags() | AKEY_EVENT_FLAG_FALLBACK,
6771 *fallbackKeyCode, event.getScanCode(),
6772 event.getMetaState(), event.getRepeatCount(),
6773 event.getDownTime());
Prabir Pradhana67623c2024-02-21 06:57:36 +00006774 if (mTracer) {
6775 newEntry->traceTracker =
6776 mTracer->traceDerivedEvent(*newEntry, *keyEntry.traceTracker);
6777 }
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006778 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
6779 ALOGD("Unhandled key event: Dispatching fallback key. "
6780 "originalKeyCode=%d, fallbackKeyCode=%d, fallbackMetaState=%08x",
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006781 originalKeyCode, *fallbackKeyCode, keyEntry.metaState);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006782 }
Prabir Pradhanb9dd1642023-11-02 18:05:36 +00006783 return newEntry;
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006784 } else {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006785 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
6786 ALOGD("Unhandled key event: No fallback key.");
6787 }
Prabir Pradhanf93562f2018-11-29 12:13:37 -08006788
6789 // Report the key as unhandled, since there is no fallback key.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006790 mReporter->reportUnhandledKey(keyEntry.id);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006791 }
6792 }
Prabir Pradhanb9dd1642023-11-02 18:05:36 +00006793 return {};
Michael Wrightd02c5b62014-02-10 15:10:22 -08006794}
6795
Michael Wrightd02c5b62014-02-10 15:10:22 -08006796void InputDispatcher::traceInboundQueueLengthLocked() {
6797 if (ATRACE_ENABLED()) {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07006798 ATRACE_INT("iq", mInboundQueue.size());
Michael Wrightd02c5b62014-02-10 15:10:22 -08006799 }
6800}
6801
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00006802void InputDispatcher::traceOutboundQueueLength(const Connection& connection) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08006803 if (ATRACE_ENABLED()) {
6804 char counterName[40];
Siarhei Vishniakou10bfdc92024-02-01 11:12:57 -08006805 snprintf(counterName, sizeof(counterName), "oq:%s",
6806 connection.getInputChannelName().c_str());
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00006807 ATRACE_INT(counterName, connection.outboundQueue.size());
Michael Wrightd02c5b62014-02-10 15:10:22 -08006808 }
6809}
6810
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00006811void InputDispatcher::traceWaitQueueLength(const Connection& connection) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08006812 if (ATRACE_ENABLED()) {
6813 char counterName[40];
Siarhei Vishniakou10bfdc92024-02-01 11:12:57 -08006814 snprintf(counterName, sizeof(counterName), "wq:%s",
6815 connection.getInputChannelName().c_str());
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00006816 ATRACE_INT(counterName, connection.waitQueue.size());
Michael Wrightd02c5b62014-02-10 15:10:22 -08006817 }
6818}
6819
Siarhei Vishniakou5e20f272023-06-08 17:24:44 -07006820void InputDispatcher::dump(std::string& dump) const {
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08006821 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006822
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08006823 dump += "Input Dispatcher State:\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08006824 dumpDispatchStateLocked(dump);
6825
Siarhei Vishniakoub1a16272020-05-06 16:09:19 -07006826 if (!mLastAnrState.empty()) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08006827 dump += "\nInput Dispatcher State at time of last ANR:\n";
Siarhei Vishniakoub1a16272020-05-06 16:09:19 -07006828 dump += mLastAnrState;
Michael Wrightd02c5b62014-02-10 15:10:22 -08006829 }
6830}
6831
6832void InputDispatcher::monitor() {
6833 // Acquire and release the lock to ensure that the dispatcher has not deadlocked.
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08006834 std::unique_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006835 mLooper->wake();
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08006836 mDispatcherIsAlive.wait(_l);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006837}
6838
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -08006839/**
6840 * Wake up the dispatcher and wait until it processes all events and commands.
6841 * The notification of mDispatcherEnteredIdle is guaranteed to happen after wake(), so
6842 * this method can be safely called from any thread, as long as you've ensured that
6843 * the work you are interested in completing has already been queued.
6844 */
Siarhei Vishniakoua66d65e2023-06-16 10:32:51 -07006845bool InputDispatcher::waitForIdle() const {
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -08006846 /**
6847 * Timeout should represent the longest possible time that a device might spend processing
6848 * events and commands.
6849 */
6850 constexpr std::chrono::duration TIMEOUT = 100ms;
6851 std::unique_lock lock(mLock);
6852 mLooper->wake();
6853 std::cv_status result = mDispatcherEnteredIdle.wait_for(lock, TIMEOUT);
6854 return result == std::cv_status::no_timeout;
6855}
6856
Vishnu Naire798b472020-07-23 13:52:21 -07006857/**
6858 * Sets focus to the window identified by the token. This must be called
6859 * after updating any input window handles.
6860 *
6861 * Params:
6862 * request.token - input channel token used to identify the window that should gain focus.
6863 * request.focusedToken - the token that the caller expects currently to be focused. If the
6864 * specified token does not match the currently focused window, this request will be dropped.
6865 * If the specified focused token matches the currently focused window, the call will succeed.
6866 * Set this to "null" if this call should succeed no matter what the currently focused token is.
6867 * request.timestamp - SYSTEM_TIME_MONOTONIC timestamp in nanos set by the client (wm)
6868 * when requesting the focus change. This determines which request gets
6869 * precedence if there is a focus change request from another source such as pointer down.
6870 */
Vishnu Nair958da932020-08-21 17:12:37 -07006871void InputDispatcher::setFocusedWindow(const FocusRequest& request) {
6872 { // acquire lock
6873 std::scoped_lock _l(mLock);
Vishnu Nairc519ff72021-01-21 08:23:08 -08006874 std::optional<FocusResolver::FocusChanges> changes =
6875 mFocusResolver.setFocusedWindow(request, getWindowHandlesLocked(request.displayId));
Prabir Pradhand6b2b052024-02-21 23:25:15 +00006876 ScopedSyntheticEventTracer traceContext(mTracer);
Vishnu Nairc519ff72021-01-21 08:23:08 -08006877 if (changes) {
Prabir Pradhand6b2b052024-02-21 23:25:15 +00006878 onFocusChangedLocked(*changes, traceContext.getTracker());
Vishnu Nair958da932020-08-21 17:12:37 -07006879 }
6880 } // release lock
6881 // Wake up poll loop since it may need to make new input dispatching choices.
6882 mLooper->wake();
6883}
6884
Prabir Pradhand6b2b052024-02-21 23:25:15 +00006885void InputDispatcher::onFocusChangedLocked(
6886 const FocusResolver::FocusChanges& changes,
6887 const std::unique_ptr<trace::EventTrackerInterface>& traceTracker,
6888 const sp<WindowInfoHandle> removedFocusedWindowHandle) {
Vishnu Nairc519ff72021-01-21 08:23:08 -08006889 if (changes.oldFocus) {
Prabir Pradhan4b9b1a12024-02-02 00:16:17 +00006890 const auto resolvedWindow = removedFocusedWindowHandle != nullptr
6891 ? removedFocusedWindowHandle
6892 : getWindowHandleLocked(changes.oldFocus, changes.displayId);
6893 if (resolvedWindow == nullptr) {
6894 LOG(FATAL) << __func__ << ": Previously focused token did not have a window";
Vishnu Nair7d3d00d2020-08-03 11:20:42 -07006895 }
Prabir Pradhan4b9b1a12024-02-02 00:16:17 +00006896 CancelationOptions options(CancelationOptions::Mode::CANCEL_NON_POINTER_EVENTS,
Prabir Pradhand6b2b052024-02-21 23:25:15 +00006897 "focus left window", traceTracker);
Prabir Pradhan4b9b1a12024-02-02 00:16:17 +00006898 synthesizeCancelationEventsForWindowLocked(resolvedWindow, options);
6899 enqueueFocusEventLocked(changes.oldFocus, /*hasFocus=*/false, changes.reason);
Vishnu Nair7d3d00d2020-08-03 11:20:42 -07006900 }
Vishnu Nairc519ff72021-01-21 08:23:08 -08006901 if (changes.newFocus) {
Siarhei Vishniakouc033dfb2023-10-03 10:45:16 -07006902 resetNoFocusedWindowTimeoutLocked();
Harry Cutts33476232023-01-30 19:57:29 +00006903 enqueueFocusEventLocked(changes.newFocus, /*hasFocus=*/true, changes.reason);
Vishnu Nair7d3d00d2020-08-03 11:20:42 -07006904 }
6905
Prabir Pradhan99987712020-11-10 18:43:05 -08006906 // If a window has pointer capture, then it must have focus. We need to ensure that this
6907 // contract is upheld when pointer capture is being disabled due to a loss of window focus.
6908 // If the window loses focus before it loses pointer capture, then the window can be in a state
6909 // where it has pointer capture but not focus, violating the contract. Therefore we must
6910 // dispatch the pointer capture event before the focus event. Since focus events are added to
6911 // the front of the queue (above), we add the pointer capture event to the front of the queue
6912 // after the focus events are added. This ensures the pointer capture event ends up at the
6913 // front.
6914 disablePointerCaptureForcedLocked();
6915
Vishnu Nairc519ff72021-01-21 08:23:08 -08006916 if (mFocusedDisplayId == changes.displayId) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00006917 sendFocusChangedCommandLocked(changes.oldFocus, changes.newFocus);
Vishnu Nair7d3d00d2020-08-03 11:20:42 -07006918 }
6919}
Vishnu Nair958da932020-08-21 17:12:37 -07006920
Prabir Pradhan99987712020-11-10 18:43:05 -08006921void InputDispatcher::disablePointerCaptureForcedLocked() {
Hiroki Sato25040232024-02-22 17:21:22 +09006922 if (!mCurrentPointerCaptureRequest.isEnable() && !mWindowTokenWithPointerCapture) {
Prabir Pradhan99987712020-11-10 18:43:05 -08006923 return;
6924 }
6925
6926 ALOGD_IF(DEBUG_FOCUS, "Disabling Pointer Capture because the window lost focus.");
6927
Hiroki Sato25040232024-02-22 17:21:22 +09006928 if (mCurrentPointerCaptureRequest.isEnable()) {
6929 setPointerCaptureLocked(nullptr);
Prabir Pradhan99987712020-11-10 18:43:05 -08006930 }
6931
6932 if (!mWindowTokenWithPointerCapture) {
6933 // No need to send capture changes because no window has capture.
6934 return;
6935 }
6936
6937 if (mPendingEvent != nullptr) {
6938 // Move the pending event to the front of the queue. This will give the chance
6939 // for the pending event to be dropped if it is a captured event.
6940 mInboundQueue.push_front(mPendingEvent);
6941 mPendingEvent = nullptr;
6942 }
6943
6944 auto entry = std::make_unique<PointerCaptureChangedEntry>(mIdGenerator.nextId(), now(),
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00006945 mCurrentPointerCaptureRequest);
Prabir Pradhan99987712020-11-10 18:43:05 -08006946 mInboundQueue.push_front(std::move(entry));
6947}
6948
Hiroki Sato25040232024-02-22 17:21:22 +09006949void InputDispatcher::setPointerCaptureLocked(const sp<IBinder>& windowToken) {
6950 mCurrentPointerCaptureRequest.window = windowToken;
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00006951 mCurrentPointerCaptureRequest.seq++;
6952 auto command = [this, request = mCurrentPointerCaptureRequest]() REQUIRES(mLock) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00006953 scoped_unlock unlock(mLock);
Prabir Pradhana41d2442023-04-20 21:30:40 +00006954 mPolicy.setPointerCapture(request);
Prabir Pradhancef936d2021-07-21 16:17:52 +00006955 };
6956 postCommandLocked(std::move(command));
Prabir Pradhan99987712020-11-10 18:43:05 -08006957}
6958
Vishnu Nair599f1412021-06-21 10:39:58 -07006959void InputDispatcher::displayRemoved(int32_t displayId) {
6960 { // acquire lock
6961 std::scoped_lock _l(mLock);
6962 // Set an empty list to remove all handles from the specific display.
Harry Cutts101ee9b2023-07-06 18:04:14 +00006963 setInputWindowsLocked(/*windowInfoHandles=*/{}, displayId);
Vishnu Nair599f1412021-06-21 10:39:58 -07006964 setFocusedApplicationLocked(displayId, nullptr);
6965 // Call focus resolver to clean up stale requests. This must be called after input windows
6966 // have been removed for the removed display.
6967 mFocusResolver.displayRemoved(displayId);
Christine Franksb768bb42021-11-29 12:11:31 -08006968 // Reset pointer capture eligibility, regardless of previous state.
6969 std::erase(mIneligibleDisplaysForPointerCapture, displayId);
Antonio Kantek15beb512022-06-13 22:35:41 +00006970 // Remove the associated touch mode state.
6971 mTouchModePerDisplay.erase(displayId);
Siarhei Vishniakou5c02a712023-05-15 15:45:02 -07006972 mVerifiersByDisplay.erase(displayId);
Siarhei Vishniakou527a4cf2024-04-19 17:31:01 +00006973 mInputFilterVerifiersByDisplay.erase(displayId);
Vishnu Nair599f1412021-06-21 10:39:58 -07006974 } // release lock
6975
6976 // Wake up poll loop since it may need to make new input dispatching choices.
6977 mLooper->wake();
6978}
6979
Patrick Williamsd828f302023-04-28 17:52:08 -05006980void InputDispatcher::onWindowInfosChanged(const gui::WindowInfosUpdate& update) {
Siarhei Vishniakouaeed0da2024-01-09 08:57:13 -08006981 if (auto result = validateWindowInfosUpdate(update); !result.ok()) {
6982 {
6983 // acquire lock
6984 std::scoped_lock _l(mLock);
6985 logDispatchStateLocked();
6986 }
6987 LOG_ALWAYS_FATAL("Incorrect WindowInfosUpdate provided: %s",
6988 result.error().message().c_str());
6989 };
chaviw15fab6f2021-06-07 14:15:52 -05006990 // The listener sends the windows as a flattened array. Separate the windows by display for
6991 // more convenient parsing.
6992 std::unordered_map<int32_t, std::vector<sp<WindowInfoHandle>>> handlesPerDisplay;
Patrick Williamsd828f302023-04-28 17:52:08 -05006993 for (const auto& info : update.windowInfos) {
chaviw15fab6f2021-06-07 14:15:52 -05006994 handlesPerDisplay.emplace(info.displayId, std::vector<sp<WindowInfoHandle>>());
Siarhei Vishniakouaed7ad02022-08-03 15:04:33 -07006995 handlesPerDisplay[info.displayId].push_back(sp<WindowInfoHandle>::make(info));
chaviw15fab6f2021-06-07 14:15:52 -05006996 }
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07006997
6998 { // acquire lock
6999 std::scoped_lock _l(mLock);
Prabir Pradhan814fe082022-07-22 20:22:18 +00007000
7001 // Ensure that we have an entry created for all existing displays so that if a displayId has
7002 // no windows, we can tell that the windows were removed from the display.
7003 for (const auto& [displayId, _] : mWindowHandlesByDisplay) {
7004 handlesPerDisplay[displayId];
7005 }
7006
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07007007 mDisplayInfos.clear();
Patrick Williamsd828f302023-04-28 17:52:08 -05007008 for (const auto& displayInfo : update.displayInfos) {
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07007009 mDisplayInfos.emplace(displayInfo.displayId, displayInfo);
7010 }
7011
7012 for (const auto& [displayId, handles] : handlesPerDisplay) {
7013 setInputWindowsLocked(handles, displayId);
7014 }
Patrick Williams9464b2c2023-05-23 11:22:04 -05007015
7016 if (update.vsyncId < mWindowInfosVsyncId) {
7017 ALOGE("Received out of order window infos update. Last update vsync id: %" PRId64
7018 ", current update vsync id: %" PRId64,
7019 mWindowInfosVsyncId, update.vsyncId);
7020 }
7021 mWindowInfosVsyncId = update.vsyncId;
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07007022 }
7023 // Wake up poll loop since it may need to make new input dispatching choices.
7024 mLooper->wake();
chaviw15fab6f2021-06-07 14:15:52 -05007025}
7026
Vishnu Nair062a8672021-09-03 16:07:44 -07007027bool InputDispatcher::shouldDropInput(
7028 const EventEntry& entry, const sp<android::gui::WindowInfoHandle>& windowHandle) const {
Prabir Pradhan51e7db02022-02-07 06:02:57 -08007029 if (windowHandle->getInfo()->inputConfig.test(WindowInfo::InputConfig::DROP_INPUT) ||
7030 (windowHandle->getInfo()->inputConfig.test(
7031 WindowInfo::InputConfig::DROP_INPUT_IF_OBSCURED) &&
Vishnu Nair062a8672021-09-03 16:07:44 -07007032 isWindowObscuredLocked(windowHandle))) {
Prabir Pradhan51e7db02022-02-07 06:02:57 -08007033 ALOGW("Dropping %s event targeting %s as requested by the input configuration {%s} on "
7034 "display %" PRId32 ".",
Vishnu Nair062a8672021-09-03 16:07:44 -07007035 ftl::enum_string(entry.type).c_str(), windowHandle->getName().c_str(),
Prabir Pradhan51e7db02022-02-07 06:02:57 -08007036 windowHandle->getInfo()->inputConfig.string().c_str(),
Vishnu Nair062a8672021-09-03 16:07:44 -07007037 windowHandle->getInfo()->displayId);
7038 return true;
7039 }
7040 return false;
7041}
7042
Siarhei Vishniakou18050092021-09-01 13:32:49 -07007043void InputDispatcher::DispatcherWindowListener::onWindowInfosChanged(
Patrick Williamsd828f302023-04-28 17:52:08 -05007044 const gui::WindowInfosUpdate& update) {
7045 mDispatcher.onWindowInfosChanged(update);
Siarhei Vishniakou18050092021-09-01 13:32:49 -07007046}
7047
Arthur Hungdfd528e2021-12-08 13:23:04 +00007048void InputDispatcher::cancelCurrentTouch() {
7049 {
7050 std::scoped_lock _l(mLock);
Prabir Pradhand6b2b052024-02-21 23:25:15 +00007051 ScopedSyntheticEventTracer traceContext(mTracer);
Arthur Hungdfd528e2021-12-08 13:23:04 +00007052 ALOGD("Canceling all ongoing pointer gestures on all displays.");
Michael Wrightfb04fd52022-11-24 22:31:11 +00007053 CancelationOptions options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS,
Prabir Pradhand6b2b052024-02-21 23:25:15 +00007054 "cancel current touch", traceContext.getTracker());
Arthur Hungdfd528e2021-12-08 13:23:04 +00007055 synthesizeCancelationEventsForAllConnectionsLocked(options);
7056
7057 mTouchStatesByDisplay.clear();
Arthur Hungdfd528e2021-12-08 13:23:04 +00007058 }
7059 // Wake up poll loop since there might be work to do.
7060 mLooper->wake();
7061}
7062
Prabir Pradhan1376fcd2022-01-21 09:56:35 -08007063void InputDispatcher::setMonitorDispatchingTimeoutForTest(std::chrono::nanoseconds timeout) {
7064 std::scoped_lock _l(mLock);
7065 mMonitorDispatchingTimeout = timeout;
7066}
7067
Arthur Hungc539dbb2022-12-08 07:45:36 +00007068void InputDispatcher::slipWallpaperTouch(ftl::Flags<InputTarget::Flags> targetFlags,
7069 const sp<WindowInfoHandle>& oldWindowHandle,
7070 const sp<WindowInfoHandle>& newWindowHandle,
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -08007071 TouchState& state, int32_t deviceId,
7072 const PointerProperties& pointerProperties,
Siarhei Vishniakoubf880522023-05-01 11:03:22 -07007073 std::vector<InputTarget>& targets) const {
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -08007074 std::vector<PointerProperties> pointers{pointerProperties};
Arthur Hungc539dbb2022-12-08 07:45:36 +00007075 const bool oldHasWallpaper = oldWindowHandle->getInfo()->inputConfig.test(
7076 gui::WindowInfo::InputConfig::DUPLICATE_TOUCH_TO_WALLPAPER);
7077 const bool newHasWallpaper = targetFlags.test(InputTarget::Flags::FOREGROUND) &&
7078 newWindowHandle->getInfo()->inputConfig.test(
7079 gui::WindowInfo::InputConfig::DUPLICATE_TOUCH_TO_WALLPAPER);
7080 const sp<WindowInfoHandle> oldWallpaper =
7081 oldHasWallpaper ? state.getWallpaperWindow() : nullptr;
7082 const sp<WindowInfoHandle> newWallpaper =
7083 newHasWallpaper ? findWallpaperWindowBelow(newWindowHandle) : nullptr;
7084 if (oldWallpaper == newWallpaper) {
7085 return;
7086 }
7087
7088 if (oldWallpaper != nullptr) {
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08007089 const TouchedWindow& oldTouchedWindow = state.getTouchedWindow(oldWallpaper);
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00007090 addPointerWindowTargetLocked(oldWallpaper, InputTarget::DispatchMode::SLIPPERY_EXIT,
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -08007091 oldTouchedWindow.targetFlags, getPointerIds(pointers),
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00007092 oldTouchedWindow.getDownTimeInTarget(deviceId), targets);
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -08007093 state.removeTouchingPointerFromWindow(deviceId, pointerProperties.id, oldWallpaper);
Arthur Hungc539dbb2022-12-08 07:45:36 +00007094 }
7095
7096 if (newWallpaper != nullptr) {
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00007097 state.addOrUpdateWindow(newWallpaper, InputTarget::DispatchMode::SLIPPERY_ENTER,
7098 InputTarget::Flags::WINDOW_IS_OBSCURED |
Arthur Hungc539dbb2022-12-08 07:45:36 +00007099 InputTarget::Flags::WINDOW_IS_PARTIALLY_OBSCURED,
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -08007100 deviceId, pointers);
Arthur Hungc539dbb2022-12-08 07:45:36 +00007101 }
7102}
7103
Prabir Pradhand6b2b052024-02-21 23:25:15 +00007104void InputDispatcher::transferWallpaperTouch(
7105 ftl::Flags<InputTarget::Flags> oldTargetFlags,
7106 ftl::Flags<InputTarget::Flags> newTargetFlags, const sp<WindowInfoHandle> fromWindowHandle,
7107 const sp<WindowInfoHandle> toWindowHandle, TouchState& state, int32_t deviceId,
7108 const std::vector<PointerProperties>& pointers,
7109 const std::unique_ptr<trace::EventTrackerInterface>& traceTracker) {
Arthur Hungc539dbb2022-12-08 07:45:36 +00007110 const bool oldHasWallpaper = oldTargetFlags.test(InputTarget::Flags::FOREGROUND) &&
7111 fromWindowHandle->getInfo()->inputConfig.test(
7112 gui::WindowInfo::InputConfig::DUPLICATE_TOUCH_TO_WALLPAPER);
7113 const bool newHasWallpaper = newTargetFlags.test(InputTarget::Flags::FOREGROUND) &&
7114 toWindowHandle->getInfo()->inputConfig.test(
7115 gui::WindowInfo::InputConfig::DUPLICATE_TOUCH_TO_WALLPAPER);
7116
7117 const sp<WindowInfoHandle> oldWallpaper =
7118 oldHasWallpaper ? state.getWallpaperWindow() : nullptr;
7119 const sp<WindowInfoHandle> newWallpaper =
7120 newHasWallpaper ? findWallpaperWindowBelow(toWindowHandle) : nullptr;
7121 if (oldWallpaper == newWallpaper) {
7122 return;
7123 }
7124
7125 if (oldWallpaper != nullptr) {
7126 CancelationOptions options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS,
Prabir Pradhand6b2b052024-02-21 23:25:15 +00007127 "transferring touch focus to another window", traceTracker);
Arthur Hungc539dbb2022-12-08 07:45:36 +00007128 state.removeWindowByToken(oldWallpaper->getToken());
7129 synthesizeCancelationEventsForWindowLocked(oldWallpaper, options);
7130 }
7131
7132 if (newWallpaper != nullptr) {
7133 nsecs_t downTimeInTarget = now();
Prabir Pradhan65455c72024-02-13 21:46:41 +00007134 ftl::Flags<InputTarget::Flags> wallpaperFlags = newTargetFlags;
7135 wallpaperFlags |= oldTargetFlags & InputTarget::Flags::SPLIT;
Arthur Hungc539dbb2022-12-08 07:45:36 +00007136 wallpaperFlags |= InputTarget::Flags::WINDOW_IS_OBSCURED |
7137 InputTarget::Flags::WINDOW_IS_PARTIALLY_OBSCURED;
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +00007138 state.addOrUpdateWindow(newWallpaper, InputTarget::DispatchMode::AS_IS, wallpaperFlags,
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -08007139 deviceId, pointers, downTimeInTarget);
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07007140 std::shared_ptr<Connection> wallpaperConnection =
7141 getConnectionLocked(newWallpaper->getToken());
Arthur Hungc539dbb2022-12-08 07:45:36 +00007142 if (wallpaperConnection != nullptr) {
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07007143 std::shared_ptr<Connection> toConnection =
7144 getConnectionLocked(toWindowHandle->getToken());
Arthur Hungc539dbb2022-12-08 07:45:36 +00007145 toConnection->inputState.mergePointerStateTo(wallpaperConnection->inputState);
7146 synthesizePointerDownEventsForConnectionLocked(downTimeInTarget, wallpaperConnection,
Prabir Pradhand6b2b052024-02-21 23:25:15 +00007147 wallpaperFlags, traceTracker);
Arthur Hungc539dbb2022-12-08 07:45:36 +00007148 }
7149 }
7150}
7151
7152sp<WindowInfoHandle> InputDispatcher::findWallpaperWindowBelow(
7153 const sp<WindowInfoHandle>& windowHandle) const {
7154 const std::vector<sp<WindowInfoHandle>>& windowHandles =
7155 getWindowHandlesLocked(windowHandle->getInfo()->displayId);
7156 bool foundWindow = false;
7157 for (const sp<WindowInfoHandle>& otherHandle : windowHandles) {
7158 if (!foundWindow && otherHandle != windowHandle) {
7159 continue;
7160 }
7161 if (windowHandle == otherHandle) {
7162 foundWindow = true;
7163 continue;
7164 }
7165
7166 if (otherHandle->getInfo()->inputConfig.test(WindowInfo::InputConfig::IS_WALLPAPER)) {
7167 return otherHandle;
7168 }
7169 }
7170 return nullptr;
7171}
7172
Siarhei Vishniakoufa2a0492023-11-14 13:13:18 -08007173void InputDispatcher::setKeyRepeatConfiguration(std::chrono::nanoseconds timeout,
7174 std::chrono::nanoseconds delay) {
Nergi Rahardi730cf3c2023-04-13 12:41:17 +09007175 std::scoped_lock _l(mLock);
7176
Siarhei Vishniakoufa2a0492023-11-14 13:13:18 -08007177 mConfig.keyRepeatTimeout = timeout.count();
7178 mConfig.keyRepeatDelay = delay.count();
Nergi Rahardi730cf3c2023-04-13 12:41:17 +09007179}
7180
Prabir Pradhan64f21d22023-11-28 21:19:42 +00007181bool InputDispatcher::isPointerInWindow(const sp<android::IBinder>& token, int32_t displayId,
7182 DeviceId deviceId, int32_t pointerId) {
7183 std::scoped_lock _l(mLock);
7184 auto touchStateIt = mTouchStatesByDisplay.find(displayId);
7185 if (touchStateIt == mTouchStatesByDisplay.end()) {
7186 return false;
7187 }
7188 for (const TouchedWindow& window : touchStateIt->second.windows) {
7189 if (window.windowHandle->getToken() == token &&
7190 (window.hasTouchingPointer(deviceId, pointerId) ||
7191 window.hasHoveringPointer(deviceId, pointerId))) {
7192 return true;
7193 }
7194 }
7195 return false;
7196}
7197
Prabir Pradhan04a66422024-03-15 22:45:27 +00007198void InputDispatcher::setInputMethodConnectionIsActive(bool isActive) {
7199 std::scoped_lock _l(mLock);
7200 if (mTracer) {
7201 mTracer->setInputMethodConnectionIsActive(isActive);
7202 }
7203}
7204
Garfield Tane84e6f92019-08-29 17:28:41 -07007205} // namespace android::inputdispatcher