blob: 61a9f82fddaeb769392528604fea413a2ce647ce [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>
Dominik Laskowski75788452021-02-09 18:51:25 -080028#include <ftl/enum.h>
Siarhei Vishniakou5c02a712023-05-15 15:45:02 -070029#include <log/log_event_list.h>
Siarhei Vishniakou31977182022-09-30 08:51:23 -070030#if defined(__ANDROID__)
chaviw15fab6f2021-06-07 14:15:52 -050031#include <gui/SurfaceComposerClient.h>
Siarhei Vishniakou31977182022-09-30 08:51:23 -070032#endif
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -080033#include <input/InputDevice.h>
Siarhei Vishniakou6e1e9872022-11-08 17:51:35 -080034#include <input/PrintTools.h>
tyiu1573a672023-02-21 22:38:32 +000035#include <openssl/mem.h>
Garfield Tan0fc2fa72019-08-29 17:22:15 -070036#include <powermanager/PowerManager.h>
Michael Wright44753b12020-07-08 13:48:11 +010037#include <unistd.h>
Garfield Tan0fc2fa72019-08-29 17:22:15 -070038#include <utils/Trace.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080039
Michael Wright44753b12020-07-08 13:48:11 +010040#include <cerrno>
41#include <cinttypes>
42#include <climits>
43#include <cstddef>
44#include <ctime>
45#include <queue>
46#include <sstream>
47
48#include "Connection.h"
Arthur Hung1a1007b2022-05-11 07:15:01 +000049#include "DebugConfig.h"
Chris Yef59a2f42020-10-16 12:55:26 -070050#include "InputDispatcher.h"
Michael Wright44753b12020-07-08 13:48:11 +010051
Michael Wrightd02c5b62014-02-10 15:10:22 -080052#define INDENT " "
53#define INDENT2 " "
54#define INDENT3 " "
55#define INDENT4 " "
56
Siarhei Vishniakou253f4642022-11-09 13:42:06 -080057using namespace android::ftl::flag_operators;
Siarhei Vishniakou6773db62023-04-21 11:30:20 -070058using android::base::Error;
Peter Collingbourneb04b9b82021-02-08 12:09:47 -080059using android::base::HwTimeoutMultiplier;
Siarhei Vishniakoueedd0fc2021-03-12 09:50:36 +000060using android::base::Result;
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -080061using android::base::StringPrintf;
Prabir Pradhan48f8cb92021-08-26 14:05:36 -070062using android::gui::DisplayInfo;
chaviw98318de2021-05-19 16:45:23 -050063using android::gui::FocusRequest;
64using android::gui::TouchOcclusionMode;
65using android::gui::WindowInfo;
66using android::gui::WindowInfoHandle;
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -080067using android::os::InputEventInjectionResult;
68using android::os::InputEventInjectionSync;
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -080069
Garfield Tane84e6f92019-08-29 17:28:41 -070070namespace android::inputdispatcher {
Michael Wrightd02c5b62014-02-10 15:10:22 -080071
Prabir Pradhancef936d2021-07-21 16:17:52 +000072namespace {
Prabir Pradhancef936d2021-07-21 16:17:52 +000073// Temporarily releases a held mutex for the lifetime of the instance.
74// Named to match std::scoped_lock
75class scoped_unlock {
76public:
77 explicit scoped_unlock(std::mutex& mutex) : mMutex(mutex) { mMutex.unlock(); }
78 ~scoped_unlock() { mMutex.lock(); }
79
80private:
81 std::mutex& mMutex;
82};
83
Michael Wrightd02c5b62014-02-10 15:10:22 -080084// Default input dispatching timeout if there is no focused application or paused window
85// from which to determine an appropriate dispatching timeout.
Peter Collingbourneb04b9b82021-02-08 12:09:47 -080086const std::chrono::duration DEFAULT_INPUT_DISPATCHING_TIMEOUT = std::chrono::milliseconds(
87 android::os::IInputConstants::UNMULTIPLIED_DEFAULT_DISPATCHING_TIMEOUT_MILLIS *
88 HwTimeoutMultiplier());
Michael Wrightd02c5b62014-02-10 15:10:22 -080089
90// Amount of time to allow for all pending events to be processed when an app switch
91// key is on the way. This is used to preempt input dispatch and drop input events
92// when an application takes too long to respond and the user has pressed an app switch key.
Michael Wright2b3c3302018-03-02 17:19:13 +000093constexpr nsecs_t APP_SWITCH_TIMEOUT = 500 * 1000000LL; // 0.5sec
Michael Wrightd02c5b62014-02-10 15:10:22 -080094
Siarhei Vishniakou289e9242022-02-15 14:50:16 -080095const std::chrono::duration STALE_EVENT_TIMEOUT = std::chrono::seconds(10) * HwTimeoutMultiplier();
Michael Wrightd02c5b62014-02-10 15:10:22 -080096
Michael Wrightd02c5b62014-02-10 15:10:22 -080097// 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 +000098constexpr nsecs_t SLOW_EVENT_PROCESSING_WARNING_TIMEOUT = 2000 * 1000000LL; // 2sec
99
100// Log a warning when an interception call takes longer than this to process.
101constexpr std::chrono::milliseconds SLOW_INTERCEPTION_THRESHOLD = 50ms;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800102
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700103// Additional key latency in case a connection is still processing some motion events.
104// This will help with the case when a user touched a button that opens a new window,
105// and gives us the chance to dispatch the key to this new window.
106constexpr std::chrono::nanoseconds KEY_WAITING_FOR_EVENTS_TIMEOUT = 500ms;
107
Michael Wrightd02c5b62014-02-10 15:10:22 -0800108// Number of recent events to keep for debugging purposes.
Michael Wright2b3c3302018-03-02 17:19:13 +0000109constexpr size_t RECENT_QUEUE_MAX_SIZE = 10;
110
Antonio Kantekea47acb2021-12-23 12:41:25 -0800111// Event log tags. See EventLogTags.logtags for reference.
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +0000112constexpr int LOGTAG_INPUT_INTERACTION = 62000;
113constexpr int LOGTAG_INPUT_FOCUS = 62001;
Arthur Hungb3307ee2021-10-14 10:57:37 +0000114constexpr int LOGTAG_INPUT_CANCEL = 62003;
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +0000115
Prabir Pradhan33e3baa2022-12-06 20:30:22 +0000116const ui::Transform kIdentityTransform;
117
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000118inline nsecs_t now() {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800119 return systemTime(SYSTEM_TIME_MONOTONIC);
120}
121
Siarhei Vishniakou63b63612023-04-12 11:00:23 -0700122inline const std::string binderToString(const sp<IBinder>& binder) {
Bernardo Rufino49d99e42021-01-18 15:16:59 +0000123 if (binder == nullptr) {
124 return "<null>";
125 }
126 return StringPrintf("%p", binder.get());
127}
128
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +0000129static std::string uidString(const gui::Uid& uid) {
130 return uid.toString();
131}
132
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000133inline int32_t getMotionEventActionPointerIndex(int32_t action) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700134 return (action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >>
135 AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800136}
137
Siarhei Vishniakou6773db62023-04-21 11:30:20 -0700138Result<void> checkKeyAction(int32_t action) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800139 switch (action) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700140 case AKEY_EVENT_ACTION_DOWN:
141 case AKEY_EVENT_ACTION_UP:
Siarhei Vishniakou6773db62023-04-21 11:30:20 -0700142 return {};
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700143 default:
Siarhei Vishniakou6773db62023-04-21 11:30:20 -0700144 return Error() << "Key event has invalid action code " << action;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800145 }
146}
147
Siarhei Vishniakou6773db62023-04-21 11:30:20 -0700148Result<void> validateKeyEvent(int32_t action) {
149 return checkKeyAction(action);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800150}
151
Siarhei Vishniakou6773db62023-04-21 11:30:20 -0700152Result<void> checkMotionAction(int32_t action, int32_t actionButton, int32_t pointerCount) {
Siarhei Vishniakou2f61bdc2022-12-02 08:55:51 -0800153 switch (MotionEvent::getActionMasked(action)) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700154 case AMOTION_EVENT_ACTION_DOWN:
Siarhei Vishniakou6773db62023-04-21 11:30:20 -0700155 case AMOTION_EVENT_ACTION_UP: {
156 if (pointerCount != 1) {
157 return Error() << "invalid pointer count " << pointerCount;
158 }
159 return {};
160 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700161 case AMOTION_EVENT_ACTION_MOVE:
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700162 case AMOTION_EVENT_ACTION_HOVER_ENTER:
163 case AMOTION_EVENT_ACTION_HOVER_MOVE:
Siarhei Vishniakou6773db62023-04-21 11:30:20 -0700164 case AMOTION_EVENT_ACTION_HOVER_EXIT: {
165 if (pointerCount < 1) {
166 return Error() << "invalid pointer count " << pointerCount;
167 }
168 return {};
169 }
Siarhei Vishniakou2f61bdc2022-12-02 08:55:51 -0800170 case AMOTION_EVENT_ACTION_CANCEL:
171 case AMOTION_EVENT_ACTION_OUTSIDE:
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700172 case AMOTION_EVENT_ACTION_SCROLL:
Siarhei Vishniakou6773db62023-04-21 11:30:20 -0700173 return {};
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700174 case AMOTION_EVENT_ACTION_POINTER_DOWN:
175 case AMOTION_EVENT_ACTION_POINTER_UP: {
Siarhei Vishniakou2f61bdc2022-12-02 08:55:51 -0800176 const int32_t index = MotionEvent::getActionIndex(action);
Siarhei Vishniakou6773db62023-04-21 11:30:20 -0700177 if (index < 0) {
178 return Error() << "invalid index " << index << " for "
179 << MotionEvent::actionToString(action);
180 }
181 if (index >= pointerCount) {
182 return Error() << "invalid index " << index << " for pointerCount " << pointerCount;
183 }
184 if (pointerCount <= 1) {
185 return Error() << "invalid pointer count " << pointerCount << " for "
186 << MotionEvent::actionToString(action);
187 }
188 return {};
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700189 }
190 case AMOTION_EVENT_ACTION_BUTTON_PRESS:
Siarhei Vishniakou6773db62023-04-21 11:30:20 -0700191 case AMOTION_EVENT_ACTION_BUTTON_RELEASE: {
192 if (actionButton == 0) {
193 return Error() << "action button should be nonzero for "
194 << MotionEvent::actionToString(action);
195 }
196 return {};
197 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700198 default:
Siarhei Vishniakou6773db62023-04-21 11:30:20 -0700199 return Error() << "invalid action " << action;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800200 }
201}
202
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000203int64_t millis(std::chrono::nanoseconds t) {
Siarhei Vishniakouc1ae5562020-06-30 14:22:57 -0500204 return std::chrono::duration_cast<std::chrono::milliseconds>(t).count();
205}
206
Siarhei Vishniakou6773db62023-04-21 11:30:20 -0700207Result<void> validateMotionEvent(int32_t action, int32_t actionButton, size_t pointerCount,
208 const PointerProperties* pointerProperties) {
209 Result<void> actionCheck = checkMotionAction(action, actionButton, pointerCount);
210 if (!actionCheck.ok()) {
211 return actionCheck;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800212 }
213 if (pointerCount < 1 || pointerCount > MAX_POINTERS) {
Siarhei Vishniakou6773db62023-04-21 11:30:20 -0700214 return Error() << "Motion event has invalid pointer count " << pointerCount
215 << "; value must be between 1 and " << MAX_POINTERS << ".";
Michael Wrightd02c5b62014-02-10 15:10:22 -0800216 }
Siarhei Vishniakou8a878352023-01-30 14:05:01 -0800217 std::bitset<MAX_POINTER_ID + 1> pointerIdBits;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800218 for (size_t i = 0; i < pointerCount; i++) {
219 int32_t id = pointerProperties[i].id;
220 if (id < 0 || id > MAX_POINTER_ID) {
Siarhei Vishniakou6773db62023-04-21 11:30:20 -0700221 return Error() << "Motion event has invalid pointer id " << id
222 << "; value must be between 0 and " << MAX_POINTER_ID;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800223 }
Siarhei Vishniakou8a878352023-01-30 14:05:01 -0800224 if (pointerIdBits.test(id)) {
Siarhei Vishniakou6773db62023-04-21 11:30:20 -0700225 return Error() << "Motion event has duplicate pointer id " << id;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800226 }
Siarhei Vishniakou8a878352023-01-30 14:05:01 -0800227 pointerIdBits.set(id);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800228 }
Siarhei Vishniakou6773db62023-04-21 11:30:20 -0700229 return {};
230}
231
232Result<void> validateInputEvent(const InputEvent& event) {
233 switch (event.getType()) {
234 case InputEventType::KEY: {
235 const KeyEvent& key = static_cast<const KeyEvent&>(event);
236 const int32_t action = key.getAction();
237 return validateKeyEvent(action);
238 }
239 case InputEventType::MOTION: {
240 const MotionEvent& motion = static_cast<const MotionEvent&>(event);
241 const int32_t action = motion.getAction();
242 const size_t pointerCount = motion.getPointerCount();
243 const PointerProperties* pointerProperties = motion.getPointerProperties();
244 const int32_t actionButton = motion.getActionButton();
245 return validateMotionEvent(action, actionButton, pointerCount, pointerProperties);
246 }
247 default: {
248 return {};
249 }
250 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800251}
252
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000253std::string dumpRegion(const Region& region) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800254 if (region.isEmpty()) {
Bernardo Rufino53fc31e2020-11-03 11:01:07 +0000255 return "<empty>";
Michael Wrightd02c5b62014-02-10 15:10:22 -0800256 }
257
Bernardo Rufino53fc31e2020-11-03 11:01:07 +0000258 std::string dump;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800259 bool first = true;
260 Region::const_iterator cur = region.begin();
261 Region::const_iterator const tail = region.end();
262 while (cur != tail) {
263 if (first) {
264 first = false;
265 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -0800266 dump += "|";
Michael Wrightd02c5b62014-02-10 15:10:22 -0800267 }
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -0800268 dump += StringPrintf("[%d,%d][%d,%d]", cur->left, cur->top, cur->right, cur->bottom);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800269 cur++;
270 }
Bernardo Rufino53fc31e2020-11-03 11:01:07 +0000271 return dump;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800272}
273
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000274std::string dumpQueue(const std::deque<DispatchEntry*>& queue, nsecs_t currentTime) {
Siarhei Vishniakou14411c92020-09-18 21:15:05 -0500275 constexpr size_t maxEntries = 50; // max events to print
276 constexpr size_t skipBegin = maxEntries / 2;
277 const size_t skipEnd = queue.size() - maxEntries / 2;
278 // skip from maxEntries / 2 ... size() - maxEntries/2
279 // only print from 0 .. skipBegin and then from skipEnd .. size()
280
281 std::string dump;
282 for (size_t i = 0; i < queue.size(); i++) {
283 const DispatchEntry& entry = *queue[i];
284 if (i >= skipBegin && i < skipEnd) {
285 dump += StringPrintf(INDENT4 "<skipped %zu entries>\n", skipEnd - skipBegin);
286 i = skipEnd - 1; // it will be incremented to "skipEnd" by 'continue'
287 continue;
288 }
289 dump.append(INDENT4);
290 dump += entry.eventEntry->getDescription();
Siarhei Vishniakou253f4642022-11-09 13:42:06 -0800291 dump += StringPrintf(", seq=%" PRIu32 ", targetFlags=%s, resolvedAction=%d, age=%" PRId64
292 "ms",
293 entry.seq, entry.targetFlags.string().c_str(), entry.resolvedAction,
Siarhei Vishniakou14411c92020-09-18 21:15:05 -0500294 ns2ms(currentTime - entry.eventEntry->eventTime));
295 if (entry.deliveryTime != 0) {
296 // This entry was delivered, so add information on how long we've been waiting
297 dump += StringPrintf(", wait=%" PRId64 "ms", ns2ms(currentTime - entry.deliveryTime));
298 }
299 dump.append("\n");
300 }
301 return dump;
302}
303
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -0700304/**
305 * Find the entry in std::unordered_map by key, and return it.
306 * If the entry is not found, return a default constructed entry.
307 *
308 * Useful when the entries are vectors, since an empty vector will be returned
309 * if the entry is not found.
310 * Also useful when the entries are sp<>. If an entry is not found, nullptr is returned.
311 */
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -0700312template <typename K, typename V>
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000313V getValueByKey(const std::unordered_map<K, V>& map, K key) {
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -0700314 auto it = map.find(key);
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -0700315 return it != map.end() ? it->second : V{};
Tiger Huang721e26f2018-07-24 22:26:19 +0800316}
317
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000318bool haveSameToken(const sp<WindowInfoHandle>& first, const sp<WindowInfoHandle>& second) {
chaviwaf87b3e2019-10-01 16:59:28 -0700319 if (first == second) {
320 return true;
321 }
322
323 if (first == nullptr || second == nullptr) {
324 return false;
325 }
326
327 return first->getToken() == second->getToken();
328}
329
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000330bool haveSameApplicationToken(const WindowInfo* first, const WindowInfo* second) {
Bernardo Rufino1ff9d592021-01-18 16:58:57 +0000331 if (first == nullptr || second == nullptr) {
332 return false;
333 }
334 return first->applicationInfo.token != nullptr &&
335 first->applicationInfo.token == second->applicationInfo.token;
336}
337
Siarhei Vishniakou8a878352023-01-30 14:05:01 -0800338template <typename T>
339size_t firstMarkedBit(T set) {
340 // TODO: replace with std::countr_zero from <bit> when that's available
341 LOG_ALWAYS_FATAL_IF(set.none());
342 size_t i = 0;
343 while (!set.test(i)) {
344 i++;
345 }
346 return i;
347}
348
Siarhei Vishniakou253f4642022-11-09 13:42:06 -0800349std::unique_ptr<DispatchEntry> createDispatchEntry(
350 const InputTarget& inputTarget, std::shared_ptr<EventEntry> eventEntry,
351 ftl::Flags<InputTarget::Flags> inputTargetFlags) {
chaviw1ff3d1e2020-07-01 15:53:47 -0700352 if (inputTarget.useDefaultPointerTransform()) {
353 const ui::Transform& transform = inputTarget.getDefaultPointerTransform();
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700354 return std::make_unique<DispatchEntry>(eventEntry, inputTargetFlags, transform,
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700355 inputTarget.displayTransform,
356 inputTarget.globalScaleFactor);
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000357 }
358
359 ALOG_ASSERT(eventEntry->type == EventEntry::Type::MOTION);
360 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(*eventEntry);
361
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700362 std::vector<PointerCoords> pointerCoords;
363 pointerCoords.resize(motionEntry.pointerCount);
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000364
365 // Use the first pointer information to normalize all other pointers. This could be any pointer
366 // as long as all other pointers are normalized to the same value and the final DispatchEntry
chaviw1ff3d1e2020-07-01 15:53:47 -0700367 // uses the transform for the normalized pointer.
368 const ui::Transform& firstPointerTransform =
Siarhei Vishniakou8a878352023-01-30 14:05:01 -0800369 inputTarget.pointerTransforms[firstMarkedBit(inputTarget.pointerIds)];
chaviw1ff3d1e2020-07-01 15:53:47 -0700370 ui::Transform inverseFirstTransform = firstPointerTransform.inverse();
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000371
372 // Iterate through all pointers in the event to normalize against the first.
373 for (uint32_t pointerIndex = 0; pointerIndex < motionEntry.pointerCount; pointerIndex++) {
374 const PointerProperties& pointerProperties = motionEntry.pointerProperties[pointerIndex];
375 uint32_t pointerId = uint32_t(pointerProperties.id);
chaviw1ff3d1e2020-07-01 15:53:47 -0700376 const ui::Transform& currTransform = inputTarget.pointerTransforms[pointerId];
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000377
378 pointerCoords[pointerIndex].copyFrom(motionEntry.pointerCoords[pointerIndex]);
chaviw1ff3d1e2020-07-01 15:53:47 -0700379 // First, apply the current pointer's transform to update the coordinates into
380 // window space.
381 pointerCoords[pointerIndex].transform(currTransform);
382 // Next, apply the inverse transform of the normalized coordinates so the
383 // current coordinates are transformed into the normalized coordinate space.
384 pointerCoords[pointerIndex].transform(inverseFirstTransform);
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000385 }
386
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700387 std::unique_ptr<MotionEntry> combinedMotionEntry =
388 std::make_unique<MotionEntry>(motionEntry.id, motionEntry.eventTime,
389 motionEntry.deviceId, motionEntry.source,
390 motionEntry.displayId, motionEntry.policyFlags,
391 motionEntry.action, motionEntry.actionButton,
392 motionEntry.flags, motionEntry.metaState,
393 motionEntry.buttonState, motionEntry.classification,
394 motionEntry.edgeFlags, motionEntry.xPrecision,
395 motionEntry.yPrecision, motionEntry.xCursorPosition,
396 motionEntry.yCursorPosition, motionEntry.downTime,
397 motionEntry.pointerCount, motionEntry.pointerProperties,
Prabir Pradhan5beda762021-12-10 09:30:08 +0000398 pointerCoords.data());
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000399
400 if (motionEntry.injectionState) {
401 combinedMotionEntry->injectionState = motionEntry.injectionState;
402 combinedMotionEntry->injectionState->refCount += 1;
403 }
404
405 std::unique_ptr<DispatchEntry> dispatchEntry =
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700406 std::make_unique<DispatchEntry>(std::move(combinedMotionEntry), inputTargetFlags,
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700407 firstPointerTransform, inputTarget.displayTransform,
408 inputTarget.globalScaleFactor);
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000409 return dispatchEntry;
410}
411
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000412status_t openInputChannelPair(const std::string& name, std::shared_ptr<InputChannel>& serverChannel,
413 std::unique_ptr<InputChannel>& clientChannel) {
Garfield Tan15601662020-09-22 15:32:38 -0700414 std::unique_ptr<InputChannel> uniqueServerChannel;
415 status_t result = InputChannel::openInputChannelPair(name, uniqueServerChannel, clientChannel);
416
417 serverChannel = std::move(uniqueServerChannel);
418 return result;
419}
420
Siarhei Vishniakoue41c4512020-09-08 19:35:58 -0500421template <typename T>
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000422bool sharedPointersEqual(const std::shared_ptr<T>& lhs, const std::shared_ptr<T>& rhs) {
Siarhei Vishniakoue41c4512020-09-08 19:35:58 -0500423 if (lhs == nullptr && rhs == nullptr) {
424 return true;
425 }
426 if (lhs == nullptr || rhs == nullptr) {
427 return false;
428 }
429 return *lhs == *rhs;
430}
431
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000432KeyEvent createKeyEvent(const KeyEntry& entry) {
Siarhei Vishniakou2e2ea992020-12-15 02:57:19 +0000433 KeyEvent event;
434 event.initialize(entry.id, entry.deviceId, entry.source, entry.displayId, INVALID_HMAC,
435 entry.action, entry.flags, entry.keyCode, entry.scanCode, entry.metaState,
436 entry.repeatCount, entry.downTime, entry.eventTime);
437 return event;
438}
439
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000440bool shouldReportMetricsForConnection(const Connection& connection) {
Siarhei Vishniakouf2652122021-03-05 21:39:46 +0000441 // Do not keep track of gesture monitors. They receive every event and would disproportionately
442 // affect the statistics.
443 if (connection.monitor) {
444 return false;
445 }
446 // If the connection is experiencing ANR, let's skip it. We have separate ANR metrics
447 if (!connection.responsive) {
448 return false;
449 }
450 return true;
451}
452
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000453bool shouldReportFinishedEvent(const DispatchEntry& dispatchEntry, const Connection& connection) {
Siarhei Vishniakouf2652122021-03-05 21:39:46 +0000454 const EventEntry& eventEntry = *dispatchEntry.eventEntry;
455 const int32_t& inputEventId = eventEntry.id;
456 if (inputEventId != dispatchEntry.resolvedEventId) {
457 // Event was transmuted
458 return false;
459 }
460 if (inputEventId == android::os::IInputConstants::INVALID_INPUT_EVENT_ID) {
461 return false;
462 }
463 // Only track latency for events that originated from hardware
464 if (eventEntry.isSynthesized()) {
465 return false;
466 }
467 const EventEntry::Type& inputEventEntryType = eventEntry.type;
468 if (inputEventEntryType == EventEntry::Type::KEY) {
469 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(eventEntry);
470 if (keyEntry.flags & AKEY_EVENT_FLAG_CANCELED) {
471 return false;
472 }
473 } else if (inputEventEntryType == EventEntry::Type::MOTION) {
474 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(eventEntry);
475 if (motionEntry.action == AMOTION_EVENT_ACTION_CANCEL ||
476 motionEntry.action == AMOTION_EVENT_ACTION_HOVER_EXIT) {
477 return false;
478 }
479 } else {
480 // Not a key or a motion
481 return false;
482 }
483 if (!shouldReportMetricsForConnection(connection)) {
484 return false;
485 }
486 return true;
487}
488
Prabir Pradhancef936d2021-07-21 16:17:52 +0000489/**
490 * Connection is responsive if it has no events in the waitQueue that are older than the
491 * current time.
492 */
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000493bool isConnectionResponsive(const Connection& connection) {
Prabir Pradhancef936d2021-07-21 16:17:52 +0000494 const nsecs_t currentTime = now();
495 for (const DispatchEntry* entry : connection.waitQueue) {
496 if (entry->timeoutTime < currentTime) {
497 return false;
498 }
499 }
500 return true;
501}
502
Antonio Kantekf16f2832021-09-28 04:39:20 +0000503// Returns true if the event type passed as argument represents a user activity.
504bool isUserActivityEvent(const EventEntry& eventEntry) {
505 switch (eventEntry.type) {
Josep del Riob3981622023-04-18 15:49:45 +0000506 case EventEntry::Type::CONFIGURATION_CHANGED:
507 case EventEntry::Type::DEVICE_RESET:
508 case EventEntry::Type::DRAG:
Antonio Kantekf16f2832021-09-28 04:39:20 +0000509 case EventEntry::Type::FOCUS:
510 case EventEntry::Type::POINTER_CAPTURE_CHANGED:
Antonio Kantekf16f2832021-09-28 04:39:20 +0000511 case EventEntry::Type::SENSOR:
Josep del Riob3981622023-04-18 15:49:45 +0000512 case EventEntry::Type::TOUCH_MODE_CHANGED:
Antonio Kantekf16f2832021-09-28 04:39:20 +0000513 return false;
Antonio Kantekf16f2832021-09-28 04:39:20 +0000514 case EventEntry::Type::KEY:
515 case EventEntry::Type::MOTION:
516 return true;
517 }
518}
519
Prabir Pradhan3f90d312021-11-19 03:57:24 -0800520// Returns true if the given window can accept pointer events at the given display location.
Prabir Pradhan82e081e2022-12-06 09:50:09 +0000521bool windowAcceptsTouchAt(const WindowInfo& windowInfo, int32_t displayId, float x, float y,
Prabir Pradhan33e3baa2022-12-06 20:30:22 +0000522 bool isStylus, const ui::Transform& displayTransform) {
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -0800523 const auto inputConfig = windowInfo.inputConfig;
524 if (windowInfo.displayId != displayId ||
525 inputConfig.test(WindowInfo::InputConfig::NOT_VISIBLE)) {
Prabir Pradhan3f90d312021-11-19 03:57:24 -0800526 return false;
527 }
Prabir Pradhand65552b2021-10-07 11:23:50 -0700528 const bool windowCanInterceptTouch = isStylus && windowInfo.interceptsStylus();
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -0800529 if (inputConfig.test(WindowInfo::InputConfig::NOT_TOUCHABLE) && !windowCanInterceptTouch) {
Prabir Pradhan3f90d312021-11-19 03:57:24 -0800530 return false;
531 }
Prabir Pradhan33e3baa2022-12-06 20:30:22 +0000532
533 // Window Manager works in the logical display coordinate space. When it specifies bounds for a
534 // window as (l, t, r, b), the range of x in [l, r) and y in [t, b) are considered to be inside
535 // the window. Points on the right and bottom edges should not be inside the window, so we need
536 // to be careful about performing a hit test when the display is rotated, since the "right" and
537 // "bottom" of the window will be different in the display (un-rotated) space compared to in the
538 // logical display in which WM determined the bounds. Perform the hit test in the logical
539 // display space to ensure these edges are considered correctly in all orientations.
540 const auto touchableRegion = displayTransform.transform(windowInfo.touchableRegion);
541 const auto p = displayTransform.transform(x, y);
542 if (!touchableRegion.contains(std::floor(p.x), std::floor(p.y))) {
Prabir Pradhan3f90d312021-11-19 03:57:24 -0800543 return false;
544 }
545 return true;
546}
547
Prabir Pradhand65552b2021-10-07 11:23:50 -0700548bool isPointerFromStylus(const MotionEntry& entry, int32_t pointerIndex) {
549 return isFromSource(entry.source, AINPUT_SOURCE_STYLUS) &&
Prabir Pradhane5626962022-10-27 20:30:53 +0000550 isStylusToolType(entry.pointerProperties[pointerIndex].toolType);
Prabir Pradhand65552b2021-10-07 11:23:50 -0700551}
552
Siarhei Vishniakou253f4642022-11-09 13:42:06 -0800553// Determines if the given window can be targeted as InputTarget::Flags::FOREGROUND.
Prabir Pradhan6dfbf262022-03-14 15:24:30 +0000554// Foreground events are only sent to "foreground targetable" windows, but not all gestures sent to
555// such window are necessarily targeted with the flag. For example, an event with ACTION_OUTSIDE can
556// be sent to such a window, but it is not a foreground event and doesn't use
Siarhei Vishniakou253f4642022-11-09 13:42:06 -0800557// InputTarget::Flags::FOREGROUND.
Prabir Pradhan6dfbf262022-03-14 15:24:30 +0000558bool canReceiveForegroundTouches(const WindowInfo& info) {
559 // A non-touchable window can still receive touch events (e.g. in the case of
560 // STYLUS_INTERCEPTOR), so prevent such windows from receiving foreground events for touches.
561 return !info.inputConfig.test(gui::WindowInfo::InputConfig::NOT_TOUCHABLE) && !info.isSpy();
562}
563
Prabir Pradhane59c6dc2023-06-13 19:53:03 +0000564bool isWindowOwnedBy(const sp<WindowInfoHandle>& windowHandle, gui::Pid pid, gui::Uid uid) {
Antonio Kantek48710e42022-03-24 14:19:30 -0700565 if (windowHandle == nullptr) {
566 return false;
567 }
568 const WindowInfo* windowInfo = windowHandle->getInfo();
569 if (pid == windowInfo->ownerPid && uid == windowInfo->ownerUid) {
570 return true;
571 }
572 return false;
573}
574
Prabir Pradhan5735a322022-04-11 17:23:34 +0000575// Checks targeted injection using the window's owner's uid.
576// Returns an empty string if an entry can be sent to the given window, or an error message if the
577// entry is a targeted injection whose uid target doesn't match the window owner.
578std::optional<std::string> verifyTargetedInjection(const sp<WindowInfoHandle>& window,
579 const EventEntry& entry) {
580 if (entry.injectionState == nullptr || !entry.injectionState->targetUid) {
581 // The event was not injected, or the injected event does not target a window.
582 return {};
583 }
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +0000584 const auto uid = *entry.injectionState->targetUid;
Prabir Pradhan5735a322022-04-11 17:23:34 +0000585 if (window == nullptr) {
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +0000586 return StringPrintf("No valid window target for injection into uid %s.",
587 uid.toString().c_str());
Prabir Pradhan5735a322022-04-11 17:23:34 +0000588 }
589 if (entry.injectionState->targetUid != window->getInfo()->ownerUid) {
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +0000590 return StringPrintf("Injected event targeted at uid %s would be dispatched to window '%s' "
591 "owned by uid %s.",
592 uid.toString().c_str(), window->getName().c_str(),
593 window->getInfo()->ownerUid.toString().c_str());
Prabir Pradhan5735a322022-04-11 17:23:34 +0000594 }
595 return {};
596}
597
Prabir Pradhan82e081e2022-12-06 09:50:09 +0000598std::pair<float, float> resolveTouchedPosition(const MotionEntry& entry) {
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -0700599 const bool isFromMouse = isFromSource(entry.source, AINPUT_SOURCE_MOUSE);
600 // Always dispatch mouse events to cursor position.
601 if (isFromMouse) {
Prabir Pradhan82e081e2022-12-06 09:50:09 +0000602 return {entry.xCursorPosition, entry.yCursorPosition};
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -0700603 }
604
605 const int32_t pointerIndex = getMotionEventActionPointerIndex(entry.action);
Prabir Pradhan82e081e2022-12-06 09:50:09 +0000606 return {entry.pointerCoords[pointerIndex].getAxisValue(AMOTION_EVENT_AXIS_X),
607 entry.pointerCoords[pointerIndex].getAxisValue(AMOTION_EVENT_AXIS_Y)};
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -0700608}
609
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -0700610std::optional<nsecs_t> getDownTime(const EventEntry& eventEntry) {
611 if (eventEntry.type == EventEntry::Type::KEY) {
612 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(eventEntry);
613 return keyEntry.downTime;
614 } else if (eventEntry.type == EventEntry::Type::MOTION) {
615 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(eventEntry);
616 return motionEntry.downTime;
617 }
618 return std::nullopt;
619}
620
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +0000621/**
622 * Compare the old touch state to the new touch state, and generate the corresponding touched
623 * windows (== input targets).
624 * If a window had the hovering pointer, but now it doesn't, produce HOVER_EXIT for that window.
625 * If the pointer just entered the new window, produce HOVER_ENTER.
626 * For pointers remaining in the window, produce HOVER_MOVE.
627 */
628std::vector<TouchedWindow> getHoveringWindowsLocked(const TouchState* oldState,
629 const TouchState& newTouchState,
630 const MotionEntry& entry) {
631 std::vector<TouchedWindow> out;
632 const int32_t maskedAction = MotionEvent::getActionMasked(entry.action);
633 if (maskedAction != AMOTION_EVENT_ACTION_HOVER_ENTER &&
634 maskedAction != AMOTION_EVENT_ACTION_HOVER_MOVE &&
635 maskedAction != AMOTION_EVENT_ACTION_HOVER_EXIT) {
636 // Not a hover event - don't need to do anything
637 return out;
638 }
639
640 // We should consider all hovering pointers here. But for now, just use the first one
641 const int32_t pointerId = entry.pointerProperties[0].id;
642
643 std::set<sp<WindowInfoHandle>> oldWindows;
644 if (oldState != nullptr) {
645 oldWindows = oldState->getWindowsWithHoveringPointer(entry.deviceId, pointerId);
646 }
647
648 std::set<sp<WindowInfoHandle>> newWindows =
649 newTouchState.getWindowsWithHoveringPointer(entry.deviceId, pointerId);
650
651 // If the pointer is no longer in the new window set, send HOVER_EXIT.
652 for (const sp<WindowInfoHandle>& oldWindow : oldWindows) {
653 if (newWindows.find(oldWindow) == newWindows.end()) {
654 TouchedWindow touchedWindow;
655 touchedWindow.windowHandle = oldWindow;
656 touchedWindow.targetFlags = InputTarget::Flags::DISPATCH_AS_HOVER_EXIT;
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +0000657 out.push_back(touchedWindow);
658 }
659 }
660
661 for (const sp<WindowInfoHandle>& newWindow : newWindows) {
662 TouchedWindow touchedWindow;
663 touchedWindow.windowHandle = newWindow;
664 if (oldWindows.find(newWindow) == oldWindows.end()) {
665 // Any windows that have this pointer now, and didn't have it before, should get
666 // HOVER_ENTER
667 touchedWindow.targetFlags = InputTarget::Flags::DISPATCH_AS_HOVER_ENTER;
668 } else {
669 // This pointer was already sent to the window. Use ACTION_HOVER_MOVE.
Siarhei Vishniakouc2eb8502023-04-11 18:33:36 -0700670 if (CC_UNLIKELY(maskedAction != AMOTION_EVENT_ACTION_HOVER_MOVE)) {
671 LOG(FATAL) << "Expected ACTION_HOVER_MOVE instead of " << entry.getDescription();
672 }
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +0000673 touchedWindow.targetFlags = InputTarget::Flags::DISPATCH_AS_IS;
674 }
Siarhei Vishniakou0836a302023-05-03 13:54:30 -0700675 touchedWindow.addHoveringPointer(entry.deviceId, pointerId);
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +0000676 if (canReceiveForegroundTouches(*newWindow->getInfo())) {
677 touchedWindow.targetFlags |= InputTarget::Flags::FOREGROUND;
678 }
679 out.push_back(touchedWindow);
680 }
681 return out;
682}
683
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -0800684template <typename T>
685std::vector<T>& operator+=(std::vector<T>& left, const std::vector<T>& right) {
686 left.insert(left.end(), right.begin(), right.end());
687 return left;
688}
689
Harry Cuttsb166c002023-05-09 13:06:05 +0000690// Filter windows in a TouchState and targets in a vector to remove untrusted windows/targets from
691// both.
692void filterUntrustedTargets(TouchState& touchState, std::vector<InputTarget>& targets) {
693 std::erase_if(touchState.windows, [&](const TouchedWindow& window) {
694 if (!window.windowHandle->getInfo()->inputConfig.test(
695 WindowInfo::InputConfig::TRUSTED_OVERLAY)) {
696 // In addition to TouchState, erase this window from the input targets! We don't have a
697 // good way to do this today except by adding a nested loop.
698 // TODO(b/282025641): simplify this code once InputTargets are being identified
699 // separately from TouchedWindows.
700 std::erase_if(targets, [&](const InputTarget& target) {
701 return target.inputChannel->getConnectionToken() == window.windowHandle->getToken();
702 });
703 return true;
704 }
705 return false;
706 });
707}
708
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000709} // namespace
710
Michael Wrightd02c5b62014-02-10 15:10:22 -0800711// --- InputDispatcher ---
712
Prabir Pradhana41d2442023-04-20 21:30:40 +0000713InputDispatcher::InputDispatcher(InputDispatcherPolicyInterface& policy)
Siarhei Vishniakou289e9242022-02-15 14:50:16 -0800714 : InputDispatcher(policy, STALE_EVENT_TIMEOUT) {}
715
Prabir Pradhana41d2442023-04-20 21:30:40 +0000716InputDispatcher::InputDispatcher(InputDispatcherPolicyInterface& policy,
Siarhei Vishniakou289e9242022-02-15 14:50:16 -0800717 std::chrono::nanoseconds staleEventTimeout)
Garfield Tan00f511d2019-06-12 16:55:40 -0700718 : mPolicy(policy),
719 mPendingEvent(nullptr),
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700720 mLastDropReason(DropReason::NOT_DROPPED),
Garfield Tanff1f1bb2020-01-28 13:24:04 -0800721 mIdGenerator(IdGenerator::Source::INPUT_DISPATCHER),
Garfield Tan00f511d2019-06-12 16:55:40 -0700722 mAppSwitchSawKeyDown(false),
Colin Cross5b799302022-10-18 21:52:41 -0700723 mAppSwitchDueTime(LLONG_MAX),
Garfield Tan00f511d2019-06-12 16:55:40 -0700724 mNextUnblockedEvent(nullptr),
Prabir Pradhan1376fcd2022-01-21 09:56:35 -0800725 mMonitorDispatchingTimeout(DEFAULT_INPUT_DISPATCHING_TIMEOUT),
Garfield Tan00f511d2019-06-12 16:55:40 -0700726 mDispatchEnabled(false),
727 mDispatchFrozen(false),
728 mInputFilterEnabled(false),
Bernardo Rufinoea97d182020-08-19 14:43:14 +0100729 mMaximumObscuringOpacityForTouch(1.0f),
Siarhei Vishniakou2508b872020-12-03 16:33:53 -1000730 mFocusedDisplayId(ADISPLAY_ID_DEFAULT),
Prabir Pradhan99987712020-11-10 18:43:05 -0800731 mWindowTokenWithPointerCapture(nullptr),
Siarhei Vishniakou289e9242022-02-15 14:50:16 -0800732 mStaleEventTimeout(staleEventTimeout),
Siarhei Vishniakoua04181f2021-03-26 05:56:49 +0000733 mLatencyAggregator(),
Antonio Kantek15beb512022-06-13 22:35:41 +0000734 mLatencyTracker(&mLatencyAggregator) {
Siarhei Vishniakouaed7ad02022-08-03 15:04:33 -0700735 mLooper = sp<Looper>::make(false);
Prabir Pradhanf93562f2018-11-29 12:13:37 -0800736 mReporter = createInputReporter();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800737
Siarhei Vishniakouaed7ad02022-08-03 15:04:33 -0700738 mWindowInfoListener = sp<DispatcherWindowListener>::make(*this);
Siarhei Vishniakou31977182022-09-30 08:51:23 -0700739#if defined(__ANDROID__)
Siarhei Vishniakou18050092021-09-01 13:32:49 -0700740 SurfaceComposerClient::getDefault()->addWindowInfosListener(mWindowInfoListener);
Siarhei Vishniakou31977182022-09-30 08:51:23 -0700741#endif
Yi Kong9b14ac62018-07-17 13:48:38 -0700742 mKeyRepeatState.lastKeyEntry = nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800743}
744
745InputDispatcher::~InputDispatcher() {
Prabir Pradhancef936d2021-07-21 16:17:52 +0000746 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800747
Prabir Pradhancef936d2021-07-21 16:17:52 +0000748 resetKeyRepeatLocked();
749 releasePendingEventLocked();
750 drainInboundQueueLocked();
751 mCommandQueue.clear();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800752
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +0000753 while (!mConnectionsByToken.empty()) {
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -0700754 std::shared_ptr<Connection> connection = mConnectionsByToken.begin()->second;
Harry Cutts33476232023-01-30 19:57:29 +0000755 removeInputChannelLocked(connection->inputChannel->getConnectionToken(), /*notify=*/false);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800756 }
757}
758
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700759status_t InputDispatcher::start() {
Prabir Pradhan5a57cff2019-10-31 18:40:33 -0700760 if (mThread) {
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700761 return ALREADY_EXISTS;
762 }
Prabir Pradhan5a57cff2019-10-31 18:40:33 -0700763 mThread = std::make_unique<InputThread>(
764 "InputDispatcher", [this]() { dispatchOnce(); }, [this]() { mLooper->wake(); });
765 return OK;
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700766}
767
768status_t InputDispatcher::stop() {
Prabir Pradhan5a57cff2019-10-31 18:40:33 -0700769 if (mThread && mThread->isCallingThread()) {
770 ALOGE("InputDispatcher cannot be stopped from its own thread!");
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700771 return INVALID_OPERATION;
772 }
Prabir Pradhan5a57cff2019-10-31 18:40:33 -0700773 mThread.reset();
774 return OK;
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700775}
776
Michael Wrightd02c5b62014-02-10 15:10:22 -0800777void InputDispatcher::dispatchOnce() {
Colin Cross5b799302022-10-18 21:52:41 -0700778 nsecs_t nextWakeupTime = LLONG_MAX;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800779 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -0800780 std::scoped_lock _l(mLock);
781 mDispatcherIsAlive.notify_all();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800782
783 // Run a dispatch loop if there are no pending commands.
784 // The dispatch loop might enqueue commands to run afterwards.
785 if (!haveCommandsLocked()) {
786 dispatchOnceInnerLocked(&nextWakeupTime);
787 }
788
789 // Run all pending commands if there are any.
790 // If any commands were run then force the next poll to wake up immediately.
Prabir Pradhancef936d2021-07-21 16:17:52 +0000791 if (runCommandsLockedInterruptable()) {
Colin Cross5b799302022-10-18 21:52:41 -0700792 nextWakeupTime = LLONG_MIN;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800793 }
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -0800794
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700795 // If we are still waiting for ack on some events,
796 // we might have to wake up earlier to check if an app is anr'ing.
797 const nsecs_t nextAnrCheck = processAnrsLocked();
798 nextWakeupTime = std::min(nextWakeupTime, nextAnrCheck);
799
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -0800800 // We are about to enter an infinitely long sleep, because we have no commands or
801 // pending or queued events
Colin Cross5b799302022-10-18 21:52:41 -0700802 if (nextWakeupTime == LLONG_MAX) {
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -0800803 mDispatcherEnteredIdle.notify_all();
804 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800805 } // release lock
806
807 // Wait for callback or timeout or wake. (make sure we round up, not down)
808 nsecs_t currentTime = now();
809 int timeoutMillis = toMillisecondTimeoutDelay(currentTime, nextWakeupTime);
810 mLooper->pollOnce(timeoutMillis);
811}
812
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700813/**
Siarhei Vishniakouf56b2692020-09-08 19:43:33 -0500814 * Raise ANR if there is no focused window.
815 * Before the ANR is raised, do a final state check:
816 * 1. The currently focused application must be the same one we are waiting for.
817 * 2. Ensure we still don't have a focused window.
818 */
819void InputDispatcher::processNoFocusedWindowAnrLocked() {
820 // Check if the application that we are waiting for is still focused.
821 std::shared_ptr<InputApplicationHandle> focusedApplication =
822 getValueByKey(mFocusedApplicationHandlesByDisplay, mAwaitedApplicationDisplayId);
823 if (focusedApplication == nullptr ||
824 focusedApplication->getApplicationToken() !=
825 mAwaitedFocusedApplication->getApplicationToken()) {
826 // Unexpected because we should have reset the ANR timer when focused application changed
827 ALOGE("Waited for a focused window, but focused application has already changed to %s",
828 focusedApplication->getName().c_str());
829 return; // The focused application has changed.
830 }
831
chaviw98318de2021-05-19 16:45:23 -0500832 const sp<WindowInfoHandle>& focusedWindowHandle =
Siarhei Vishniakouf56b2692020-09-08 19:43:33 -0500833 getFocusedWindowHandleLocked(mAwaitedApplicationDisplayId);
834 if (focusedWindowHandle != nullptr) {
835 return; // We now have a focused window. No need for ANR.
836 }
837 onAnrLocked(mAwaitedFocusedApplication);
838}
839
840/**
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700841 * Check if any of the connections' wait queues have events that are too old.
842 * If we waited for events to be ack'ed for more than the window timeout, raise an ANR.
843 * Return the time at which we should wake up next.
844 */
845nsecs_t InputDispatcher::processAnrsLocked() {
846 const nsecs_t currentTime = now();
Colin Cross5b799302022-10-18 21:52:41 -0700847 nsecs_t nextAnrCheck = LLONG_MAX;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700848 // Check if we are waiting for a focused window to appear. Raise ANR if waited too long
849 if (mNoFocusedWindowTimeoutTime.has_value() && mAwaitedFocusedApplication != nullptr) {
850 if (currentTime >= *mNoFocusedWindowTimeoutTime) {
Siarhei Vishniakouf56b2692020-09-08 19:43:33 -0500851 processNoFocusedWindowAnrLocked();
Chris Yea209fde2020-07-22 13:54:51 -0700852 mAwaitedFocusedApplication.reset();
Siarhei Vishniakouf56b2692020-09-08 19:43:33 -0500853 mNoFocusedWindowTimeoutTime = std::nullopt;
Colin Cross5b799302022-10-18 21:52:41 -0700854 return LLONG_MIN;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700855 } else {
Siarhei Vishniakou38a6d272020-10-20 20:29:33 -0500856 // Keep waiting. We will drop the event when mNoFocusedWindowTimeoutTime comes.
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700857 nextAnrCheck = *mNoFocusedWindowTimeoutTime;
858 }
859 }
860
861 // Check if any connection ANRs are due
862 nextAnrCheck = std::min(nextAnrCheck, mAnrTracker.firstTimeout());
863 if (currentTime < nextAnrCheck) { // most likely scenario
864 return nextAnrCheck; // everything is normal. Let's check again at nextAnrCheck
865 }
866
867 // If we reached here, we have an unresponsive connection.
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -0700868 std::shared_ptr<Connection> connection = getConnectionLocked(mAnrTracker.firstToken());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700869 if (connection == nullptr) {
870 ALOGE("Could not find connection for entry %" PRId64, mAnrTracker.firstTimeout());
871 return nextAnrCheck;
872 }
873 connection->responsive = false;
874 // Stop waking up for this unresponsive connection
875 mAnrTracker.eraseToken(connection->inputChannel->getConnectionToken());
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +0000876 onAnrLocked(connection);
Colin Cross5b799302022-10-18 21:52:41 -0700877 return LLONG_MIN;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700878}
879
Prabir Pradhan1376fcd2022-01-21 09:56:35 -0800880std::chrono::nanoseconds InputDispatcher::getDispatchingTimeoutLocked(
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -0700881 const std::shared_ptr<Connection>& connection) {
Prabir Pradhan1376fcd2022-01-21 09:56:35 -0800882 if (connection->monitor) {
883 return mMonitorDispatchingTimeout;
884 }
885 const sp<WindowInfoHandle> window =
886 getWindowHandleLocked(connection->inputChannel->getConnectionToken());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700887 if (window != nullptr) {
Siarhei Vishniakou70622952020-07-30 11:17:23 -0500888 return window->getDispatchingTimeout(DEFAULT_INPUT_DISPATCHING_TIMEOUT);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700889 }
Siarhei Vishniakou70622952020-07-30 11:17:23 -0500890 return DEFAULT_INPUT_DISPATCHING_TIMEOUT;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700891}
892
Michael Wrightd02c5b62014-02-10 15:10:22 -0800893void InputDispatcher::dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) {
894 nsecs_t currentTime = now();
895
Jeff Browndc5992e2014-04-11 01:27:26 -0700896 // Reset the key repeat timer whenever normal dispatch is suspended while the
897 // device is in a non-interactive state. This is to ensure that we abort a key
898 // repeat if the device is just coming out of sleep.
899 if (!mDispatchEnabled) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800900 resetKeyRepeatLocked();
901 }
902
903 // If dispatching is frozen, do not process timeouts or try to deliver any new events.
904 if (mDispatchFrozen) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +0100905 if (DEBUG_FOCUS) {
906 ALOGD("Dispatch frozen. Waiting some more.");
907 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800908 return;
909 }
910
911 // Optimize latency of app switches.
912 // Essentially we start a short timeout when an app switch key (HOME / ENDCALL) has
913 // been pressed. When it expires, we preempt dispatch and drop all other pending events.
914 bool isAppSwitchDue = mAppSwitchDueTime <= currentTime;
915 if (mAppSwitchDueTime < *nextWakeupTime) {
916 *nextWakeupTime = mAppSwitchDueTime;
917 }
918
919 // Ready to start a new event.
920 // If we don't already have a pending event, go grab one.
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700921 if (!mPendingEvent) {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -0700922 if (mInboundQueue.empty()) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800923 if (isAppSwitchDue) {
924 // The inbound queue is empty so the app switch key we were waiting
925 // for will never arrive. Stop waiting for it.
926 resetPendingAppSwitchLocked(false);
927 isAppSwitchDue = false;
928 }
929
930 // Synthesize a key repeat if appropriate.
931 if (mKeyRepeatState.lastKeyEntry) {
932 if (currentTime >= mKeyRepeatState.nextRepeatTime) {
933 mPendingEvent = synthesizeKeyRepeatLocked(currentTime);
934 } else {
935 if (mKeyRepeatState.nextRepeatTime < *nextWakeupTime) {
936 *nextWakeupTime = mKeyRepeatState.nextRepeatTime;
937 }
938 }
939 }
940
941 // Nothing to do if there is no pending event.
942 if (!mPendingEvent) {
943 return;
944 }
945 } else {
946 // Inbound queue has at least one entry.
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -0700947 mPendingEvent = mInboundQueue.front();
948 mInboundQueue.pop_front();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800949 traceInboundQueueLengthLocked();
950 }
951
952 // Poke user activity for this event.
953 if (mPendingEvent->policyFlags & POLICY_FLAG_PASS_TO_USER) {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700954 pokeUserActivityLocked(*mPendingEvent);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800955 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800956 }
957
958 // Now we have an event to dispatch.
959 // All events are eventually dequeued and processed this way, even if we intend to drop them.
Yi Kong9b14ac62018-07-17 13:48:38 -0700960 ALOG_ASSERT(mPendingEvent != nullptr);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800961 bool done = false;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700962 DropReason dropReason = DropReason::NOT_DROPPED;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800963 if (!(mPendingEvent->policyFlags & POLICY_FLAG_PASS_TO_USER)) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700964 dropReason = DropReason::POLICY;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800965 } else if (!mDispatchEnabled) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700966 dropReason = DropReason::DISABLED;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800967 }
968
969 if (mNextUnblockedEvent == mPendingEvent) {
Yi Kong9b14ac62018-07-17 13:48:38 -0700970 mNextUnblockedEvent = nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800971 }
972
973 switch (mPendingEvent->type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -0700974 case EventEntry::Type::CONFIGURATION_CHANGED: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700975 const ConfigurationChangedEntry& typedEntry =
976 static_cast<const ConfigurationChangedEntry&>(*mPendingEvent);
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700977 done = dispatchConfigurationChangedLocked(currentTime, typedEntry);
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700978 dropReason = DropReason::NOT_DROPPED; // configuration changes are never dropped
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700979 break;
980 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800981
Siarhei Vishniakou49483272019-10-22 13:13:47 -0700982 case EventEntry::Type::DEVICE_RESET: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700983 const DeviceResetEntry& typedEntry =
984 static_cast<const DeviceResetEntry&>(*mPendingEvent);
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700985 done = dispatchDeviceResetLocked(currentTime, typedEntry);
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700986 dropReason = DropReason::NOT_DROPPED; // device resets are never dropped
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700987 break;
988 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800989
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +0100990 case EventEntry::Type::FOCUS: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700991 std::shared_ptr<FocusEntry> typedEntry =
992 std::static_pointer_cast<FocusEntry>(mPendingEvent);
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +0100993 dispatchFocusLocked(currentTime, typedEntry);
994 done = true;
995 dropReason = DropReason::NOT_DROPPED; // focus events are never dropped
996 break;
997 }
998
Antonio Kantek7242d8b2021-08-05 16:07:20 -0700999 case EventEntry::Type::TOUCH_MODE_CHANGED: {
1000 const auto typedEntry = std::static_pointer_cast<TouchModeEntry>(mPendingEvent);
1001 dispatchTouchModeChangeLocked(currentTime, typedEntry);
1002 done = true;
1003 dropReason = DropReason::NOT_DROPPED; // touch mode events are never dropped
1004 break;
1005 }
1006
Prabir Pradhan99987712020-11-10 18:43:05 -08001007 case EventEntry::Type::POINTER_CAPTURE_CHANGED: {
1008 const auto typedEntry =
1009 std::static_pointer_cast<PointerCaptureChangedEntry>(mPendingEvent);
1010 dispatchPointerCaptureChangedLocked(currentTime, typedEntry, dropReason);
1011 done = true;
1012 break;
1013 }
1014
arthurhungb89ccb02020-12-30 16:19:01 +08001015 case EventEntry::Type::DRAG: {
1016 std::shared_ptr<DragEntry> typedEntry =
1017 std::static_pointer_cast<DragEntry>(mPendingEvent);
1018 dispatchDragLocked(currentTime, typedEntry);
1019 done = true;
1020 break;
1021 }
1022
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001023 case EventEntry::Type::KEY: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001024 std::shared_ptr<KeyEntry> keyEntry = std::static_pointer_cast<KeyEntry>(mPendingEvent);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001025 if (isAppSwitchDue) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001026 if (isAppSwitchKeyEvent(*keyEntry)) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001027 resetPendingAppSwitchLocked(true);
1028 isAppSwitchDue = false;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001029 } else if (dropReason == DropReason::NOT_DROPPED) {
1030 dropReason = DropReason::APP_SWITCH;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001031 }
1032 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001033 if (dropReason == DropReason::NOT_DROPPED && isStaleEvent(currentTime, *keyEntry)) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001034 dropReason = DropReason::STALE;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001035 }
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001036 if (dropReason == DropReason::NOT_DROPPED && mNextUnblockedEvent) {
1037 dropReason = DropReason::BLOCKED;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001038 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001039 done = dispatchKeyLocked(currentTime, keyEntry, &dropReason, nextWakeupTime);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001040 break;
1041 }
1042
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001043 case EventEntry::Type::MOTION: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001044 std::shared_ptr<MotionEntry> motionEntry =
1045 std::static_pointer_cast<MotionEntry>(mPendingEvent);
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001046 if (dropReason == DropReason::NOT_DROPPED && isAppSwitchDue) {
1047 dropReason = DropReason::APP_SWITCH;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001048 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001049 if (dropReason == DropReason::NOT_DROPPED && isStaleEvent(currentTime, *motionEntry)) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001050 dropReason = DropReason::STALE;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001051 }
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001052 if (dropReason == DropReason::NOT_DROPPED && mNextUnblockedEvent) {
1053 dropReason = DropReason::BLOCKED;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001054 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001055 done = dispatchMotionLocked(currentTime, motionEntry, &dropReason, nextWakeupTime);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001056 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001057 }
Chris Yef59a2f42020-10-16 12:55:26 -07001058
1059 case EventEntry::Type::SENSOR: {
1060 std::shared_ptr<SensorEntry> sensorEntry =
1061 std::static_pointer_cast<SensorEntry>(mPendingEvent);
1062 if (dropReason == DropReason::NOT_DROPPED && isAppSwitchDue) {
1063 dropReason = DropReason::APP_SWITCH;
1064 }
1065 // Sensor timestamps use SYSTEM_TIME_BOOTTIME time base, so we can't use
1066 // 'currentTime' here, get SYSTEM_TIME_BOOTTIME instead.
1067 nsecs_t bootTime = systemTime(SYSTEM_TIME_BOOTTIME);
1068 if (dropReason == DropReason::NOT_DROPPED && isStaleEvent(bootTime, *sensorEntry)) {
1069 dropReason = DropReason::STALE;
1070 }
1071 dispatchSensorLocked(currentTime, sensorEntry, &dropReason, nextWakeupTime);
1072 done = true;
1073 break;
1074 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001075 }
1076
1077 if (done) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001078 if (dropReason != DropReason::NOT_DROPPED) {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001079 dropInboundEventLocked(*mPendingEvent, dropReason);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001080 }
Michael Wright3a981722015-06-10 15:26:13 +01001081 mLastDropReason = dropReason;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001082
1083 releasePendingEventLocked();
Colin Cross5b799302022-10-18 21:52:41 -07001084 *nextWakeupTime = LLONG_MIN; // force next poll to wake up immediately
Michael Wrightd02c5b62014-02-10 15:10:22 -08001085 }
1086}
1087
Siarhei Vishniakou289e9242022-02-15 14:50:16 -08001088bool InputDispatcher::isStaleEvent(nsecs_t currentTime, const EventEntry& entry) {
1089 return std::chrono::nanoseconds(currentTime - entry.eventTime) >= mStaleEventTimeout;
1090}
1091
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001092/**
1093 * Return true if the events preceding this incoming motion event should be dropped
1094 * Return false otherwise (the default behaviour)
1095 */
1096bool InputDispatcher::shouldPruneInboundQueueLocked(const MotionEntry& motionEntry) {
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001097 const bool isPointerDownEvent = motionEntry.action == AMOTION_EVENT_ACTION_DOWN &&
Prabir Pradhanaa561d12021-09-24 06:57:33 -07001098 isFromSource(motionEntry.source, AINPUT_SOURCE_CLASS_POINTER);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001099
1100 // Optimize case where the current application is unresponsive and the user
1101 // decides to touch a window in a different application.
1102 // If the application takes too long to catch up then we drop all events preceding
1103 // the touch into the other window.
1104 if (isPointerDownEvent && mAwaitedFocusedApplication != nullptr) {
Siarhei Vishniakou9306c382022-09-30 15:30:31 -07001105 const int32_t displayId = motionEntry.displayId;
1106 const auto [x, y] = resolveTouchedPosition(motionEntry);
Harry Cutts33476232023-01-30 19:57:29 +00001107 const bool isStylus = isPointerFromStylus(motionEntry, /*pointerIndex=*/0);
Siarhei Vishniakou9306c382022-09-30 15:30:31 -07001108
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08001109 auto [touchedWindowHandle, _] = findTouchedWindowAtLocked(displayId, x, y, isStylus);
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001110 if (touchedWindowHandle != nullptr &&
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001111 touchedWindowHandle->getApplicationToken() !=
1112 mAwaitedFocusedApplication->getApplicationToken()) {
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001113 // User touched a different application than the one we are waiting on.
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001114 ALOGI("Pruning input queue because user touched a different application while waiting "
1115 "for %s",
1116 mAwaitedFocusedApplication->getName().c_str());
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001117 return true;
1118 }
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001119
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08001120 // Alternatively, maybe there's a spy window that could handle this event.
1121 const std::vector<sp<WindowInfoHandle>> touchedSpies =
1122 findTouchedSpyWindowsAtLocked(displayId, x, y, isStylus);
1123 for (const auto& windowHandle : touchedSpies) {
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07001124 const std::shared_ptr<Connection> connection =
1125 getConnectionLocked(windowHandle->getToken());
Siarhei Vishniakou34ed4d42020-06-18 00:43:02 +00001126 if (connection != nullptr && connection->responsive) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08001127 // This spy window could take more input. Drop all events preceding this
1128 // event, so that the spy window can get a chance to receive the stream.
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001129 ALOGW("Pruning the input queue because %s is unresponsive, but we have a "
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08001130 "responsive spy window that may handle the event.",
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001131 mAwaitedFocusedApplication->getName().c_str());
1132 return true;
1133 }
1134 }
1135 }
1136
1137 // Prevent getting stuck: if we have a pending key event, and some motion events that have not
1138 // yet been processed by some connections, the dispatcher will wait for these motion
1139 // events to be processed before dispatching the key event. This is because these motion events
1140 // may cause a new window to be launched, which the user might expect to receive focus.
1141 // To prevent waiting forever for such events, just send the key to the currently focused window
1142 if (isPointerDownEvent && mKeyIsWaitingForEventsTimeout) {
1143 ALOGD("Received a new pointer down event, stop waiting for events to process and "
1144 "just send the pending key event to the focused window.");
1145 mKeyIsWaitingForEventsTimeout = now();
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001146 }
1147 return false;
1148}
1149
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001150bool InputDispatcher::enqueueInboundEventLocked(std::unique_ptr<EventEntry> newEntry) {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001151 bool needWake = mInboundQueue.empty();
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001152 mInboundQueue.push_back(std::move(newEntry));
1153 EventEntry& entry = *(mInboundQueue.back());
Michael Wrightd02c5b62014-02-10 15:10:22 -08001154 traceInboundQueueLengthLocked();
1155
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001156 switch (entry.type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001157 case EventEntry::Type::KEY: {
Prabir Pradhan5735a322022-04-11 17:23:34 +00001158 LOG_ALWAYS_FATAL_IF((entry.policyFlags & POLICY_FLAG_TRUSTED) == 0,
1159 "Unexpected untrusted event.");
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001160 // Optimize app switch latency.
1161 // If the application takes too long to catch up then we drop all events preceding
1162 // the app switch key.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001163 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(entry);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001164 if (isAppSwitchKeyEvent(keyEntry)) {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001165 if (keyEntry.action == AKEY_EVENT_ACTION_DOWN) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001166 mAppSwitchSawKeyDown = true;
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001167 } else if (keyEntry.action == AKEY_EVENT_ACTION_UP) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001168 if (mAppSwitchSawKeyDown) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001169 if (DEBUG_APP_SWITCH) {
1170 ALOGD("App switch is pending!");
1171 }
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001172 mAppSwitchDueTime = keyEntry.eventTime + APP_SWITCH_TIMEOUT;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001173 mAppSwitchSawKeyDown = false;
1174 needWake = true;
1175 }
1176 }
1177 }
Arthur Hung2ee6d0b2022-03-03 20:19:38 +08001178
1179 // If a new up event comes in, and the pending event with same key code has been asked
1180 // to try again later because of the policy. We have to reset the intercept key wake up
1181 // time for it may have been handled in the policy and could be dropped.
1182 if (keyEntry.action == AKEY_EVENT_ACTION_UP && mPendingEvent &&
1183 mPendingEvent->type == EventEntry::Type::KEY) {
1184 KeyEntry& pendingKey = static_cast<KeyEntry&>(*mPendingEvent);
1185 if (pendingKey.keyCode == keyEntry.keyCode &&
1186 pendingKey.interceptKeyResult ==
Michael Wright5caf55a2022-11-24 22:31:42 +00001187 KeyEntry::InterceptKeyResult::TRY_AGAIN_LATER) {
1188 pendingKey.interceptKeyResult = KeyEntry::InterceptKeyResult::UNKNOWN;
Arthur Hung2ee6d0b2022-03-03 20:19:38 +08001189 pendingKey.interceptKeyWakeupTime = 0;
1190 needWake = true;
1191 }
1192 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001193 break;
1194 }
1195
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001196 case EventEntry::Type::MOTION: {
Prabir Pradhan5735a322022-04-11 17:23:34 +00001197 LOG_ALWAYS_FATAL_IF((entry.policyFlags & POLICY_FLAG_TRUSTED) == 0,
1198 "Unexpected untrusted event.");
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001199 if (shouldPruneInboundQueueLocked(static_cast<MotionEntry&>(entry))) {
1200 mNextUnblockedEvent = mInboundQueue.back();
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001201 needWake = true;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001202 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001203 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001204 }
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001205 case EventEntry::Type::FOCUS: {
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001206 LOG_ALWAYS_FATAL("Focus events should be inserted using enqueueFocusEventLocked");
1207 break;
1208 }
Antonio Kantek7242d8b2021-08-05 16:07:20 -07001209 case EventEntry::Type::TOUCH_MODE_CHANGED:
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001210 case EventEntry::Type::CONFIGURATION_CHANGED:
Prabir Pradhan99987712020-11-10 18:43:05 -08001211 case EventEntry::Type::DEVICE_RESET:
Chris Yef59a2f42020-10-16 12:55:26 -07001212 case EventEntry::Type::SENSOR:
arthurhungb89ccb02020-12-30 16:19:01 +08001213 case EventEntry::Type::POINTER_CAPTURE_CHANGED:
1214 case EventEntry::Type::DRAG: {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001215 // nothing to do
1216 break;
1217 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001218 }
1219
1220 return needWake;
1221}
1222
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001223void InputDispatcher::addRecentEventLocked(std::shared_ptr<EventEntry> entry) {
Chris Yef59a2f42020-10-16 12:55:26 -07001224 // Do not store sensor event in recent queue to avoid flooding the queue.
1225 if (entry->type != EventEntry::Type::SENSOR) {
1226 mRecentQueue.push_back(entry);
1227 }
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001228 if (mRecentQueue.size() > RECENT_QUEUE_MAX_SIZE) {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001229 mRecentQueue.pop_front();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001230 }
1231}
1232
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08001233std::pair<sp<WindowInfoHandle>, std::vector<InputTarget>>
Prabir Pradhan82e081e2022-12-06 09:50:09 +00001234InputDispatcher::findTouchedWindowAtLocked(int32_t displayId, float x, float y, bool isStylus,
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08001235 bool ignoreDragWindow) const {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001236 // Traverse windows from front to back to find touched window.
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08001237 std::vector<InputTarget> outsideTargets;
Prabir Pradhan07e05b62021-11-19 03:57:24 -08001238 const auto& windowHandles = getWindowHandlesLocked(displayId);
chaviw98318de2021-05-19 16:45:23 -05001239 for (const sp<WindowInfoHandle>& windowHandle : windowHandles) {
arthurhung6d4bed92021-03-17 11:59:33 +08001240 if (ignoreDragWindow && haveSameToken(windowHandle, mDragState->dragWindow)) {
arthurhungb89ccb02020-12-30 16:19:01 +08001241 continue;
1242 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001243
Prabir Pradhan3f90d312021-11-19 03:57:24 -08001244 const WindowInfo& info = *windowHandle->getInfo();
Prabir Pradhan33e3baa2022-12-06 20:30:22 +00001245 if (!info.isSpy() &&
1246 windowAcceptsTouchAt(info, displayId, x, y, isStylus, getTransformLocked(displayId))) {
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08001247 return {windowHandle, outsideTargets};
Prabir Pradhan3f90d312021-11-19 03:57:24 -08001248 }
Tiger Huang85b8c5e2019-01-17 18:34:54 +08001249
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08001250 if (info.inputConfig.test(WindowInfo::InputConfig::WATCH_OUTSIDE_TOUCH)) {
1251 addWindowTargetLocked(windowHandle, InputTarget::Flags::DISPATCH_AS_OUTSIDE,
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08001252 /*pointerIds=*/{}, /*firstDownTimeInTarget=*/std::nullopt,
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08001253 outsideTargets);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001254 }
1255 }
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08001256 return {nullptr, {}};
Michael Wrightd02c5b62014-02-10 15:10:22 -08001257}
1258
Prabir Pradhand65552b2021-10-07 11:23:50 -07001259std::vector<sp<WindowInfoHandle>> InputDispatcher::findTouchedSpyWindowsAtLocked(
Prabir Pradhan82e081e2022-12-06 09:50:09 +00001260 int32_t displayId, float x, float y, bool isStylus) const {
Prabir Pradhan07e05b62021-11-19 03:57:24 -08001261 // Traverse windows from front to back and gather the touched spy windows.
1262 std::vector<sp<WindowInfoHandle>> spyWindows;
1263 const auto& windowHandles = getWindowHandlesLocked(displayId);
1264 for (const sp<WindowInfoHandle>& windowHandle : windowHandles) {
1265 const WindowInfo& info = *windowHandle->getInfo();
1266
Prabir Pradhan33e3baa2022-12-06 20:30:22 +00001267 if (!windowAcceptsTouchAt(info, displayId, x, y, isStylus, getTransformLocked(displayId))) {
Prabir Pradhan07e05b62021-11-19 03:57:24 -08001268 continue;
1269 }
1270 if (!info.isSpy()) {
1271 // The first touched non-spy window was found, so return the spy windows touched so far.
1272 return spyWindows;
1273 }
1274 spyWindows.push_back(windowHandle);
1275 }
1276 return spyWindows;
1277}
1278
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001279void InputDispatcher::dropInboundEventLocked(const EventEntry& entry, DropReason dropReason) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001280 const char* reason;
1281 switch (dropReason) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001282 case DropReason::POLICY:
Prabir Pradhan65613802023-02-22 23:36:58 +00001283 if (debugInboundEventDetails()) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001284 ALOGD("Dropped event because policy consumed it.");
1285 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001286 reason = "inbound event was dropped because the policy consumed it";
1287 break;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001288 case DropReason::DISABLED:
1289 if (mLastDropReason != DropReason::DISABLED) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001290 ALOGI("Dropped event because input dispatch is disabled.");
1291 }
1292 reason = "inbound event was dropped because input dispatch is disabled";
1293 break;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001294 case DropReason::APP_SWITCH:
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001295 ALOGI("Dropped event because of pending overdue app switch.");
1296 reason = "inbound event was dropped because of pending overdue app switch";
1297 break;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001298 case DropReason::BLOCKED:
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001299 ALOGI("Dropped event because the current application is not responding and the user "
1300 "has started interacting with a different application.");
1301 reason = "inbound event was dropped because the current application is not responding "
1302 "and the user has started interacting with a different application";
1303 break;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001304 case DropReason::STALE:
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001305 ALOGI("Dropped event because it is stale.");
1306 reason = "inbound event was dropped because it is stale";
1307 break;
Prabir Pradhan99987712020-11-10 18:43:05 -08001308 case DropReason::NO_POINTER_CAPTURE:
1309 ALOGI("Dropped event because there is no window with Pointer Capture.");
1310 reason = "inbound event was dropped because there is no window with Pointer Capture";
1311 break;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001312 case DropReason::NOT_DROPPED: {
1313 LOG_ALWAYS_FATAL("Should not be dropping a NOT_DROPPED event");
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001314 return;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001315 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001316 }
1317
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001318 switch (entry.type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001319 case EventEntry::Type::KEY: {
Michael Wrightfb04fd52022-11-24 22:31:11 +00001320 CancelationOptions options(CancelationOptions::Mode::CANCEL_NON_POINTER_EVENTS, reason);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001321 synthesizeCancelationEventsForAllConnectionsLocked(options);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001322 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001323 }
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001324 case EventEntry::Type::MOTION: {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001325 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(entry);
1326 if (motionEntry.source & AINPUT_SOURCE_CLASS_POINTER) {
Michael Wrightfb04fd52022-11-24 22:31:11 +00001327 CancelationOptions options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS, reason);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001328 synthesizeCancelationEventsForAllConnectionsLocked(options);
1329 } else {
Michael Wrightfb04fd52022-11-24 22:31:11 +00001330 CancelationOptions options(CancelationOptions::Mode::CANCEL_NON_POINTER_EVENTS,
1331 reason);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001332 synthesizeCancelationEventsForAllConnectionsLocked(options);
1333 }
1334 break;
1335 }
Chris Yef59a2f42020-10-16 12:55:26 -07001336 case EventEntry::Type::SENSOR: {
1337 break;
1338 }
arthurhungb89ccb02020-12-30 16:19:01 +08001339 case EventEntry::Type::POINTER_CAPTURE_CHANGED:
1340 case EventEntry::Type::DRAG: {
Prabir Pradhan99987712020-11-10 18:43:05 -08001341 break;
1342 }
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001343 case EventEntry::Type::FOCUS:
Antonio Kantek7242d8b2021-08-05 16:07:20 -07001344 case EventEntry::Type::TOUCH_MODE_CHANGED:
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001345 case EventEntry::Type::CONFIGURATION_CHANGED:
1346 case EventEntry::Type::DEVICE_RESET: {
Dominik Laskowski75788452021-02-09 18:51:25 -08001347 LOG_ALWAYS_FATAL("Should not drop %s events", ftl::enum_string(entry.type).c_str());
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001348 break;
1349 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001350 }
1351}
1352
Siarhei Vishniakou61291d42019-02-11 18:13:20 -08001353static bool isAppSwitchKeyCode(int32_t keyCode) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001354 return keyCode == AKEYCODE_HOME || keyCode == AKEYCODE_ENDCALL ||
1355 keyCode == AKEYCODE_APP_SWITCH;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001356}
1357
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001358bool InputDispatcher::isAppSwitchKeyEvent(const KeyEntry& keyEntry) {
1359 return !(keyEntry.flags & AKEY_EVENT_FLAG_CANCELED) && isAppSwitchKeyCode(keyEntry.keyCode) &&
1360 (keyEntry.policyFlags & POLICY_FLAG_TRUSTED) &&
1361 (keyEntry.policyFlags & POLICY_FLAG_PASS_TO_USER);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001362}
1363
Siarhei Vishniakou4c9d6ff2023-04-18 11:23:20 -07001364bool InputDispatcher::isAppSwitchPendingLocked() const {
Colin Cross5b799302022-10-18 21:52:41 -07001365 return mAppSwitchDueTime != LLONG_MAX;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001366}
1367
1368void InputDispatcher::resetPendingAppSwitchLocked(bool handled) {
Colin Cross5b799302022-10-18 21:52:41 -07001369 mAppSwitchDueTime = LLONG_MAX;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001370
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001371 if (DEBUG_APP_SWITCH) {
1372 if (handled) {
1373 ALOGD("App switch has arrived.");
1374 } else {
1375 ALOGD("App switch was abandoned.");
1376 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001377 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001378}
1379
Michael Wrightd02c5b62014-02-10 15:10:22 -08001380bool InputDispatcher::haveCommandsLocked() const {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001381 return !mCommandQueue.empty();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001382}
1383
Prabir Pradhancef936d2021-07-21 16:17:52 +00001384bool InputDispatcher::runCommandsLockedInterruptable() {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001385 if (mCommandQueue.empty()) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001386 return false;
1387 }
1388
1389 do {
Prabir Pradhancef936d2021-07-21 16:17:52 +00001390 auto command = std::move(mCommandQueue.front());
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001391 mCommandQueue.pop_front();
Prabir Pradhancef936d2021-07-21 16:17:52 +00001392 // Commands are run with the lock held, but may release and re-acquire the lock from within.
1393 command();
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001394 } while (!mCommandQueue.empty());
Michael Wrightd02c5b62014-02-10 15:10:22 -08001395 return true;
1396}
1397
Prabir Pradhancef936d2021-07-21 16:17:52 +00001398void InputDispatcher::postCommandLocked(Command&& command) {
1399 mCommandQueue.push_back(command);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001400}
1401
1402void InputDispatcher::drainInboundQueueLocked() {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001403 while (!mInboundQueue.empty()) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001404 std::shared_ptr<EventEntry> entry = mInboundQueue.front();
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001405 mInboundQueue.pop_front();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001406 releaseInboundEventLocked(entry);
1407 }
1408 traceInboundQueueLengthLocked();
1409}
1410
1411void InputDispatcher::releasePendingEventLocked() {
1412 if (mPendingEvent) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001413 releaseInboundEventLocked(mPendingEvent);
Yi Kong9b14ac62018-07-17 13:48:38 -07001414 mPendingEvent = nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001415 }
1416}
1417
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001418void InputDispatcher::releaseInboundEventLocked(std::shared_ptr<EventEntry> entry) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001419 InjectionState* injectionState = entry->injectionState;
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001420 if (injectionState && injectionState->injectionResult == InputEventInjectionResult::PENDING) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001421 if (DEBUG_DISPATCH_CYCLE) {
1422 ALOGD("Injected inbound event was dropped.");
1423 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001424 setInjectionResult(*entry, InputEventInjectionResult::FAILED);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001425 }
1426 if (entry == mNextUnblockedEvent) {
Yi Kong9b14ac62018-07-17 13:48:38 -07001427 mNextUnblockedEvent = nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001428 }
1429 addRecentEventLocked(entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001430}
1431
1432void InputDispatcher::resetKeyRepeatLocked() {
1433 if (mKeyRepeatState.lastKeyEntry) {
Yi Kong9b14ac62018-07-17 13:48:38 -07001434 mKeyRepeatState.lastKeyEntry = nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001435 }
1436}
1437
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001438std::shared_ptr<KeyEntry> InputDispatcher::synthesizeKeyRepeatLocked(nsecs_t currentTime) {
1439 std::shared_ptr<KeyEntry> entry = mKeyRepeatState.lastKeyEntry;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001440
Michael Wright2e732952014-09-24 13:26:59 -07001441 uint32_t policyFlags = entry->policyFlags &
1442 (POLICY_FLAG_RAW_MASK | POLICY_FLAG_PASS_TO_USER | POLICY_FLAG_TRUSTED);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001443
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001444 std::shared_ptr<KeyEntry> newEntry =
1445 std::make_unique<KeyEntry>(mIdGenerator.nextId(), currentTime, entry->deviceId,
1446 entry->source, entry->displayId, policyFlags, entry->action,
1447 entry->flags, entry->keyCode, entry->scanCode,
1448 entry->metaState, entry->repeatCount + 1, entry->downTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001449
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001450 newEntry->syntheticRepeat = true;
1451 mKeyRepeatState.lastKeyEntry = newEntry;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001452 mKeyRepeatState.nextRepeatTime = currentTime + mConfig.keyRepeatDelay;
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001453 return newEntry;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001454}
1455
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001456bool InputDispatcher::dispatchConfigurationChangedLocked(nsecs_t currentTime,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001457 const ConfigurationChangedEntry& entry) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001458 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
1459 ALOGD("dispatchConfigurationChanged - eventTime=%" PRId64, entry.eventTime);
1460 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001461
1462 // Reset key repeating in case a keyboard device was added or removed or something.
1463 resetKeyRepeatLocked();
1464
1465 // Enqueue a command to run outside the lock to tell the policy that the configuration changed.
Prabir Pradhancef936d2021-07-21 16:17:52 +00001466 auto command = [this, eventTime = entry.eventTime]() REQUIRES(mLock) {
1467 scoped_unlock unlock(mLock);
Prabir Pradhana41d2442023-04-20 21:30:40 +00001468 mPolicy.notifyConfigurationChanged(eventTime);
Prabir Pradhancef936d2021-07-21 16:17:52 +00001469 };
1470 postCommandLocked(std::move(command));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001471 return true;
1472}
1473
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001474bool InputDispatcher::dispatchDeviceResetLocked(nsecs_t currentTime,
1475 const DeviceResetEntry& entry) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001476 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
1477 ALOGD("dispatchDeviceReset - eventTime=%" PRId64 ", deviceId=%d", entry.eventTime,
1478 entry.deviceId);
1479 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001480
liushenxiang42232912021-05-21 20:24:09 +08001481 // Reset key repeating in case a keyboard device was disabled or enabled.
1482 if (mKeyRepeatState.lastKeyEntry && mKeyRepeatState.lastKeyEntry->deviceId == entry.deviceId) {
1483 resetKeyRepeatLocked();
1484 }
1485
Michael Wrightfb04fd52022-11-24 22:31:11 +00001486 CancelationOptions options(CancelationOptions::Mode::CANCEL_ALL_EVENTS, "device was reset");
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001487 options.deviceId = entry.deviceId;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001488 synthesizeCancelationEventsForAllConnectionsLocked(options);
Siarhei Vishniakou0686f0c2023-05-02 11:56:15 -07001489
1490 // Remove all active pointers from this device
1491 for (auto& [_, touchState] : mTouchStatesByDisplay) {
1492 touchState.removeAllPointersForDevice(entry.deviceId);
1493 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001494 return true;
1495}
1496
Vishnu Nairad321cd2020-08-20 16:40:21 -07001497void InputDispatcher::enqueueFocusEventLocked(const sp<IBinder>& windowToken, bool hasFocus,
Vishnu Nairc519ff72021-01-21 08:23:08 -08001498 const std::string& reason) {
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001499 if (mPendingEvent != nullptr) {
1500 // Move the pending event to the front of the queue. This will give the chance
1501 // for the pending event to get dispatched to the newly focused window
1502 mInboundQueue.push_front(mPendingEvent);
1503 mPendingEvent = nullptr;
1504 }
1505
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001506 std::unique_ptr<FocusEntry> focusEntry =
1507 std::make_unique<FocusEntry>(mIdGenerator.nextId(), now(), windowToken, hasFocus,
1508 reason);
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001509
1510 // This event should go to the front of the queue, but behind all other focus events
1511 // Find the last focus event, and insert right after it
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001512 std::deque<std::shared_ptr<EventEntry>>::reverse_iterator it =
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001513 std::find_if(mInboundQueue.rbegin(), mInboundQueue.rend(),
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001514 [](const std::shared_ptr<EventEntry>& event) {
1515 return event->type == EventEntry::Type::FOCUS;
1516 });
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001517
1518 // Maintain the order of focus events. Insert the entry after all other focus events.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001519 mInboundQueue.insert(it.base(), std::move(focusEntry));
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001520}
1521
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001522void InputDispatcher::dispatchFocusLocked(nsecs_t currentTime, std::shared_ptr<FocusEntry> entry) {
Siarhei Vishniakouce5ab082020-07-09 17:03:21 -05001523 std::shared_ptr<InputChannel> channel = getInputChannelLocked(entry->connectionToken);
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001524 if (channel == nullptr) {
1525 return; // Window has gone away
1526 }
1527 InputTarget target;
1528 target.inputChannel = channel;
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08001529 target.flags = InputTarget::Flags::DISPATCH_AS_IS;
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001530 entry->dispatchInProgress = true;
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00001531 std::string message = std::string("Focus ") + (entry->hasFocus ? "entering " : "leaving ") +
1532 channel->getName();
Vishnu Nair7d3d00d2020-08-03 11:20:42 -07001533 std::string reason = std::string("reason=").append(entry->reason);
1534 android_log_event_list(LOGTAG_INPUT_FOCUS) << message << reason << LOG_ID_EVENTS;
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001535 dispatchEventLocked(currentTime, entry, {target});
1536}
1537
Prabir Pradhan99987712020-11-10 18:43:05 -08001538void InputDispatcher::dispatchPointerCaptureChangedLocked(
1539 nsecs_t currentTime, const std::shared_ptr<PointerCaptureChangedEntry>& entry,
1540 DropReason& dropReason) {
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001541 dropReason = DropReason::NOT_DROPPED;
1542
Prabir Pradhan99987712020-11-10 18:43:05 -08001543 const bool haveWindowWithPointerCapture = mWindowTokenWithPointerCapture != nullptr;
Prabir Pradhan99987712020-11-10 18:43:05 -08001544 sp<IBinder> token;
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001545
1546 if (entry->pointerCaptureRequest.enable) {
1547 // Enable Pointer Capture.
1548 if (haveWindowWithPointerCapture &&
1549 (entry->pointerCaptureRequest == mCurrentPointerCaptureRequest)) {
Prabir Pradhan7092e262022-05-03 16:51:09 +00001550 // This can happen if pointer capture is disabled and re-enabled before we notify the
1551 // app of the state change, so there is no need to notify the app.
1552 ALOGI("Skipping dispatch of Pointer Capture being enabled: no state change.");
1553 return;
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001554 }
1555 if (!mCurrentPointerCaptureRequest.enable) {
Prabir Pradhan99987712020-11-10 18:43:05 -08001556 // This can happen if a window requests capture and immediately releases capture.
1557 ALOGW("No window requested Pointer Capture.");
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001558 dropReason = DropReason::NO_POINTER_CAPTURE;
Prabir Pradhan99987712020-11-10 18:43:05 -08001559 return;
1560 }
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001561 if (entry->pointerCaptureRequest.seq != mCurrentPointerCaptureRequest.seq) {
1562 ALOGI("Skipping dispatch of Pointer Capture being enabled: sequence number mismatch.");
1563 return;
1564 }
1565
Vishnu Nairc519ff72021-01-21 08:23:08 -08001566 token = mFocusResolver.getFocusedWindowToken(mFocusedDisplayId);
Prabir Pradhan99987712020-11-10 18:43:05 -08001567 LOG_ALWAYS_FATAL_IF(!token, "Cannot find focused window for Pointer Capture.");
1568 mWindowTokenWithPointerCapture = token;
1569 } else {
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001570 // Disable Pointer Capture.
1571 // We do not check if the sequence number matches for requests to disable Pointer Capture
1572 // for two reasons:
1573 // 1. Pointer Capture can be disabled by a focus change, which means we can get two entries
1574 // to disable capture with the same sequence number: one generated by
1575 // disablePointerCaptureForcedLocked() and another as an acknowledgement of Pointer
1576 // Capture being disabled in InputReader.
1577 // 2. We respect any request to disable Pointer Capture generated by InputReader, since the
1578 // actual Pointer Capture state that affects events being generated by input devices is
1579 // in InputReader.
1580 if (!haveWindowWithPointerCapture) {
1581 // Pointer capture was already forcefully disabled because of focus change.
1582 dropReason = DropReason::NOT_DROPPED;
1583 return;
1584 }
Prabir Pradhan99987712020-11-10 18:43:05 -08001585 token = mWindowTokenWithPointerCapture;
1586 mWindowTokenWithPointerCapture = nullptr;
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001587 if (mCurrentPointerCaptureRequest.enable) {
Prabir Pradhan7d030382020-12-21 07:58:35 -08001588 setPointerCaptureLocked(false);
1589 }
Prabir Pradhan99987712020-11-10 18:43:05 -08001590 }
1591
1592 auto channel = getInputChannelLocked(token);
1593 if (channel == nullptr) {
1594 // Window has gone away, clean up Pointer Capture state.
1595 mWindowTokenWithPointerCapture = nullptr;
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001596 if (mCurrentPointerCaptureRequest.enable) {
Prabir Pradhan7d030382020-12-21 07:58:35 -08001597 setPointerCaptureLocked(false);
1598 }
Prabir Pradhan99987712020-11-10 18:43:05 -08001599 return;
1600 }
1601 InputTarget target;
1602 target.inputChannel = channel;
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08001603 target.flags = InputTarget::Flags::DISPATCH_AS_IS;
Prabir Pradhan99987712020-11-10 18:43:05 -08001604 entry->dispatchInProgress = true;
1605 dispatchEventLocked(currentTime, entry, {target});
1606
1607 dropReason = DropReason::NOT_DROPPED;
1608}
1609
Antonio Kantek7242d8b2021-08-05 16:07:20 -07001610void InputDispatcher::dispatchTouchModeChangeLocked(nsecs_t currentTime,
1611 const std::shared_ptr<TouchModeEntry>& entry) {
1612 const std::vector<sp<WindowInfoHandle>>& windowHandles =
Antonio Kantek15beb512022-06-13 22:35:41 +00001613 getWindowHandlesLocked(entry->displayId);
Antonio Kantek7242d8b2021-08-05 16:07:20 -07001614 if (windowHandles.empty()) {
1615 return;
1616 }
1617 const std::vector<InputTarget> inputTargets =
1618 getInputTargetsFromWindowHandlesLocked(windowHandles);
1619 if (inputTargets.empty()) {
1620 return;
1621 }
1622 entry->dispatchInProgress = true;
1623 dispatchEventLocked(currentTime, entry, inputTargets);
1624}
1625
1626std::vector<InputTarget> InputDispatcher::getInputTargetsFromWindowHandlesLocked(
1627 const std::vector<sp<WindowInfoHandle>>& windowHandles) const {
1628 std::vector<InputTarget> inputTargets;
1629 for (const sp<WindowInfoHandle>& handle : windowHandles) {
Antonio Kantek7242d8b2021-08-05 16:07:20 -07001630 const sp<IBinder>& token = handle->getToken();
1631 if (token == nullptr) {
1632 continue;
1633 }
1634 std::shared_ptr<InputChannel> channel = getInputChannelLocked(token);
1635 if (channel == nullptr) {
1636 continue; // Window has gone away
1637 }
1638 InputTarget target;
1639 target.inputChannel = channel;
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08001640 target.flags = InputTarget::Flags::DISPATCH_AS_IS;
Antonio Kantek7242d8b2021-08-05 16:07:20 -07001641 inputTargets.push_back(target);
1642 }
1643 return inputTargets;
1644}
1645
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001646bool InputDispatcher::dispatchKeyLocked(nsecs_t currentTime, std::shared_ptr<KeyEntry> entry,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001647 DropReason* dropReason, nsecs_t* nextWakeupTime) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001648 // Preprocessing.
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001649 if (!entry->dispatchInProgress) {
1650 if (entry->repeatCount == 0 && entry->action == AKEY_EVENT_ACTION_DOWN &&
1651 (entry->policyFlags & POLICY_FLAG_TRUSTED) &&
1652 (!(entry->policyFlags & POLICY_FLAG_DISABLE_KEY_REPEAT))) {
1653 if (mKeyRepeatState.lastKeyEntry &&
Chris Ye2ad95392020-09-01 13:44:44 -07001654 mKeyRepeatState.lastKeyEntry->keyCode == entry->keyCode &&
Michael Wrightd02c5b62014-02-10 15:10:22 -08001655 // We have seen two identical key downs in a row which indicates that the device
1656 // driver is automatically generating key repeats itself. We take note of the
1657 // repeat here, but we disable our own next key repeat timer since it is clear that
1658 // we will not need to synthesize key repeats ourselves.
Chris Ye2ad95392020-09-01 13:44:44 -07001659 mKeyRepeatState.lastKeyEntry->deviceId == entry->deviceId) {
1660 // Make sure we don't get key down from a different device. If a different
1661 // device Id has same key pressed down, the new device Id will replace the
1662 // current one to hold the key repeat with repeat count reset.
1663 // In the future when got a KEY_UP on the device id, drop it and do not
1664 // stop the key repeat on current device.
Michael Wrightd02c5b62014-02-10 15:10:22 -08001665 entry->repeatCount = mKeyRepeatState.lastKeyEntry->repeatCount + 1;
1666 resetKeyRepeatLocked();
Colin Cross5b799302022-10-18 21:52:41 -07001667 mKeyRepeatState.nextRepeatTime = LLONG_MAX; // don't generate repeats ourselves
Michael Wrightd02c5b62014-02-10 15:10:22 -08001668 } else {
1669 // Not a repeat. Save key down state in case we do see a repeat later.
1670 resetKeyRepeatLocked();
1671 mKeyRepeatState.nextRepeatTime = entry->eventTime + mConfig.keyRepeatTimeout;
1672 }
1673 mKeyRepeatState.lastKeyEntry = entry;
Chris Ye2ad95392020-09-01 13:44:44 -07001674 } else if (entry->action == AKEY_EVENT_ACTION_UP && mKeyRepeatState.lastKeyEntry &&
1675 mKeyRepeatState.lastKeyEntry->deviceId != entry->deviceId) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001676 // The key on device 'deviceId' is still down, do not stop key repeat
Prabir Pradhan65613802023-02-22 23:36:58 +00001677 if (debugInboundEventDetails()) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001678 ALOGD("deviceId=%d got KEY_UP as stale", entry->deviceId);
1679 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001680 } else if (!entry->syntheticRepeat) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001681 resetKeyRepeatLocked();
1682 }
1683
1684 if (entry->repeatCount == 1) {
1685 entry->flags |= AKEY_EVENT_FLAG_LONG_PRESS;
1686 } else {
1687 entry->flags &= ~AKEY_EVENT_FLAG_LONG_PRESS;
1688 }
1689
1690 entry->dispatchInProgress = true;
1691
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001692 logOutboundKeyDetails("dispatchKey - ", *entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001693 }
1694
1695 // Handle case where the policy asked us to try again later last time.
Michael Wright5caf55a2022-11-24 22:31:42 +00001696 if (entry->interceptKeyResult == KeyEntry::InterceptKeyResult::TRY_AGAIN_LATER) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001697 if (currentTime < entry->interceptKeyWakeupTime) {
1698 if (entry->interceptKeyWakeupTime < *nextWakeupTime) {
1699 *nextWakeupTime = entry->interceptKeyWakeupTime;
1700 }
1701 return false; // wait until next wakeup
1702 }
Michael Wright5caf55a2022-11-24 22:31:42 +00001703 entry->interceptKeyResult = KeyEntry::InterceptKeyResult::UNKNOWN;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001704 entry->interceptKeyWakeupTime = 0;
1705 }
1706
1707 // Give the policy a chance to intercept the key.
Michael Wright5caf55a2022-11-24 22:31:42 +00001708 if (entry->interceptKeyResult == KeyEntry::InterceptKeyResult::UNKNOWN) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001709 if (entry->policyFlags & POLICY_FLAG_PASS_TO_USER) {
Vishnu Nairad321cd2020-08-20 16:40:21 -07001710 sp<IBinder> focusedWindowToken =
Vishnu Nairc519ff72021-01-21 08:23:08 -08001711 mFocusResolver.getFocusedWindowToken(getTargetDisplayId(*entry));
Prabir Pradhancef936d2021-07-21 16:17:52 +00001712
1713 auto command = [this, focusedWindowToken, entry]() REQUIRES(mLock) {
1714 doInterceptKeyBeforeDispatchingCommand(focusedWindowToken, *entry);
1715 };
1716 postCommandLocked(std::move(command));
Josep del Riob3981622023-04-18 15:49:45 +00001717 // Poke user activity for keys not passed to user
1718 pokeUserActivityLocked(*entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001719 return false; // wait for the command to run
1720 } else {
Michael Wright5caf55a2022-11-24 22:31:42 +00001721 entry->interceptKeyResult = KeyEntry::InterceptKeyResult::CONTINUE;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001722 }
Michael Wright5caf55a2022-11-24 22:31:42 +00001723 } else if (entry->interceptKeyResult == KeyEntry::InterceptKeyResult::SKIP) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001724 if (*dropReason == DropReason::NOT_DROPPED) {
1725 *dropReason = DropReason::POLICY;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001726 }
1727 }
1728
1729 // Clean up if dropping the event.
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001730 if (*dropReason != DropReason::NOT_DROPPED) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001731 setInjectionResult(*entry,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001732 *dropReason == DropReason::POLICY ? InputEventInjectionResult::SUCCEEDED
1733 : InputEventInjectionResult::FAILED);
Garfield Tan6a5a14e2020-01-28 13:24:04 -08001734 mReporter->reportDroppedKey(entry->id);
Josep del Riob3981622023-04-18 15:49:45 +00001735 // Poke user activity for undispatched keys
1736 pokeUserActivityLocked(*entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001737 return true;
1738 }
1739
1740 // Identify targets.
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07001741 InputEventInjectionResult injectionResult;
1742 sp<WindowInfoHandle> focusedWindow =
1743 findFocusedWindowTargetLocked(currentTime, *entry, nextWakeupTime,
1744 /*byref*/ injectionResult);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001745 if (injectionResult == InputEventInjectionResult::PENDING) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001746 return false;
1747 }
1748
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001749 setInjectionResult(*entry, injectionResult);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001750 if (injectionResult != InputEventInjectionResult::SUCCEEDED) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001751 return true;
1752 }
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07001753 LOG_ALWAYS_FATAL_IF(focusedWindow == nullptr);
1754
1755 std::vector<InputTarget> inputTargets;
1756 addWindowTargetLocked(focusedWindow,
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08001757 InputTarget::Flags::FOREGROUND | InputTarget::Flags::DISPATCH_AS_IS,
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08001758 /*pointerIds=*/{}, getDownTime(*entry), inputTargets);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001759
Arthur Hung2fbf37f2018-09-13 18:16:41 +08001760 // Add monitor channels from event's or focused display.
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001761 addGlobalMonitoringTargetsLocked(inputTargets, getTargetDisplayId(*entry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001762
1763 // Dispatch the key.
1764 dispatchEventLocked(currentTime, entry, inputTargets);
1765 return true;
1766}
1767
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001768void InputDispatcher::logOutboundKeyDetails(const char* prefix, const KeyEntry& entry) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001769 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
1770 ALOGD("%seventTime=%" PRId64 ", deviceId=%d, source=0x%x, displayId=%" PRId32 ", "
1771 "policyFlags=0x%x, action=0x%x, flags=0x%x, keyCode=0x%x, scanCode=0x%x, "
1772 "metaState=0x%x, repeatCount=%d, downTime=%" PRId64,
1773 prefix, entry.eventTime, entry.deviceId, entry.source, entry.displayId,
1774 entry.policyFlags, entry.action, entry.flags, entry.keyCode, entry.scanCode,
1775 entry.metaState, entry.repeatCount, entry.downTime);
1776 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001777}
1778
Prabir Pradhancef936d2021-07-21 16:17:52 +00001779void InputDispatcher::dispatchSensorLocked(nsecs_t currentTime,
1780 const std::shared_ptr<SensorEntry>& entry,
Chris Yef59a2f42020-10-16 12:55:26 -07001781 DropReason* dropReason, nsecs_t* nextWakeupTime) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001782 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
1783 ALOGD("notifySensorEvent eventTime=%" PRId64 ", hwTimestamp=%" PRId64 ", deviceId=%d, "
1784 "source=0x%x, sensorType=%s",
1785 entry->eventTime, entry->hwTimestamp, entry->deviceId, entry->source,
Dominik Laskowski75788452021-02-09 18:51:25 -08001786 ftl::enum_string(entry->sensorType).c_str());
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001787 }
Prabir Pradhancef936d2021-07-21 16:17:52 +00001788 auto command = [this, entry]() REQUIRES(mLock) {
1789 scoped_unlock unlock(mLock);
1790
1791 if (entry->accuracyChanged) {
Prabir Pradhana41d2442023-04-20 21:30:40 +00001792 mPolicy.notifySensorAccuracy(entry->deviceId, entry->sensorType, entry->accuracy);
Prabir Pradhancef936d2021-07-21 16:17:52 +00001793 }
Prabir Pradhana41d2442023-04-20 21:30:40 +00001794 mPolicy.notifySensorEvent(entry->deviceId, entry->sensorType, entry->accuracy,
1795 entry->hwTimestamp, entry->values);
Prabir Pradhancef936d2021-07-21 16:17:52 +00001796 };
1797 postCommandLocked(std::move(command));
Chris Yef59a2f42020-10-16 12:55:26 -07001798}
1799
1800bool InputDispatcher::flushSensor(int deviceId, InputDeviceSensorType sensorType) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001801 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
1802 ALOGD("flushSensor deviceId=%d, sensorType=%s", deviceId,
Dominik Laskowski75788452021-02-09 18:51:25 -08001803 ftl::enum_string(sensorType).c_str());
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001804 }
Chris Yef59a2f42020-10-16 12:55:26 -07001805 { // acquire lock
1806 std::scoped_lock _l(mLock);
1807
1808 for (auto it = mInboundQueue.begin(); it != mInboundQueue.end(); it++) {
1809 std::shared_ptr<EventEntry> entry = *it;
1810 if (entry->type == EventEntry::Type::SENSOR) {
1811 it = mInboundQueue.erase(it);
1812 releaseInboundEventLocked(entry);
1813 }
1814 }
1815 }
1816 return true;
1817}
1818
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001819bool InputDispatcher::dispatchMotionLocked(nsecs_t currentTime, std::shared_ptr<MotionEntry> entry,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001820 DropReason* dropReason, nsecs_t* nextWakeupTime) {
Michael Wright3dd60e22019-03-27 22:06:44 +00001821 ATRACE_CALL();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001822 // Preprocessing.
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001823 if (!entry->dispatchInProgress) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001824 entry->dispatchInProgress = true;
1825
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001826 logOutboundMotionDetails("dispatchMotion - ", *entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001827 }
1828
1829 // Clean up if dropping the event.
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001830 if (*dropReason != DropReason::NOT_DROPPED) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001831 setInjectionResult(*entry,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001832 *dropReason == DropReason::POLICY ? InputEventInjectionResult::SUCCEEDED
1833 : InputEventInjectionResult::FAILED);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001834 return true;
1835 }
1836
Prabir Pradhanaa561d12021-09-24 06:57:33 -07001837 const bool isPointerEvent = isFromSource(entry->source, AINPUT_SOURCE_CLASS_POINTER);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001838
1839 // Identify targets.
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08001840 std::vector<InputTarget> inputTargets;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001841
1842 bool conflictingPointerActions = false;
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001843 InputEventInjectionResult injectionResult;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001844 if (isPointerEvent) {
1845 // Pointer event. (eg. touchscreen)
Vaibhav Devmurari6abcf8f2022-06-06 10:08:05 +00001846
1847 if (mDragState &&
1848 (entry->action & AMOTION_EVENT_ACTION_MASK) == AMOTION_EVENT_ACTION_POINTER_DOWN) {
1849 // If drag and drop ongoing and pointer down occur: pilfer drag window pointers
1850 pilferPointersLocked(mDragState->dragWindow->getToken());
1851 }
1852
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08001853 inputTargets =
Siarhei Vishniakou4fe57392022-10-25 13:44:30 -07001854 findTouchedWindowTargetsLocked(currentTime, *entry, &conflictingPointerActions,
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07001855 /*byref*/ injectionResult);
Siarhei Vishniakou8619eb32022-12-01 21:30:59 -08001856 LOG_ALWAYS_FATAL_IF(injectionResult != InputEventInjectionResult::SUCCEEDED &&
1857 !inputTargets.empty());
Michael Wrightd02c5b62014-02-10 15:10:22 -08001858 } else {
1859 // Non touch event. (eg. trackball)
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07001860 sp<WindowInfoHandle> focusedWindow =
1861 findFocusedWindowTargetLocked(currentTime, *entry, nextWakeupTime, injectionResult);
1862 if (injectionResult == InputEventInjectionResult::SUCCEEDED) {
1863 LOG_ALWAYS_FATAL_IF(focusedWindow == nullptr);
1864 addWindowTargetLocked(focusedWindow,
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08001865 InputTarget::Flags::FOREGROUND |
1866 InputTarget::Flags::DISPATCH_AS_IS,
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08001867 /*pointerIds=*/{}, getDownTime(*entry), inputTargets);
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07001868 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001869 }
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001870 if (injectionResult == InputEventInjectionResult::PENDING) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001871 return false;
1872 }
1873
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001874 setInjectionResult(*entry, injectionResult);
Prabir Pradhan5735a322022-04-11 17:23:34 +00001875 if (injectionResult == InputEventInjectionResult::TARGET_MISMATCH) {
Siarhei Vishniakou767917f2020-03-24 20:49:09 -07001876 return true;
1877 }
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001878 if (injectionResult != InputEventInjectionResult::SUCCEEDED) {
Michael Wrightfb04fd52022-11-24 22:31:11 +00001879 CancelationOptions::Mode mode(
1880 isPointerEvent ? CancelationOptions::Mode::CANCEL_POINTER_EVENTS
1881 : CancelationOptions::Mode::CANCEL_NON_POINTER_EVENTS);
Siarhei Vishniakou767917f2020-03-24 20:49:09 -07001882 CancelationOptions options(mode, "input event injection failed");
1883 synthesizeCancelationEventsForMonitorsLocked(options);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001884 return true;
1885 }
1886
Arthur Hung2fbf37f2018-09-13 18:16:41 +08001887 // Add monitor channels from event's or focused display.
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001888 addGlobalMonitoringTargetsLocked(inputTargets, getTargetDisplayId(*entry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001889
1890 // Dispatch the motion.
1891 if (conflictingPointerActions) {
Michael Wrightfb04fd52022-11-24 22:31:11 +00001892 CancelationOptions options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001893 "conflicting pointer actions");
Michael Wrightd02c5b62014-02-10 15:10:22 -08001894 synthesizeCancelationEventsForAllConnectionsLocked(options);
1895 }
1896 dispatchEventLocked(currentTime, entry, inputTargets);
1897 return true;
1898}
1899
chaviw98318de2021-05-19 16:45:23 -05001900void InputDispatcher::enqueueDragEventLocked(const sp<WindowInfoHandle>& windowHandle,
Arthur Hung54745652022-04-20 07:17:41 +00001901 bool isExiting, const int32_t rawX,
1902 const int32_t rawY) {
1903 const vec2 xy = windowHandle->getInfo()->transform.transform(vec2(rawX, rawY));
arthurhungb89ccb02020-12-30 16:19:01 +08001904 std::unique_ptr<DragEntry> dragEntry =
Arthur Hung54745652022-04-20 07:17:41 +00001905 std::make_unique<DragEntry>(mIdGenerator.nextId(), now(), windowHandle->getToken(),
1906 isExiting, xy.x, xy.y);
arthurhungb89ccb02020-12-30 16:19:01 +08001907
1908 enqueueInboundEventLocked(std::move(dragEntry));
1909}
1910
1911void InputDispatcher::dispatchDragLocked(nsecs_t currentTime, std::shared_ptr<DragEntry> entry) {
1912 std::shared_ptr<InputChannel> channel = getInputChannelLocked(entry->connectionToken);
1913 if (channel == nullptr) {
1914 return; // Window has gone away
1915 }
1916 InputTarget target;
1917 target.inputChannel = channel;
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08001918 target.flags = InputTarget::Flags::DISPATCH_AS_IS;
arthurhungb89ccb02020-12-30 16:19:01 +08001919 entry->dispatchInProgress = true;
1920 dispatchEventLocked(currentTime, entry, {target});
1921}
1922
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001923void InputDispatcher::logOutboundMotionDetails(const char* prefix, const MotionEntry& entry) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001924 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
Siarhei Vishniakou0b0374d2022-11-17 17:40:53 -08001925 ALOGD("%seventTime=%" PRId64 ", deviceId=%d, source=%s, displayId=%" PRId32
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001926 ", policyFlags=0x%x, "
Siarhei Vishniakouca205502021-07-16 21:31:58 +00001927 "action=%s, actionButton=0x%x, flags=0x%x, "
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001928 "metaState=0x%x, buttonState=0x%x,"
1929 "edgeFlags=0x%x, xPrecision=%f, yPrecision=%f, downTime=%" PRId64,
Siarhei Vishniakou0b0374d2022-11-17 17:40:53 -08001930 prefix, entry.eventTime, entry.deviceId,
1931 inputEventSourceToString(entry.source).c_str(), entry.displayId, entry.policyFlags,
1932 MotionEvent::actionToString(entry.action).c_str(), entry.actionButton, entry.flags,
1933 entry.metaState, entry.buttonState, entry.edgeFlags, entry.xPrecision,
1934 entry.yPrecision, entry.downTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001935
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001936 for (uint32_t i = 0; i < entry.pointerCount; i++) {
Siarhei Vishniakou6d73f832022-07-21 17:27:03 -07001937 ALOGD(" Pointer %d: id=%d, toolType=%s, "
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001938 "x=%f, y=%f, pressure=%f, size=%f, "
1939 "touchMajor=%f, touchMinor=%f, toolMajor=%f, toolMinor=%f, "
1940 "orientation=%f",
Siarhei Vishniakou6d73f832022-07-21 17:27:03 -07001941 i, entry.pointerProperties[i].id,
1942 ftl::enum_string(entry.pointerProperties[i].toolType).c_str(),
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001943 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_X),
1944 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_Y),
1945 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_PRESSURE),
1946 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_SIZE),
1947 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR),
1948 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR),
1949 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR),
1950 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR),
1951 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION));
1952 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001953 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001954}
1955
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001956void InputDispatcher::dispatchEventLocked(nsecs_t currentTime,
1957 std::shared_ptr<EventEntry> eventEntry,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001958 const std::vector<InputTarget>& inputTargets) {
Michael Wright3dd60e22019-03-27 22:06:44 +00001959 ATRACE_CALL();
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001960 if (DEBUG_DISPATCH_CYCLE) {
1961 ALOGD("dispatchEventToCurrentInputTargets");
1962 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001963
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00001964 processInteractionsLocked(*eventEntry, inputTargets);
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00001965
Michael Wrightd02c5b62014-02-10 15:10:22 -08001966 ALOG_ASSERT(eventEntry->dispatchInProgress); // should already have been set to true
1967
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001968 pokeUserActivityLocked(*eventEntry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001969
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08001970 for (const InputTarget& inputTarget : inputTargets) {
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07001971 std::shared_ptr<Connection> connection =
Siarhei Vishniakou26d3cfb2019-10-15 17:02:32 -07001972 getConnectionLocked(inputTarget.inputChannel->getConnectionToken());
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07001973 if (connection != nullptr) {
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08001974 prepareDispatchCycleLocked(currentTime, connection, eventEntry, inputTarget);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001975 } else {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01001976 if (DEBUG_FOCUS) {
1977 ALOGD("Dropping event delivery to target with channel '%s' because it "
1978 "is no longer registered with the input dispatcher.",
1979 inputTarget.inputChannel->getName().c_str());
1980 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001981 }
1982 }
1983}
1984
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07001985void InputDispatcher::cancelEventsForAnrLocked(const std::shared_ptr<Connection>& connection) {
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001986 // We will not be breaking any connections here, even if the policy wants us to abort dispatch.
1987 // If the policy decides to close the app, we will get a channel removal event via
1988 // unregisterInputChannel, and will clean up the connection that way. We are already not
1989 // sending new pointers to the connection when it blocked, but focused events will continue to
1990 // pile up.
1991 ALOGW("Canceling events for %s because it is unresponsive",
1992 connection->inputChannel->getName().c_str());
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08001993 if (connection->status == Connection::Status::NORMAL) {
Michael Wrightfb04fd52022-11-24 22:31:11 +00001994 CancelationOptions options(CancelationOptions::Mode::CANCEL_ALL_EVENTS,
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001995 "application not responding");
1996 synthesizeCancelationEventsForConnectionLocked(connection, options);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001997 }
1998}
1999
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002000void InputDispatcher::resetNoFocusedWindowTimeoutLocked() {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01002001 if (DEBUG_FOCUS) {
2002 ALOGD("Resetting ANR timeouts.");
2003 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002004
2005 // Reset input target wait timeout.
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002006 mNoFocusedWindowTimeoutTime = std::nullopt;
Chris Yea209fde2020-07-22 13:54:51 -07002007 mAwaitedFocusedApplication.reset();
Michael Wrightd02c5b62014-02-10 15:10:22 -08002008}
2009
Tiger Huang721e26f2018-07-24 22:26:19 +08002010/**
2011 * Get the display id that the given event should go to. If this event specifies a valid display id,
2012 * then it should be dispatched to that display. Otherwise, the event goes to the focused display.
2013 * Focused display is the display that the user most recently interacted with.
2014 */
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002015int32_t InputDispatcher::getTargetDisplayId(const EventEntry& entry) {
Tiger Huang721e26f2018-07-24 22:26:19 +08002016 int32_t displayId;
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002017 switch (entry.type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07002018 case EventEntry::Type::KEY: {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002019 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(entry);
2020 displayId = keyEntry.displayId;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002021 break;
2022 }
Siarhei Vishniakou49483272019-10-22 13:13:47 -07002023 case EventEntry::Type::MOTION: {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002024 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(entry);
2025 displayId = motionEntry.displayId;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002026 break;
2027 }
Antonio Kantekf16f2832021-09-28 04:39:20 +00002028 case EventEntry::Type::TOUCH_MODE_CHANGED:
Prabir Pradhan99987712020-11-10 18:43:05 -08002029 case EventEntry::Type::POINTER_CAPTURE_CHANGED:
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01002030 case EventEntry::Type::FOCUS:
Siarhei Vishniakou49483272019-10-22 13:13:47 -07002031 case EventEntry::Type::CONFIGURATION_CHANGED:
Chris Yef59a2f42020-10-16 12:55:26 -07002032 case EventEntry::Type::DEVICE_RESET:
arthurhungb89ccb02020-12-30 16:19:01 +08002033 case EventEntry::Type::SENSOR:
2034 case EventEntry::Type::DRAG: {
Dominik Laskowski75788452021-02-09 18:51:25 -08002035 ALOGE("%s events do not have a target display", ftl::enum_string(entry.type).c_str());
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002036 return ADISPLAY_ID_NONE;
2037 }
Tiger Huang721e26f2018-07-24 22:26:19 +08002038 }
2039 return displayId == ADISPLAY_ID_NONE ? mFocusedDisplayId : displayId;
2040}
2041
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002042bool InputDispatcher::shouldWaitToSendKeyLocked(nsecs_t currentTime,
2043 const char* focusedWindowName) {
2044 if (mAnrTracker.empty()) {
2045 // already processed all events that we waited for
2046 mKeyIsWaitingForEventsTimeout = std::nullopt;
2047 return false;
2048 }
2049
2050 if (!mKeyIsWaitingForEventsTimeout.has_value()) {
2051 // Start the timer
Siarhei Vishniakoud706a282021-02-13 00:08:48 +00002052 // Wait to send key because there are unprocessed events that may cause focus to change
Siarhei Vishniakou70622952020-07-30 11:17:23 -05002053 mKeyIsWaitingForEventsTimeout = currentTime +
2054 std::chrono::duration_cast<std::chrono::nanoseconds>(KEY_WAITING_FOR_EVENTS_TIMEOUT)
2055 .count();
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002056 return true;
2057 }
2058
2059 // We still have pending events, and already started the timer
2060 if (currentTime < *mKeyIsWaitingForEventsTimeout) {
2061 return true; // Still waiting
2062 }
2063
2064 // Waited too long, and some connection still hasn't processed all motions
2065 // Just send the key to the focused window
2066 ALOGW("Dispatching key to %s even though there are other unprocessed events",
2067 focusedWindowName);
2068 mKeyIsWaitingForEventsTimeout = std::nullopt;
2069 return false;
2070}
2071
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002072sp<WindowInfoHandle> InputDispatcher::findFocusedWindowTargetLocked(
2073 nsecs_t currentTime, const EventEntry& entry, nsecs_t* nextWakeupTime,
2074 InputEventInjectionResult& outInjectionResult) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002075 std::string reason;
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002076 outInjectionResult = InputEventInjectionResult::FAILED; // Default result
Michael Wrightd02c5b62014-02-10 15:10:22 -08002077
Tiger Huang721e26f2018-07-24 22:26:19 +08002078 int32_t displayId = getTargetDisplayId(entry);
chaviw98318de2021-05-19 16:45:23 -05002079 sp<WindowInfoHandle> focusedWindowHandle = getFocusedWindowHandleLocked(displayId);
Chris Yea209fde2020-07-22 13:54:51 -07002080 std::shared_ptr<InputApplicationHandle> focusedApplicationHandle =
Tiger Huang721e26f2018-07-24 22:26:19 +08002081 getValueByKey(mFocusedApplicationHandlesByDisplay, displayId);
2082
Michael Wrightd02c5b62014-02-10 15:10:22 -08002083 // If there is no currently focused window and no focused application
2084 // then drop the event.
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002085 if (focusedWindowHandle == nullptr && focusedApplicationHandle == nullptr) {
2086 ALOGI("Dropping %s event because there is no focused window or focused application in "
2087 "display %" PRId32 ".",
Dominik Laskowski75788452021-02-09 18:51:25 -08002088 ftl::enum_string(entry.type).c_str(), displayId);
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002089 return nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002090 }
2091
Vishnu Nair062a8672021-09-03 16:07:44 -07002092 // Drop key events if requested by input feature
2093 if (focusedWindowHandle != nullptr && shouldDropInput(entry, focusedWindowHandle)) {
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002094 return nullptr;
Vishnu Nair062a8672021-09-03 16:07:44 -07002095 }
2096
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002097 // Compatibility behavior: raise ANR if there is a focused application, but no focused window.
2098 // Only start counting when we have a focused event to dispatch. The ANR is canceled if we
2099 // start interacting with another application via touch (app switch). This code can be removed
2100 // if the "no focused window ANR" is moved to the policy. Input doesn't know whether
2101 // an app is expected to have a focused window.
2102 if (focusedWindowHandle == nullptr && focusedApplicationHandle != nullptr) {
2103 if (!mNoFocusedWindowTimeoutTime.has_value()) {
2104 // We just discovered that there's no focused window. Start the ANR timer
Siarhei Vishniakouc1ae5562020-06-30 14:22:57 -05002105 std::chrono::nanoseconds timeout = focusedApplicationHandle->getDispatchingTimeout(
2106 DEFAULT_INPUT_DISPATCHING_TIMEOUT);
2107 mNoFocusedWindowTimeoutTime = currentTime + timeout.count();
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002108 mAwaitedFocusedApplication = focusedApplicationHandle;
Siarhei Vishniakouf56b2692020-09-08 19:43:33 -05002109 mAwaitedApplicationDisplayId = displayId;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002110 ALOGW("Waiting because no window has focus but %s may eventually add a "
2111 "window when it finishes starting up. Will wait for %" PRId64 "ms",
Siarhei Vishniakouc1ae5562020-06-30 14:22:57 -05002112 mAwaitedFocusedApplication->getName().c_str(), millis(timeout));
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002113 *nextWakeupTime = *mNoFocusedWindowTimeoutTime;
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002114 outInjectionResult = InputEventInjectionResult::PENDING;
2115 return nullptr;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002116 } else if (currentTime > *mNoFocusedWindowTimeoutTime) {
2117 // Already raised ANR. Drop the event
2118 ALOGE("Dropping %s event because there is no focused window",
Dominik Laskowski75788452021-02-09 18:51:25 -08002119 ftl::enum_string(entry.type).c_str());
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002120 return nullptr;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002121 } else {
2122 // Still waiting for the focused window
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002123 outInjectionResult = InputEventInjectionResult::PENDING;
2124 return nullptr;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002125 }
2126 }
2127
2128 // we have a valid, non-null focused window
2129 resetNoFocusedWindowTimeoutLocked();
2130
Prabir Pradhan5735a322022-04-11 17:23:34 +00002131 // Verify targeted injection.
2132 if (const auto err = verifyTargetedInjection(focusedWindowHandle, entry); err) {
2133 ALOGW("Dropping injected event: %s", (*err).c_str());
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002134 outInjectionResult = InputEventInjectionResult::TARGET_MISMATCH;
2135 return nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002136 }
2137
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08002138 if (focusedWindowHandle->getInfo()->inputConfig.test(
2139 WindowInfo::InputConfig::PAUSE_DISPATCHING)) {
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002140 ALOGI("Waiting because %s is paused", focusedWindowHandle->getName().c_str());
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002141 outInjectionResult = InputEventInjectionResult::PENDING;
2142 return nullptr;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002143 }
2144
2145 // If the event is a key event, then we must wait for all previous events to
2146 // complete before delivering it because previous events may have the
2147 // side-effect of transferring focus to a different window and we want to
2148 // ensure that the following keys are sent to the new window.
2149 //
2150 // Suppose the user touches a button in a window then immediately presses "A".
2151 // If the button causes a pop-up window to appear then we want to ensure that
2152 // the "A" key is delivered to the new pop-up window. This is because users
2153 // often anticipate pending UI changes when typing on a keyboard.
2154 // To obtain this behavior, we must serialize key events with respect to all
2155 // prior input events.
2156 if (entry.type == EventEntry::Type::KEY) {
2157 if (shouldWaitToSendKeyLocked(currentTime, focusedWindowHandle->getName().c_str())) {
2158 *nextWakeupTime = *mKeyIsWaitingForEventsTimeout;
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002159 outInjectionResult = InputEventInjectionResult::PENDING;
2160 return nullptr;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002161 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002162 }
2163
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002164 outInjectionResult = InputEventInjectionResult::SUCCEEDED;
2165 return focusedWindowHandle;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002166}
2167
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002168/**
2169 * Given a list of monitors, remove the ones we cannot find a connection for, and the ones
2170 * that are currently unresponsive.
2171 */
Prabir Pradhan0a99c922021-09-03 08:27:53 -07002172std::vector<Monitor> InputDispatcher::selectResponsiveMonitorsLocked(
2173 const std::vector<Monitor>& monitors) const {
2174 std::vector<Monitor> responsiveMonitors;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002175 std::copy_if(monitors.begin(), monitors.end(), std::back_inserter(responsiveMonitors),
Prabir Pradhan0a99c922021-09-03 08:27:53 -07002176 [this](const Monitor& monitor) REQUIRES(mLock) {
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07002177 std::shared_ptr<Connection> connection =
Prabir Pradhan0a99c922021-09-03 08:27:53 -07002178 getConnectionLocked(monitor.inputChannel->getConnectionToken());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002179 if (connection == nullptr) {
2180 ALOGE("Could not find connection for monitor %s",
Prabir Pradhan0a99c922021-09-03 08:27:53 -07002181 monitor.inputChannel->getName().c_str());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002182 return false;
2183 }
2184 if (!connection->responsive) {
2185 ALOGW("Unresponsive monitor %s will not get the new gesture",
2186 connection->inputChannel->getName().c_str());
2187 return false;
2188 }
2189 return true;
2190 });
2191 return responsiveMonitors;
2192}
2193
Siarhei Vishniakou64a98532022-10-25 15:20:24 -07002194/**
2195 * In general, touch should be always split between windows. Some exceptions:
2196 * 1. Don't split touch is if we have an active pointer down, and a new pointer is going down that's
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07002197 * from the same device, *and* the window that's receiving the current pointer does not support
2198 * split touch.
Siarhei Vishniakou64a98532022-10-25 15:20:24 -07002199 * 2. Don't split mouse events
2200 */
2201bool InputDispatcher::shouldSplitTouch(const TouchState& touchState,
2202 const MotionEntry& entry) const {
2203 if (isFromSource(entry.source, AINPUT_SOURCE_MOUSE)) {
2204 // We should never split mouse events
2205 return false;
2206 }
2207 for (const TouchedWindow& touchedWindow : touchState.windows) {
2208 if (touchedWindow.windowHandle->getInfo()->isSpy()) {
2209 // Spy windows should not affect whether or not touch is split.
2210 continue;
2211 }
2212 if (touchedWindow.windowHandle->getInfo()->supportsSplitTouch()) {
2213 continue;
2214 }
Arthur Hungc539dbb2022-12-08 07:45:36 +00002215 if (touchedWindow.windowHandle->getInfo()->inputConfig.test(
2216 gui::WindowInfo::InputConfig::IS_WALLPAPER)) {
2217 // Wallpaper window should not affect whether or not touch is split
2218 continue;
2219 }
2220
Siarhei Vishniakou45504fe2023-05-05 16:05:10 -07002221 if (touchedWindow.hasTouchingPointers(entry.deviceId)) {
Siarhei Vishniakou64a98532022-10-25 15:20:24 -07002222 return false;
2223 }
2224 }
2225 return true;
2226}
2227
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002228std::vector<InputTarget> InputDispatcher::findTouchedWindowTargetsLocked(
Siarhei Vishniakou4fe57392022-10-25 13:44:30 -07002229 nsecs_t currentTime, const MotionEntry& entry, bool* outConflictingPointerActions,
2230 InputEventInjectionResult& outInjectionResult) {
Michael Wright3dd60e22019-03-27 22:06:44 +00002231 ATRACE_CALL();
Michael Wrightd02c5b62014-02-10 15:10:22 -08002232
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002233 std::vector<InputTarget> targets;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002234 // For security reasons, we defer updating the touch state until we are sure that
2235 // event injection will be allowed.
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002236 const int32_t displayId = entry.displayId;
2237 const int32_t action = entry.action;
Siarhei Vishniakoubf880522023-05-01 11:03:22 -07002238 const int32_t maskedAction = MotionEvent::getActionMasked(action);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002239
2240 // Update the touch state as needed based on the properties of the touch event.
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002241 outInjectionResult = InputEventInjectionResult::PENDING;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002242
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002243 // Copy current touch state into tempTouchState.
2244 // This state will be used to update mTouchStatesByDisplay at the end of this function.
2245 // If no state for the specified display exists, then our initial state will be empty.
Yi Kong9b14ac62018-07-17 13:48:38 -07002246 const TouchState* oldState = nullptr;
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002247 TouchState tempTouchState;
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002248 if (const auto it = mTouchStatesByDisplay.find(displayId); it != mTouchStatesByDisplay.end()) {
2249 oldState = &(it->second);
Prabir Pradhane680f9b2022-02-04 04:24:00 -08002250 tempTouchState = *oldState;
Jeff Brownf086ddb2014-02-11 14:28:48 -08002251 }
2252
Siarhei Vishniakou64a98532022-10-25 15:20:24 -07002253 bool isSplit = shouldSplitTouch(tempTouchState, entry);
Siarhei Vishniakou45504fe2023-05-05 16:05:10 -07002254 bool switchedDevice = false;
2255 if (oldState != nullptr) {
2256 std::set<int32_t> oldActiveDevices = oldState->getActiveDeviceIds();
2257 const bool anotherDeviceIsActive =
2258 oldActiveDevices.count(entry.deviceId) == 0 && !oldActiveDevices.empty();
2259 switchedDevice |= anotherDeviceIsActive;
2260 switchedDevice |= oldState->source != entry.source;
2261 }
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002262
2263 const bool isHoverAction = (maskedAction == AMOTION_EVENT_ACTION_HOVER_MOVE ||
2264 maskedAction == AMOTION_EVENT_ACTION_HOVER_ENTER ||
2265 maskedAction == AMOTION_EVENT_ACTION_HOVER_EXIT);
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002266 // A DOWN could be generated from POINTER_DOWN if the initial pointers did not land into any
2267 // touchable windows.
2268 const bool wasDown = oldState != nullptr && oldState->isDown();
2269 const bool isDown = (maskedAction == AMOTION_EVENT_ACTION_DOWN) ||
2270 (maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN && !wasDown);
Siarhei Vishniakoua235c042023-05-02 09:59:09 -07002271 const bool newGesture = isDown || maskedAction == AMOTION_EVENT_ACTION_SCROLL ||
2272 maskedAction == AMOTION_EVENT_ACTION_HOVER_ENTER ||
2273 maskedAction == AMOTION_EVENT_ACTION_HOVER_MOVE;
Prabir Pradhanaa561d12021-09-24 06:57:33 -07002274 const bool isFromMouse = isFromSource(entry.source, AINPUT_SOURCE_MOUSE);
Siarhei Vishniakou5cee1e32022-11-29 12:35:39 -08002275
Siarhei Vishniakouf372b812023-02-14 18:06:51 -08002276 // If pointers are already down, let's finish the current gesture and ignore the new events
2277 // from another device. However, if the new event is a down event, let's cancel the current
2278 // touch and let the new one take over.
2279 if (switchedDevice && wasDown && !isDown) {
Siarhei Vishniakou45504fe2023-05-05 16:05:10 -07002280 LOG(INFO) << "Dropping event because a pointer for another device "
Siarhei Vishniakouf372b812023-02-14 18:06:51 -08002281 << " is already down in display " << displayId << ": " << entry.getDescription();
2282 // TODO(b/211379801): test multiple simultaneous input streams.
2283 outInjectionResult = InputEventInjectionResult::FAILED;
2284 return {}; // wrong device
2285 }
2286
Michael Wrightd02c5b62014-02-10 15:10:22 -08002287 if (newGesture) {
Siarhei Vishniakouf372b812023-02-14 18:06:51 -08002288 // If a new gesture is starting, clear the touch state completely.
2289 tempTouchState.reset();
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002290 tempTouchState.source = entry.source;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002291 isSplit = false;
Kevin Schoedel1eb587b2017-05-03 13:58:56 -04002292 } else if (switchedDevice && maskedAction == AMOTION_EVENT_ACTION_MOVE) {
Siarhei Vishniakouf0007dd2020-04-13 11:40:37 -07002293 ALOGI("Dropping move event because a pointer for a different device is already active "
2294 "in display %" PRId32,
2295 displayId);
Siarhei Vishniakou16e4fa02023-02-16 17:48:56 -08002296 // TODO(b/211379801): test multiple simultaneous input streams.
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002297 outInjectionResult = InputEventInjectionResult::FAILED;
Siarhei Vishniakou8619eb32022-12-01 21:30:59 -08002298 return {}; // wrong device
Michael Wrightd02c5b62014-02-10 15:10:22 -08002299 }
2300
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +00002301 if (isHoverAction) {
2302 // For hover actions, we will treat 'tempTouchState' as a new state, so let's erase
2303 // all of the existing hovering pointers and recompute.
2304 tempTouchState.clearHoveringPointers();
2305 }
2306
Michael Wrightd02c5b62014-02-10 15:10:22 -08002307 if (newGesture || (isSplit && maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN)) {
2308 /* Case 1: New splittable pointer going down, or need target for hover or scroll. */
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07002309 const auto [x, y] = resolveTouchedPosition(entry);
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002310 const int32_t pointerIndex = getMotionEventActionPointerIndex(action);
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002311 // Outside targets should be added upon first dispatched DOWN event. That means, this should
2312 // be a pointer that would generate ACTION_DOWN, *and* touch should not already be down.
Prabir Pradhand65552b2021-10-07 11:23:50 -07002313 const bool isStylus = isPointerFromStylus(entry, pointerIndex);
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002314 auto [newTouchedWindowHandle, outsideTargets] =
2315 findTouchedWindowAtLocked(displayId, x, y, isStylus);
Michael Wright3dd60e22019-03-27 22:06:44 +00002316
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002317 if (isDown) {
2318 targets += outsideTargets;
2319 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002320 // Handle the case where we did not find a window.
Yi Kong9b14ac62018-07-17 13:48:38 -07002321 if (newTouchedWindowHandle == nullptr) {
Prabir Pradhan82e081e2022-12-06 09:50:09 +00002322 ALOGD("No new touched window at (%.1f, %.1f) in display %" PRId32, x, y, displayId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002323 // Try to assign the pointer to the first foreground window we find, if there is one.
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002324 newTouchedWindowHandle = tempTouchState.getFirstForegroundWindowHandle();
Michael Wright3dd60e22019-03-27 22:06:44 +00002325 }
2326
Prabir Pradhan5735a322022-04-11 17:23:34 +00002327 // Verify targeted injection.
2328 if (const auto err = verifyTargetedInjection(newTouchedWindowHandle, entry); err) {
2329 ALOGW("Dropping injected touch event: %s", (*err).c_str());
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002330 outInjectionResult = os::InputEventInjectionResult::TARGET_MISMATCH;
Prabir Pradhan5735a322022-04-11 17:23:34 +00002331 newTouchedWindowHandle = nullptr;
Siarhei Vishniakou8619eb32022-12-01 21:30:59 -08002332 return {};
Prabir Pradhan5735a322022-04-11 17:23:34 +00002333 }
2334
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002335 // Figure out whether splitting will be allowed for this window.
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002336 if (newTouchedWindowHandle != nullptr) {
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002337 if (newTouchedWindowHandle->getInfo()->supportsSplitTouch()) {
2338 // New window supports splitting, but we should never split mouse events.
2339 isSplit = !isFromMouse;
2340 } else if (isSplit) {
2341 // New window does not support splitting but we have already split events.
2342 // Ignore the new window.
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002343 newTouchedWindowHandle = nullptr;
2344 }
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002345 } else {
2346 // No window is touched, so set split to true. This will allow the next pointer down to
Prabir Pradhan713bb3e2021-12-20 02:07:40 -08002347 // be delivered to a new window which supports split touch. Pointers from a mouse device
2348 // should never be split.
Siarhei Vishniakou64a98532022-10-25 15:20:24 -07002349 isSplit = !isFromMouse;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002350 }
2351
Prabir Pradhan07e05b62021-11-19 03:57:24 -08002352 std::vector<sp<WindowInfoHandle>> newTouchedWindows =
Prabir Pradhand65552b2021-10-07 11:23:50 -07002353 findTouchedSpyWindowsAtLocked(displayId, x, y, isStylus);
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002354 if (newTouchedWindowHandle != nullptr) {
Prabir Pradhan07e05b62021-11-19 03:57:24 -08002355 // Process the foreground window first so that it is the first to receive the event.
2356 newTouchedWindows.insert(newTouchedWindows.begin(), newTouchedWindowHandle);
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002357 }
2358
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002359 if (newTouchedWindows.empty()) {
Prabir Pradhan82e081e2022-12-06 09:50:09 +00002360 ALOGI("Dropping event because there is no touchable window at (%.1f, %.1f) on display "
2361 "%d.",
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002362 x, y, displayId);
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002363 outInjectionResult = InputEventInjectionResult::FAILED;
Siarhei Vishniakou8619eb32022-12-01 21:30:59 -08002364 return {};
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002365 }
2366
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002367 for (const sp<WindowInfoHandle>& windowHandle : newTouchedWindows) {
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07002368 if (!canWindowReceiveMotionLocked(windowHandle, entry)) {
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002369 continue;
2370 }
2371
Siarhei Vishniakoub681c202023-05-01 11:22:33 -07002372 if (maskedAction == AMOTION_EVENT_ACTION_HOVER_ENTER ||
2373 maskedAction == AMOTION_EVENT_ACTION_HOVER_MOVE) {
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +00002374 const int32_t pointerId = entry.pointerProperties[0].id;
Siarhei Vishniakoub681c202023-05-01 11:22:33 -07002375 // The "windowHandle" is the target of this hovering pointer.
2376 tempTouchState.addHoveringPointerToWindow(windowHandle, entry.deviceId, pointerId);
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +00002377 }
2378
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002379 // Set target flags.
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002380 ftl::Flags<InputTarget::Flags> targetFlags = InputTarget::Flags::DISPATCH_AS_IS;
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002381
Prabir Pradhan6dfbf262022-03-14 15:24:30 +00002382 if (canReceiveForegroundTouches(*windowHandle->getInfo())) {
2383 // There should only be one touched window that can be "foreground" for the pointer.
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002384 targetFlags |= InputTarget::Flags::FOREGROUND;
Prabir Pradhan07e05b62021-11-19 03:57:24 -08002385 }
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002386
2387 if (isSplit) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002388 targetFlags |= InputTarget::Flags::SPLIT;
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002389 }
2390 if (isWindowObscuredAtPointLocked(windowHandle, x, y)) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002391 targetFlags |= InputTarget::Flags::WINDOW_IS_OBSCURED;
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002392 } else if (isWindowObscuredLocked(windowHandle)) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002393 targetFlags |= InputTarget::Flags::WINDOW_IS_PARTIALLY_OBSCURED;
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002394 }
Michael Wright3dd60e22019-03-27 22:06:44 +00002395
2396 // Update the temporary touch state.
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08002397 std::bitset<MAX_POINTER_ID + 1> pointerIds;
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +00002398 if (!isHoverAction) {
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08002399 pointerIds.set(entry.pointerProperties[pointerIndex].id);
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +00002400 }
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002401
Siarhei Vishniakoue0431e42023-01-28 17:01:39 -08002402 const bool isDownOrPointerDown = maskedAction == AMOTION_EVENT_ACTION_DOWN ||
2403 maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN;
2404
Siarhei Vishniakouf372b812023-02-14 18:06:51 -08002405 // TODO(b/211379801): Currently, even if pointerIds are empty (hover case), we would
2406 // still add a window to the touch state. We should avoid doing that, but some of the
2407 // later checks ("at least one foreground window") rely on this in order to dispatch
2408 // the event properly, so that needs to be updated, possibly by looking at InputTargets.
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07002409 tempTouchState.addOrUpdateWindow(windowHandle, targetFlags, entry.deviceId, pointerIds,
Siarhei Vishniakoue0431e42023-01-28 17:01:39 -08002410 isDownOrPointerDown
2411 ? std::make_optional(entry.eventTime)
2412 : std::nullopt);
Arthur Hungc539dbb2022-12-08 07:45:36 +00002413
2414 // If this is the pointer going down and the touched window has a wallpaper
2415 // then also add the touched wallpaper windows so they are locked in for the duration
2416 // of the touch gesture.
2417 // We do not collect wallpapers during HOVER_MOVE or SCROLL because the wallpaper
2418 // engine only supports touch events. We would need to add a mechanism similar
2419 // to View.onGenericMotionEvent to enable wallpapers to handle these events.
Siarhei Vishniakoue0431e42023-01-28 17:01:39 -08002420 if (isDownOrPointerDown) {
Arthur Hungc539dbb2022-12-08 07:45:36 +00002421 if (targetFlags.test(InputTarget::Flags::FOREGROUND) &&
2422 windowHandle->getInfo()->inputConfig.test(
2423 gui::WindowInfo::InputConfig::DUPLICATE_TOUCH_TO_WALLPAPER)) {
2424 sp<WindowInfoHandle> wallpaper = findWallpaperWindowBelow(windowHandle);
2425 if (wallpaper != nullptr) {
2426 ftl::Flags<InputTarget::Flags> wallpaperFlags =
2427 InputTarget::Flags::WINDOW_IS_OBSCURED |
2428 InputTarget::Flags::WINDOW_IS_PARTIALLY_OBSCURED |
2429 InputTarget::Flags::DISPATCH_AS_IS;
2430 if (isSplit) {
2431 wallpaperFlags |= InputTarget::Flags::SPLIT;
2432 }
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07002433 tempTouchState.addOrUpdateWindow(wallpaper, wallpaperFlags, entry.deviceId,
2434 pointerIds, entry.eventTime);
Arthur Hungc539dbb2022-12-08 07:45:36 +00002435 }
2436 }
2437 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002438 }
Vaibhav Devmurariff798f32022-05-09 23:45:04 +00002439
Siarhei Vishniakou060f82b2023-01-27 06:39:14 -08002440 // If a window is already pilfering some pointers, give it this new pointer as well and
2441 // make it pilfering. This will prevent other non-spy windows from getting this pointer,
2442 // which is a specific behaviour that we want.
2443 const int32_t pointerId = entry.pointerProperties[pointerIndex].id;
2444 for (TouchedWindow& touchedWindow : tempTouchState.windows) {
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07002445 if (touchedWindow.hasTouchingPointer(entry.deviceId, pointerId) &&
2446 touchedWindow.hasPilferingPointers(entry.deviceId)) {
Siarhei Vishniakou060f82b2023-01-27 06:39:14 -08002447 // This window is already pilfering some pointers, and this new pointer is also
2448 // going to it. Therefore, take over this pointer and don't give it to anyone
2449 // else.
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07002450 touchedWindow.addPilferingPointer(entry.deviceId, pointerId);
Vaibhav Devmurariff798f32022-05-09 23:45:04 +00002451 }
2452 }
Siarhei Vishniakou060f82b2023-01-27 06:39:14 -08002453
2454 // Restrict all pilfered pointers to the pilfering windows.
2455 tempTouchState.cancelPointersForNonPilferingWindows();
Michael Wrightd02c5b62014-02-10 15:10:22 -08002456 } else {
2457 /* Case 2: Pointer move, up, cancel or non-splittable pointer down. */
2458
2459 // If the pointer is not currently down, then ignore the event.
Siarhei Vishniakoua235c042023-05-02 09:59:09 -07002460 if (!tempTouchState.isDown() && maskedAction != AMOTION_EVENT_ACTION_HOVER_EXIT) {
Siarhei Vishniakouf372b812023-02-14 18:06:51 -08002461 LOG(INFO) << "Dropping event because the pointer is not down or we previously "
2462 "dropped the pointer down event in display "
2463 << displayId << ": " << entry.getDescription();
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002464 outInjectionResult = InputEventInjectionResult::FAILED;
Siarhei Vishniakou8619eb32022-12-01 21:30:59 -08002465 return {};
Michael Wrightd02c5b62014-02-10 15:10:22 -08002466 }
2467
Siarhei Vishniakoua235c042023-05-02 09:59:09 -07002468 // If the pointer is not currently hovering, then ignore the event.
2469 if (maskedAction == AMOTION_EVENT_ACTION_HOVER_EXIT) {
2470 const int32_t pointerId = entry.pointerProperties[0].id;
2471 if (oldState == nullptr ||
2472 oldState->getWindowsWithHoveringPointer(entry.deviceId, pointerId).empty()) {
2473 LOG(INFO) << "Dropping event because the hovering pointer is not in any windows in "
2474 "display "
2475 << displayId << ": " << entry.getDescription();
2476 outInjectionResult = InputEventInjectionResult::FAILED;
2477 return {};
2478 }
2479 tempTouchState.removeHoveringPointer(entry.deviceId, pointerId);
2480 }
2481
arthurhung6d4bed92021-03-17 11:59:33 +08002482 addDragEventLocked(entry);
arthurhungb89ccb02020-12-30 16:19:01 +08002483
Michael Wrightd02c5b62014-02-10 15:10:22 -08002484 // Check whether touches should slip outside of the current foreground window.
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002485 if (maskedAction == AMOTION_EVENT_ACTION_MOVE && entry.pointerCount == 1 &&
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002486 tempTouchState.isSlippery()) {
Siarhei Vishniakou9306c382022-09-30 15:30:31 -07002487 const auto [x, y] = resolveTouchedPosition(entry);
Harry Cutts33476232023-01-30 19:57:29 +00002488 const bool isStylus = isPointerFromStylus(entry, /*pointerIndex=*/0);
chaviw98318de2021-05-19 16:45:23 -05002489 sp<WindowInfoHandle> oldTouchedWindowHandle =
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002490 tempTouchState.getFirstForegroundWindowHandle();
Siarhei Vishniakou0f6558d2023-04-21 12:05:13 -07002491 LOG_ALWAYS_FATAL_IF(oldTouchedWindowHandle == nullptr);
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002492 auto [newTouchedWindowHandle, _] = findTouchedWindowAtLocked(displayId, x, y, isStylus);
Vishnu Nair062a8672021-09-03 16:07:44 -07002493
Prabir Pradhan5735a322022-04-11 17:23:34 +00002494 // Verify targeted injection.
2495 if (const auto err = verifyTargetedInjection(newTouchedWindowHandle, entry); err) {
2496 ALOGW("Dropping injected event: %s", (*err).c_str());
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002497 outInjectionResult = os::InputEventInjectionResult::TARGET_MISMATCH;
Siarhei Vishniakou8619eb32022-12-01 21:30:59 -08002498 return {};
Prabir Pradhan5735a322022-04-11 17:23:34 +00002499 }
2500
Vishnu Nair062a8672021-09-03 16:07:44 -07002501 // Drop touch events if requested by input feature
2502 if (newTouchedWindowHandle != nullptr &&
2503 shouldDropInput(entry, newTouchedWindowHandle)) {
2504 newTouchedWindowHandle = nullptr;
2505 }
2506
Siarhei Vishniakouafa08cc2023-05-08 22:35:50 -07002507 if (newTouchedWindowHandle != nullptr &&
2508 !haveSameToken(oldTouchedWindowHandle, newTouchedWindowHandle)) {
Siarhei Vishniakou0f6558d2023-04-21 12:05:13 -07002509 ALOGD("Touch is slipping out of window %s into window %s in display %" PRId32,
2510 oldTouchedWindowHandle->getName().c_str(),
2511 newTouchedWindowHandle->getName().c_str(), displayId);
2512
Michael Wrightd02c5b62014-02-10 15:10:22 -08002513 // Make a slippery exit from the old window.
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08002514 std::bitset<MAX_POINTER_ID + 1> pointerIds;
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002515 const int32_t pointerId = entry.pointerProperties[0].id;
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08002516 pointerIds.set(pointerId);
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002517
2518 const TouchedWindow& touchedWindow =
2519 tempTouchState.getTouchedWindow(oldTouchedWindowHandle);
2520 addWindowTargetLocked(oldTouchedWindowHandle,
2521 InputTarget::Flags::DISPATCH_AS_SLIPPERY_EXIT, pointerIds,
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07002522 touchedWindow.getDownTimeInTarget(entry.deviceId), targets);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002523
2524 // Make a slippery entrance into the new window.
2525 if (newTouchedWindowHandle->getInfo()->supportsSplitTouch()) {
Prabir Pradhan713bb3e2021-12-20 02:07:40 -08002526 isSplit = !isFromMouse;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002527 }
2528
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002529 ftl::Flags<InputTarget::Flags> targetFlags =
2530 InputTarget::Flags::DISPATCH_AS_SLIPPERY_ENTER;
Prabir Pradhan6dfbf262022-03-14 15:24:30 +00002531 if (canReceiveForegroundTouches(*newTouchedWindowHandle->getInfo())) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002532 targetFlags |= InputTarget::Flags::FOREGROUND;
Prabir Pradhan6dfbf262022-03-14 15:24:30 +00002533 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002534 if (isSplit) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002535 targetFlags |= InputTarget::Flags::SPLIT;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002536 }
2537 if (isWindowObscuredAtPointLocked(newTouchedWindowHandle, x, y)) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002538 targetFlags |= InputTarget::Flags::WINDOW_IS_OBSCURED;
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10002539 } else if (isWindowObscuredLocked(newTouchedWindowHandle)) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002540 targetFlags |= InputTarget::Flags::WINDOW_IS_PARTIALLY_OBSCURED;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002541 }
2542
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07002543 tempTouchState.addOrUpdateWindow(newTouchedWindowHandle, targetFlags,
2544 entry.deviceId, pointerIds, entry.eventTime);
Arthur Hungc539dbb2022-12-08 07:45:36 +00002545
2546 // Check if the wallpaper window should deliver the corresponding event.
2547 slipWallpaperTouch(targetFlags, oldTouchedWindowHandle, newTouchedWindowHandle,
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07002548 tempTouchState, entry.deviceId, pointerId, targets);
2549 tempTouchState.removeTouchingPointerFromWindow(entry.deviceId, pointerId,
2550 oldTouchedWindowHandle);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002551 }
2552 }
Arthur Hung96483742022-11-15 03:30:48 +00002553
2554 // Update the pointerIds for non-splittable when it received pointer down.
2555 if (!isSplit && maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN) {
2556 // If no split, we suppose all touched windows should receive pointer down.
2557 const int32_t pointerIndex = getMotionEventActionPointerIndex(action);
2558 for (size_t i = 0; i < tempTouchState.windows.size(); i++) {
2559 TouchedWindow& touchedWindow = tempTouchState.windows[i];
2560 // Ignore drag window for it should just track one pointer.
2561 if (mDragState && mDragState->dragWindow == touchedWindow.windowHandle) {
2562 continue;
2563 }
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07002564 touchedWindow.addTouchingPointer(entry.deviceId,
2565 entry.pointerProperties[pointerIndex].id);
Arthur Hung96483742022-11-15 03:30:48 +00002566 }
2567 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002568 }
2569
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002570 // Update dispatching for hover enter and exit.
Sam Dubeyf886dec2023-01-27 13:28:19 +00002571 {
2572 std::vector<TouchedWindow> hoveringWindows =
2573 getHoveringWindowsLocked(oldState, tempTouchState, entry);
2574 for (const TouchedWindow& touchedWindow : hoveringWindows) {
Siarhei Vishniakoud5876ba2023-05-15 17:58:34 -07002575 std::optional<InputTarget> target =
2576 createInputTargetLocked(touchedWindow.windowHandle, touchedWindow.targetFlags,
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07002577 touchedWindow.getDownTimeInTarget(entry.deviceId));
Siarhei Vishniakoud5876ba2023-05-15 17:58:34 -07002578 if (!target) {
2579 continue;
2580 }
2581 // Hardcode to single hovering pointer for now.
2582 std::bitset<MAX_POINTER_ID + 1> pointerIds;
2583 pointerIds.set(entry.pointerProperties[0].id);
2584 target->addPointers(pointerIds, touchedWindow.windowHandle->getInfo()->transform);
2585 targets.push_back(*target);
Sam Dubeyf886dec2023-01-27 13:28:19 +00002586 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002587 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002588
Prabir Pradhan5735a322022-04-11 17:23:34 +00002589 // Ensure that all touched windows are valid for injection.
2590 if (entry.injectionState != nullptr) {
2591 std::string errs;
2592 for (const TouchedWindow& touchedWindow : tempTouchState.windows) {
Prabir Pradhan5735a322022-04-11 17:23:34 +00002593 const auto err = verifyTargetedInjection(touchedWindow.windowHandle, entry);
2594 if (err) errs += "\n - " + *err;
2595 }
2596 if (!errs.empty()) {
2597 ALOGW("Dropping targeted injection: At least one touched window is not owned by uid "
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00002598 "%s:%s",
2599 entry.injectionState->targetUid->toString().c_str(), errs.c_str());
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002600 outInjectionResult = InputEventInjectionResult::TARGET_MISMATCH;
Siarhei Vishniakou8619eb32022-12-01 21:30:59 -08002601 return {};
Prabir Pradhan5735a322022-04-11 17:23:34 +00002602 }
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002603 }
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002604
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002605 // Check whether windows listening for outside touches are owned by the same UID. If the owner
2606 // has a different UID, then we will not reveal coordinate information to this window.
Michael Wrightd02c5b62014-02-10 15:10:22 -08002607 if (maskedAction == AMOTION_EVENT_ACTION_DOWN) {
chaviw98318de2021-05-19 16:45:23 -05002608 sp<WindowInfoHandle> foregroundWindowHandle =
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002609 tempTouchState.getFirstForegroundWindowHandle();
Michael Wright3dd60e22019-03-27 22:06:44 +00002610 if (foregroundWindowHandle) {
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00002611 const auto foregroundWindowUid = foregroundWindowHandle->getInfo()->ownerUid;
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002612 for (InputTarget& target : targets) {
2613 if (target.flags.test(InputTarget::Flags::DISPATCH_AS_OUTSIDE)) {
2614 sp<WindowInfoHandle> targetWindow =
2615 getWindowHandleLocked(target.inputChannel->getConnectionToken());
2616 if (targetWindow->getInfo()->ownerUid != foregroundWindowUid) {
2617 target.flags |= InputTarget::Flags::ZERO_COORDS;
Michael Wright3dd60e22019-03-27 22:06:44 +00002618 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002619 }
2620 }
2621 }
2622 }
2623
Harry Cuttsb166c002023-05-09 13:06:05 +00002624 // If this is a touchpad navigation gesture, it needs to only be sent to trusted targets, as we
2625 // only want the system UI to handle these gestures.
2626 const bool isTouchpadNavGesture = isFromSource(entry.source, AINPUT_SOURCE_MOUSE) &&
2627 entry.classification == MotionClassification::MULTI_FINGER_SWIPE;
2628 if (isTouchpadNavGesture) {
2629 filterUntrustedTargets(/* byref */ tempTouchState, /* byref */ targets);
2630 }
2631
Siarhei Vishniakoua235c042023-05-02 09:59:09 -07002632 // Output targets from the touch state.
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002633 for (const TouchedWindow& touchedWindow : tempTouchState.windows) {
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07002634 if (!touchedWindow.hasTouchingPointers(entry.deviceId) &&
2635 !touchedWindow.hasHoveringPointers(entry.deviceId)) {
Siarhei Vishniakoue0431e42023-01-28 17:01:39 -08002636 // Windows with hovering pointers are getting persisted inside TouchState.
2637 // Do not send this event to those windows.
2638 continue;
2639 }
Harry Cuttsb166c002023-05-09 13:06:05 +00002640
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002641 addWindowTargetLocked(touchedWindow.windowHandle, touchedWindow.targetFlags,
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07002642 touchedWindow.getTouchingPointers(entry.deviceId),
2643 touchedWindow.getDownTimeInTarget(entry.deviceId), targets);
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +00002644 }
Sam Dubey39d37cf2022-12-07 18:05:35 +00002645
Siarhei Vishniakou580fb3a2023-05-05 15:02:20 -07002646 // During targeted injection, only allow owned targets to receive events
2647 std::erase_if(targets, [&](const InputTarget& target) {
2648 LOG_ALWAYS_FATAL_IF(target.windowHandle == nullptr);
2649 const auto err = verifyTargetedInjection(target.windowHandle, entry);
2650 if (err) {
2651 LOG(WARNING) << "Dropping injected event from " << target.windowHandle->getName()
2652 << ": " << (*err);
2653 return true;
2654 }
2655 return false;
2656 });
2657
Siarhei Vishniakoua235c042023-05-02 09:59:09 -07002658 if (targets.empty()) {
2659 LOG(INFO) << "Dropping event because no targets were found: " << entry.getDescription();
2660 outInjectionResult = InputEventInjectionResult::FAILED;
2661 return {};
2662 }
2663
2664 // If we only have windows getting ACTION_OUTSIDE, then drop the event, because there is no
2665 // window that is actually receiving the entire gesture.
2666 if (std::all_of(targets.begin(), targets.end(), [](const InputTarget& target) {
2667 return target.flags.test(InputTarget::Flags::DISPATCH_AS_OUTSIDE);
2668 })) {
2669 LOG(INFO) << "Dropping event because all windows would just receive ACTION_OUTSIDE: "
2670 << entry.getDescription();
2671 outInjectionResult = InputEventInjectionResult::FAILED;
2672 return {};
2673 }
2674
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +00002675 outInjectionResult = InputEventInjectionResult::SUCCEEDED;
Sam Dubeyf886dec2023-01-27 13:28:19 +00002676 // Drop the outside or hover touch windows since we will not care about them
2677 // in the next iteration.
2678 tempTouchState.filterNonAsIsTouchWindows();
Michael Wrightd02c5b62014-02-10 15:10:22 -08002679
Michael Wrightd02c5b62014-02-10 15:10:22 -08002680 // Update final pieces of touch state if the injector had permission.
Siarhei Vishniakou79c32662022-10-25 17:56:25 -07002681 if (switchedDevice) {
2682 if (DEBUG_FOCUS) {
2683 ALOGD("Conflicting pointer actions: Switched to a different device.");
2684 }
2685 *outConflictingPointerActions = true;
2686 }
2687
2688 if (isHoverAction) {
2689 // Started hovering, therefore no longer down.
Siarhei Vishniakou3ad385b2022-11-04 10:09:53 -07002690 if (oldState && oldState->isDown()) {
Siarhei Vishniakou6e1e9872022-11-08 17:51:35 -08002691 ALOGD_IF(DEBUG_FOCUS,
2692 "Conflicting pointer actions: Hover received while pointer was down.");
Siarhei Vishniakou767917f2020-03-24 20:49:09 -07002693 *outConflictingPointerActions = true;
2694 }
Siarhei Vishniakou79c32662022-10-25 17:56:25 -07002695 if (maskedAction == AMOTION_EVENT_ACTION_HOVER_ENTER ||
2696 maskedAction == AMOTION_EVENT_ACTION_HOVER_MOVE) {
Siarhei Vishniakou79c32662022-10-25 17:56:25 -07002697 tempTouchState.source = entry.source;
Siarhei Vishniakou767917f2020-03-24 20:49:09 -07002698 }
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +00002699 } else if (maskedAction == AMOTION_EVENT_ACTION_UP) {
2700 // Pointer went up.
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07002701 tempTouchState.removeTouchingPointer(entry.deviceId, entry.pointerProperties[0].id);
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +00002702 } else if (maskedAction == AMOTION_EVENT_ACTION_CANCEL) {
Siarhei Vishniakou79c32662022-10-25 17:56:25 -07002703 // All pointers up or canceled.
2704 tempTouchState.reset();
2705 } else if (maskedAction == AMOTION_EVENT_ACTION_DOWN) {
2706 // First pointer went down.
Siarhei Vishniakouf372b812023-02-14 18:06:51 -08002707 if (oldState && (oldState->isDown() || oldState->hasHoveringPointers())) {
2708 ALOGD("Conflicting pointer actions: Down received while already down or hovering.");
Siarhei Vishniakou79c32662022-10-25 17:56:25 -07002709 *outConflictingPointerActions = true;
Siarhei Vishniakou767917f2020-03-24 20:49:09 -07002710 }
Siarhei Vishniakou79c32662022-10-25 17:56:25 -07002711 } else if (maskedAction == AMOTION_EVENT_ACTION_POINTER_UP) {
2712 // One pointer went up.
2713 int32_t pointerIndex = getMotionEventActionPointerIndex(action);
2714 uint32_t pointerId = entry.pointerProperties[pointerIndex].id;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002715
Siarhei Vishniakou79c32662022-10-25 17:56:25 -07002716 for (size_t i = 0; i < tempTouchState.windows.size();) {
2717 TouchedWindow& touchedWindow = tempTouchState.windows[i];
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07002718 touchedWindow.removeTouchingPointer(entry.deviceId, pointerId);
2719 if (!touchedWindow.hasTouchingPointers(entry.deviceId)) {
Siarhei Vishniakou79c32662022-10-25 17:56:25 -07002720 tempTouchState.windows.erase(tempTouchState.windows.begin() + i);
2721 continue;
2722 }
2723 i += 1;
2724 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002725 }
2726
Siarhei Vishniakou79c32662022-10-25 17:56:25 -07002727 // Save changes unless the action was scroll in which case the temporary touch
2728 // state was only valid for this one action.
2729 if (maskedAction != AMOTION_EVENT_ACTION_SCROLL) {
Siarhei Vishniakou40b8fbd2022-11-04 10:50:26 -07002730 if (displayId >= 0) {
Siarhei Vishniakouf372b812023-02-14 18:06:51 -08002731 tempTouchState.clearWindowsWithoutPointers();
Siarhei Vishniakou79c32662022-10-25 17:56:25 -07002732 mTouchStatesByDisplay[displayId] = tempTouchState;
2733 } else {
2734 mTouchStatesByDisplay.erase(displayId);
2735 }
2736 }
2737
Siarhei Vishniakou0b0374d2022-11-17 17:40:53 -08002738 if (tempTouchState.windows.empty()) {
2739 mTouchStatesByDisplay.erase(displayId);
2740 }
2741
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002742 return targets;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002743}
2744
arthurhung6d4bed92021-03-17 11:59:33 +08002745void InputDispatcher::finishDragAndDrop(int32_t displayId, float x, float y) {
Prabir Pradhand65552b2021-10-07 11:23:50 -07002746 // Prevent stylus interceptor windows from affecting drag and drop behavior for now, until we
2747 // have an explicit reason to support it.
2748 constexpr bool isStylus = false;
2749
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002750 auto [dropWindow, _] =
Harry Cutts33476232023-01-30 19:57:29 +00002751 findTouchedWindowAtLocked(displayId, x, y, isStylus, /*ignoreDragWindow=*/true);
arthurhung6d4bed92021-03-17 11:59:33 +08002752 if (dropWindow) {
2753 vec2 local = dropWindow->getInfo()->transform.transform(x, y);
Prabir Pradhancef936d2021-07-21 16:17:52 +00002754 sendDropWindowCommandLocked(dropWindow->getToken(), local.x, local.y);
Arthur Hung6d0571e2021-04-09 20:18:16 +08002755 } else {
Arthur Hung54745652022-04-20 07:17:41 +00002756 ALOGW("No window found when drop.");
Prabir Pradhancef936d2021-07-21 16:17:52 +00002757 sendDropWindowCommandLocked(nullptr, 0, 0);
arthurhung6d4bed92021-03-17 11:59:33 +08002758 }
2759 mDragState.reset();
2760}
2761
2762void InputDispatcher::addDragEventLocked(const MotionEntry& entry) {
Arthur Hung3915c1f2022-05-31 07:17:17 +00002763 if (!mDragState || mDragState->dragWindow->getInfo()->displayId != entry.displayId) {
arthurhungb89ccb02020-12-30 16:19:01 +08002764 return;
2765 }
2766
arthurhung6d4bed92021-03-17 11:59:33 +08002767 if (!mDragState->isStartDrag) {
2768 mDragState->isStartDrag = true;
2769 mDragState->isStylusButtonDownAtStart =
2770 (entry.buttonState & AMOTION_EVENT_BUTTON_STYLUS_PRIMARY) != 0;
2771 }
2772
Arthur Hung54745652022-04-20 07:17:41 +00002773 // Find the pointer index by id.
2774 int32_t pointerIndex = 0;
2775 for (; static_cast<uint32_t>(pointerIndex) < entry.pointerCount; pointerIndex++) {
2776 const PointerProperties& pointerProperties = entry.pointerProperties[pointerIndex];
2777 if (pointerProperties.id == mDragState->pointerId) {
2778 break;
arthurhung6d4bed92021-03-17 11:59:33 +08002779 }
Arthur Hung54745652022-04-20 07:17:41 +00002780 }
arthurhung6d4bed92021-03-17 11:59:33 +08002781
Arthur Hung54745652022-04-20 07:17:41 +00002782 if (uint32_t(pointerIndex) == entry.pointerCount) {
2783 LOG_ALWAYS_FATAL("Should find a valid pointer index by id %d", mDragState->pointerId);
Arthur Hung54745652022-04-20 07:17:41 +00002784 }
2785
2786 const int32_t maskedAction = entry.action & AMOTION_EVENT_ACTION_MASK;
2787 const int32_t x = entry.pointerCoords[pointerIndex].getX();
2788 const int32_t y = entry.pointerCoords[pointerIndex].getY();
2789
2790 switch (maskedAction) {
2791 case AMOTION_EVENT_ACTION_MOVE: {
2792 // Handle the special case : stylus button no longer pressed.
2793 bool isStylusButtonDown =
2794 (entry.buttonState & AMOTION_EVENT_BUTTON_STYLUS_PRIMARY) != 0;
2795 if (mDragState->isStylusButtonDownAtStart && !isStylusButtonDown) {
2796 finishDragAndDrop(entry.displayId, x, y);
2797 return;
2798 }
2799
2800 // Prevent stylus interceptor windows from affecting drag and drop behavior for now,
2801 // until we have an explicit reason to support it.
2802 constexpr bool isStylus = false;
2803
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002804 auto [hoverWindowHandle, _] = findTouchedWindowAtLocked(entry.displayId, x, y, isStylus,
Harry Cutts33476232023-01-30 19:57:29 +00002805 /*ignoreDragWindow=*/true);
Arthur Hung54745652022-04-20 07:17:41 +00002806 // enqueue drag exit if needed.
2807 if (hoverWindowHandle != mDragState->dragHoverWindowHandle &&
2808 !haveSameToken(hoverWindowHandle, mDragState->dragHoverWindowHandle)) {
2809 if (mDragState->dragHoverWindowHandle != nullptr) {
Harry Cutts33476232023-01-30 19:57:29 +00002810 enqueueDragEventLocked(mDragState->dragHoverWindowHandle, /*isExiting=*/true, x,
Arthur Hung54745652022-04-20 07:17:41 +00002811 y);
2812 }
2813 mDragState->dragHoverWindowHandle = hoverWindowHandle;
2814 }
2815 // enqueue drag location if needed.
2816 if (hoverWindowHandle != nullptr) {
Harry Cutts33476232023-01-30 19:57:29 +00002817 enqueueDragEventLocked(hoverWindowHandle, /*isExiting=*/false, x, y);
Arthur Hung54745652022-04-20 07:17:41 +00002818 }
2819 break;
2820 }
2821
2822 case AMOTION_EVENT_ACTION_POINTER_UP:
2823 if (getMotionEventActionPointerIndex(entry.action) != pointerIndex) {
2824 break;
2825 }
2826 // The drag pointer is up.
2827 [[fallthrough]];
2828 case AMOTION_EVENT_ACTION_UP:
2829 finishDragAndDrop(entry.displayId, x, y);
2830 break;
2831 case AMOTION_EVENT_ACTION_CANCEL: {
2832 ALOGD("Receiving cancel when drag and drop.");
2833 sendDropWindowCommandLocked(nullptr, 0, 0);
2834 mDragState.reset();
2835 break;
2836 }
arthurhungb89ccb02020-12-30 16:19:01 +08002837 }
2838}
2839
Siarhei Vishniakou6c377b32023-05-15 17:03:39 -07002840std::optional<InputTarget> InputDispatcher::createInputTargetLocked(
2841 const sp<android::gui::WindowInfoHandle>& windowHandle,
2842 ftl::Flags<InputTarget::Flags> targetFlags,
2843 std::optional<nsecs_t> firstDownTimeInTarget) const {
2844 std::shared_ptr<InputChannel> inputChannel = getInputChannelLocked(windowHandle->getToken());
2845 if (inputChannel == nullptr) {
2846 ALOGW("Not creating InputTarget for %s, no input channel", windowHandle->getName().c_str());
2847 return {};
2848 }
2849 InputTarget inputTarget;
2850 inputTarget.inputChannel = inputChannel;
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00002851 inputTarget.windowHandle = windowHandle;
Siarhei Vishniakou6c377b32023-05-15 17:03:39 -07002852 inputTarget.flags = targetFlags;
2853 inputTarget.globalScaleFactor = windowHandle->getInfo()->globalScaleFactor;
2854 inputTarget.firstDownTimeInTarget = firstDownTimeInTarget;
2855 const auto& displayInfoIt = mDisplayInfos.find(windowHandle->getInfo()->displayId);
2856 if (displayInfoIt != mDisplayInfos.end()) {
2857 inputTarget.displayTransform = displayInfoIt->second.transform;
2858 } else {
Siarhei Vishniakou580fb3a2023-05-05 15:02:20 -07002859 // DisplayInfo not found for this window on display windowHandle->getInfo()->displayId.
Siarhei Vishniakou6c377b32023-05-15 17:03:39 -07002860 // TODO(b/198444055): Make this an error message after 'setInputWindows' API is removed.
2861 }
2862 return inputTarget;
2863}
2864
chaviw98318de2021-05-19 16:45:23 -05002865void InputDispatcher::addWindowTargetLocked(const sp<WindowInfoHandle>& windowHandle,
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002866 ftl::Flags<InputTarget::Flags> targetFlags,
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08002867 std::bitset<MAX_POINTER_ID + 1> pointerIds,
Vaibhav Devmurari882bd9b2022-06-23 14:54:54 +00002868 std::optional<nsecs_t> firstDownTimeInTarget,
Siarhei Vishniakouf75cddb2022-10-25 10:42:16 -07002869 std::vector<InputTarget>& inputTargets) const {
Chavi Weingarten65f98b82020-01-16 18:56:50 +00002870 std::vector<InputTarget>::iterator it =
2871 std::find_if(inputTargets.begin(), inputTargets.end(),
2872 [&windowHandle](const InputTarget& inputTarget) {
2873 return inputTarget.inputChannel->getConnectionToken() ==
2874 windowHandle->getToken();
2875 });
Chavi Weingarten97b8eec2020-01-09 18:09:08 +00002876
chaviw98318de2021-05-19 16:45:23 -05002877 const WindowInfo* windowInfo = windowHandle->getInfo();
Chavi Weingarten65f98b82020-01-16 18:56:50 +00002878
2879 if (it == inputTargets.end()) {
Siarhei Vishniakou6c377b32023-05-15 17:03:39 -07002880 std::optional<InputTarget> target =
2881 createInputTargetLocked(windowHandle, targetFlags, firstDownTimeInTarget);
2882 if (!target) {
Chavi Weingarten65f98b82020-01-16 18:56:50 +00002883 return;
2884 }
Siarhei Vishniakou6c377b32023-05-15 17:03:39 -07002885 inputTargets.push_back(*target);
Chavi Weingarten65f98b82020-01-16 18:56:50 +00002886 it = inputTargets.end() - 1;
2887 }
2888
2889 ALOG_ASSERT(it->flags == targetFlags);
2890 ALOG_ASSERT(it->globalScaleFactor == windowInfo->globalScaleFactor);
2891
chaviw1ff3d1e2020-07-01 15:53:47 -07002892 it->addPointers(pointerIds, windowInfo->transform);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002893}
2894
Michael Wright3dd60e22019-03-27 22:06:44 +00002895void InputDispatcher::addGlobalMonitoringTargetsLocked(std::vector<InputTarget>& inputTargets,
Prabir Pradhan0a99c922021-09-03 08:27:53 -07002896 int32_t displayId) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002897 auto monitorsIt = mGlobalMonitorsByDisplay.find(displayId);
2898 if (monitorsIt == mGlobalMonitorsByDisplay.end()) return;
Michael Wright3dd60e22019-03-27 22:06:44 +00002899
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002900 for (const Monitor& monitor : selectResponsiveMonitorsLocked(monitorsIt->second)) {
2901 InputTarget target;
2902 target.inputChannel = monitor.inputChannel;
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002903 target.flags = InputTarget::Flags::DISPATCH_AS_IS;
Vaibhav Devmurari882bd9b2022-06-23 14:54:54 +00002904 // target.firstDownTimeInTarget is not set for global monitors. It is only required in split
2905 // touch and global monitoring works as intended even without setting firstDownTimeInTarget
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002906 if (const auto& it = mDisplayInfos.find(displayId); it != mDisplayInfos.end()) {
2907 target.displayTransform = it->second.transform;
Arthur Hung2fbf37f2018-09-13 18:16:41 +08002908 }
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002909 target.setDefaultPointerTransform(target.displayTransform);
2910 inputTargets.push_back(target);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002911 }
2912}
2913
Robert Carrc9bf1d32020-04-13 17:21:08 -07002914/**
2915 * Indicate whether one window handle should be considered as obscuring
2916 * another window handle. We only check a few preconditions. Actually
2917 * checking the bounds is left to the caller.
2918 */
chaviw98318de2021-05-19 16:45:23 -05002919static bool canBeObscuredBy(const sp<WindowInfoHandle>& windowHandle,
2920 const sp<WindowInfoHandle>& otherHandle) {
Robert Carrc9bf1d32020-04-13 17:21:08 -07002921 // Compare by token so cloned layers aren't counted
2922 if (haveSameToken(windowHandle, otherHandle)) {
2923 return false;
2924 }
2925 auto info = windowHandle->getInfo();
2926 auto otherInfo = otherHandle->getInfo();
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08002927 if (otherInfo->inputConfig.test(WindowInfo::InputConfig::NOT_VISIBLE)) {
Robert Carrc9bf1d32020-04-13 17:21:08 -07002928 return false;
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08002929 } else if (otherInfo->alpha == 0 &&
2930 otherInfo->inputConfig.test(WindowInfo::InputConfig::NOT_TOUCHABLE)) {
Bernardo Rufino653d2e02020-10-20 17:32:40 +00002931 // Those act as if they were invisible, so we don't need to flag them.
2932 // We do want to potentially flag touchable windows even if they have 0
2933 // opacity, since they can consume touches and alter the effects of the
2934 // user interaction (eg. apps that rely on
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002935 // Flags::WINDOW_IS_PARTIALLY_OBSCURED should still be told about those
Bernardo Rufino653d2e02020-10-20 17:32:40 +00002936 // windows), hence we also check for FLAG_NOT_TOUCHABLE.
2937 return false;
Bernardo Rufino8007daf2020-09-22 09:40:01 +00002938 } else if (info->ownerUid == otherInfo->ownerUid) {
2939 // If ownerUid is the same we don't generate occlusion events as there
2940 // is no security boundary within an uid.
Robert Carrc9bf1d32020-04-13 17:21:08 -07002941 return false;
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08002942 } else if (otherInfo->inputConfig.test(gui::WindowInfo::InputConfig::TRUSTED_OVERLAY)) {
Robert Carrc9bf1d32020-04-13 17:21:08 -07002943 return false;
2944 } else if (otherInfo->displayId != info->displayId) {
2945 return false;
2946 }
2947 return true;
2948}
2949
Bernardo Rufinoea97d182020-08-19 14:43:14 +01002950/**
2951 * Returns touch occlusion information in the form of TouchOcclusionInfo. To check if the touch is
2952 * untrusted, one should check:
2953 *
2954 * 1. If result.hasBlockingOcclusion is true.
2955 * If it's, it means the touch should be blocked due to a window with occlusion mode of
2956 * BLOCK_UNTRUSTED.
2957 *
2958 * 2. If result.obscuringOpacity > mMaximumObscuringOpacityForTouch.
2959 * If it is (and 1 is false), then the touch should be blocked because a stack of windows
2960 * (possibly only one) with occlusion mode of USE_OPACITY from one UID resulted in a composed
2961 * obscuring opacity above the threshold. Note that if there was no window of occlusion mode
2962 * USE_OPACITY, result.obscuringOpacity would've been 0 and since
2963 * mMaximumObscuringOpacityForTouch >= 0, the condition above would never be true.
2964 *
2965 * If neither of those is true, then it means the touch can be allowed.
2966 */
2967InputDispatcher::TouchOcclusionInfo InputDispatcher::computeTouchOcclusionInfoLocked(
chaviw98318de2021-05-19 16:45:23 -05002968 const sp<WindowInfoHandle>& windowHandle, int32_t x, int32_t y) const {
2969 const WindowInfo* windowInfo = windowHandle->getInfo();
Bernardo Rufino4bae0ac2020-10-14 18:33:46 +00002970 int32_t displayId = windowInfo->displayId;
chaviw98318de2021-05-19 16:45:23 -05002971 const std::vector<sp<WindowInfoHandle>>& windowHandles = getWindowHandlesLocked(displayId);
Bernardo Rufinoea97d182020-08-19 14:43:14 +01002972 TouchOcclusionInfo info;
2973 info.hasBlockingOcclusion = false;
2974 info.obscuringOpacity = 0;
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00002975 info.obscuringUid = gui::Uid::INVALID;
2976 std::map<gui::Uid, float> opacityByUid;
chaviw98318de2021-05-19 16:45:23 -05002977 for (const sp<WindowInfoHandle>& otherHandle : windowHandles) {
Bernardo Rufinoea97d182020-08-19 14:43:14 +01002978 if (windowHandle == otherHandle) {
2979 break; // All future windows are below us. Exit early.
2980 }
chaviw98318de2021-05-19 16:45:23 -05002981 const WindowInfo* otherInfo = otherHandle->getInfo();
Bernardo Rufino1ff9d592021-01-18 16:58:57 +00002982 if (canBeObscuredBy(windowHandle, otherHandle) && otherInfo->frameContainsPoint(x, y) &&
2983 !haveSameApplicationToken(windowInfo, otherInfo)) {
Bernardo Rufino4bae0ac2020-10-14 18:33:46 +00002984 if (DEBUG_TOUCH_OCCLUSION) {
2985 info.debugInfo.push_back(
2986 dumpWindowForTouchOcclusion(otherInfo, /* isTouchedWindow */ false));
2987 }
Bernardo Rufinoea97d182020-08-19 14:43:14 +01002988 // canBeObscuredBy() has returned true above, which means this window is untrusted, so
2989 // we perform the checks below to see if the touch can be propagated or not based on the
2990 // window's touch occlusion mode
2991 if (otherInfo->touchOcclusionMode == TouchOcclusionMode::BLOCK_UNTRUSTED) {
2992 info.hasBlockingOcclusion = true;
2993 info.obscuringUid = otherInfo->ownerUid;
2994 info.obscuringPackage = otherInfo->packageName;
2995 break;
2996 }
2997 if (otherInfo->touchOcclusionMode == TouchOcclusionMode::USE_OPACITY) {
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00002998 const auto uid = otherInfo->ownerUid;
Bernardo Rufinoea97d182020-08-19 14:43:14 +01002999 float opacity =
3000 (opacityByUid.find(uid) == opacityByUid.end()) ? 0 : opacityByUid[uid];
3001 // Given windows A and B:
3002 // opacity(A, B) = 1 - [1 - opacity(A)] * [1 - opacity(B)]
3003 opacity = 1 - (1 - opacity) * (1 - otherInfo->alpha);
3004 opacityByUid[uid] = opacity;
3005 if (opacity > info.obscuringOpacity) {
3006 info.obscuringOpacity = opacity;
3007 info.obscuringUid = uid;
3008 info.obscuringPackage = otherInfo->packageName;
3009 }
3010 }
3011 }
3012 }
Bernardo Rufino4bae0ac2020-10-14 18:33:46 +00003013 if (DEBUG_TOUCH_OCCLUSION) {
3014 info.debugInfo.push_back(
3015 dumpWindowForTouchOcclusion(windowInfo, /* isTouchedWindow */ true));
3016 }
Bernardo Rufinoea97d182020-08-19 14:43:14 +01003017 return info;
3018}
3019
chaviw98318de2021-05-19 16:45:23 -05003020std::string InputDispatcher::dumpWindowForTouchOcclusion(const WindowInfo* info,
Bernardo Rufino4bae0ac2020-10-14 18:33:46 +00003021 bool isTouchedWindow) const {
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00003022 return StringPrintf(INDENT2 "* %spackage=%s/%s, id=%" PRId32 ", mode=%s, alpha=%.2f, "
Prabir Pradhan51e7db02022-02-07 06:02:57 -08003023 "frame=[%" PRId32 ",%" PRId32 "][%" PRId32 ",%" PRId32
3024 "], touchableRegion=%s, window={%s}, inputConfig={%s}, "
3025 "hasToken=%s, applicationInfo.name=%s, applicationInfo.token=%s\n",
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08003026 isTouchedWindow ? "[TOUCHED] " : "", info->packageName.c_str(),
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00003027 info->ownerUid.toString().c_str(), info->id,
3028 toString(info->touchOcclusionMode).c_str(), info->alpha, info->frameLeft,
3029 info->frameTop, info->frameRight, info->frameBottom,
3030 dumpRegion(info->touchableRegion).c_str(), info->name.c_str(),
3031 info->inputConfig.string().c_str(), toString(info->token != nullptr),
3032 info->applicationInfo.name.c_str(),
Siarhei Vishniakou63b63612023-04-12 11:00:23 -07003033 binderToString(info->applicationInfo.token).c_str());
Bernardo Rufino4bae0ac2020-10-14 18:33:46 +00003034}
3035
Bernardo Rufinoea97d182020-08-19 14:43:14 +01003036bool InputDispatcher::isTouchTrustedLocked(const TouchOcclusionInfo& occlusionInfo) const {
3037 if (occlusionInfo.hasBlockingOcclusion) {
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00003038 ALOGW("Untrusted touch due to occlusion by %s/%s", occlusionInfo.obscuringPackage.c_str(),
3039 occlusionInfo.obscuringUid.toString().c_str());
Bernardo Rufinoea97d182020-08-19 14:43:14 +01003040 return false;
3041 }
3042 if (occlusionInfo.obscuringOpacity > mMaximumObscuringOpacityForTouch) {
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00003043 ALOGW("Untrusted touch due to occlusion by %s/%s (obscuring opacity = "
Bernardo Rufinoea97d182020-08-19 14:43:14 +01003044 "%.2f, maximum allowed = %.2f)",
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00003045 occlusionInfo.obscuringPackage.c_str(), occlusionInfo.obscuringUid.toString().c_str(),
Bernardo Rufinoea97d182020-08-19 14:43:14 +01003046 occlusionInfo.obscuringOpacity, mMaximumObscuringOpacityForTouch);
3047 return false;
3048 }
3049 return true;
3050}
3051
chaviw98318de2021-05-19 16:45:23 -05003052bool InputDispatcher::isWindowObscuredAtPointLocked(const sp<WindowInfoHandle>& windowHandle,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003053 int32_t x, int32_t y) const {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003054 int32_t displayId = windowHandle->getInfo()->displayId;
chaviw98318de2021-05-19 16:45:23 -05003055 const std::vector<sp<WindowInfoHandle>>& windowHandles = getWindowHandlesLocked(displayId);
3056 for (const sp<WindowInfoHandle>& otherHandle : windowHandles) {
Robert Carrc9bf1d32020-04-13 17:21:08 -07003057 if (windowHandle == otherHandle) {
3058 break; // All future windows are below us. Exit early.
Michael Wrightd02c5b62014-02-10 15:10:22 -08003059 }
chaviw98318de2021-05-19 16:45:23 -05003060 const WindowInfo* otherInfo = otherHandle->getInfo();
Robert Carrc9bf1d32020-04-13 17:21:08 -07003061 if (canBeObscuredBy(windowHandle, otherHandle) &&
minchelif28cc4e2020-03-19 11:18:11 +08003062 otherInfo->frameContainsPoint(x, y)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003063 return true;
3064 }
3065 }
3066 return false;
3067}
3068
chaviw98318de2021-05-19 16:45:23 -05003069bool InputDispatcher::isWindowObscuredLocked(const sp<WindowInfoHandle>& windowHandle) const {
Michael Wrightcdcd8f22016-03-22 16:52:13 -07003070 int32_t displayId = windowHandle->getInfo()->displayId;
chaviw98318de2021-05-19 16:45:23 -05003071 const std::vector<sp<WindowInfoHandle>>& windowHandles = getWindowHandlesLocked(displayId);
3072 const WindowInfo* windowInfo = windowHandle->getInfo();
3073 for (const sp<WindowInfoHandle>& otherHandle : windowHandles) {
Robert Carrc9bf1d32020-04-13 17:21:08 -07003074 if (windowHandle == otherHandle) {
3075 break; // All future windows are below us. Exit early.
Michael Wrightcdcd8f22016-03-22 16:52:13 -07003076 }
chaviw98318de2021-05-19 16:45:23 -05003077 const WindowInfo* otherInfo = otherHandle->getInfo();
Robert Carrc9bf1d32020-04-13 17:21:08 -07003078 if (canBeObscuredBy(windowHandle, otherHandle) &&
minchelif28cc4e2020-03-19 11:18:11 +08003079 otherInfo->overlaps(windowInfo)) {
Michael Wrightcdcd8f22016-03-22 16:52:13 -07003080 return true;
3081 }
3082 }
3083 return false;
3084}
3085
Siarhei Vishniakou61291d42019-02-11 18:13:20 -08003086std::string InputDispatcher::getApplicationWindowLabel(
chaviw98318de2021-05-19 16:45:23 -05003087 const InputApplicationHandle* applicationHandle, const sp<WindowInfoHandle>& windowHandle) {
Yi Kong9b14ac62018-07-17 13:48:38 -07003088 if (applicationHandle != nullptr) {
3089 if (windowHandle != nullptr) {
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07003090 return applicationHandle->getName() + " - " + windowHandle->getName();
Michael Wrightd02c5b62014-02-10 15:10:22 -08003091 } else {
3092 return applicationHandle->getName();
3093 }
Yi Kong9b14ac62018-07-17 13:48:38 -07003094 } else if (windowHandle != nullptr) {
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07003095 return windowHandle->getInfo()->applicationInfo.name + " - " + windowHandle->getName();
Michael Wrightd02c5b62014-02-10 15:10:22 -08003096 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08003097 return "<unknown application or window>";
Michael Wrightd02c5b62014-02-10 15:10:22 -08003098 }
3099}
3100
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003101void InputDispatcher::pokeUserActivityLocked(const EventEntry& eventEntry) {
Antonio Kantekf16f2832021-09-28 04:39:20 +00003102 if (!isUserActivityEvent(eventEntry)) {
3103 // Not poking user activity if the event type does not represent a user activity
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01003104 return;
3105 }
Tiger Huang721e26f2018-07-24 22:26:19 +08003106 int32_t displayId = getTargetDisplayId(eventEntry);
chaviw98318de2021-05-19 16:45:23 -05003107 sp<WindowInfoHandle> focusedWindowHandle = getFocusedWindowHandleLocked(displayId);
Josep del Riob3981622023-04-18 15:49:45 +00003108 const WindowInfo* windowDisablingUserActivityInfo = nullptr;
Tiger Huang721e26f2018-07-24 22:26:19 +08003109 if (focusedWindowHandle != nullptr) {
chaviw98318de2021-05-19 16:45:23 -05003110 const WindowInfo* info = focusedWindowHandle->getInfo();
Prabir Pradhan51e7db02022-02-07 06:02:57 -08003111 if (info->inputConfig.test(WindowInfo::InputConfig::DISABLE_USER_ACTIVITY)) {
Josep del Riob3981622023-04-18 15:49:45 +00003112 windowDisablingUserActivityInfo = info;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003113 }
3114 }
3115
3116 int32_t eventType = USER_ACTIVITY_EVENT_OTHER;
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003117 switch (eventEntry.type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003118 case EventEntry::Type::MOTION: {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003119 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(eventEntry);
3120 if (motionEntry.action == AMOTION_EVENT_ACTION_CANCEL) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003121 return;
3122 }
Josep del Riob3981622023-04-18 15:49:45 +00003123 if (windowDisablingUserActivityInfo != nullptr) {
3124 if (DEBUG_DISPATCH_CYCLE) {
3125 ALOGD("Not poking user activity: disabled by window '%s'.",
3126 windowDisablingUserActivityInfo->name.c_str());
3127 }
3128 return;
3129 }
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003130 if (MotionEvent::isTouchEvent(motionEntry.source, motionEntry.action)) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003131 eventType = USER_ACTIVITY_EVENT_TOUCH;
3132 }
3133 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003134 }
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003135 case EventEntry::Type::KEY: {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003136 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(eventEntry);
3137 if (keyEntry.flags & AKEY_EVENT_FLAG_CANCELED) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003138 return;
3139 }
Josep del Riob3981622023-04-18 15:49:45 +00003140 // If the key code is unknown, we don't consider it user activity
3141 if (keyEntry.keyCode == AKEYCODE_UNKNOWN) {
3142 return;
3143 }
3144 // Don't inhibit events that were intercepted or are not passed to
3145 // the apps, like system shortcuts
3146 if (windowDisablingUserActivityInfo != nullptr &&
3147 keyEntry.interceptKeyResult != KeyEntry::InterceptKeyResult::SKIP &&
3148 keyEntry.policyFlags & POLICY_FLAG_PASS_TO_USER) {
3149 if (DEBUG_DISPATCH_CYCLE) {
3150 ALOGD("Not poking user activity: disabled by window '%s'.",
3151 windowDisablingUserActivityInfo->name.c_str());
3152 }
3153 return;
3154 }
3155
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003156 eventType = USER_ACTIVITY_EVENT_BUTTON;
3157 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003158 }
Antonio Kantekf16f2832021-09-28 04:39:20 +00003159 default: {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003160 LOG_ALWAYS_FATAL("%s events are not user activity",
Dominik Laskowski75788452021-02-09 18:51:25 -08003161 ftl::enum_string(eventEntry.type).c_str());
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003162 break;
3163 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003164 }
3165
Prabir Pradhancef936d2021-07-21 16:17:52 +00003166 auto command = [this, eventTime = eventEntry.eventTime, eventType, displayId]()
3167 REQUIRES(mLock) {
3168 scoped_unlock unlock(mLock);
Prabir Pradhana41d2442023-04-20 21:30:40 +00003169 mPolicy.pokeUserActivity(eventTime, eventType, displayId);
Prabir Pradhancef936d2021-07-21 16:17:52 +00003170 };
3171 postCommandLocked(std::move(command));
Michael Wrightd02c5b62014-02-10 15:10:22 -08003172}
3173
3174void InputDispatcher::prepareDispatchCycleLocked(nsecs_t currentTime,
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003175 const std::shared_ptr<Connection>& connection,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003176 std::shared_ptr<EventEntry> eventEntry,
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08003177 const InputTarget& inputTarget) {
Michael Wright3dd60e22019-03-27 22:06:44 +00003178 if (ATRACE_ENABLED()) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003179 std::string message =
Garfield Tanff1f1bb2020-01-28 13:24:04 -08003180 StringPrintf("prepareDispatchCycleLocked(inputChannel=%s, id=0x%" PRIx32 ")",
Garfield Tan6a5a14e2020-01-28 13:24:04 -08003181 connection->getInputChannelName().c_str(), eventEntry->id);
Michael Wright3dd60e22019-03-27 22:06:44 +00003182 ATRACE_NAME(message.c_str());
3183 }
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003184 if (DEBUG_DISPATCH_CYCLE) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003185 ALOGD("channel '%s' ~ prepareDispatchCycle - flags=%s, "
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08003186 "globalScaleFactor=%f, pointerIds=%s %s",
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003187 connection->getInputChannelName().c_str(), inputTarget.flags.string().c_str(),
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08003188 inputTarget.globalScaleFactor, bitsetToString(inputTarget.pointerIds).c_str(),
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003189 inputTarget.getPointerInfoString().c_str());
3190 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003191
3192 // Skip this event if the connection status is not normal.
3193 // We don't want to enqueue additional outbound events if the connection is broken.
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08003194 if (connection->status != Connection::Status::NORMAL) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003195 if (DEBUG_DISPATCH_CYCLE) {
3196 ALOGD("channel '%s' ~ Dropping event because the channel status is %s",
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08003197 connection->getInputChannelName().c_str(),
3198 ftl::enum_string(connection->status).c_str());
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003199 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003200 return;
3201 }
3202
3203 // Split a motion event if needed.
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003204 if (inputTarget.flags.test(InputTarget::Flags::SPLIT)) {
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08003205 LOG_ALWAYS_FATAL_IF(eventEntry->type != EventEntry::Type::MOTION,
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003206 "Entry type %s should not have Flags::SPLIT",
Dominik Laskowski75788452021-02-09 18:51:25 -08003207 ftl::enum_string(eventEntry->type).c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08003208
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003209 const MotionEntry& originalMotionEntry = static_cast<const MotionEntry&>(*eventEntry);
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08003210 if (inputTarget.pointerIds.count() != originalMotionEntry.pointerCount) {
Siarhei Vishniakou16e4fa02023-02-16 17:48:56 -08003211 if (!inputTarget.firstDownTimeInTarget.has_value()) {
3212 logDispatchStateLocked();
3213 LOG(FATAL) << "Splitting motion events requires a down time to be set for the "
3214 "target on connection "
3215 << connection->getInputChannelName() << " for "
3216 << originalMotionEntry.getDescription();
3217 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003218 std::unique_ptr<MotionEntry> splitMotionEntry =
Vaibhav Devmurari882bd9b2022-06-23 14:54:54 +00003219 splitMotionEvent(originalMotionEntry, inputTarget.pointerIds,
3220 inputTarget.firstDownTimeInTarget.value());
Michael Wrightd02c5b62014-02-10 15:10:22 -08003221 if (!splitMotionEntry) {
3222 return; // split event was dropped
3223 }
Arthur Hungb3307ee2021-10-14 10:57:37 +00003224 if (splitMotionEntry->action == AMOTION_EVENT_ACTION_CANCEL) {
3225 std::string reason = std::string("reason=pointer cancel on split window");
3226 android_log_event_list(LOGTAG_INPUT_CANCEL)
3227 << connection->getInputChannelName().c_str() << reason << LOG_ID_EVENTS;
3228 }
Siarhei Vishniakou86587282019-09-09 18:20:15 +01003229 if (DEBUG_FOCUS) {
3230 ALOGD("channel '%s' ~ Split motion event.",
3231 connection->getInputChannelName().c_str());
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003232 logOutboundMotionDetails(" ", *splitMotionEntry);
Siarhei Vishniakou86587282019-09-09 18:20:15 +01003233 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003234 enqueueDispatchEntriesLocked(currentTime, connection, std::move(splitMotionEntry),
3235 inputTarget);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003236 return;
3237 }
3238 }
3239
3240 // Not splitting. Enqueue dispatch entries for the event as is.
3241 enqueueDispatchEntriesLocked(currentTime, connection, eventEntry, inputTarget);
3242}
3243
3244void InputDispatcher::enqueueDispatchEntriesLocked(nsecs_t currentTime,
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003245 const std::shared_ptr<Connection>& connection,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003246 std::shared_ptr<EventEntry> eventEntry,
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08003247 const InputTarget& inputTarget) {
Michael Wright3dd60e22019-03-27 22:06:44 +00003248 if (ATRACE_ENABLED()) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003249 std::string message =
Garfield Tanff1f1bb2020-01-28 13:24:04 -08003250 StringPrintf("enqueueDispatchEntriesLocked(inputChannel=%s, id=0x%" PRIx32 ")",
Garfield Tan6a5a14e2020-01-28 13:24:04 -08003251 connection->getInputChannelName().c_str(), eventEntry->id);
Michael Wright3dd60e22019-03-27 22:06:44 +00003252 ATRACE_NAME(message.c_str());
3253 }
Siarhei Vishniakou5cee1e32022-11-29 12:35:39 -08003254 LOG_ALWAYS_FATAL_IF(!inputTarget.flags.any(InputTarget::DISPATCH_MASK),
3255 "No dispatch flags are set for %s", eventEntry->getDescription().c_str());
Michael Wright3dd60e22019-03-27 22:06:44 +00003256
hongzuo liu95785e22022-09-06 02:51:35 +00003257 const bool wasEmpty = connection->outboundQueue.empty();
Michael Wrightd02c5b62014-02-10 15:10:22 -08003258
3259 // Enqueue dispatch entries for the requested modes.
chaviw8c9cf542019-03-25 13:02:48 -07003260 enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003261 InputTarget::Flags::DISPATCH_AS_HOVER_EXIT);
chaviw8c9cf542019-03-25 13:02:48 -07003262 enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003263 InputTarget::Flags::DISPATCH_AS_OUTSIDE);
chaviw8c9cf542019-03-25 13:02:48 -07003264 enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003265 InputTarget::Flags::DISPATCH_AS_HOVER_ENTER);
chaviw8c9cf542019-03-25 13:02:48 -07003266 enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003267 InputTarget::Flags::DISPATCH_AS_IS);
chaviw8c9cf542019-03-25 13:02:48 -07003268 enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003269 InputTarget::Flags::DISPATCH_AS_SLIPPERY_EXIT);
chaviw8c9cf542019-03-25 13:02:48 -07003270 enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003271 InputTarget::Flags::DISPATCH_AS_SLIPPERY_ENTER);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003272
3273 // If the outbound queue was previously empty, start the dispatch cycle going.
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07003274 if (wasEmpty && !connection->outboundQueue.empty()) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003275 startDispatchCycleLocked(currentTime, connection);
3276 }
3277}
3278
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003279void InputDispatcher::enqueueDispatchEntryLocked(const std::shared_ptr<Connection>& connection,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003280 std::shared_ptr<EventEntry> eventEntry,
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08003281 const InputTarget& inputTarget,
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003282 ftl::Flags<InputTarget::Flags> dispatchMode) {
Michael Wright3dd60e22019-03-27 22:06:44 +00003283 if (ATRACE_ENABLED()) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003284 std::string message = StringPrintf("enqueueDispatchEntry(inputChannel=%s, dispatchMode=%s)",
3285 connection->getInputChannelName().c_str(),
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003286 dispatchMode.string().c_str());
Michael Wright3dd60e22019-03-27 22:06:44 +00003287 ATRACE_NAME(message.c_str());
3288 }
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003289 ftl::Flags<InputTarget::Flags> inputTargetFlags = inputTarget.flags;
3290 if (!inputTargetFlags.any(dispatchMode)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003291 return;
3292 }
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003293
3294 inputTargetFlags.clear(InputTarget::DISPATCH_MASK);
3295 inputTargetFlags |= dispatchMode;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003296
3297 // This is a new event.
3298 // Enqueue a new dispatch entry onto the outbound queue for this connection.
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08003299 std::unique_ptr<DispatchEntry> dispatchEntry =
Chavi Weingarten65f98b82020-01-16 18:56:50 +00003300 createDispatchEntry(inputTarget, eventEntry, inputTargetFlags);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003301
Chavi Weingarten65f98b82020-01-16 18:56:50 +00003302 // Use the eventEntry from dispatchEntry since the entry may have changed and can now be a
3303 // different EventEntry than what was passed in.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003304 EventEntry& newEntry = *(dispatchEntry->eventEntry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003305 // Apply target flags and update the connection's input state.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003306 switch (newEntry.type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003307 case EventEntry::Type::KEY: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003308 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(newEntry);
Garfield Tanff1f1bb2020-01-28 13:24:04 -08003309 dispatchEntry->resolvedEventId = keyEntry.id;
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003310 dispatchEntry->resolvedAction = keyEntry.action;
3311 dispatchEntry->resolvedFlags = keyEntry.flags;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003312
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003313 if (!connection->inputState.trackKey(keyEntry, dispatchEntry->resolvedAction,
3314 dispatchEntry->resolvedFlags)) {
Siarhei Vishniakouc94dafe2023-05-26 10:24:19 -07003315 LOG(WARNING) << "channel " << connection->getInputChannelName()
3316 << "~ dropping inconsistent event: " << *dispatchEntry;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003317 return; // skip the inconsistent event
3318 }
3319 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003320 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003321
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003322 case EventEntry::Type::MOTION: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003323 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(newEntry);
Garfield Tanff1f1bb2020-01-28 13:24:04 -08003324 // Assign a default value to dispatchEntry that will never be generated by InputReader,
3325 // and assign a InputDispatcher value if it doesn't change in the if-else chain below.
3326 constexpr int32_t DEFAULT_RESOLVED_EVENT_ID =
3327 static_cast<int32_t>(IdGenerator::Source::OTHER);
3328 dispatchEntry->resolvedEventId = DEFAULT_RESOLVED_EVENT_ID;
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003329 if (dispatchMode.test(InputTarget::Flags::DISPATCH_AS_OUTSIDE)) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003330 dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_OUTSIDE;
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003331 } else if (dispatchMode.test(InputTarget::Flags::DISPATCH_AS_HOVER_EXIT)) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003332 dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_HOVER_EXIT;
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003333 } else if (dispatchMode.test(InputTarget::Flags::DISPATCH_AS_HOVER_ENTER)) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003334 dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_HOVER_ENTER;
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003335 } else if (dispatchMode.test(InputTarget::Flags::DISPATCH_AS_SLIPPERY_EXIT)) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003336 dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_CANCEL;
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003337 } else if (dispatchMode.test(InputTarget::Flags::DISPATCH_AS_SLIPPERY_ENTER)) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003338 dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_DOWN;
3339 } else {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003340 dispatchEntry->resolvedAction = motionEntry.action;
Garfield Tanff1f1bb2020-01-28 13:24:04 -08003341 dispatchEntry->resolvedEventId = motionEntry.id;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003342 }
3343 if (dispatchEntry->resolvedAction == AMOTION_EVENT_ACTION_HOVER_MOVE &&
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003344 !connection->inputState.isHovering(motionEntry.deviceId, motionEntry.source,
3345 motionEntry.displayId)) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003346 if (DEBUG_DISPATCH_CYCLE) {
3347 ALOGD("channel '%s' ~ enqueueDispatchEntryLocked: filling in missing hover "
3348 "enter event",
3349 connection->getInputChannelName().c_str());
3350 }
Siarhei Vishniakouf2652122021-03-05 21:39:46 +00003351 // We keep the 'resolvedEventId' here equal to the original 'motionEntry.id' because
3352 // this is a one-to-one event conversion.
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003353 dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_HOVER_ENTER;
3354 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003355
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003356 dispatchEntry->resolvedFlags = motionEntry.flags;
Siarhei Vishniakou1ae72f12023-01-29 12:55:30 -08003357 if (dispatchEntry->resolvedAction == AMOTION_EVENT_ACTION_CANCEL) {
3358 dispatchEntry->resolvedFlags |= AMOTION_EVENT_FLAG_CANCELED;
3359 }
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003360 if (dispatchEntry->targetFlags.test(InputTarget::Flags::WINDOW_IS_OBSCURED)) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003361 dispatchEntry->resolvedFlags |= AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED;
3362 }
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003363 if (dispatchEntry->targetFlags.test(InputTarget::Flags::WINDOW_IS_PARTIALLY_OBSCURED)) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003364 dispatchEntry->resolvedFlags |= AMOTION_EVENT_FLAG_WINDOW_IS_PARTIALLY_OBSCURED;
3365 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003366
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003367 if (!connection->inputState.trackMotion(motionEntry, dispatchEntry->resolvedAction,
3368 dispatchEntry->resolvedFlags)) {
Siarhei Vishniakouc94dafe2023-05-26 10:24:19 -07003369 LOG(WARNING) << "channel " << connection->getInputChannelName()
3370 << "~ dropping inconsistent event: " << *dispatchEntry;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003371 return; // skip the inconsistent event
3372 }
3373
Garfield Tanff1f1bb2020-01-28 13:24:04 -08003374 dispatchEntry->resolvedEventId =
3375 dispatchEntry->resolvedEventId == DEFAULT_RESOLVED_EVENT_ID
3376 ? mIdGenerator.nextId()
3377 : motionEntry.id;
3378 if (ATRACE_ENABLED() && dispatchEntry->resolvedEventId != motionEntry.id) {
3379 std::string message = StringPrintf("Transmute MotionEvent(id=0x%" PRIx32
3380 ") to MotionEvent(id=0x%" PRIx32 ").",
3381 motionEntry.id, dispatchEntry->resolvedEventId);
3382 ATRACE_NAME(message.c_str());
3383 }
3384
Prabir Pradhan47cf0a02021-03-11 20:30:57 -08003385 if ((motionEntry.flags & AMOTION_EVENT_FLAG_NO_FOCUS_CHANGE) &&
3386 (motionEntry.policyFlags & POLICY_FLAG_TRUSTED)) {
3387 // Skip reporting pointer down outside focus to the policy.
3388 break;
3389 }
3390
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003391 dispatchPointerDownOutsideFocus(motionEntry.source, dispatchEntry->resolvedAction,
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08003392 inputTarget.inputChannel->getConnectionToken());
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003393
3394 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003395 }
Prabir Pradhan99987712020-11-10 18:43:05 -08003396 case EventEntry::Type::FOCUS:
Antonio Kantek7242d8b2021-08-05 16:07:20 -07003397 case EventEntry::Type::TOUCH_MODE_CHANGED:
arthurhungb89ccb02020-12-30 16:19:01 +08003398 case EventEntry::Type::POINTER_CAPTURE_CHANGED:
3399 case EventEntry::Type::DRAG: {
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01003400 break;
3401 }
Chris Yef59a2f42020-10-16 12:55:26 -07003402 case EventEntry::Type::SENSOR: {
3403 LOG_ALWAYS_FATAL("SENSOR events should not go to apps via input channel");
3404 break;
3405 }
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003406 case EventEntry::Type::CONFIGURATION_CHANGED:
3407 case EventEntry::Type::DEVICE_RESET: {
3408 LOG_ALWAYS_FATAL("%s events should not go to apps",
Dominik Laskowski75788452021-02-09 18:51:25 -08003409 ftl::enum_string(newEntry.type).c_str());
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003410 break;
3411 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003412 }
3413
3414 // Remember that we are waiting for this dispatch to complete.
3415 if (dispatchEntry->hasForegroundTarget()) {
Chavi Weingarten65f98b82020-01-16 18:56:50 +00003416 incrementPendingForegroundDispatches(newEntry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003417 }
3418
3419 // Enqueue the dispatch entry.
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08003420 connection->outboundQueue.push_back(dispatchEntry.release());
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00003421 traceOutboundQueueLength(*connection);
chaviw8c9cf542019-03-25 13:02:48 -07003422}
3423
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003424/**
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00003425 * This function is for debugging and metrics collection. It has two roles.
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003426 *
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00003427 * The first role is to log input interaction with windows, which helps determine what the user was
3428 * interacting with. For example, if user is touching launcher, we will see an input_interaction log
3429 * that user started interacting with launcher window, as well as any other window that received
3430 * that gesture, such as the wallpaper or other spy windows. A new input_interaction is only logged
3431 * when the set of tokens that received the event changes. It is not logged again as long as the
3432 * user is interacting with the same windows.
3433 *
3434 * The second role is to track input device activity for metrics collection. For each input event,
3435 * we report the set of UIDs that the input device interacted with to the policy. Unlike for the
3436 * input_interaction logs, the device interaction is reported even when the set of interaction
3437 * tokens do not change.
3438 *
3439 * For these purposes, we do not count ACTION_OUTSIDE, ACTION_UP and ACTION_CANCEL actions as
3440 * interaction. This includes up and cancel events for both keys and motions.
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003441 */
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00003442void InputDispatcher::processInteractionsLocked(const EventEntry& entry,
3443 const std::vector<InputTarget>& targets) {
3444 int32_t deviceId;
3445 nsecs_t eventTime;
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003446 // Skip ACTION_UP events, and all events other than keys and motions
3447 if (entry.type == EventEntry::Type::KEY) {
3448 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(entry);
3449 if (keyEntry.action == AKEY_EVENT_ACTION_UP) {
3450 return;
3451 }
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00003452 deviceId = keyEntry.deviceId;
3453 eventTime = keyEntry.eventTime;
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003454 } else if (entry.type == EventEntry::Type::MOTION) {
3455 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(entry);
3456 if (motionEntry.action == AMOTION_EVENT_ACTION_UP ||
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00003457 motionEntry.action == AMOTION_EVENT_ACTION_CANCEL ||
3458 MotionEvent::getActionMasked(motionEntry.action) == AMOTION_EVENT_ACTION_POINTER_UP) {
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003459 return;
3460 }
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00003461 deviceId = motionEntry.deviceId;
3462 eventTime = motionEntry.eventTime;
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003463 } else {
3464 return; // Not a key or a motion
3465 }
3466
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00003467 std::set<gui::Uid> interactionUids;
Prabir Pradhan6a9a8312021-04-23 11:59:31 -07003468 std::unordered_set<sp<IBinder>, StrongPointerHash<IBinder>> newConnectionTokens;
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003469 std::vector<std::shared_ptr<Connection>> newConnections;
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003470 for (const InputTarget& target : targets) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003471 if (target.flags.test(InputTarget::Flags::DISPATCH_AS_OUTSIDE)) {
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003472 continue; // Skip windows that receive ACTION_OUTSIDE
3473 }
3474
3475 sp<IBinder> token = target.inputChannel->getConnectionToken();
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003476 std::shared_ptr<Connection> connection = getConnectionLocked(token);
Siarhei Vishniakoud706a282021-02-13 00:08:48 +00003477 if (connection == nullptr) {
3478 continue;
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003479 }
3480 newConnectionTokens.insert(std::move(token));
3481 newConnections.emplace_back(connection);
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00003482 if (target.windowHandle) {
3483 interactionUids.emplace(target.windowHandle->getInfo()->ownerUid);
3484 }
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003485 }
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00003486
3487 auto command = [this, deviceId, eventTime, uids = std::move(interactionUids)]()
3488 REQUIRES(mLock) {
3489 scoped_unlock unlock(mLock);
3490 mPolicy.notifyDeviceInteraction(deviceId, eventTime, uids);
3491 };
3492 postCommandLocked(std::move(command));
3493
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003494 if (newConnectionTokens == mInteractionConnectionTokens) {
3495 return; // no change
3496 }
3497 mInteractionConnectionTokens = newConnectionTokens;
3498
Siarhei Vishniakoud706a282021-02-13 00:08:48 +00003499 std::string targetList;
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003500 for (const std::shared_ptr<Connection>& connection : newConnections) {
Siarhei Vishniakoud706a282021-02-13 00:08:48 +00003501 targetList += connection->getWindowName() + ", ";
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003502 }
Siarhei Vishniakoud706a282021-02-13 00:08:48 +00003503 std::string message = "Interaction with: " + targetList;
3504 if (targetList.empty()) {
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003505 message += "<none>";
3506 }
3507 android_log_event_list(LOGTAG_INPUT_INTERACTION) << message << LOG_ID_EVENTS;
3508}
3509
chaviwfd6d3512019-03-25 13:23:49 -07003510void InputDispatcher::dispatchPointerDownOutsideFocus(uint32_t source, int32_t action,
Vishnu Nairad321cd2020-08-20 16:40:21 -07003511 const sp<IBinder>& token) {
chaviw8c9cf542019-03-25 13:02:48 -07003512 int32_t maskedAction = action & AMOTION_EVENT_ACTION_MASK;
chaviwfd6d3512019-03-25 13:23:49 -07003513 uint32_t maskedSource = source & AINPUT_SOURCE_CLASS_MASK;
3514 if (maskedSource != AINPUT_SOURCE_CLASS_POINTER || maskedAction != AMOTION_EVENT_ACTION_DOWN) {
chaviw8c9cf542019-03-25 13:02:48 -07003515 return;
3516 }
3517
Vishnu Nairc519ff72021-01-21 08:23:08 -08003518 sp<IBinder> focusedToken = mFocusResolver.getFocusedWindowToken(mFocusedDisplayId);
Vishnu Nairad321cd2020-08-20 16:40:21 -07003519 if (focusedToken == token) {
3520 // ignore since token is focused
chaviw8c9cf542019-03-25 13:02:48 -07003521 return;
3522 }
3523
Prabir Pradhancef936d2021-07-21 16:17:52 +00003524 auto command = [this, token]() REQUIRES(mLock) {
3525 scoped_unlock unlock(mLock);
Prabir Pradhana41d2442023-04-20 21:30:40 +00003526 mPolicy.onPointerDownOutsideFocus(token);
Prabir Pradhancef936d2021-07-21 16:17:52 +00003527 };
3528 postCommandLocked(std::move(command));
Michael Wrightd02c5b62014-02-10 15:10:22 -08003529}
3530
Siarhei Vishniakoucce7e112022-10-25 13:31:17 -07003531status_t InputDispatcher::publishMotionEvent(Connection& connection,
3532 DispatchEntry& dispatchEntry) const {
3533 const EventEntry& eventEntry = *(dispatchEntry.eventEntry);
3534 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(eventEntry);
3535
3536 PointerCoords scaledCoords[MAX_POINTERS];
3537 const PointerCoords* usingCoords = motionEntry.pointerCoords;
3538
3539 // Set the X and Y offset and X and Y scale depending on the input source.
3540 if ((motionEntry.source & AINPUT_SOURCE_CLASS_POINTER) &&
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003541 !(dispatchEntry.targetFlags.test(InputTarget::Flags::ZERO_COORDS))) {
Siarhei Vishniakoucce7e112022-10-25 13:31:17 -07003542 float globalScaleFactor = dispatchEntry.globalScaleFactor;
3543 if (globalScaleFactor != 1.0f) {
3544 for (uint32_t i = 0; i < motionEntry.pointerCount; i++) {
3545 scaledCoords[i] = motionEntry.pointerCoords[i];
3546 // Don't apply window scale here since we don't want scale to affect raw
3547 // coordinates. The scale will be sent back to the client and applied
3548 // later when requesting relative coordinates.
Harry Cutts33476232023-01-30 19:57:29 +00003549 scaledCoords[i].scale(globalScaleFactor, /*windowXScale=*/1, /*windowYScale=*/1);
Siarhei Vishniakoucce7e112022-10-25 13:31:17 -07003550 }
3551 usingCoords = scaledCoords;
3552 }
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003553 } else if (dispatchEntry.targetFlags.test(InputTarget::Flags::ZERO_COORDS)) {
Siarhei Vishniakoucce7e112022-10-25 13:31:17 -07003554 // We don't want the dispatch target to know the coordinates
3555 for (uint32_t i = 0; i < motionEntry.pointerCount; i++) {
3556 scaledCoords[i].clear();
3557 }
3558 usingCoords = scaledCoords;
3559 }
3560
3561 std::array<uint8_t, 32> hmac = getSignature(motionEntry, dispatchEntry);
3562
3563 // Publish the motion event.
3564 return connection.inputPublisher
3565 .publishMotionEvent(dispatchEntry.seq, dispatchEntry.resolvedEventId,
3566 motionEntry.deviceId, motionEntry.source, motionEntry.displayId,
3567 std::move(hmac), dispatchEntry.resolvedAction,
3568 motionEntry.actionButton, dispatchEntry.resolvedFlags,
3569 motionEntry.edgeFlags, motionEntry.metaState,
3570 motionEntry.buttonState, motionEntry.classification,
3571 dispatchEntry.transform, motionEntry.xPrecision,
3572 motionEntry.yPrecision, motionEntry.xCursorPosition,
3573 motionEntry.yCursorPosition, dispatchEntry.rawTransform,
3574 motionEntry.downTime, motionEntry.eventTime,
3575 motionEntry.pointerCount, motionEntry.pointerProperties,
3576 usingCoords);
3577}
3578
Michael Wrightd02c5b62014-02-10 15:10:22 -08003579void InputDispatcher::startDispatchCycleLocked(nsecs_t currentTime,
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003580 const std::shared_ptr<Connection>& connection) {
Michael Wright3dd60e22019-03-27 22:06:44 +00003581 if (ATRACE_ENABLED()) {
3582 std::string message = StringPrintf("startDispatchCycleLocked(inputChannel=%s)",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003583 connection->getInputChannelName().c_str());
Michael Wright3dd60e22019-03-27 22:06:44 +00003584 ATRACE_NAME(message.c_str());
3585 }
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003586 if (DEBUG_DISPATCH_CYCLE) {
3587 ALOGD("channel '%s' ~ startDispatchCycle", connection->getInputChannelName().c_str());
3588 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003589
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08003590 while (connection->status == Connection::Status::NORMAL && !connection->outboundQueue.empty()) {
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07003591 DispatchEntry* dispatchEntry = connection->outboundQueue.front();
Michael Wrightd02c5b62014-02-10 15:10:22 -08003592 dispatchEntry->deliveryTime = currentTime;
Prabir Pradhan1376fcd2022-01-21 09:56:35 -08003593 const std::chrono::nanoseconds timeout = getDispatchingTimeoutLocked(connection);
Siarhei Vishniakou70622952020-07-30 11:17:23 -05003594 dispatchEntry->timeoutTime = currentTime + timeout.count();
Michael Wrightd02c5b62014-02-10 15:10:22 -08003595
3596 // Publish the event.
3597 status_t status;
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003598 const EventEntry& eventEntry = *(dispatchEntry->eventEntry);
3599 switch (eventEntry.type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003600 case EventEntry::Type::KEY: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003601 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(eventEntry);
3602 std::array<uint8_t, 32> hmac = getSignature(keyEntry, *dispatchEntry);
Siarhei Vishniakoud010b012023-01-18 15:00:53 -08003603 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
3604 LOG(DEBUG) << "Publishing " << *dispatchEntry << " to "
3605 << connection->getInputChannelName();
3606 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003607
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003608 // Publish the key event.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003609 status = connection->inputPublisher
3610 .publishKeyEvent(dispatchEntry->seq,
3611 dispatchEntry->resolvedEventId, keyEntry.deviceId,
3612 keyEntry.source, keyEntry.displayId,
3613 std::move(hmac), dispatchEntry->resolvedAction,
3614 dispatchEntry->resolvedFlags, keyEntry.keyCode,
3615 keyEntry.scanCode, keyEntry.metaState,
3616 keyEntry.repeatCount, keyEntry.downTime,
3617 keyEntry.eventTime);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003618 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003619 }
3620
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003621 case EventEntry::Type::MOTION: {
Siarhei Vishniakoud010b012023-01-18 15:00:53 -08003622 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
3623 LOG(DEBUG) << "Publishing " << *dispatchEntry << " to "
3624 << connection->getInputChannelName();
3625 }
Siarhei Vishniakoucce7e112022-10-25 13:31:17 -07003626 status = publishMotionEvent(*connection, *dispatchEntry);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003627 break;
3628 }
Prabir Pradhan99987712020-11-10 18:43:05 -08003629
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01003630 case EventEntry::Type::FOCUS: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003631 const FocusEntry& focusEntry = static_cast<const FocusEntry&>(eventEntry);
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01003632 status = connection->inputPublisher.publishFocusEvent(dispatchEntry->seq,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003633 focusEntry.id,
Antonio Kantek3cfec7b2021-11-05 18:26:17 -07003634 focusEntry.hasFocus);
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01003635 break;
3636 }
3637
Antonio Kantek7242d8b2021-08-05 16:07:20 -07003638 case EventEntry::Type::TOUCH_MODE_CHANGED: {
3639 const TouchModeEntry& touchModeEntry =
3640 static_cast<const TouchModeEntry&>(eventEntry);
3641 status = connection->inputPublisher
3642 .publishTouchModeEvent(dispatchEntry->seq, touchModeEntry.id,
3643 touchModeEntry.inTouchMode);
3644
3645 break;
3646 }
3647
Prabir Pradhan99987712020-11-10 18:43:05 -08003648 case EventEntry::Type::POINTER_CAPTURE_CHANGED: {
3649 const auto& captureEntry =
3650 static_cast<const PointerCaptureChangedEntry&>(eventEntry);
3651 status = connection->inputPublisher
3652 .publishCaptureEvent(dispatchEntry->seq, captureEntry.id,
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00003653 captureEntry.pointerCaptureRequest.enable);
Prabir Pradhan99987712020-11-10 18:43:05 -08003654 break;
3655 }
3656
arthurhungb89ccb02020-12-30 16:19:01 +08003657 case EventEntry::Type::DRAG: {
3658 const DragEntry& dragEntry = static_cast<const DragEntry&>(eventEntry);
3659 status = connection->inputPublisher.publishDragEvent(dispatchEntry->seq,
3660 dragEntry.id, dragEntry.x,
3661 dragEntry.y,
3662 dragEntry.isExiting);
3663 break;
3664 }
3665
Siarhei Vishniakou3b37f9a2019-11-23 13:42:41 -08003666 case EventEntry::Type::CONFIGURATION_CHANGED:
Chris Yef59a2f42020-10-16 12:55:26 -07003667 case EventEntry::Type::DEVICE_RESET:
3668 case EventEntry::Type::SENSOR: {
Siarhei Vishniakou3b37f9a2019-11-23 13:42:41 -08003669 LOG_ALWAYS_FATAL("Should never start dispatch cycles for %s events",
Dominik Laskowski75788452021-02-09 18:51:25 -08003670 ftl::enum_string(eventEntry.type).c_str());
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003671 return;
Siarhei Vishniakou3b37f9a2019-11-23 13:42:41 -08003672 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003673 }
3674
3675 // Check the result.
3676 if (status) {
3677 if (status == WOULD_BLOCK) {
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07003678 if (connection->waitQueue.empty()) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003679 ALOGE("channel '%s' ~ Could not publish event because the pipe is full. "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003680 "This is unexpected because the wait queue is empty, so the pipe "
3681 "should be empty and we shouldn't have any problems writing an "
Siarhei Vishniakou09b02ac2021-04-14 22:24:04 +00003682 "event to it, status=%s(%d)",
3683 connection->getInputChannelName().c_str(), statusToString(status).c_str(),
3684 status);
Harry Cutts33476232023-01-30 19:57:29 +00003685 abortBrokenDispatchCycleLocked(currentTime, connection, /*notify=*/true);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003686 } else {
3687 // Pipe is full and we are waiting for the app to finish process some events
3688 // before sending more events to it.
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003689 if (DEBUG_DISPATCH_CYCLE) {
3690 ALOGD("channel '%s' ~ Could not publish event because the pipe is full, "
3691 "waiting for the application to catch up",
3692 connection->getInputChannelName().c_str());
3693 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003694 }
3695 } else {
3696 ALOGE("channel '%s' ~ Could not publish event due to an unexpected error, "
Siarhei Vishniakou09b02ac2021-04-14 22:24:04 +00003697 "status=%s(%d)",
3698 connection->getInputChannelName().c_str(), statusToString(status).c_str(),
3699 status);
Harry Cutts33476232023-01-30 19:57:29 +00003700 abortBrokenDispatchCycleLocked(currentTime, connection, /*notify=*/true);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003701 }
3702 return;
3703 }
3704
3705 // Re-enqueue the event on the wait queue.
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07003706 connection->outboundQueue.erase(std::remove(connection->outboundQueue.begin(),
3707 connection->outboundQueue.end(),
3708 dispatchEntry));
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00003709 traceOutboundQueueLength(*connection);
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07003710 connection->waitQueue.push_back(dispatchEntry);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003711 if (connection->responsive) {
3712 mAnrTracker.insert(dispatchEntry->timeoutTime,
3713 connection->inputChannel->getConnectionToken());
3714 }
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00003715 traceWaitQueueLength(*connection);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003716 }
3717}
3718
chaviw09c8d2d2020-08-24 15:48:26 -07003719std::array<uint8_t, 32> InputDispatcher::sign(const VerifiedInputEvent& event) const {
3720 size_t size;
3721 switch (event.type) {
3722 case VerifiedInputEvent::Type::KEY: {
3723 size = sizeof(VerifiedKeyEvent);
3724 break;
3725 }
3726 case VerifiedInputEvent::Type::MOTION: {
3727 size = sizeof(VerifiedMotionEvent);
3728 break;
3729 }
3730 }
3731 const uint8_t* start = reinterpret_cast<const uint8_t*>(&event);
3732 return mHmacKeyManager.sign(start, size);
3733}
3734
Edgar Arriagac6ae4bb2020-04-16 18:46:48 -07003735const std::array<uint8_t, 32> InputDispatcher::getSignature(
3736 const MotionEntry& motionEntry, const DispatchEntry& dispatchEntry) const {
Siarhei Vishniakoubf880522023-05-01 11:03:22 -07003737 const int32_t actionMasked = MotionEvent::getActionMasked(dispatchEntry.resolvedAction);
Prabir Pradhanb5cb9572021-09-24 06:35:16 -07003738 if (actionMasked != AMOTION_EVENT_ACTION_UP && actionMasked != AMOTION_EVENT_ACTION_DOWN) {
Edgar Arriagac6ae4bb2020-04-16 18:46:48 -07003739 // Only sign events up and down events as the purely move events
3740 // are tied to their up/down counterparts so signing would be redundant.
Prabir Pradhanb5cb9572021-09-24 06:35:16 -07003741 return INVALID_HMAC;
Edgar Arriagac6ae4bb2020-04-16 18:46:48 -07003742 }
Prabir Pradhanb5cb9572021-09-24 06:35:16 -07003743
3744 VerifiedMotionEvent verifiedEvent =
3745 verifiedMotionEventFromMotionEntry(motionEntry, dispatchEntry.rawTransform);
3746 verifiedEvent.actionMasked = actionMasked;
3747 verifiedEvent.flags = dispatchEntry.resolvedFlags & VERIFIED_MOTION_EVENT_FLAGS;
3748 return sign(verifiedEvent);
Edgar Arriagac6ae4bb2020-04-16 18:46:48 -07003749}
3750
3751const std::array<uint8_t, 32> InputDispatcher::getSignature(
3752 const KeyEntry& keyEntry, const DispatchEntry& dispatchEntry) const {
3753 VerifiedKeyEvent verifiedEvent = verifiedKeyEventFromKeyEntry(keyEntry);
3754 verifiedEvent.flags = dispatchEntry.resolvedFlags & VERIFIED_KEY_EVENT_FLAGS;
3755 verifiedEvent.action = dispatchEntry.resolvedAction;
chaviw09c8d2d2020-08-24 15:48:26 -07003756 return sign(verifiedEvent);
Edgar Arriagac6ae4bb2020-04-16 18:46:48 -07003757}
3758
Michael Wrightd02c5b62014-02-10 15:10:22 -08003759void InputDispatcher::finishDispatchCycleLocked(nsecs_t currentTime,
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003760 const std::shared_ptr<Connection>& connection,
3761 uint32_t seq, bool handled, nsecs_t consumeTime) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003762 if (DEBUG_DISPATCH_CYCLE) {
3763 ALOGD("channel '%s' ~ finishDispatchCycle - seq=%u, handled=%s",
3764 connection->getInputChannelName().c_str(), seq, toString(handled));
3765 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003766
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08003767 if (connection->status == Connection::Status::BROKEN ||
3768 connection->status == Connection::Status::ZOMBIE) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003769 return;
3770 }
3771
3772 // Notify other system components and prepare to start the next dispatch cycle.
Prabir Pradhancef936d2021-07-21 16:17:52 +00003773 auto command = [this, currentTime, connection, seq, handled, consumeTime]() REQUIRES(mLock) {
3774 doDispatchCycleFinishedCommand(currentTime, connection, seq, handled, consumeTime);
3775 };
3776 postCommandLocked(std::move(command));
Michael Wrightd02c5b62014-02-10 15:10:22 -08003777}
3778
3779void InputDispatcher::abortBrokenDispatchCycleLocked(nsecs_t currentTime,
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003780 const std::shared_ptr<Connection>& connection,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003781 bool notify) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003782 if (DEBUG_DISPATCH_CYCLE) {
Siarhei Vishniakou63b63612023-04-12 11:00:23 -07003783 LOG(DEBUG) << "channel '" << connection->getInputChannelName() << "'~ " << __func__
3784 << " - notify=" << toString(notify);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003785 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003786
3787 // Clear the dispatch queues.
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07003788 drainDispatchQueue(connection->outboundQueue);
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00003789 traceOutboundQueueLength(*connection);
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07003790 drainDispatchQueue(connection->waitQueue);
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00003791 traceWaitQueueLength(*connection);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003792
3793 // The connection appears to be unrecoverably broken.
3794 // Ignore already broken or zombie connections.
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08003795 if (connection->status == Connection::Status::NORMAL) {
3796 connection->status = Connection::Status::BROKEN;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003797
3798 if (notify) {
3799 // Notify other system components.
Prabir Pradhancef936d2021-07-21 16:17:52 +00003800 ALOGE("channel '%s' ~ Channel is unrecoverably broken and will be disposed!",
3801 connection->getInputChannelName().c_str());
3802
3803 auto command = [this, connection]() REQUIRES(mLock) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00003804 scoped_unlock unlock(mLock);
Prabir Pradhana41d2442023-04-20 21:30:40 +00003805 mPolicy.notifyInputChannelBroken(connection->inputChannel->getConnectionToken());
Prabir Pradhancef936d2021-07-21 16:17:52 +00003806 };
3807 postCommandLocked(std::move(command));
Michael Wrightd02c5b62014-02-10 15:10:22 -08003808 }
3809 }
3810}
3811
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07003812void InputDispatcher::drainDispatchQueue(std::deque<DispatchEntry*>& queue) {
3813 while (!queue.empty()) {
3814 DispatchEntry* dispatchEntry = queue.front();
3815 queue.pop_front();
Siarhei Vishniakou62683e82019-03-06 17:59:56 -08003816 releaseDispatchEntry(dispatchEntry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003817 }
3818}
3819
Siarhei Vishniakou62683e82019-03-06 17:59:56 -08003820void InputDispatcher::releaseDispatchEntry(DispatchEntry* dispatchEntry) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003821 if (dispatchEntry->hasForegroundTarget()) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003822 decrementPendingForegroundDispatches(*(dispatchEntry->eventEntry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08003823 }
3824 delete dispatchEntry;
3825}
3826
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00003827int InputDispatcher::handleReceiveCallback(int events, sp<IBinder> connectionToken) {
3828 std::scoped_lock _l(mLock);
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003829 std::shared_ptr<Connection> connection = getConnectionLocked(connectionToken);
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00003830 if (connection == nullptr) {
3831 ALOGW("Received looper callback for unknown input channel token %p. events=0x%x",
3832 connectionToken.get(), events);
3833 return 0; // remove the callback
3834 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003835
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00003836 bool notify;
3837 if (!(events & (ALOOPER_EVENT_ERROR | ALOOPER_EVENT_HANGUP))) {
3838 if (!(events & ALOOPER_EVENT_INPUT)) {
3839 ALOGW("channel '%s' ~ Received spurious callback for unhandled poll event. "
3840 "events=0x%x",
3841 connection->getInputChannelName().c_str(), events);
3842 return 1;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003843 }
3844
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00003845 nsecs_t currentTime = now();
3846 bool gotOne = false;
3847 status_t status = OK;
3848 for (;;) {
3849 Result<InputPublisher::ConsumerResponse> result =
3850 connection->inputPublisher.receiveConsumerResponse();
3851 if (!result.ok()) {
3852 status = result.error().code();
3853 break;
3854 }
3855
3856 if (std::holds_alternative<InputPublisher::Finished>(*result)) {
3857 const InputPublisher::Finished& finish =
3858 std::get<InputPublisher::Finished>(*result);
3859 finishDispatchCycleLocked(currentTime, connection, finish.seq, finish.handled,
3860 finish.consumeTime);
3861 } else if (std::holds_alternative<InputPublisher::Timeline>(*result)) {
Siarhei Vishniakouf2652122021-03-05 21:39:46 +00003862 if (shouldReportMetricsForConnection(*connection)) {
3863 const InputPublisher::Timeline& timeline =
3864 std::get<InputPublisher::Timeline>(*result);
3865 mLatencyTracker
3866 .trackGraphicsLatency(timeline.inputEventId,
3867 connection->inputChannel->getConnectionToken(),
3868 std::move(timeline.graphicsTimeline));
3869 }
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00003870 }
3871 gotOne = true;
3872 }
3873 if (gotOne) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00003874 runCommandsLockedInterruptable();
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00003875 if (status == WOULD_BLOCK) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003876 return 1;
3877 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003878 }
3879
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00003880 notify = status != DEAD_OBJECT || !connection->monitor;
3881 if (notify) {
3882 ALOGE("channel '%s' ~ Failed to receive finished signal. status=%s(%d)",
3883 connection->getInputChannelName().c_str(), statusToString(status).c_str(),
3884 status);
3885 }
3886 } else {
3887 // Monitor channels are never explicitly unregistered.
3888 // We do it automatically when the remote endpoint is closed so don't warn about them.
3889 const bool stillHaveWindowHandle =
3890 getWindowHandleLocked(connection->inputChannel->getConnectionToken()) != nullptr;
3891 notify = !connection->monitor && stillHaveWindowHandle;
3892 if (notify) {
3893 ALOGW("channel '%s' ~ Consumer closed input channel or an error occurred. events=0x%x",
3894 connection->getInputChannelName().c_str(), events);
3895 }
3896 }
3897
3898 // Remove the channel.
3899 removeInputChannelLocked(connection->inputChannel->getConnectionToken(), notify);
3900 return 0; // remove the callback
Michael Wrightd02c5b62014-02-10 15:10:22 -08003901}
3902
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003903void InputDispatcher::synthesizeCancelationEventsForAllConnectionsLocked(
Michael Wrightd02c5b62014-02-10 15:10:22 -08003904 const CancelationOptions& options) {
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00003905 for (const auto& [token, connection] : mConnectionsByToken) {
Siarhei Vishniakou2e2ea992020-12-15 02:57:19 +00003906 synthesizeCancelationEventsForConnectionLocked(connection, options);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003907 }
3908}
3909
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003910void InputDispatcher::synthesizeCancelationEventsForMonitorsLocked(
Michael Wrightfa13dcf2015-06-12 13:25:11 +01003911 const CancelationOptions& options) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08003912 for (const auto& [_, monitors] : mGlobalMonitorsByDisplay) {
Michael Wright3dd60e22019-03-27 22:06:44 +00003913 for (const Monitor& monitor : monitors) {
3914 synthesizeCancelationEventsForInputChannelLocked(monitor.inputChannel, options);
Arthur Hung2fbf37f2018-09-13 18:16:41 +08003915 }
Michael Wrightfa13dcf2015-06-12 13:25:11 +01003916 }
3917}
3918
Michael Wrightd02c5b62014-02-10 15:10:22 -08003919void InputDispatcher::synthesizeCancelationEventsForInputChannelLocked(
Siarhei Vishniakouce5ab082020-07-09 17:03:21 -05003920 const std::shared_ptr<InputChannel>& channel, const CancelationOptions& options) {
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003921 std::shared_ptr<Connection> connection = getConnectionLocked(channel->getConnectionToken());
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07003922 if (connection == nullptr) {
3923 return;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003924 }
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07003925
3926 synthesizeCancelationEventsForConnectionLocked(connection, options);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003927}
3928
3929void InputDispatcher::synthesizeCancelationEventsForConnectionLocked(
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003930 const std::shared_ptr<Connection>& connection, const CancelationOptions& options) {
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08003931 if (connection->status == Connection::Status::BROKEN) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003932 return;
3933 }
3934
3935 nsecs_t currentTime = now();
3936
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003937 std::vector<std::unique_ptr<EventEntry>> cancelationEvents =
Siarhei Vishniakou00fca7c2019-10-29 13:05:57 -07003938 connection->inputState.synthesizeCancelationEvents(currentTime, options);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003939
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08003940 if (cancelationEvents.empty()) {
3941 return;
3942 }
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003943 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
3944 ALOGD("channel '%s' ~ Synthesized %zu cancelation events to bring channel back in sync "
Siarhei Vishniakou2e3e4432023-02-09 18:34:11 -08003945 "with reality: %s, mode=%s.",
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003946 connection->getInputChannelName().c_str(), cancelationEvents.size(), options.reason,
Siarhei Vishniakou2e3e4432023-02-09 18:34:11 -08003947 ftl::enum_string(options.mode).c_str());
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003948 }
Svet Ganov5d3bc372020-01-26 23:11:07 -08003949
Arthur Hungb3307ee2021-10-14 10:57:37 +00003950 std::string reason = std::string("reason=").append(options.reason);
3951 android_log_event_list(LOGTAG_INPUT_CANCEL)
3952 << connection->getInputChannelName().c_str() << reason << LOG_ID_EVENTS;
3953
Svet Ganov5d3bc372020-01-26 23:11:07 -08003954 InputTarget target;
chaviw98318de2021-05-19 16:45:23 -05003955 sp<WindowInfoHandle> windowHandle =
Svet Ganov5d3bc372020-01-26 23:11:07 -08003956 getWindowHandleLocked(connection->inputChannel->getConnectionToken());
3957 if (windowHandle != nullptr) {
chaviw98318de2021-05-19 16:45:23 -05003958 const WindowInfo* windowInfo = windowHandle->getInfo();
chaviw1ff3d1e2020-07-01 15:53:47 -07003959 target.setDefaultPointerTransform(windowInfo->transform);
Svet Ganov5d3bc372020-01-26 23:11:07 -08003960 target.globalScaleFactor = windowInfo->globalScaleFactor;
3961 }
3962 target.inputChannel = connection->inputChannel;
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003963 target.flags = InputTarget::Flags::DISPATCH_AS_IS;
Svet Ganov5d3bc372020-01-26 23:11:07 -08003964
hongzuo liu95785e22022-09-06 02:51:35 +00003965 const bool wasEmpty = connection->outboundQueue.empty();
3966
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08003967 for (size_t i = 0; i < cancelationEvents.size(); i++) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003968 std::unique_ptr<EventEntry> cancelationEventEntry = std::move(cancelationEvents[i]);
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08003969 switch (cancelationEventEntry->type) {
3970 case EventEntry::Type::KEY: {
3971 logOutboundKeyDetails("cancel - ",
3972 static_cast<const KeyEntry&>(*cancelationEventEntry));
3973 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003974 }
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08003975 case EventEntry::Type::MOTION: {
3976 logOutboundMotionDetails("cancel - ",
3977 static_cast<const MotionEntry&>(*cancelationEventEntry));
3978 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003979 }
Prabir Pradhan99987712020-11-10 18:43:05 -08003980 case EventEntry::Type::FOCUS:
Antonio Kantek7242d8b2021-08-05 16:07:20 -07003981 case EventEntry::Type::TOUCH_MODE_CHANGED:
arthurhungb89ccb02020-12-30 16:19:01 +08003982 case EventEntry::Type::POINTER_CAPTURE_CHANGED:
3983 case EventEntry::Type::DRAG: {
Prabir Pradhan99987712020-11-10 18:43:05 -08003984 LOG_ALWAYS_FATAL("Canceling %s events is not supported",
Dominik Laskowski75788452021-02-09 18:51:25 -08003985 ftl::enum_string(cancelationEventEntry->type).c_str());
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08003986 break;
3987 }
3988 case EventEntry::Type::CONFIGURATION_CHANGED:
Chris Yef59a2f42020-10-16 12:55:26 -07003989 case EventEntry::Type::DEVICE_RESET:
3990 case EventEntry::Type::SENSOR: {
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08003991 LOG_ALWAYS_FATAL("%s event should not be found inside Connections's queue",
Dominik Laskowski75788452021-02-09 18:51:25 -08003992 ftl::enum_string(cancelationEventEntry->type).c_str());
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08003993 break;
3994 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003995 }
3996
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003997 enqueueDispatchEntryLocked(connection, std::move(cancelationEventEntry), target,
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003998 InputTarget::Flags::DISPATCH_AS_IS);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003999 }
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08004000
hongzuo liu95785e22022-09-06 02:51:35 +00004001 // If the outbound queue was previously empty, start the dispatch cycle going.
4002 if (wasEmpty && !connection->outboundQueue.empty()) {
4003 startDispatchCycleLocked(currentTime, connection);
4004 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004005}
4006
Svet Ganov5d3bc372020-01-26 23:11:07 -08004007void InputDispatcher::synthesizePointerDownEventsForConnectionLocked(
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07004008 const nsecs_t downTime, const std::shared_ptr<Connection>& connection,
Arthur Hungc539dbb2022-12-08 07:45:36 +00004009 ftl::Flags<InputTarget::Flags> targetFlags) {
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08004010 if (connection->status == Connection::Status::BROKEN) {
Svet Ganov5d3bc372020-01-26 23:11:07 -08004011 return;
4012 }
4013
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004014 std::vector<std::unique_ptr<EventEntry>> downEvents =
Vaibhav Devmurari882bd9b2022-06-23 14:54:54 +00004015 connection->inputState.synthesizePointerDownEvents(downTime);
Svet Ganov5d3bc372020-01-26 23:11:07 -08004016
4017 if (downEvents.empty()) {
4018 return;
4019 }
4020
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004021 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
Svet Ganov5d3bc372020-01-26 23:11:07 -08004022 ALOGD("channel '%s' ~ Synthesized %zu down events to ensure consistent event stream.",
4023 connection->getInputChannelName().c_str(), downEvents.size());
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004024 }
Svet Ganov5d3bc372020-01-26 23:11:07 -08004025
4026 InputTarget target;
chaviw98318de2021-05-19 16:45:23 -05004027 sp<WindowInfoHandle> windowHandle =
Svet Ganov5d3bc372020-01-26 23:11:07 -08004028 getWindowHandleLocked(connection->inputChannel->getConnectionToken());
4029 if (windowHandle != nullptr) {
chaviw98318de2021-05-19 16:45:23 -05004030 const WindowInfo* windowInfo = windowHandle->getInfo();
chaviw1ff3d1e2020-07-01 15:53:47 -07004031 target.setDefaultPointerTransform(windowInfo->transform);
Svet Ganov5d3bc372020-01-26 23:11:07 -08004032 target.globalScaleFactor = windowInfo->globalScaleFactor;
4033 }
4034 target.inputChannel = connection->inputChannel;
Arthur Hungc539dbb2022-12-08 07:45:36 +00004035 target.flags = targetFlags;
Svet Ganov5d3bc372020-01-26 23:11:07 -08004036
hongzuo liu95785e22022-09-06 02:51:35 +00004037 const bool wasEmpty = connection->outboundQueue.empty();
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004038 for (std::unique_ptr<EventEntry>& downEventEntry : downEvents) {
Svet Ganov5d3bc372020-01-26 23:11:07 -08004039 switch (downEventEntry->type) {
4040 case EventEntry::Type::MOTION: {
4041 logOutboundMotionDetails("down - ",
4042 static_cast<const MotionEntry&>(*downEventEntry));
4043 break;
4044 }
4045
4046 case EventEntry::Type::KEY:
4047 case EventEntry::Type::FOCUS:
Antonio Kantek7242d8b2021-08-05 16:07:20 -07004048 case EventEntry::Type::TOUCH_MODE_CHANGED:
Svet Ganov5d3bc372020-01-26 23:11:07 -08004049 case EventEntry::Type::CONFIGURATION_CHANGED:
Prabir Pradhan99987712020-11-10 18:43:05 -08004050 case EventEntry::Type::DEVICE_RESET:
Chris Yef59a2f42020-10-16 12:55:26 -07004051 case EventEntry::Type::POINTER_CAPTURE_CHANGED:
arthurhungb89ccb02020-12-30 16:19:01 +08004052 case EventEntry::Type::SENSOR:
4053 case EventEntry::Type::DRAG: {
Svet Ganov5d3bc372020-01-26 23:11:07 -08004054 LOG_ALWAYS_FATAL("%s event should not be found inside Connections's queue",
Dominik Laskowski75788452021-02-09 18:51:25 -08004055 ftl::enum_string(downEventEntry->type).c_str());
Svet Ganov5d3bc372020-01-26 23:11:07 -08004056 break;
4057 }
4058 }
4059
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004060 enqueueDispatchEntryLocked(connection, std::move(downEventEntry), target,
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08004061 InputTarget::Flags::DISPATCH_AS_IS);
Svet Ganov5d3bc372020-01-26 23:11:07 -08004062 }
4063
hongzuo liu95785e22022-09-06 02:51:35 +00004064 // If the outbound queue was previously empty, start the dispatch cycle going.
4065 if (wasEmpty && !connection->outboundQueue.empty()) {
4066 startDispatchCycleLocked(downTime, connection);
4067 }
Svet Ganov5d3bc372020-01-26 23:11:07 -08004068}
4069
Arthur Hungc539dbb2022-12-08 07:45:36 +00004070void InputDispatcher::synthesizeCancelationEventsForWindowLocked(
4071 const sp<WindowInfoHandle>& windowHandle, const CancelationOptions& options) {
4072 if (windowHandle != nullptr) {
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07004073 std::shared_ptr<Connection> wallpaperConnection =
4074 getConnectionLocked(windowHandle->getToken());
Arthur Hungc539dbb2022-12-08 07:45:36 +00004075 if (wallpaperConnection != nullptr) {
4076 synthesizeCancelationEventsForConnectionLocked(wallpaperConnection, options);
4077 }
4078 }
4079}
4080
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004081std::unique_ptr<MotionEntry> InputDispatcher::splitMotionEvent(
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08004082 const MotionEntry& originalMotionEntry, std::bitset<MAX_POINTER_ID + 1> pointerIds,
4083 nsecs_t splitDownTime) {
4084 ALOG_ASSERT(pointerIds.any());
Michael Wrightd02c5b62014-02-10 15:10:22 -08004085
4086 uint32_t splitPointerIndexMap[MAX_POINTERS];
4087 PointerProperties splitPointerProperties[MAX_POINTERS];
4088 PointerCoords splitPointerCoords[MAX_POINTERS];
4089
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07004090 uint32_t originalPointerCount = originalMotionEntry.pointerCount;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004091 uint32_t splitPointerCount = 0;
4092
4093 for (uint32_t originalPointerIndex = 0; originalPointerIndex < originalPointerCount;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004094 originalPointerIndex++) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004095 const PointerProperties& pointerProperties =
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07004096 originalMotionEntry.pointerProperties[originalPointerIndex];
Michael Wrightd02c5b62014-02-10 15:10:22 -08004097 uint32_t pointerId = uint32_t(pointerProperties.id);
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08004098 if (pointerIds.test(pointerId)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004099 splitPointerIndexMap[splitPointerCount] = originalPointerIndex;
4100 splitPointerProperties[splitPointerCount].copyFrom(pointerProperties);
4101 splitPointerCoords[splitPointerCount].copyFrom(
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07004102 originalMotionEntry.pointerCoords[originalPointerIndex]);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004103 splitPointerCount += 1;
4104 }
4105 }
4106
4107 if (splitPointerCount != pointerIds.count()) {
4108 // This is bad. We are missing some of the pointers that we expected to deliver.
4109 // Most likely this indicates that we received an ACTION_MOVE events that has
4110 // different pointer ids than we expected based on the previous ACTION_DOWN
4111 // or ACTION_POINTER_DOWN events that caused us to decide to split the pointers
4112 // in this way.
4113 ALOGW("Dropping split motion event because the pointer count is %d but "
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08004114 "we expected there to be %zu pointers. This probably means we received "
Siarhei Vishniakou16e4fa02023-02-16 17:48:56 -08004115 "a broken sequence of pointer ids from the input device: %s",
4116 splitPointerCount, pointerIds.count(), originalMotionEntry.getDescription().c_str());
Yi Kong9b14ac62018-07-17 13:48:38 -07004117 return nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004118 }
4119
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07004120 int32_t action = originalMotionEntry.action;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004121 int32_t maskedAction = action & AMOTION_EVENT_ACTION_MASK;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004122 if (maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN ||
4123 maskedAction == AMOTION_EVENT_ACTION_POINTER_UP) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004124 int32_t originalPointerIndex = getMotionEventActionPointerIndex(action);
4125 const PointerProperties& pointerProperties =
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07004126 originalMotionEntry.pointerProperties[originalPointerIndex];
Michael Wrightd02c5b62014-02-10 15:10:22 -08004127 uint32_t pointerId = uint32_t(pointerProperties.id);
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08004128 if (pointerIds.test(pointerId)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004129 if (pointerIds.count() == 1) {
4130 // The first/last pointer went down/up.
4131 action = maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004132 ? AMOTION_EVENT_ACTION_DOWN
arthurhungea3f4fc2020-12-21 23:18:53 +08004133 : (originalMotionEntry.flags & AMOTION_EVENT_FLAG_CANCELED) != 0
4134 ? AMOTION_EVENT_ACTION_CANCEL
4135 : AMOTION_EVENT_ACTION_UP;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004136 } else {
4137 // A secondary pointer went down/up.
4138 uint32_t splitPointerIndex = 0;
4139 while (pointerId != uint32_t(splitPointerProperties[splitPointerIndex].id)) {
4140 splitPointerIndex += 1;
4141 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004142 action = maskedAction |
4143 (splitPointerIndex << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004144 }
4145 } else {
4146 // An unrelated pointer changed.
4147 action = AMOTION_EVENT_ACTION_MOVE;
4148 }
4149 }
4150
Siarhei Vishniakou59e302b2023-06-05 08:04:53 -07004151 if (action == AMOTION_EVENT_ACTION_DOWN && splitDownTime != originalMotionEntry.eventTime) {
4152 logDispatchStateLocked();
4153 LOG_ALWAYS_FATAL("Split motion event has mismatching downTime and eventTime for "
4154 "ACTION_DOWN, motionEntry=%s, splitDownTime=%" PRId64,
4155 originalMotionEntry.getDescription().c_str(), splitDownTime);
Vaibhav Devmurari882bd9b2022-06-23 14:54:54 +00004156 }
4157
Garfield Tanff1f1bb2020-01-28 13:24:04 -08004158 int32_t newId = mIdGenerator.nextId();
4159 if (ATRACE_ENABLED()) {
4160 std::string message = StringPrintf("Split MotionEvent(id=0x%" PRIx32
4161 ") to MotionEvent(id=0x%" PRIx32 ").",
4162 originalMotionEntry.id, newId);
4163 ATRACE_NAME(message.c_str());
4164 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004165 std::unique_ptr<MotionEntry> splitMotionEntry =
4166 std::make_unique<MotionEntry>(newId, originalMotionEntry.eventTime,
4167 originalMotionEntry.deviceId, originalMotionEntry.source,
4168 originalMotionEntry.displayId,
4169 originalMotionEntry.policyFlags, action,
4170 originalMotionEntry.actionButton,
4171 originalMotionEntry.flags, originalMotionEntry.metaState,
4172 originalMotionEntry.buttonState,
4173 originalMotionEntry.classification,
4174 originalMotionEntry.edgeFlags,
4175 originalMotionEntry.xPrecision,
4176 originalMotionEntry.yPrecision,
4177 originalMotionEntry.xCursorPosition,
Vaibhav Devmurari882bd9b2022-06-23 14:54:54 +00004178 originalMotionEntry.yCursorPosition, splitDownTime,
4179 splitPointerCount, splitPointerProperties,
4180 splitPointerCoords);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004181
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07004182 if (originalMotionEntry.injectionState) {
4183 splitMotionEntry->injectionState = originalMotionEntry.injectionState;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004184 splitMotionEntry->injectionState->refCount += 1;
4185 }
4186
4187 return splitMotionEntry;
4188}
4189
Prabir Pradhan678438e2023-04-13 19:32:51 +00004190void InputDispatcher::notifyConfigurationChanged(const NotifyConfigurationChangedArgs& args) {
Prabir Pradhan65613802023-02-22 23:36:58 +00004191 if (debugInboundEventDetails()) {
Prabir Pradhan678438e2023-04-13 19:32:51 +00004192 ALOGD("notifyConfigurationChanged - eventTime=%" PRId64, args.eventTime);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004193 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004194
Antonio Kantekf16f2832021-09-28 04:39:20 +00004195 bool needWake = false;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004196 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004197 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004198
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004199 std::unique_ptr<ConfigurationChangedEntry> newEntry =
Prabir Pradhan678438e2023-04-13 19:32:51 +00004200 std::make_unique<ConfigurationChangedEntry>(args.id, args.eventTime);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004201 needWake = enqueueInboundEventLocked(std::move(newEntry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08004202 } // release lock
4203
4204 if (needWake) {
4205 mLooper->wake();
4206 }
4207}
4208
Siarhei Vishniakou61fafdd2018-04-13 11:00:58 -05004209/**
4210 * If one of the meta shortcuts is detected, process them here:
Vaibhav Devmurari34cd5b02023-02-23 14:51:18 +00004211 * Meta + Backspace; Meta + Grave; Meta + Left arrow -> generate BACK
4212 * Most System shortcuts are handled in PhoneWindowManager.java except 'Back' shortcuts. Unlike
4213 * Back, other shortcuts DO NOT need to be sent to applications and are fully handled by the system.
4214 * But for Back key and Back shortcuts, we need to send KEYCODE_BACK to applications which can
4215 * potentially handle the back key presses.
4216 * Note: We don't send any Meta based KeyEvents to applications, so we need to convert to a KeyEvent
4217 * where meta modifier is off before sending. Currently only use case is 'Back'.
Siarhei Vishniakou61fafdd2018-04-13 11:00:58 -05004218 */
4219void InputDispatcher::accelerateMetaShortcuts(const int32_t deviceId, const int32_t action,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004220 int32_t& keyCode, int32_t& metaState) {
Siarhei Vishniakou61fafdd2018-04-13 11:00:58 -05004221 if (metaState & AMETA_META_ON && action == AKEY_EVENT_ACTION_DOWN) {
4222 int32_t newKeyCode = AKEYCODE_UNKNOWN;
Vaibhav Devmurari34cd5b02023-02-23 14:51:18 +00004223 if (keyCode == AKEYCODE_DEL || keyCode == AKEYCODE_GRAVE || keyCode == AKEYCODE_DPAD_LEFT) {
Siarhei Vishniakou61fafdd2018-04-13 11:00:58 -05004224 newKeyCode = AKEYCODE_BACK;
Siarhei Vishniakou61fafdd2018-04-13 11:00:58 -05004225 }
4226 if (newKeyCode != AKEYCODE_UNKNOWN) {
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004227 std::scoped_lock _l(mLock);
Siarhei Vishniakou61fafdd2018-04-13 11:00:58 -05004228 struct KeyReplacement replacement = {keyCode, deviceId};
Siarhei Vishniakou4700f822020-03-24 19:05:54 -07004229 mReplacedKeys[replacement] = newKeyCode;
Siarhei Vishniakou61fafdd2018-04-13 11:00:58 -05004230 keyCode = newKeyCode;
4231 metaState &= ~(AMETA_META_ON | AMETA_META_LEFT_ON | AMETA_META_RIGHT_ON);
4232 }
4233 } else if (action == AKEY_EVENT_ACTION_UP) {
4234 // In order to maintain a consistent stream of up and down events, check to see if the key
4235 // going up is one we've replaced in a down event and haven't yet replaced in an up event,
4236 // even if the modifier was released between the down and the up events.
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004237 std::scoped_lock _l(mLock);
Siarhei Vishniakou61fafdd2018-04-13 11:00:58 -05004238 struct KeyReplacement replacement = {keyCode, deviceId};
Siarhei Vishniakou4700f822020-03-24 19:05:54 -07004239 auto replacementIt = mReplacedKeys.find(replacement);
4240 if (replacementIt != mReplacedKeys.end()) {
4241 keyCode = replacementIt->second;
4242 mReplacedKeys.erase(replacementIt);
Siarhei Vishniakou61fafdd2018-04-13 11:00:58 -05004243 metaState &= ~(AMETA_META_ON | AMETA_META_LEFT_ON | AMETA_META_RIGHT_ON);
4244 }
4245 }
4246}
4247
Prabir Pradhan678438e2023-04-13 19:32:51 +00004248void InputDispatcher::notifyKey(const NotifyKeyArgs& args) {
Prabir Pradhan96282b02023-02-24 22:36:17 +00004249 ALOGD_IF(debugInboundEventDetails(),
4250 "notifyKey - id=%" PRIx32 ", eventTime=%" PRId64
4251 ", deviceId=%d, source=%s, displayId=%" PRId32
4252 "policyFlags=0x%x, action=%s, flags=0x%x, keyCode=%s, scanCode=0x%x, metaState=0x%x, "
4253 "downTime=%" PRId64,
Prabir Pradhan678438e2023-04-13 19:32:51 +00004254 args.id, args.eventTime, args.deviceId, inputEventSourceToString(args.source).c_str(),
4255 args.displayId, args.policyFlags, KeyEvent::actionToString(args.action), args.flags,
4256 KeyEvent::getLabel(args.keyCode), args.scanCode, args.metaState, args.downTime);
Siarhei Vishniakou6773db62023-04-21 11:30:20 -07004257 Result<void> keyCheck = validateKeyEvent(args.action);
4258 if (!keyCheck.ok()) {
4259 LOG(ERROR) << "invalid key event: " << keyCheck.error();
Michael Wrightd02c5b62014-02-10 15:10:22 -08004260 return;
4261 }
4262
Prabir Pradhan678438e2023-04-13 19:32:51 +00004263 uint32_t policyFlags = args.policyFlags;
4264 int32_t flags = args.flags;
4265 int32_t metaState = args.metaState;
Siarhei Vishniakou622bd322018-10-29 18:02:27 -07004266 // InputDispatcher tracks and generates key repeats on behalf of
4267 // whatever notifies it, so repeatCount should always be set to 0
4268 constexpr int32_t repeatCount = 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004269 if ((policyFlags & POLICY_FLAG_VIRTUAL) || (flags & AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY)) {
4270 policyFlags |= POLICY_FLAG_VIRTUAL;
4271 flags |= AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY;
4272 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004273 if (policyFlags & POLICY_FLAG_FUNCTION) {
4274 metaState |= AMETA_FUNCTION_ON;
4275 }
4276
4277 policyFlags |= POLICY_FLAG_TRUSTED;
4278
Prabir Pradhan678438e2023-04-13 19:32:51 +00004279 int32_t keyCode = args.keyCode;
4280 accelerateMetaShortcuts(args.deviceId, args.action, keyCode, metaState);
Michael Wright78f24442014-08-06 15:55:28 -07004281
Michael Wrightd02c5b62014-02-10 15:10:22 -08004282 KeyEvent event;
Prabir Pradhan678438e2023-04-13 19:32:51 +00004283 event.initialize(args.id, args.deviceId, args.source, args.displayId, INVALID_HMAC, args.action,
4284 flags, keyCode, args.scanCode, metaState, repeatCount, args.downTime,
4285 args.eventTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004286
Michael Wright2b3c3302018-03-02 17:19:13 +00004287 android::base::Timer t;
Prabir Pradhana41d2442023-04-20 21:30:40 +00004288 mPolicy.interceptKeyBeforeQueueing(event, /*byref*/ policyFlags);
Michael Wright2b3c3302018-03-02 17:19:13 +00004289 if (t.duration() > SLOW_INTERCEPTION_THRESHOLD) {
4290 ALOGW("Excessive delay in interceptKeyBeforeQueueing; took %s ms",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004291 std::to_string(t.duration().count()).c_str());
Michael Wright2b3c3302018-03-02 17:19:13 +00004292 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004293
Antonio Kantekf16f2832021-09-28 04:39:20 +00004294 bool needWake = false;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004295 { // acquire lock
4296 mLock.lock();
4297
4298 if (shouldSendKeyToInputFilterLocked(args)) {
4299 mLock.unlock();
4300
Siarhei Vishniakouf00a4ec2021-06-16 03:55:32 +00004301 policyFlags |= POLICY_FLAG_FILTERED;
Prabir Pradhana41d2442023-04-20 21:30:40 +00004302 if (!mPolicy.filterInputEvent(event, policyFlags)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004303 return; // event was consumed by the filter
4304 }
4305
4306 mLock.lock();
4307 }
4308
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004309 std::unique_ptr<KeyEntry> newEntry =
Prabir Pradhan678438e2023-04-13 19:32:51 +00004310 std::make_unique<KeyEntry>(args.id, args.eventTime, args.deviceId, args.source,
4311 args.displayId, policyFlags, args.action, flags, keyCode,
4312 args.scanCode, metaState, repeatCount, args.downTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004313
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004314 needWake = enqueueInboundEventLocked(std::move(newEntry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08004315 mLock.unlock();
4316 } // release lock
4317
4318 if (needWake) {
4319 mLooper->wake();
4320 }
4321}
4322
Prabir Pradhan678438e2023-04-13 19:32:51 +00004323bool InputDispatcher::shouldSendKeyToInputFilterLocked(const NotifyKeyArgs& args) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004324 return mInputFilterEnabled;
4325}
4326
Prabir Pradhan678438e2023-04-13 19:32:51 +00004327void InputDispatcher::notifyMotion(const NotifyMotionArgs& args) {
Prabir Pradhan65613802023-02-22 23:36:58 +00004328 if (debugInboundEventDetails()) {
Prabir Pradhan96282b02023-02-24 22:36:17 +00004329 ALOGD("notifyMotion - id=%" PRIx32 " eventTime=%" PRId64 ", deviceId=%d, source=%s, "
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004330 "displayId=%" PRId32 ", policyFlags=0x%x, "
Siarhei Vishniakou6ebd0692022-10-20 15:05:45 -07004331 "action=%s, actionButton=0x%x, flags=0x%x, metaState=0x%x, buttonState=0x%x, "
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004332 "edgeFlags=0x%x, xPrecision=%f, yPrecision=%f, xCursorPosition=%f, "
4333 "yCursorPosition=%f, downTime=%" PRId64,
Prabir Pradhan678438e2023-04-13 19:32:51 +00004334 args.id, args.eventTime, args.deviceId, inputEventSourceToString(args.source).c_str(),
4335 args.displayId, args.policyFlags, MotionEvent::actionToString(args.action).c_str(),
4336 args.actionButton, args.flags, args.metaState, args.buttonState, args.edgeFlags,
4337 args.xPrecision, args.yPrecision, args.xCursorPosition, args.yCursorPosition,
4338 args.downTime);
Siarhei Vishniakou3218fc02023-06-15 20:41:02 -07004339 for (uint32_t i = 0; i < args.getPointerCount(); i++) {
Prabir Pradhan96282b02023-02-24 22:36:17 +00004340 ALOGD(" Pointer %d: id=%d, toolType=%s, x=%f, y=%f, pressure=%f, size=%f, "
4341 "touchMajor=%f, touchMinor=%f, toolMajor=%f, toolMinor=%f, orientation=%f",
Prabir Pradhan678438e2023-04-13 19:32:51 +00004342 i, args.pointerProperties[i].id,
4343 ftl::enum_string(args.pointerProperties[i].toolType).c_str(),
4344 args.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_X),
4345 args.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_Y),
4346 args.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_PRESSURE),
4347 args.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_SIZE),
4348 args.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR),
4349 args.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR),
4350 args.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR),
4351 args.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR),
4352 args.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION));
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004353 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004354 }
Siarhei Vishniakou4ca97272023-03-01 11:31:35 -08004355
Siarhei Vishniakou3218fc02023-06-15 20:41:02 -07004356 Result<void> motionCheck =
4357 validateMotionEvent(args.action, args.actionButton, args.getPointerCount(),
4358 args.pointerProperties.data());
Siarhei Vishniakou6773db62023-04-21 11:30:20 -07004359 if (!motionCheck.ok()) {
4360 LOG(ERROR) << "Invalid event: " << args.dump() << "; reason: " << motionCheck.error();
Siarhei Vishniakou4ca97272023-03-01 11:31:35 -08004361 return;
4362 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004363
Siarhei Vishniakou5c02a712023-05-15 15:45:02 -07004364 if (DEBUG_VERIFY_EVENTS) {
4365 auto [it, _] =
4366 mVerifiersByDisplay.try_emplace(args.displayId,
4367 StringPrintf("display %" PRId32, args.displayId));
4368 Result<void> result =
Siarhei Vishniakou3218fc02023-06-15 20:41:02 -07004369 it->second.processMovement(args.deviceId, args.action, args.getPointerCount(),
4370 args.pointerProperties.data(), args.pointerCoords.data(),
4371 args.flags);
Siarhei Vishniakou5c02a712023-05-15 15:45:02 -07004372 if (!result.ok()) {
4373 LOG(FATAL) << "Bad stream: " << result.error() << " caused by " << args.dump();
4374 }
4375 }
4376
Prabir Pradhan678438e2023-04-13 19:32:51 +00004377 uint32_t policyFlags = args.policyFlags;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004378 policyFlags |= POLICY_FLAG_TRUSTED;
Michael Wright2b3c3302018-03-02 17:19:13 +00004379
4380 android::base::Timer t;
Prabir Pradhana41d2442023-04-20 21:30:40 +00004381 mPolicy.interceptMotionBeforeQueueing(args.displayId, args.eventTime, policyFlags);
Michael Wright2b3c3302018-03-02 17:19:13 +00004382 if (t.duration() > SLOW_INTERCEPTION_THRESHOLD) {
4383 ALOGW("Excessive delay in interceptMotionBeforeQueueing; took %s ms",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004384 std::to_string(t.duration().count()).c_str());
Michael Wright2b3c3302018-03-02 17:19:13 +00004385 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004386
Antonio Kantekf16f2832021-09-28 04:39:20 +00004387 bool needWake = false;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004388 { // acquire lock
4389 mLock.lock();
Siarhei Vishniakou5bf25d92023-02-08 15:43:38 -08004390 if (!(policyFlags & POLICY_FLAG_PASS_TO_USER)) {
4391 // Set the flag anyway if we already have an ongoing gesture. That would allow us to
4392 // complete the processing of the current stroke.
Prabir Pradhan678438e2023-04-13 19:32:51 +00004393 const auto touchStateIt = mTouchStatesByDisplay.find(args.displayId);
Siarhei Vishniakou5bf25d92023-02-08 15:43:38 -08004394 if (touchStateIt != mTouchStatesByDisplay.end()) {
4395 const TouchState& touchState = touchStateIt->second;
Siarhei Vishniakou45504fe2023-05-05 16:05:10 -07004396 if (touchState.hasTouchingPointers(args.deviceId)) {
Siarhei Vishniakou5bf25d92023-02-08 15:43:38 -08004397 policyFlags |= POLICY_FLAG_PASS_TO_USER;
4398 }
4399 }
4400 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004401
4402 if (shouldSendMotionToInputFilterLocked(args)) {
Prabir Pradhan81420cc2021-09-06 10:28:50 -07004403 ui::Transform displayTransform;
Prabir Pradhan678438e2023-04-13 19:32:51 +00004404 if (const auto it = mDisplayInfos.find(args.displayId); it != mDisplayInfos.end()) {
Prabir Pradhan81420cc2021-09-06 10:28:50 -07004405 displayTransform = it->second.transform;
4406 }
4407
Michael Wrightd02c5b62014-02-10 15:10:22 -08004408 mLock.unlock();
4409
4410 MotionEvent event;
Prabir Pradhan678438e2023-04-13 19:32:51 +00004411 event.initialize(args.id, args.deviceId, args.source, args.displayId, INVALID_HMAC,
4412 args.action, args.actionButton, args.flags, args.edgeFlags,
4413 args.metaState, args.buttonState, args.classification,
4414 displayTransform, args.xPrecision, args.yPrecision,
4415 args.xCursorPosition, args.yCursorPosition, displayTransform,
Siarhei Vishniakou3218fc02023-06-15 20:41:02 -07004416 args.downTime, args.eventTime, args.getPointerCount(),
4417 args.pointerProperties.data(), args.pointerCoords.data());
Michael Wrightd02c5b62014-02-10 15:10:22 -08004418
4419 policyFlags |= POLICY_FLAG_FILTERED;
Prabir Pradhana41d2442023-04-20 21:30:40 +00004420 if (!mPolicy.filterInputEvent(event, policyFlags)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004421 return; // event was consumed by the filter
4422 }
4423
4424 mLock.lock();
4425 }
4426
4427 // Just enqueue a new motion event.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004428 std::unique_ptr<MotionEntry> newEntry =
Prabir Pradhan678438e2023-04-13 19:32:51 +00004429 std::make_unique<MotionEntry>(args.id, args.eventTime, args.deviceId, args.source,
4430 args.displayId, policyFlags, args.action,
4431 args.actionButton, args.flags, args.metaState,
4432 args.buttonState, args.classification, args.edgeFlags,
4433 args.xPrecision, args.yPrecision,
4434 args.xCursorPosition, args.yCursorPosition,
Siarhei Vishniakou3218fc02023-06-15 20:41:02 -07004435 args.downTime, args.getPointerCount(),
4436 args.pointerProperties.data(),
4437 args.pointerCoords.data());
Michael Wrightd02c5b62014-02-10 15:10:22 -08004438
Prabir Pradhan678438e2023-04-13 19:32:51 +00004439 if (args.id != android::os::IInputConstants::INVALID_INPUT_EVENT_ID &&
4440 IdGenerator::getSource(args.id) == IdGenerator::Source::INPUT_READER &&
Siarhei Vishniakou363e7292021-07-09 03:22:42 +00004441 !mInputFilterEnabled) {
Prabir Pradhan678438e2023-04-13 19:32:51 +00004442 const bool isDown = args.action == AMOTION_EVENT_ACTION_DOWN;
4443 mLatencyTracker.trackListener(args.id, isDown, args.eventTime, args.readTime);
Siarhei Vishniakou363e7292021-07-09 03:22:42 +00004444 }
4445
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004446 needWake = enqueueInboundEventLocked(std::move(newEntry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08004447 mLock.unlock();
4448 } // release lock
4449
4450 if (needWake) {
4451 mLooper->wake();
4452 }
4453}
4454
Prabir Pradhan678438e2023-04-13 19:32:51 +00004455void InputDispatcher::notifySensor(const NotifySensorArgs& args) {
Prabir Pradhan65613802023-02-22 23:36:58 +00004456 if (debugInboundEventDetails()) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004457 ALOGD("notifySensor - id=%" PRIx32 " eventTime=%" PRId64 ", deviceId=%d, source=0x%x, "
4458 " sensorType=%s",
Prabir Pradhan678438e2023-04-13 19:32:51 +00004459 args.id, args.eventTime, args.deviceId, args.source,
4460 ftl::enum_string(args.sensorType).c_str());
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004461 }
Chris Yef59a2f42020-10-16 12:55:26 -07004462
Antonio Kantekf16f2832021-09-28 04:39:20 +00004463 bool needWake = false;
Chris Yef59a2f42020-10-16 12:55:26 -07004464 { // acquire lock
4465 mLock.lock();
4466
4467 // Just enqueue a new sensor event.
4468 std::unique_ptr<SensorEntry> newEntry =
Prabir Pradhan678438e2023-04-13 19:32:51 +00004469 std::make_unique<SensorEntry>(args.id, args.eventTime, args.deviceId, args.source,
4470 /* policyFlags=*/0, args.hwTimestamp, args.sensorType,
4471 args.accuracy, args.accuracyChanged, args.values);
Chris Yef59a2f42020-10-16 12:55:26 -07004472
4473 needWake = enqueueInboundEventLocked(std::move(newEntry));
4474 mLock.unlock();
4475 } // release lock
4476
4477 if (needWake) {
4478 mLooper->wake();
4479 }
4480}
4481
Prabir Pradhan678438e2023-04-13 19:32:51 +00004482void InputDispatcher::notifyVibratorState(const NotifyVibratorStateArgs& args) {
Prabir Pradhan65613802023-02-22 23:36:58 +00004483 if (debugInboundEventDetails()) {
Prabir Pradhan678438e2023-04-13 19:32:51 +00004484 ALOGD("notifyVibratorState - eventTime=%" PRId64 ", device=%d, isOn=%d", args.eventTime,
4485 args.deviceId, args.isOn);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004486 }
Prabir Pradhana41d2442023-04-20 21:30:40 +00004487 mPolicy.notifyVibratorState(args.deviceId, args.isOn);
Chris Yefb552902021-02-03 17:18:37 -08004488}
4489
Prabir Pradhan678438e2023-04-13 19:32:51 +00004490bool InputDispatcher::shouldSendMotionToInputFilterLocked(const NotifyMotionArgs& args) {
Jackal Guof9696682018-10-05 12:23:23 +08004491 return mInputFilterEnabled;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004492}
4493
Prabir Pradhan678438e2023-04-13 19:32:51 +00004494void InputDispatcher::notifySwitch(const NotifySwitchArgs& args) {
Prabir Pradhan65613802023-02-22 23:36:58 +00004495 if (debugInboundEventDetails()) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004496 ALOGD("notifySwitch - eventTime=%" PRId64 ", policyFlags=0x%x, switchValues=0x%08x, "
4497 "switchMask=0x%08x",
Prabir Pradhan678438e2023-04-13 19:32:51 +00004498 args.eventTime, args.policyFlags, args.switchValues, args.switchMask);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004499 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004500
Prabir Pradhan678438e2023-04-13 19:32:51 +00004501 uint32_t policyFlags = args.policyFlags;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004502 policyFlags |= POLICY_FLAG_TRUSTED;
Prabir Pradhana41d2442023-04-20 21:30:40 +00004503 mPolicy.notifySwitch(args.eventTime, args.switchValues, args.switchMask, policyFlags);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004504}
4505
Prabir Pradhan678438e2023-04-13 19:32:51 +00004506void InputDispatcher::notifyDeviceReset(const NotifyDeviceResetArgs& args) {
Prabir Pradhan65613802023-02-22 23:36:58 +00004507 if (debugInboundEventDetails()) {
Prabir Pradhan678438e2023-04-13 19:32:51 +00004508 ALOGD("notifyDeviceReset - eventTime=%" PRId64 ", deviceId=%d", args.eventTime,
4509 args.deviceId);
Prabir Pradhan61a5d242021-07-26 16:41:09 +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
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004514 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004515
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004516 std::unique_ptr<DeviceResetEntry> newEntry =
Prabir Pradhan678438e2023-04-13 19:32:51 +00004517 std::make_unique<DeviceResetEntry>(args.id, args.eventTime, args.deviceId);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004518 needWake = enqueueInboundEventLocked(std::move(newEntry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08004519 } // release lock
4520
4521 if (needWake) {
4522 mLooper->wake();
4523 }
4524}
4525
Prabir Pradhan678438e2023-04-13 19:32:51 +00004526void InputDispatcher::notifyPointerCaptureChanged(const NotifyPointerCaptureChangedArgs& args) {
Prabir Pradhan65613802023-02-22 23:36:58 +00004527 if (debugInboundEventDetails()) {
Prabir Pradhan678438e2023-04-13 19:32:51 +00004528 ALOGD("notifyPointerCaptureChanged - eventTime=%" PRId64 ", enabled=%s", args.eventTime,
4529 args.request.enable ? "true" : "false");
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004530 }
Prabir Pradhan7e186182020-11-10 13:56:45 -08004531
Antonio Kantekf16f2832021-09-28 04:39:20 +00004532 bool needWake = false;
Prabir Pradhan99987712020-11-10 18:43:05 -08004533 { // acquire lock
4534 std::scoped_lock _l(mLock);
Prabir Pradhan678438e2023-04-13 19:32:51 +00004535 auto entry =
4536 std::make_unique<PointerCaptureChangedEntry>(args.id, args.eventTime, args.request);
Prabir Pradhan99987712020-11-10 18:43:05 -08004537 needWake = enqueueInboundEventLocked(std::move(entry));
4538 } // release lock
4539
4540 if (needWake) {
4541 mLooper->wake();
4542 }
Prabir Pradhan7e186182020-11-10 13:56:45 -08004543}
4544
Prabir Pradhan5735a322022-04-11 17:23:34 +00004545InputEventInjectionResult InputDispatcher::injectInputEvent(const InputEvent* event,
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00004546 std::optional<gui::Uid> targetUid,
Prabir Pradhan5735a322022-04-11 17:23:34 +00004547 InputEventInjectionSync syncMode,
4548 std::chrono::milliseconds timeout,
4549 uint32_t policyFlags) {
Siarhei Vishniakou6773db62023-04-21 11:30:20 -07004550 Result<void> eventValidation = validateInputEvent(*event);
4551 if (!eventValidation.ok()) {
4552 LOG(INFO) << "Injection failed: invalid event: " << eventValidation.error();
4553 return InputEventInjectionResult::FAILED;
4554 }
4555
Prabir Pradhan65613802023-02-22 23:36:58 +00004556 if (debugInboundEventDetails()) {
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00004557 LOG(DEBUG) << __func__ << ": targetUid=" << toString(targetUid, &uidString)
Siarhei Vishniakou63b63612023-04-12 11:00:23 -07004558 << ", syncMode=" << ftl::enum_string(syncMode) << ", timeout=" << timeout.count()
4559 << "ms, policyFlags=0x" << std::hex << policyFlags << std::dec
4560 << ", event=" << *event;
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004561 }
Siarhei Vishniakou097c3db2020-05-06 14:18:38 -07004562 nsecs_t endTime = now() + std::chrono::duration_cast<std::chrono::nanoseconds>(timeout).count();
Michael Wrightd02c5b62014-02-10 15:10:22 -08004563
Prabir Pradhan5735a322022-04-11 17:23:34 +00004564 policyFlags |= POLICY_FLAG_INJECTED | POLICY_FLAG_TRUSTED;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004565
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004566 // For all injected events, set device id = VIRTUAL_KEYBOARD_ID. The only exception is events
Siarhei Vishniakouf00a4ec2021-06-16 03:55:32 +00004567 // that have gone through the InputFilter. If the event passed through the InputFilter, assign
4568 // the provided device id. If the InputFilter is accessibility, and it modifies or synthesizes
4569 // the injected event, it is responsible for setting POLICY_FLAG_INJECTED_FROM_ACCESSIBILITY.
4570 // For those events, we will set FLAG_IS_ACCESSIBILITY_EVENT to allow apps to distinguish them
4571 // from events that originate from actual hardware.
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004572 int32_t resolvedDeviceId = VIRTUAL_KEYBOARD_ID;
Siarhei Vishniakouf00a4ec2021-06-16 03:55:32 +00004573 if (policyFlags & POLICY_FLAG_FILTERED) {
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004574 resolvedDeviceId = event->getDeviceId();
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004575 }
4576
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004577 std::queue<std::unique_ptr<EventEntry>> injectedEntries;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004578 switch (event->getType()) {
Siarhei Vishniakou63b63612023-04-12 11:00:23 -07004579 case InputEventType::KEY: {
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -08004580 const KeyEvent& incomingKey = static_cast<const KeyEvent&>(*event);
Siarhei Vishniakou6773db62023-04-21 11:30:20 -07004581 const int32_t action = incomingKey.getAction();
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -08004582 int32_t flags = incomingKey.getFlags();
Siarhei Vishniakouf00a4ec2021-06-16 03:55:32 +00004583 if (policyFlags & POLICY_FLAG_INJECTED_FROM_ACCESSIBILITY) {
4584 flags |= AKEY_EVENT_FLAG_IS_ACCESSIBILITY_EVENT;
4585 }
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -08004586 int32_t keyCode = incomingKey.getKeyCode();
4587 int32_t metaState = incomingKey.getMetaState();
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004588 accelerateMetaShortcuts(resolvedDeviceId, action,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004589 /*byref*/ keyCode, /*byref*/ metaState);
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -08004590 KeyEvent keyEvent;
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004591 keyEvent.initialize(incomingKey.getId(), resolvedDeviceId, incomingKey.getSource(),
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -08004592 incomingKey.getDisplayId(), INVALID_HMAC, action, flags, keyCode,
4593 incomingKey.getScanCode(), metaState, incomingKey.getRepeatCount(),
4594 incomingKey.getDownTime(), incomingKey.getEventTime());
Michael Wrightd02c5b62014-02-10 15:10:22 -08004595
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004596 if (flags & AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY) {
4597 policyFlags |= POLICY_FLAG_VIRTUAL;
Michael Wright2b3c3302018-03-02 17:19:13 +00004598 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004599
4600 if (!(policyFlags & POLICY_FLAG_FILTERED)) {
4601 android::base::Timer t;
Prabir Pradhana41d2442023-04-20 21:30:40 +00004602 mPolicy.interceptKeyBeforeQueueing(keyEvent, /*byref*/ policyFlags);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004603 if (t.duration() > SLOW_INTERCEPTION_THRESHOLD) {
4604 ALOGW("Excessive delay in interceptKeyBeforeQueueing; took %s ms",
4605 std::to_string(t.duration().count()).c_str());
4606 }
4607 }
4608
4609 mLock.lock();
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004610 std::unique_ptr<KeyEntry> injectedEntry =
4611 std::make_unique<KeyEntry>(incomingKey.getId(), incomingKey.getEventTime(),
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004612 resolvedDeviceId, incomingKey.getSource(),
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004613 incomingKey.getDisplayId(), policyFlags, action,
4614 flags, keyCode, incomingKey.getScanCode(), metaState,
4615 incomingKey.getRepeatCount(),
4616 incomingKey.getDownTime());
4617 injectedEntries.push(std::move(injectedEntry));
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004618 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004619 }
4620
Siarhei Vishniakou63b63612023-04-12 11:00:23 -07004621 case InputEventType::MOTION: {
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004622 const MotionEvent& motionEvent = static_cast<const MotionEvent&>(*event);
Prabir Pradhanaa561d12021-09-24 06:57:33 -07004623 const bool isPointerEvent =
4624 isFromSource(event->getSource(), AINPUT_SOURCE_CLASS_POINTER);
4625 // If a pointer event has no displayId specified, inject it to the default display.
4626 const uint32_t displayId = isPointerEvent && (event->getDisplayId() == ADISPLAY_ID_NONE)
4627 ? ADISPLAY_ID_DEFAULT
4628 : event->getDisplayId();
Siarhei Vishniakouf00a4ec2021-06-16 03:55:32 +00004629 int32_t flags = motionEvent.getFlags();
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004630
4631 if (!(policyFlags & POLICY_FLAG_FILTERED)) {
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004632 nsecs_t eventTime = motionEvent.getEventTime();
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004633 android::base::Timer t;
Prabir Pradhana41d2442023-04-20 21:30:40 +00004634 mPolicy.interceptMotionBeforeQueueing(displayId, eventTime, /*byref*/ policyFlags);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004635 if (t.duration() > SLOW_INTERCEPTION_THRESHOLD) {
4636 ALOGW("Excessive delay in interceptMotionBeforeQueueing; took %s ms",
4637 std::to_string(t.duration().count()).c_str());
4638 }
4639 }
4640
Siarhei Vishniakouf00a4ec2021-06-16 03:55:32 +00004641 if (policyFlags & POLICY_FLAG_INJECTED_FROM_ACCESSIBILITY) {
4642 flags |= AMOTION_EVENT_FLAG_IS_ACCESSIBILITY_EVENT;
4643 }
4644
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004645 mLock.lock();
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004646 const nsecs_t* sampleEventTimes = motionEvent.getSampleEventTimes();
4647 const PointerCoords* samplePointerCoords = motionEvent.getSamplePointerCoords();
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004648 std::unique_ptr<MotionEntry> injectedEntry =
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004649 std::make_unique<MotionEntry>(motionEvent.getId(), *sampleEventTimes,
4650 resolvedDeviceId, motionEvent.getSource(),
Siarhei Vishniakou6773db62023-04-21 11:30:20 -07004651 displayId, policyFlags, motionEvent.getAction(),
4652 motionEvent.getActionButton(), flags,
4653 motionEvent.getMetaState(),
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004654 motionEvent.getButtonState(),
4655 motionEvent.getClassification(),
4656 motionEvent.getEdgeFlags(),
4657 motionEvent.getXPrecision(),
4658 motionEvent.getYPrecision(),
4659 motionEvent.getRawXCursorPosition(),
4660 motionEvent.getRawYCursorPosition(),
Siarhei Vishniakou6773db62023-04-21 11:30:20 -07004661 motionEvent.getDownTime(),
4662 motionEvent.getPointerCount(),
4663 motionEvent.getPointerProperties(),
4664 samplePointerCoords);
Prabir Pradhandaa2f142021-12-10 09:30:08 +00004665 transformMotionEntryForInjectionLocked(*injectedEntry, motionEvent.getTransform());
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004666 injectedEntries.push(std::move(injectedEntry));
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004667 for (size_t i = motionEvent.getHistorySize(); i > 0; i--) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004668 sampleEventTimes += 1;
Siarhei Vishniakou6773db62023-04-21 11:30:20 -07004669 samplePointerCoords += motionEvent.getPointerCount();
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004670 std::unique_ptr<MotionEntry> nextInjectedEntry =
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004671 std::make_unique<MotionEntry>(motionEvent.getId(), *sampleEventTimes,
4672 resolvedDeviceId, motionEvent.getSource(),
Siarhei Vishniakou6773db62023-04-21 11:30:20 -07004673 displayId, policyFlags,
4674 motionEvent.getAction(),
4675 motionEvent.getActionButton(), flags,
4676 motionEvent.getMetaState(),
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004677 motionEvent.getButtonState(),
4678 motionEvent.getClassification(),
4679 motionEvent.getEdgeFlags(),
4680 motionEvent.getXPrecision(),
4681 motionEvent.getYPrecision(),
4682 motionEvent.getRawXCursorPosition(),
4683 motionEvent.getRawYCursorPosition(),
4684 motionEvent.getDownTime(),
Siarhei Vishniakou6773db62023-04-21 11:30:20 -07004685 motionEvent.getPointerCount(),
4686 motionEvent.getPointerProperties(),
Prabir Pradhan5beda762021-12-10 09:30:08 +00004687 samplePointerCoords);
Prabir Pradhandaa2f142021-12-10 09:30:08 +00004688 transformMotionEntryForInjectionLocked(*nextInjectedEntry,
4689 motionEvent.getTransform());
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004690 injectedEntries.push(std::move(nextInjectedEntry));
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004691 }
4692 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004693 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004694
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004695 default:
Siarhei Vishniakou63b63612023-04-12 11:00:23 -07004696 LOG(WARNING) << "Cannot inject " << ftl::enum_string(event->getType()) << " events";
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004697 return InputEventInjectionResult::FAILED;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004698 }
4699
Prabir Pradhan5735a322022-04-11 17:23:34 +00004700 InjectionState* injectionState = new InjectionState(targetUid);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004701 if (syncMode == InputEventInjectionSync::NONE) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004702 injectionState->injectionIsAsync = true;
4703 }
4704
4705 injectionState->refCount += 1;
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07004706 injectedEntries.back()->injectionState = injectionState;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004707
4708 bool needWake = false;
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07004709 while (!injectedEntries.empty()) {
Siarhei Vishniakoud010b012023-01-18 15:00:53 -08004710 if (DEBUG_INJECTION) {
4711 LOG(DEBUG) << "Injecting " << injectedEntries.front()->getDescription();
4712 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004713 needWake |= enqueueInboundEventLocked(std::move(injectedEntries.front()));
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07004714 injectedEntries.pop();
Michael Wrightd02c5b62014-02-10 15:10:22 -08004715 }
4716
4717 mLock.unlock();
4718
4719 if (needWake) {
4720 mLooper->wake();
4721 }
4722
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004723 InputEventInjectionResult injectionResult;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004724 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004725 std::unique_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004726
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004727 if (syncMode == InputEventInjectionSync::NONE) {
4728 injectionResult = InputEventInjectionResult::SUCCEEDED;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004729 } else {
4730 for (;;) {
4731 injectionResult = injectionState->injectionResult;
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004732 if (injectionResult != InputEventInjectionResult::PENDING) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004733 break;
4734 }
4735
4736 nsecs_t remainingTimeout = endTime - now();
4737 if (remainingTimeout <= 0) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004738 if (DEBUG_INJECTION) {
4739 ALOGD("injectInputEvent - Timed out waiting for injection result "
4740 "to become available.");
4741 }
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004742 injectionResult = InputEventInjectionResult::TIMED_OUT;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004743 break;
4744 }
4745
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004746 mInjectionResultAvailable.wait_for(_l, std::chrono::nanoseconds(remainingTimeout));
Michael Wrightd02c5b62014-02-10 15:10:22 -08004747 }
4748
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004749 if (injectionResult == InputEventInjectionResult::SUCCEEDED &&
4750 syncMode == InputEventInjectionSync::WAIT_FOR_FINISHED) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004751 while (injectionState->pendingForegroundDispatches != 0) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004752 if (DEBUG_INJECTION) {
4753 ALOGD("injectInputEvent - Waiting for %d pending foreground dispatches.",
4754 injectionState->pendingForegroundDispatches);
4755 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004756 nsecs_t remainingTimeout = endTime - now();
4757 if (remainingTimeout <= 0) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004758 if (DEBUG_INJECTION) {
4759 ALOGD("injectInputEvent - Timed out waiting for pending foreground "
4760 "dispatches to finish.");
4761 }
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004762 injectionResult = InputEventInjectionResult::TIMED_OUT;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004763 break;
4764 }
4765
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004766 mInjectionSyncFinished.wait_for(_l, std::chrono::nanoseconds(remainingTimeout));
Michael Wrightd02c5b62014-02-10 15:10:22 -08004767 }
4768 }
4769 }
4770
4771 injectionState->release();
4772 } // release lock
4773
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004774 if (DEBUG_INJECTION) {
Siarhei Vishniakoud010b012023-01-18 15:00:53 -08004775 LOG(DEBUG) << "injectInputEvent - Finished with result "
4776 << ftl::enum_string(injectionResult);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004777 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004778
4779 return injectionResult;
4780}
4781
Siarhei Vishniakou54d3e182020-01-15 17:38:38 -08004782std::unique_ptr<VerifiedInputEvent> InputDispatcher::verifyInputEvent(const InputEvent& event) {
Gang Wange9087892020-01-07 12:17:14 -05004783 std::array<uint8_t, 32> calculatedHmac;
4784 std::unique_ptr<VerifiedInputEvent> result;
4785 switch (event.getType()) {
Siarhei Vishniakou63b63612023-04-12 11:00:23 -07004786 case InputEventType::KEY: {
Gang Wange9087892020-01-07 12:17:14 -05004787 const KeyEvent& keyEvent = static_cast<const KeyEvent&>(event);
4788 VerifiedKeyEvent verifiedKeyEvent = verifiedKeyEventFromKeyEvent(keyEvent);
4789 result = std::make_unique<VerifiedKeyEvent>(verifiedKeyEvent);
chaviw09c8d2d2020-08-24 15:48:26 -07004790 calculatedHmac = sign(verifiedKeyEvent);
Gang Wange9087892020-01-07 12:17:14 -05004791 break;
4792 }
Siarhei Vishniakou63b63612023-04-12 11:00:23 -07004793 case InputEventType::MOTION: {
Gang Wange9087892020-01-07 12:17:14 -05004794 const MotionEvent& motionEvent = static_cast<const MotionEvent&>(event);
4795 VerifiedMotionEvent verifiedMotionEvent =
4796 verifiedMotionEventFromMotionEvent(motionEvent);
4797 result = std::make_unique<VerifiedMotionEvent>(verifiedMotionEvent);
chaviw09c8d2d2020-08-24 15:48:26 -07004798 calculatedHmac = sign(verifiedMotionEvent);
Gang Wange9087892020-01-07 12:17:14 -05004799 break;
4800 }
4801 default: {
4802 ALOGE("Cannot verify events of type %" PRId32, event.getType());
4803 return nullptr;
4804 }
4805 }
4806 if (calculatedHmac == INVALID_HMAC) {
4807 return nullptr;
4808 }
tyiu1573a672023-02-21 22:38:32 +00004809 if (0 != CRYPTO_memcmp(calculatedHmac.data(), event.getHmac().data(), calculatedHmac.size())) {
Gang Wange9087892020-01-07 12:17:14 -05004810 return nullptr;
4811 }
4812 return result;
Siarhei Vishniakou54d3e182020-01-15 17:38:38 -08004813}
4814
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004815void InputDispatcher::setInjectionResult(EventEntry& entry,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004816 InputEventInjectionResult injectionResult) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004817 InjectionState* injectionState = entry.injectionState;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004818 if (injectionState) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004819 if (DEBUG_INJECTION) {
Siarhei Vishniakoud010b012023-01-18 15:00:53 -08004820 LOG(DEBUG) << "Setting input event injection result to "
4821 << ftl::enum_string(injectionResult);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004822 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004823
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004824 if (injectionState->injectionIsAsync && !(entry.policyFlags & POLICY_FLAG_FILTERED)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004825 // Log the outcome since the injector did not wait for the injection result.
4826 switch (injectionResult) {
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004827 case InputEventInjectionResult::SUCCEEDED:
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004828 ALOGV("Asynchronous input event injection succeeded.");
4829 break;
Prabir Pradhan5735a322022-04-11 17:23:34 +00004830 case InputEventInjectionResult::TARGET_MISMATCH:
4831 ALOGV("Asynchronous input event injection target mismatch.");
4832 break;
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004833 case InputEventInjectionResult::FAILED:
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004834 ALOGW("Asynchronous input event injection failed.");
4835 break;
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004836 case InputEventInjectionResult::TIMED_OUT:
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004837 ALOGW("Asynchronous input event injection timed out.");
4838 break;
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004839 case InputEventInjectionResult::PENDING:
4840 ALOGE("Setting result to 'PENDING' for asynchronous injection");
4841 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004842 }
4843 }
4844
4845 injectionState->injectionResult = injectionResult;
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004846 mInjectionResultAvailable.notify_all();
Michael Wrightd02c5b62014-02-10 15:10:22 -08004847 }
4848}
4849
Prabir Pradhandaa2f142021-12-10 09:30:08 +00004850void InputDispatcher::transformMotionEntryForInjectionLocked(
4851 MotionEntry& entry, const ui::Transform& injectedTransform) const {
Prabir Pradhan81420cc2021-09-06 10:28:50 -07004852 // Input injection works in the logical display coordinate space, but the input pipeline works
4853 // display space, so we need to transform the injected events accordingly.
4854 const auto it = mDisplayInfos.find(entry.displayId);
4855 if (it == mDisplayInfos.end()) return;
Prabir Pradhandaa2f142021-12-10 09:30:08 +00004856 const auto& transformToDisplay = it->second.transform.inverse() * injectedTransform;
Prabir Pradhan81420cc2021-09-06 10:28:50 -07004857
Prabir Pradhand9a2ebe2022-07-20 19:25:13 +00004858 if (entry.xCursorPosition != AMOTION_EVENT_INVALID_CURSOR_POSITION &&
4859 entry.yCursorPosition != AMOTION_EVENT_INVALID_CURSOR_POSITION) {
4860 const vec2 cursor =
4861 MotionEvent::calculateTransformedXY(entry.source, transformToDisplay,
4862 {entry.xCursorPosition, entry.yCursorPosition});
4863 entry.xCursorPosition = cursor.x;
4864 entry.yCursorPosition = cursor.y;
4865 }
Prabir Pradhan81420cc2021-09-06 10:28:50 -07004866 for (uint32_t i = 0; i < entry.pointerCount; i++) {
Prabir Pradhan8e6ce222022-02-24 09:08:54 -08004867 entry.pointerCoords[i] =
4868 MotionEvent::calculateTransformedCoords(entry.source, transformToDisplay,
4869 entry.pointerCoords[i]);
Prabir Pradhan81420cc2021-09-06 10:28:50 -07004870 }
4871}
4872
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004873void InputDispatcher::incrementPendingForegroundDispatches(EventEntry& entry) {
4874 InjectionState* injectionState = entry.injectionState;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004875 if (injectionState) {
4876 injectionState->pendingForegroundDispatches += 1;
4877 }
4878}
4879
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004880void InputDispatcher::decrementPendingForegroundDispatches(EventEntry& entry) {
4881 InjectionState* injectionState = entry.injectionState;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004882 if (injectionState) {
4883 injectionState->pendingForegroundDispatches -= 1;
4884
4885 if (injectionState->pendingForegroundDispatches == 0) {
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004886 mInjectionSyncFinished.notify_all();
Michael Wrightd02c5b62014-02-10 15:10:22 -08004887 }
4888 }
4889}
4890
chaviw98318de2021-05-19 16:45:23 -05004891const std::vector<sp<WindowInfoHandle>>& InputDispatcher::getWindowHandlesLocked(
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08004892 int32_t displayId) const {
chaviw98318de2021-05-19 16:45:23 -05004893 static const std::vector<sp<WindowInfoHandle>> EMPTY_WINDOW_HANDLES;
Vishnu Nairad321cd2020-08-20 16:40:21 -07004894 auto it = mWindowHandlesByDisplay.find(displayId);
4895 return it != mWindowHandlesByDisplay.end() ? it->second : EMPTY_WINDOW_HANDLES;
Arthur Hungb92218b2018-08-14 12:00:21 +08004896}
4897
chaviw98318de2021-05-19 16:45:23 -05004898sp<WindowInfoHandle> InputDispatcher::getWindowHandleLocked(
chaviwfbe5d9c2018-12-26 12:23:37 -08004899 const sp<IBinder>& windowHandleToken) const {
arthurhungbe737672020-06-24 12:29:21 +08004900 if (windowHandleToken == nullptr) {
4901 return nullptr;
4902 }
4903
Arthur Hungb92218b2018-08-14 12:00:21 +08004904 for (auto& it : mWindowHandlesByDisplay) {
chaviw98318de2021-05-19 16:45:23 -05004905 const std::vector<sp<WindowInfoHandle>>& windowHandles = it.second;
4906 for (const sp<WindowInfoHandle>& windowHandle : windowHandles) {
chaviwfbe5d9c2018-12-26 12:23:37 -08004907 if (windowHandle->getToken() == windowHandleToken) {
Arthur Hungb92218b2018-08-14 12:00:21 +08004908 return windowHandle;
4909 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004910 }
4911 }
Yi Kong9b14ac62018-07-17 13:48:38 -07004912 return nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004913}
4914
chaviw98318de2021-05-19 16:45:23 -05004915sp<WindowInfoHandle> InputDispatcher::getWindowHandleLocked(const sp<IBinder>& windowHandleToken,
4916 int displayId) const {
Vishnu Nairad321cd2020-08-20 16:40:21 -07004917 if (windowHandleToken == nullptr) {
4918 return nullptr;
4919 }
4920
chaviw98318de2021-05-19 16:45:23 -05004921 for (const sp<WindowInfoHandle>& windowHandle : getWindowHandlesLocked(displayId)) {
Vishnu Nairad321cd2020-08-20 16:40:21 -07004922 if (windowHandle->getToken() == windowHandleToken) {
4923 return windowHandle;
4924 }
4925 }
4926 return nullptr;
4927}
4928
chaviw98318de2021-05-19 16:45:23 -05004929sp<WindowInfoHandle> InputDispatcher::getWindowHandleLocked(
4930 const sp<WindowInfoHandle>& windowHandle) const {
Mady Mellor017bcd12020-06-23 19:12:00 +00004931 for (auto& it : mWindowHandlesByDisplay) {
chaviw98318de2021-05-19 16:45:23 -05004932 const std::vector<sp<WindowInfoHandle>>& windowHandles = it.second;
4933 for (const sp<WindowInfoHandle>& handle : windowHandles) {
arthurhungbe737672020-06-24 12:29:21 +08004934 if (handle->getId() == windowHandle->getId() &&
4935 handle->getToken() == windowHandle->getToken()) {
Mady Mellor017bcd12020-06-23 19:12:00 +00004936 if (windowHandle->getInfo()->displayId != it.first) {
4937 ALOGE("Found window %s in display %" PRId32
4938 ", but it should belong to display %" PRId32,
4939 windowHandle->getName().c_str(), it.first,
4940 windowHandle->getInfo()->displayId);
4941 }
Prabir Pradhan6a9a8312021-04-23 11:59:31 -07004942 return handle;
Arthur Hungb92218b2018-08-14 12:00:21 +08004943 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004944 }
4945 }
Prabir Pradhan6a9a8312021-04-23 11:59:31 -07004946 return nullptr;
4947}
4948
chaviw98318de2021-05-19 16:45:23 -05004949sp<WindowInfoHandle> InputDispatcher::getFocusedWindowHandleLocked(int displayId) const {
Prabir Pradhan6a9a8312021-04-23 11:59:31 -07004950 sp<IBinder> focusedToken = mFocusResolver.getFocusedWindowToken(displayId);
4951 return getWindowHandleLocked(focusedToken, displayId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004952}
4953
Prabir Pradhan33e3baa2022-12-06 20:30:22 +00004954ui::Transform InputDispatcher::getTransformLocked(int32_t displayId) const {
4955 auto displayInfoIt = mDisplayInfos.find(displayId);
4956 return displayInfoIt != mDisplayInfos.end() ? displayInfoIt->second.transform
4957 : kIdentityTransform;
4958}
4959
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07004960bool InputDispatcher::canWindowReceiveMotionLocked(const sp<WindowInfoHandle>& window,
4961 const MotionEntry& motionEntry) const {
4962 const WindowInfo& info = *window->getInfo();
4963
4964 // Skip spy window targets that are not valid for targeted injection.
4965 if (const auto err = verifyTargetedInjection(window, motionEntry); err) {
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05004966 return false;
4967 }
4968
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07004969 if (info.inputConfig.test(WindowInfo::InputConfig::PAUSE_DISPATCHING)) {
4970 ALOGI("Not sending touch event to %s because it is paused", window->getName().c_str());
4971 return false;
4972 }
4973
4974 if (info.inputConfig.test(WindowInfo::InputConfig::NO_INPUT_CHANNEL)) {
4975 ALOGW("Not sending touch gesture to %s because it has config NO_INPUT_CHANNEL",
4976 window->getName().c_str());
4977 return false;
4978 }
4979
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07004980 std::shared_ptr<Connection> connection = getConnectionLocked(window->getToken());
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05004981 if (connection == nullptr) {
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07004982 ALOGW("Not sending touch to %s because there's no corresponding connection",
4983 window->getName().c_str());
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05004984 return false;
4985 }
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07004986
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05004987 if (!connection->responsive) {
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07004988 ALOGW("Not sending touch to %s because it is not responsive", window->getName().c_str());
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05004989 return false;
4990 }
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07004991
4992 // Drop events that can't be trusted due to occlusion
4993 const auto [x, y] = resolveTouchedPosition(motionEntry);
4994 TouchOcclusionInfo occlusionInfo = computeTouchOcclusionInfoLocked(window, x, y);
4995 if (!isTouchTrustedLocked(occlusionInfo)) {
4996 if (DEBUG_TOUCH_OCCLUSION) {
Prabir Pradhan82e081e2022-12-06 09:50:09 +00004997 ALOGD("Stack of obscuring windows during untrusted touch (%.1f, %.1f):", x, y);
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07004998 for (const auto& log : occlusionInfo.debugInfo) {
4999 ALOGD("%s", log.c_str());
5000 }
5001 }
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00005002 ALOGW("Dropping untrusted touch event due to %s/%s", occlusionInfo.obscuringPackage.c_str(),
5003 occlusionInfo.obscuringUid.toString().c_str());
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07005004 return false;
5005 }
5006
5007 // Drop touch events if requested by input feature
5008 if (shouldDropInput(motionEntry, window)) {
5009 return false;
5010 }
5011
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05005012 return true;
5013}
5014
Siarhei Vishniakouce5ab082020-07-09 17:03:21 -05005015std::shared_ptr<InputChannel> InputDispatcher::getInputChannelLocked(
5016 const sp<IBinder>& token) const {
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005017 auto connectionIt = mConnectionsByToken.find(token);
5018 if (connectionIt == mConnectionsByToken.end()) {
Robert Carr5c8a0262018-10-03 16:30:44 -07005019 return nullptr;
5020 }
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005021 return connectionIt->second->inputChannel;
Robert Carr5c8a0262018-10-03 16:30:44 -07005022}
5023
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005024void InputDispatcher::updateWindowHandlesForDisplayLocked(
chaviw98318de2021-05-19 16:45:23 -05005025 const std::vector<sp<WindowInfoHandle>>& windowInfoHandles, int32_t displayId) {
5026 if (windowInfoHandles.empty()) {
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005027 // Remove all handles on a display if there are no windows left.
5028 mWindowHandlesByDisplay.erase(displayId);
5029 return;
5030 }
5031
5032 // Since we compare the pointer of input window handles across window updates, we need
5033 // to make sure the handle object for the same window stays unchanged across updates.
chaviw98318de2021-05-19 16:45:23 -05005034 const std::vector<sp<WindowInfoHandle>>& oldHandles = getWindowHandlesLocked(displayId);
5035 std::unordered_map<int32_t /*id*/, sp<WindowInfoHandle>> oldHandlesById;
5036 for (const sp<WindowInfoHandle>& handle : oldHandles) {
chaviwaf87b3e2019-10-01 16:59:28 -07005037 oldHandlesById[handle->getId()] = handle;
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005038 }
5039
chaviw98318de2021-05-19 16:45:23 -05005040 std::vector<sp<WindowInfoHandle>> newHandles;
5041 for (const sp<WindowInfoHandle>& handle : windowInfoHandles) {
chaviw98318de2021-05-19 16:45:23 -05005042 const WindowInfo* info = handle->getInfo();
Siarhei Vishniakou64452932020-11-06 17:51:32 -06005043 if (getInputChannelLocked(handle->getToken()) == nullptr) {
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005044 const bool noInputChannel =
Prabir Pradhan51e7db02022-02-07 06:02:57 -08005045 info->inputConfig.test(WindowInfo::InputConfig::NO_INPUT_CHANNEL);
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08005046 const bool canReceiveInput =
5047 !info->inputConfig.test(WindowInfo::InputConfig::NOT_TOUCHABLE) ||
5048 !info->inputConfig.test(WindowInfo::InputConfig::NOT_FOCUSABLE);
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005049 if (canReceiveInput && !noInputChannel) {
John Recke0710582019-09-26 13:46:12 -07005050 ALOGV("Window handle %s has no registered input channel",
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005051 handle->getName().c_str());
Robert Carr2984b7a2020-04-13 17:06:45 -07005052 continue;
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005053 }
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005054 }
5055
5056 if (info->displayId != displayId) {
5057 ALOGE("Window %s updated by wrong display %d, should belong to display %d",
5058 handle->getName().c_str(), displayId, info->displayId);
5059 continue;
5060 }
5061
Robert Carredd13602020-04-13 17:24:34 -07005062 if ((oldHandlesById.find(handle->getId()) != oldHandlesById.end()) &&
5063 (oldHandlesById.at(handle->getId())->getToken() == handle->getToken())) {
chaviw98318de2021-05-19 16:45:23 -05005064 const sp<WindowInfoHandle>& oldHandle = oldHandlesById.at(handle->getId());
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005065 oldHandle->updateFrom(handle);
5066 newHandles.push_back(oldHandle);
5067 } else {
5068 newHandles.push_back(handle);
5069 }
5070 }
5071
5072 // Insert or replace
5073 mWindowHandlesByDisplay[displayId] = newHandles;
5074}
5075
Arthur Hung72d8dc32020-03-28 00:48:39 +00005076void InputDispatcher::setInputWindows(
chaviw98318de2021-05-19 16:45:23 -05005077 const std::unordered_map<int32_t, std::vector<sp<WindowInfoHandle>>>& handlesPerDisplay) {
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07005078 // TODO(b/198444055): Remove setInputWindows from InputDispatcher.
Arthur Hung72d8dc32020-03-28 00:48:39 +00005079 { // acquire lock
5080 std::scoped_lock _l(mLock);
Siarhei Vishniakou2508b872020-12-03 16:33:53 -10005081 for (const auto& [displayId, handles] : handlesPerDisplay) {
5082 setInputWindowsLocked(handles, displayId);
Arthur Hung72d8dc32020-03-28 00:48:39 +00005083 }
5084 }
5085 // Wake up poll loop since it may need to make new input dispatching choices.
5086 mLooper->wake();
5087}
5088
Arthur Hungb92218b2018-08-14 12:00:21 +08005089/**
5090 * Called from InputManagerService, update window handle list by displayId that can receive input.
5091 * A window handle contains information about InputChannel, Touch Region, Types, Focused,...
5092 * If set an empty list, remove all handles from the specific display.
5093 * For focused handle, check if need to change and send a cancel event to previous one.
5094 * For removed handle, check if need to send a cancel event if already in touch.
5095 */
Arthur Hung72d8dc32020-03-28 00:48:39 +00005096void InputDispatcher::setInputWindowsLocked(
chaviw98318de2021-05-19 16:45:23 -05005097 const std::vector<sp<WindowInfoHandle>>& windowInfoHandles, int32_t displayId) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005098 if (DEBUG_FOCUS) {
5099 std::string windowList;
chaviw98318de2021-05-19 16:45:23 -05005100 for (const sp<WindowInfoHandle>& iwh : windowInfoHandles) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005101 windowList += iwh->getName() + " ";
5102 }
5103 ALOGD("setInputWindows displayId=%" PRId32 " %s", displayId, windowList.c_str());
5104 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005105
Prabir Pradhand65552b2021-10-07 11:23:50 -07005106 // Check preconditions for new input windows
chaviw98318de2021-05-19 16:45:23 -05005107 for (const sp<WindowInfoHandle>& window : windowInfoHandles) {
Prabir Pradhand65552b2021-10-07 11:23:50 -07005108 const WindowInfo& info = *window->getInfo();
5109
5110 // Ensure all tokens are null if the window has feature NO_INPUT_CHANNEL
Prabir Pradhan51e7db02022-02-07 06:02:57 -08005111 const bool noInputWindow = info.inputConfig.test(WindowInfo::InputConfig::NO_INPUT_CHANNEL);
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05005112 if (noInputWindow && window->getToken() != nullptr) {
5113 ALOGE("%s has feature NO_INPUT_WINDOW, but a non-null token. Clearing",
5114 window->getName().c_str());
5115 window->releaseChannel();
5116 }
Prabir Pradhand65552b2021-10-07 11:23:50 -07005117
Prabir Pradhan5c85e052021-12-22 02:27:12 -08005118 // Ensure all spy windows are trusted overlays
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08005119 LOG_ALWAYS_FATAL_IF(info.isSpy() &&
5120 !info.inputConfig.test(
5121 WindowInfo::InputConfig::TRUSTED_OVERLAY),
Prabir Pradhan5c85e052021-12-22 02:27:12 -08005122 "%s has feature SPY, but is not a trusted overlay.",
5123 window->getName().c_str());
5124
Prabir Pradhand65552b2021-10-07 11:23:50 -07005125 // Ensure all stylus interceptors are trusted overlays
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08005126 LOG_ALWAYS_FATAL_IF(info.interceptsStylus() &&
5127 !info.inputConfig.test(
5128 WindowInfo::InputConfig::TRUSTED_OVERLAY),
Prabir Pradhand65552b2021-10-07 11:23:50 -07005129 "%s has feature INTERCEPTS_STYLUS, but is not a trusted overlay.",
5130 window->getName().c_str());
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05005131 }
5132
Arthur Hung72d8dc32020-03-28 00:48:39 +00005133 // Copy old handles for release if they are no longer present.
chaviw98318de2021-05-19 16:45:23 -05005134 const std::vector<sp<WindowInfoHandle>> oldWindowHandles = getWindowHandlesLocked(displayId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005135
Prabir Pradhan93a0f912021-04-21 13:47:42 -07005136 // Save the old windows' orientation by ID before it gets updated.
5137 std::unordered_map<int32_t, uint32_t> oldWindowOrientations;
chaviw98318de2021-05-19 16:45:23 -05005138 for (const sp<WindowInfoHandle>& handle : oldWindowHandles) {
Prabir Pradhan93a0f912021-04-21 13:47:42 -07005139 oldWindowOrientations.emplace(handle->getId(),
5140 handle->getInfo()->transform.getOrientation());
5141 }
5142
chaviw98318de2021-05-19 16:45:23 -05005143 updateWindowHandlesForDisplayLocked(windowInfoHandles, displayId);
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005144
chaviw98318de2021-05-19 16:45:23 -05005145 const std::vector<sp<WindowInfoHandle>>& windowHandles = getWindowHandlesLocked(displayId);
Arthur Hung72d8dc32020-03-28 00:48:39 +00005146
Vishnu Nairc519ff72021-01-21 08:23:08 -08005147 std::optional<FocusResolver::FocusChanges> changes =
5148 mFocusResolver.setInputWindows(displayId, windowHandles);
5149 if (changes) {
5150 onFocusChangedLocked(*changes);
Arthur Hung72d8dc32020-03-28 00:48:39 +00005151 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005152
Siarhei Vishniakou4700f822020-03-24 19:05:54 -07005153 std::unordered_map<int32_t, TouchState>::iterator stateIt =
5154 mTouchStatesByDisplay.find(displayId);
5155 if (stateIt != mTouchStatesByDisplay.end()) {
5156 TouchState& state = stateIt->second;
Arthur Hung72d8dc32020-03-28 00:48:39 +00005157 for (size_t i = 0; i < state.windows.size();) {
5158 TouchedWindow& touchedWindow = state.windows[i];
Prabir Pradhan6a9a8312021-04-23 11:59:31 -07005159 if (getWindowHandleLocked(touchedWindow.windowHandle) == nullptr) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005160 if (DEBUG_FOCUS) {
Arthur Hung72d8dc32020-03-28 00:48:39 +00005161 ALOGD("Touched window was removed: %s in display %" PRId32,
5162 touchedWindow.windowHandle->getName().c_str(), displayId);
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005163 }
Siarhei Vishniakouce5ab082020-07-09 17:03:21 -05005164 std::shared_ptr<InputChannel> touchedInputChannel =
Arthur Hung72d8dc32020-03-28 00:48:39 +00005165 getInputChannelLocked(touchedWindow.windowHandle->getToken());
5166 if (touchedInputChannel != nullptr) {
Michael Wrightfb04fd52022-11-24 22:31:11 +00005167 CancelationOptions options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS,
Arthur Hung72d8dc32020-03-28 00:48:39 +00005168 "touched window was removed");
5169 synthesizeCancelationEventsForInputChannelLocked(touchedInputChannel, options);
Siarhei Vishniakouca205502021-07-16 21:31:58 +00005170 // Since we are about to drop the touch, cancel the events for the wallpaper as
5171 // well.
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08005172 if (touchedWindow.targetFlags.test(InputTarget::Flags::FOREGROUND) &&
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08005173 touchedWindow.windowHandle->getInfo()->inputConfig.test(
5174 gui::WindowInfo::InputConfig::DUPLICATE_TOUCH_TO_WALLPAPER)) {
Siarhei Vishniakouca205502021-07-16 21:31:58 +00005175 sp<WindowInfoHandle> wallpaper = state.getWallpaperWindow();
Arthur Hungc539dbb2022-12-08 07:45:36 +00005176 synthesizeCancelationEventsForWindowLocked(wallpaper, options);
Siarhei Vishniakouca205502021-07-16 21:31:58 +00005177 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005178 }
Arthur Hung72d8dc32020-03-28 00:48:39 +00005179 state.windows.erase(state.windows.begin() + i);
5180 } else {
5181 ++i;
Michael Wrightd02c5b62014-02-10 15:10:22 -08005182 }
5183 }
arthurhungb89ccb02020-12-30 16:19:01 +08005184
arthurhung6d4bed92021-03-17 11:59:33 +08005185 // If drag window is gone, it would receive a cancel event and broadcast the DRAG_END. We
arthurhungb89ccb02020-12-30 16:19:01 +08005186 // could just clear the state here.
Arthur Hung3915c1f2022-05-31 07:17:17 +00005187 if (mDragState && mDragState->dragWindow->getInfo()->displayId == displayId &&
arthurhung6d4bed92021-03-17 11:59:33 +08005188 std::find(windowHandles.begin(), windowHandles.end(), mDragState->dragWindow) ==
arthurhungb89ccb02020-12-30 16:19:01 +08005189 windowHandles.end()) {
Arthur Hung3915c1f2022-05-31 07:17:17 +00005190 ALOGI("Drag window went away: %s", mDragState->dragWindow->getName().c_str());
5191 sendDropWindowCommandLocked(nullptr, 0, 0);
arthurhung6d4bed92021-03-17 11:59:33 +08005192 mDragState.reset();
arthurhungb89ccb02020-12-30 16:19:01 +08005193 }
Arthur Hung72d8dc32020-03-28 00:48:39 +00005194 }
Arthur Hung25e2af12020-03-26 12:58:37 +00005195
Prabir Pradhan8b89c2f2021-07-29 16:30:14 +00005196 // Determine if the orientation of any of the input windows have changed, and cancel all
5197 // pointer events if necessary.
5198 for (const sp<WindowInfoHandle>& oldWindowHandle : oldWindowHandles) {
5199 const sp<WindowInfoHandle> newWindowHandle = getWindowHandleLocked(oldWindowHandle);
5200 if (newWindowHandle != nullptr &&
5201 newWindowHandle->getInfo()->transform.getOrientation() !=
5202 oldWindowOrientations[oldWindowHandle->getId()]) {
5203 std::shared_ptr<InputChannel> inputChannel =
5204 getInputChannelLocked(newWindowHandle->getToken());
5205 if (inputChannel != nullptr) {
Michael Wrightfb04fd52022-11-24 22:31:11 +00005206 CancelationOptions options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS,
Prabir Pradhan8b89c2f2021-07-29 16:30:14 +00005207 "touched window's orientation changed");
5208 synthesizeCancelationEventsForInputChannelLocked(inputChannel, options);
Prabir Pradhan93a0f912021-04-21 13:47:42 -07005209 }
5210 }
5211 }
5212
Arthur Hung72d8dc32020-03-28 00:48:39 +00005213 // Release information for windows that are no longer present.
5214 // This ensures that unused input channels are released promptly.
5215 // Otherwise, they might stick around until the window handle is destroyed
5216 // which might not happen until the next GC.
chaviw98318de2021-05-19 16:45:23 -05005217 for (const sp<WindowInfoHandle>& oldWindowHandle : oldWindowHandles) {
Prabir Pradhan6a9a8312021-04-23 11:59:31 -07005218 if (getWindowHandleLocked(oldWindowHandle) == nullptr) {
Arthur Hung72d8dc32020-03-28 00:48:39 +00005219 if (DEBUG_FOCUS) {
5220 ALOGD("Window went away: %s", oldWindowHandle->getName().c_str());
Arthur Hung25e2af12020-03-26 12:58:37 +00005221 }
Arthur Hung72d8dc32020-03-28 00:48:39 +00005222 oldWindowHandle->releaseChannel();
Arthur Hung25e2af12020-03-26 12:58:37 +00005223 }
chaviw291d88a2019-02-14 10:33:58 -08005224 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005225}
5226
5227void InputDispatcher::setFocusedApplication(
Chris Yea209fde2020-07-22 13:54:51 -07005228 int32_t displayId, const std::shared_ptr<InputApplicationHandle>& inputApplicationHandle) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005229 if (DEBUG_FOCUS) {
5230 ALOGD("setFocusedApplication displayId=%" PRId32 " %s", displayId,
5231 inputApplicationHandle ? inputApplicationHandle->getName().c_str() : "<nullptr>");
5232 }
Siarhei Vishniakoue41c4512020-09-08 19:35:58 -05005233 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08005234 std::scoped_lock _l(mLock);
Vishnu Nair599f1412021-06-21 10:39:58 -07005235 setFocusedApplicationLocked(displayId, inputApplicationHandle);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005236 } // release lock
5237
5238 // Wake up poll loop since it may need to make new input dispatching choices.
5239 mLooper->wake();
5240}
5241
Vishnu Nair599f1412021-06-21 10:39:58 -07005242void InputDispatcher::setFocusedApplicationLocked(
5243 int32_t displayId, const std::shared_ptr<InputApplicationHandle>& inputApplicationHandle) {
5244 std::shared_ptr<InputApplicationHandle> oldFocusedApplicationHandle =
5245 getValueByKey(mFocusedApplicationHandlesByDisplay, displayId);
5246
5247 if (sharedPointersEqual(oldFocusedApplicationHandle, inputApplicationHandle)) {
5248 return; // This application is already focused. No need to wake up or change anything.
5249 }
5250
5251 // Set the new application handle.
5252 if (inputApplicationHandle != nullptr) {
5253 mFocusedApplicationHandlesByDisplay[displayId] = inputApplicationHandle;
5254 } else {
5255 mFocusedApplicationHandlesByDisplay.erase(displayId);
5256 }
5257
5258 // No matter what the old focused application was, stop waiting on it because it is
5259 // no longer focused.
5260 resetNoFocusedWindowTimeoutLocked();
5261}
5262
Tiger Huang721e26f2018-07-24 22:26:19 +08005263/**
5264 * Sets the focused display, which is responsible for receiving focus-dispatched input events where
5265 * the display not specified.
5266 *
5267 * We track any unreleased events for each window. If a window loses the ability to receive the
5268 * released event, we will send a cancel event to it. So when the focused display is changed, we
5269 * cancel all the unreleased display-unspecified events for the focused window on the old focused
5270 * display. The display-specified events won't be affected.
5271 */
5272void InputDispatcher::setFocusedDisplay(int32_t displayId) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005273 if (DEBUG_FOCUS) {
5274 ALOGD("setFocusedDisplay displayId=%" PRId32, displayId);
5275 }
Tiger Huang721e26f2018-07-24 22:26:19 +08005276 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08005277 std::scoped_lock _l(mLock);
Tiger Huang721e26f2018-07-24 22:26:19 +08005278
5279 if (mFocusedDisplayId != displayId) {
Vishnu Nairad321cd2020-08-20 16:40:21 -07005280 sp<IBinder> oldFocusedWindowToken =
Vishnu Nairc519ff72021-01-21 08:23:08 -08005281 mFocusResolver.getFocusedWindowToken(mFocusedDisplayId);
Vishnu Nairad321cd2020-08-20 16:40:21 -07005282 if (oldFocusedWindowToken != nullptr) {
Siarhei Vishniakouce5ab082020-07-09 17:03:21 -05005283 std::shared_ptr<InputChannel> inputChannel =
Vishnu Nairad321cd2020-08-20 16:40:21 -07005284 getInputChannelLocked(oldFocusedWindowToken);
Tiger Huang721e26f2018-07-24 22:26:19 +08005285 if (inputChannel != nullptr) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07005286 CancelationOptions
Michael Wrightfb04fd52022-11-24 22:31:11 +00005287 options(CancelationOptions::Mode::CANCEL_NON_POINTER_EVENTS,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07005288 "The display which contains this window no longer has focus.");
Michael Wright3dd60e22019-03-27 22:06:44 +00005289 options.displayId = ADISPLAY_ID_NONE;
Tiger Huang721e26f2018-07-24 22:26:19 +08005290 synthesizeCancelationEventsForInputChannelLocked(inputChannel, options);
5291 }
5292 }
5293 mFocusedDisplayId = displayId;
5294
Chris Ye3c2d6f52020-08-09 10:39:48 -07005295 // Find new focused window and validate
Vishnu Nairc519ff72021-01-21 08:23:08 -08005296 sp<IBinder> newFocusedWindowToken = mFocusResolver.getFocusedWindowToken(displayId);
Prabir Pradhancef936d2021-07-21 16:17:52 +00005297 sendFocusChangedCommandLocked(oldFocusedWindowToken, newFocusedWindowToken);
Robert Carrf759f162018-11-13 12:57:11 -08005298
Vishnu Nairad321cd2020-08-20 16:40:21 -07005299 if (newFocusedWindowToken == nullptr) {
Tiger Huang721e26f2018-07-24 22:26:19 +08005300 ALOGW("Focused display #%" PRId32 " does not have a focused window.", displayId);
Vishnu Nairc519ff72021-01-21 08:23:08 -08005301 if (mFocusResolver.hasFocusedWindowTokens()) {
Vishnu Nairad321cd2020-08-20 16:40:21 -07005302 ALOGE("But another display has a focused window\n%s",
Vishnu Nairc519ff72021-01-21 08:23:08 -08005303 mFocusResolver.dumpFocusedWindows().c_str());
Tiger Huang721e26f2018-07-24 22:26:19 +08005304 }
5305 }
5306 }
Tiger Huang721e26f2018-07-24 22:26:19 +08005307 } // release lock
5308
5309 // Wake up poll loop since it may need to make new input dispatching choices.
5310 mLooper->wake();
5311}
5312
Michael Wrightd02c5b62014-02-10 15:10:22 -08005313void InputDispatcher::setInputDispatchMode(bool enabled, bool frozen) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005314 if (DEBUG_FOCUS) {
5315 ALOGD("setInputDispatchMode: enabled=%d, frozen=%d", enabled, frozen);
5316 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005317
5318 bool changed;
5319 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08005320 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005321
5322 if (mDispatchEnabled != enabled || mDispatchFrozen != frozen) {
5323 if (mDispatchFrozen && !frozen) {
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005324 resetNoFocusedWindowTimeoutLocked();
Michael Wrightd02c5b62014-02-10 15:10:22 -08005325 }
5326
5327 if (mDispatchEnabled && !enabled) {
5328 resetAndDropEverythingLocked("dispatcher is being disabled");
5329 }
5330
5331 mDispatchEnabled = enabled;
5332 mDispatchFrozen = frozen;
5333 changed = true;
5334 } else {
5335 changed = false;
5336 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005337 } // release lock
5338
5339 if (changed) {
5340 // Wake up poll loop since it may need to make new input dispatching choices.
5341 mLooper->wake();
5342 }
5343}
5344
5345void InputDispatcher::setInputFilterEnabled(bool enabled) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005346 if (DEBUG_FOCUS) {
5347 ALOGD("setInputFilterEnabled: enabled=%d", enabled);
5348 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005349
5350 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08005351 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005352
5353 if (mInputFilterEnabled == enabled) {
5354 return;
5355 }
5356
5357 mInputFilterEnabled = enabled;
5358 resetAndDropEverythingLocked("input filter is being enabled or disabled");
5359 } // release lock
5360
5361 // Wake up poll loop since there might be work to do to drop everything.
5362 mLooper->wake();
5363}
5364
Prabir Pradhane59c6dc2023-06-13 19:53:03 +00005365bool InputDispatcher::setInTouchMode(bool inTouchMode, gui::Pid pid, gui::Uid uid,
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00005366 bool hasPermission, int32_t displayId) {
Antonio Kantekf16f2832021-09-28 04:39:20 +00005367 bool needWake = false;
5368 {
5369 std::scoped_lock lock(mLock);
Antonio Kantek15beb512022-06-13 22:35:41 +00005370 ALOGD_IF(DEBUG_TOUCH_MODE,
Prabir Pradhane59c6dc2023-06-13 19:53:03 +00005371 "Request to change touch mode to %s (calling pid=%s, uid=%s, "
Antonio Kantek15beb512022-06-13 22:35:41 +00005372 "hasPermission=%s, target displayId=%d, mTouchModePerDisplay[displayId]=%s)",
Prabir Pradhane59c6dc2023-06-13 19:53:03 +00005373 toString(inTouchMode), pid.toString().c_str(), uid.toString().c_str(),
5374 toString(hasPermission), displayId,
Antonio Kantek15beb512022-06-13 22:35:41 +00005375 mTouchModePerDisplay.count(displayId) == 0
5376 ? "not set"
5377 : std::to_string(mTouchModePerDisplay[displayId]).c_str());
5378
Antonio Kantek15beb512022-06-13 22:35:41 +00005379 auto touchModeIt = mTouchModePerDisplay.find(displayId);
5380 if (touchModeIt != mTouchModePerDisplay.end() && touchModeIt->second == inTouchMode) {
Antonio Kantekea47acb2021-12-23 12:41:25 -08005381 return false;
Antonio Kantekf16f2832021-09-28 04:39:20 +00005382 }
Antonio Kantekea47acb2021-12-23 12:41:25 -08005383 if (!hasPermission) {
Antonio Kantek48710e42022-03-24 14:19:30 -07005384 if (!focusedWindowIsOwnedByLocked(pid, uid) &&
5385 !recentWindowsAreOwnedByLocked(pid, uid)) {
Prabir Pradhane59c6dc2023-06-13 19:53:03 +00005386 ALOGD("Touch mode switch rejected, caller (pid=%s, uid=%s) doesn't own the focused "
Antonio Kantek48710e42022-03-24 14:19:30 -07005387 "window nor none of the previously interacted window",
Prabir Pradhane59c6dc2023-06-13 19:53:03 +00005388 pid.toString().c_str(), uid.toString().c_str());
Antonio Kantekea47acb2021-12-23 12:41:25 -08005389 return false;
5390 }
Antonio Kantekf16f2832021-09-28 04:39:20 +00005391 }
Antonio Kantek15beb512022-06-13 22:35:41 +00005392 mTouchModePerDisplay[displayId] = inTouchMode;
5393 auto entry = std::make_unique<TouchModeEntry>(mIdGenerator.nextId(), now(), inTouchMode,
5394 displayId);
Antonio Kantekf16f2832021-09-28 04:39:20 +00005395 needWake = enqueueInboundEventLocked(std::move(entry));
5396 } // release lock
5397
5398 if (needWake) {
5399 mLooper->wake();
5400 }
Antonio Kantekea47acb2021-12-23 12:41:25 -08005401 return true;
Siarhei Vishniakouf3bc1aa2019-11-25 13:48:53 -08005402}
5403
Prabir Pradhane59c6dc2023-06-13 19:53:03 +00005404bool InputDispatcher::focusedWindowIsOwnedByLocked(gui::Pid pid, gui::Uid uid) {
Antonio Kantek48710e42022-03-24 14:19:30 -07005405 const sp<IBinder> focusedToken = mFocusResolver.getFocusedWindowToken(mFocusedDisplayId);
5406 if (focusedToken == nullptr) {
5407 return false;
5408 }
5409 sp<WindowInfoHandle> windowHandle = getWindowHandleLocked(focusedToken);
5410 return isWindowOwnedBy(windowHandle, pid, uid);
5411}
5412
Prabir Pradhane59c6dc2023-06-13 19:53:03 +00005413bool InputDispatcher::recentWindowsAreOwnedByLocked(gui::Pid pid, gui::Uid uid) {
Antonio Kantek48710e42022-03-24 14:19:30 -07005414 return std::find_if(mInteractionConnectionTokens.begin(), mInteractionConnectionTokens.end(),
5415 [&](const sp<IBinder>& connectionToken) REQUIRES(mLock) {
5416 const sp<WindowInfoHandle> windowHandle =
5417 getWindowHandleLocked(connectionToken);
5418 return isWindowOwnedBy(windowHandle, pid, uid);
5419 }) != mInteractionConnectionTokens.end();
5420}
5421
Bernardo Rufinoea97d182020-08-19 14:43:14 +01005422void InputDispatcher::setMaximumObscuringOpacityForTouch(float opacity) {
5423 if (opacity < 0 || opacity > 1) {
5424 LOG_ALWAYS_FATAL("Maximum obscuring opacity for touch should be >= 0 and <= 1");
5425 return;
5426 }
5427
5428 std::scoped_lock lock(mLock);
5429 mMaximumObscuringOpacityForTouch = opacity;
5430}
5431
Siarhei Vishniakou40b8fbd2022-11-04 10:50:26 -07005432std::tuple<TouchState*, TouchedWindow*, int32_t /*displayId*/>
5433InputDispatcher::findTouchStateWindowAndDisplayLocked(const sp<IBinder>& token) {
Arthur Hungabbb9d82021-09-01 14:52:30 +00005434 for (auto& [displayId, state] : mTouchStatesByDisplay) {
5435 for (TouchedWindow& w : state.windows) {
5436 if (w.windowHandle->getToken() == token) {
Siarhei Vishniakou40b8fbd2022-11-04 10:50:26 -07005437 return std::make_tuple(&state, &w, displayId);
Arthur Hungabbb9d82021-09-01 14:52:30 +00005438 }
5439 }
5440 }
Siarhei Vishniakou40b8fbd2022-11-04 10:50:26 -07005441 return std::make_tuple(nullptr, nullptr, ADISPLAY_ID_DEFAULT);
Arthur Hungabbb9d82021-09-01 14:52:30 +00005442}
5443
arthurhungb89ccb02020-12-30 16:19:01 +08005444bool InputDispatcher::transferTouchFocus(const sp<IBinder>& fromToken, const sp<IBinder>& toToken,
5445 bool isDragDrop) {
chaviwfbe5d9c2018-12-26 12:23:37 -08005446 if (fromToken == toToken) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005447 if (DEBUG_FOCUS) {
5448 ALOGD("Trivial transfer to same window.");
5449 }
chaviwfbe5d9c2018-12-26 12:23:37 -08005450 return true;
5451 }
5452
Michael Wrightd02c5b62014-02-10 15:10:22 -08005453 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08005454 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005455
Arthur Hungabbb9d82021-09-01 14:52:30 +00005456 // Find the target touch state and touched window by fromToken.
Siarhei Vishniakou40b8fbd2022-11-04 10:50:26 -07005457 auto [state, touchedWindow, displayId] = findTouchStateWindowAndDisplayLocked(fromToken);
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07005458
Arthur Hungabbb9d82021-09-01 14:52:30 +00005459 if (state == nullptr || touchedWindow == nullptr) {
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07005460 ALOGD("Touch transfer failed because from window is not being touched.");
Michael Wrightd02c5b62014-02-10 15:10:22 -08005461 return false;
5462 }
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07005463 std::set<int32_t> deviceIds = touchedWindow->getTouchingDeviceIds();
5464 if (deviceIds.size() != 1) {
5465 LOG(DEBUG) << "Can't transfer touch. Currently touching devices: " << dumpSet(deviceIds)
5466 << " for window: " << touchedWindow->dump();
5467 return false;
5468 }
5469 const int32_t deviceId = *deviceIds.begin();
Arthur Hungabbb9d82021-09-01 14:52:30 +00005470
Arthur Hungabbb9d82021-09-01 14:52:30 +00005471 sp<WindowInfoHandle> toWindowHandle = getWindowHandleLocked(toToken, displayId);
5472 if (toWindowHandle == nullptr) {
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07005473 ALOGW("Cannot transfer touch because to window not found.");
Arthur Hungabbb9d82021-09-01 14:52:30 +00005474 return false;
5475 }
5476
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005477 if (DEBUG_FOCUS) {
5478 ALOGD("transferTouchFocus: fromWindowHandle=%s, toWindowHandle=%s",
Arthur Hungabbb9d82021-09-01 14:52:30 +00005479 touchedWindow->windowHandle->getName().c_str(),
5480 toWindowHandle->getName().c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08005481 }
5482
Arthur Hungabbb9d82021-09-01 14:52:30 +00005483 // Erase old window.
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08005484 ftl::Flags<InputTarget::Flags> oldTargetFlags = touchedWindow->targetFlags;
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07005485 std::bitset<MAX_POINTER_ID + 1> pointerIds = touchedWindow->getTouchingPointers(deviceId);
Arthur Hungc539dbb2022-12-08 07:45:36 +00005486 sp<WindowInfoHandle> fromWindowHandle = touchedWindow->windowHandle;
Arthur Hungabbb9d82021-09-01 14:52:30 +00005487 state->removeWindowByToken(fromToken);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005488
Arthur Hungabbb9d82021-09-01 14:52:30 +00005489 // Add new window.
Vaibhav Devmurari882bd9b2022-06-23 14:54:54 +00005490 nsecs_t downTimeInTarget = now();
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08005491 ftl::Flags<InputTarget::Flags> newTargetFlags =
5492 oldTargetFlags & (InputTarget::Flags::SPLIT | InputTarget::Flags::DISPATCH_AS_IS);
Prabir Pradhan6dfbf262022-03-14 15:24:30 +00005493 if (canReceiveForegroundTouches(*toWindowHandle->getInfo())) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08005494 newTargetFlags |= InputTarget::Flags::FOREGROUND;
Prabir Pradhan6dfbf262022-03-14 15:24:30 +00005495 }
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07005496 state->addOrUpdateWindow(toWindowHandle, newTargetFlags, deviceId, pointerIds,
5497 downTimeInTarget);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005498
Arthur Hungabbb9d82021-09-01 14:52:30 +00005499 // Store the dragging window.
5500 if (isDragDrop) {
Arthur Hungb75c2aa2022-07-15 09:35:36 +00005501 if (pointerIds.count() != 1) {
5502 ALOGW("The drag and drop cannot be started when there is no pointer or more than 1"
5503 " pointer on the window.");
Arthur Hung54745652022-04-20 07:17:41 +00005504 return false;
5505 }
Arthur Hungb75c2aa2022-07-15 09:35:36 +00005506 // Track the pointer id for drag window and generate the drag state.
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08005507 const size_t id = firstMarkedBit(pointerIds);
Arthur Hung54745652022-04-20 07:17:41 +00005508 mDragState = std::make_unique<DragState>(toWindowHandle, id);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005509 }
5510
Arthur Hungabbb9d82021-09-01 14:52:30 +00005511 // Synthesize cancel for old window and down for new window.
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07005512 std::shared_ptr<Connection> fromConnection = getConnectionLocked(fromToken);
5513 std::shared_ptr<Connection> toConnection = getConnectionLocked(toToken);
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07005514 if (fromConnection != nullptr && toConnection != nullptr) {
Svet Ganov5d3bc372020-01-26 23:11:07 -08005515 fromConnection->inputState.mergePointerStateTo(toConnection->inputState);
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07005516 CancelationOptions options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS,
5517 "transferring touch from this window to another window");
Michael Wrightd02c5b62014-02-10 15:10:22 -08005518 synthesizeCancelationEventsForConnectionLocked(fromConnection, options);
Arthur Hungc539dbb2022-12-08 07:45:36 +00005519 synthesizePointerDownEventsForConnectionLocked(downTimeInTarget, toConnection,
5520 newTargetFlags);
5521
5522 // Check if the wallpaper window should deliver the corresponding event.
5523 transferWallpaperTouch(oldTargetFlags, newTargetFlags, fromWindowHandle, toWindowHandle,
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07005524 *state, deviceId, pointerIds);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005525 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005526 } // release lock
5527
5528 // Wake up poll loop since it may need to make new input dispatching choices.
5529 mLooper->wake();
5530 return true;
5531}
5532
Siarhei Vishniakou7ae7afd2022-03-31 15:26:13 -07005533/**
5534 * Get the touched foreground window on the given display.
5535 * Return null if there are no windows touched on that display, or if more than one foreground
5536 * window is being touched.
5537 */
5538sp<WindowInfoHandle> InputDispatcher::findTouchedForegroundWindowLocked(int32_t displayId) const {
5539 auto stateIt = mTouchStatesByDisplay.find(displayId);
5540 if (stateIt == mTouchStatesByDisplay.end()) {
5541 ALOGI("No touch state on display %" PRId32, displayId);
5542 return nullptr;
5543 }
5544
5545 const TouchState& state = stateIt->second;
5546 sp<WindowInfoHandle> touchedForegroundWindow;
5547 // If multiple foreground windows are touched, return nullptr
5548 for (const TouchedWindow& window : state.windows) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08005549 if (window.targetFlags.test(InputTarget::Flags::FOREGROUND)) {
Siarhei Vishniakou7ae7afd2022-03-31 15:26:13 -07005550 if (touchedForegroundWindow != nullptr) {
5551 ALOGI("Two or more foreground windows: %s and %s",
5552 touchedForegroundWindow->getName().c_str(),
5553 window.windowHandle->getName().c_str());
5554 return nullptr;
5555 }
5556 touchedForegroundWindow = window.windowHandle;
5557 }
5558 }
5559 return touchedForegroundWindow;
5560}
5561
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +00005562// Binder call
Siarhei Vishniakou7ae7afd2022-03-31 15:26:13 -07005563bool InputDispatcher::transferTouch(const sp<IBinder>& destChannelToken, int32_t displayId) {
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +00005564 sp<IBinder> fromToken;
5565 { // acquire lock
5566 std::scoped_lock _l(mLock);
Arthur Hungabbb9d82021-09-01 14:52:30 +00005567 sp<WindowInfoHandle> toWindowHandle = getWindowHandleLocked(destChannelToken, displayId);
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +00005568 if (toWindowHandle == nullptr) {
Siarhei Vishniakou7ae7afd2022-03-31 15:26:13 -07005569 ALOGW("Could not find window associated with token=%p on display %" PRId32,
5570 destChannelToken.get(), displayId);
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +00005571 return false;
5572 }
5573
Siarhei Vishniakou7ae7afd2022-03-31 15:26:13 -07005574 sp<WindowInfoHandle> from = findTouchedForegroundWindowLocked(displayId);
5575 if (from == nullptr) {
5576 ALOGE("Could not find a source window in %s for %p", __func__, destChannelToken.get());
5577 return false;
5578 }
5579
5580 fromToken = from->getToken();
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +00005581 } // release lock
5582
5583 return transferTouchFocus(fromToken, destChannelToken);
5584}
5585
Michael Wrightd02c5b62014-02-10 15:10:22 -08005586void InputDispatcher::resetAndDropEverythingLocked(const char* reason) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005587 if (DEBUG_FOCUS) {
5588 ALOGD("Resetting and dropping all events (%s).", reason);
5589 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005590
Michael Wrightfb04fd52022-11-24 22:31:11 +00005591 CancelationOptions options(CancelationOptions::Mode::CANCEL_ALL_EVENTS, reason);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005592 synthesizeCancelationEventsForAllConnectionsLocked(options);
5593
5594 resetKeyRepeatLocked();
5595 releasePendingEventLocked();
5596 drainInboundQueueLocked();
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005597 resetNoFocusedWindowTimeoutLocked();
Michael Wrightd02c5b62014-02-10 15:10:22 -08005598
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005599 mAnrTracker.clear();
Jeff Brownf086ddb2014-02-11 14:28:48 -08005600 mTouchStatesByDisplay.clear();
Michael Wright78f24442014-08-06 15:55:28 -07005601 mReplacedKeys.clear();
Michael Wrightd02c5b62014-02-10 15:10:22 -08005602}
5603
Siarhei Vishniakou4c9d6ff2023-04-18 11:23:20 -07005604void InputDispatcher::logDispatchStateLocked() const {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005605 std::string dump;
Michael Wrightd02c5b62014-02-10 15:10:22 -08005606 dumpDispatchStateLocked(dump);
5607
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005608 std::istringstream stream(dump);
5609 std::string line;
5610
5611 while (std::getline(stream, line, '\n')) {
Siarhei Vishniakoua235c042023-05-02 09:59:09 -07005612 ALOGI("%s", line.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08005613 }
5614}
5615
Siarhei Vishniakou4c9d6ff2023-04-18 11:23:20 -07005616std::string InputDispatcher::dumpPointerCaptureStateLocked() const {
Prabir Pradhan99987712020-11-10 18:43:05 -08005617 std::string dump;
5618
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00005619 dump += StringPrintf(INDENT "Pointer Capture Requested: %s\n",
5620 toString(mCurrentPointerCaptureRequest.enable));
Prabir Pradhan99987712020-11-10 18:43:05 -08005621
5622 std::string windowName = "None";
5623 if (mWindowTokenWithPointerCapture) {
chaviw98318de2021-05-19 16:45:23 -05005624 const sp<WindowInfoHandle> captureWindowHandle =
Prabir Pradhan99987712020-11-10 18:43:05 -08005625 getWindowHandleLocked(mWindowTokenWithPointerCapture);
5626 windowName = captureWindowHandle ? captureWindowHandle->getName().c_str()
5627 : "token has capture without window";
5628 }
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00005629 dump += StringPrintf(INDENT "Current Window with Pointer Capture: %s\n", windowName.c_str());
Prabir Pradhan99987712020-11-10 18:43:05 -08005630
5631 return dump;
5632}
5633
Siarhei Vishniakou4c9d6ff2023-04-18 11:23:20 -07005634void InputDispatcher::dumpDispatchStateLocked(std::string& dump) const {
Siarhei Vishniakou043a3ec2019-05-01 11:30:46 -07005635 dump += StringPrintf(INDENT "DispatchEnabled: %s\n", toString(mDispatchEnabled));
5636 dump += StringPrintf(INDENT "DispatchFrozen: %s\n", toString(mDispatchFrozen));
5637 dump += StringPrintf(INDENT "InputFilterEnabled: %s\n", toString(mInputFilterEnabled));
Tiger Huang721e26f2018-07-24 22:26:19 +08005638 dump += StringPrintf(INDENT "FocusedDisplayId: %" PRId32 "\n", mFocusedDisplayId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005639
Tiger Huang721e26f2018-07-24 22:26:19 +08005640 if (!mFocusedApplicationHandlesByDisplay.empty()) {
5641 dump += StringPrintf(INDENT "FocusedApplications:\n");
5642 for (auto& it : mFocusedApplicationHandlesByDisplay) {
5643 const int32_t displayId = it.first;
Chris Yea209fde2020-07-22 13:54:51 -07005644 const std::shared_ptr<InputApplicationHandle>& applicationHandle = it.second;
Siarhei Vishniakou70622952020-07-30 11:17:23 -05005645 const std::chrono::duration timeout =
5646 applicationHandle->getDispatchingTimeout(DEFAULT_INPUT_DISPATCHING_TIMEOUT);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07005647 dump += StringPrintf(INDENT2 "displayId=%" PRId32
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07005648 ", name='%s', dispatchingTimeout=%" PRId64 "ms\n",
Siarhei Vishniakou70622952020-07-30 11:17:23 -05005649 displayId, applicationHandle->getName().c_str(), millis(timeout));
Tiger Huang721e26f2018-07-24 22:26:19 +08005650 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005651 } else {
Tiger Huang721e26f2018-07-24 22:26:19 +08005652 dump += StringPrintf(INDENT "FocusedApplications: <none>\n");
Michael Wrightd02c5b62014-02-10 15:10:22 -08005653 }
Tiger Huang721e26f2018-07-24 22:26:19 +08005654
Vishnu Nairc519ff72021-01-21 08:23:08 -08005655 dump += mFocusResolver.dump();
Prabir Pradhan99987712020-11-10 18:43:05 -08005656 dump += dumpPointerCaptureStateLocked();
Michael Wrightd02c5b62014-02-10 15:10:22 -08005657
Siarhei Vishniakou4700f822020-03-24 19:05:54 -07005658 if (!mTouchStatesByDisplay.empty()) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005659 dump += StringPrintf(INDENT "TouchStatesByDisplay:\n");
Siarhei Vishniakou40b8fbd2022-11-04 10:50:26 -07005660 for (const auto& [displayId, state] : mTouchStatesByDisplay) {
Siarhei Vishniakou6e1e9872022-11-08 17:51:35 -08005661 std::string touchStateDump = addLinePrefix(state.dump(), INDENT2);
5662 dump += INDENT2 + std::to_string(displayId) + " : " + touchStateDump;
Michael Wrightd02c5b62014-02-10 15:10:22 -08005663 }
5664 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005665 dump += INDENT "TouchStates: <no displays touched>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005666 }
5667
arthurhung6d4bed92021-03-17 11:59:33 +08005668 if (mDragState) {
5669 dump += StringPrintf(INDENT "DragState:\n");
5670 mDragState->dump(dump, INDENT2);
5671 }
5672
Arthur Hungb92218b2018-08-14 12:00:21 +08005673 if (!mWindowHandlesByDisplay.empty()) {
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07005674 for (const auto& [displayId, windowHandles] : mWindowHandlesByDisplay) {
5675 dump += StringPrintf(INDENT "Display: %" PRId32 "\n", displayId);
5676 if (const auto& it = mDisplayInfos.find(displayId); it != mDisplayInfos.end()) {
5677 const auto& displayInfo = it->second;
5678 dump += StringPrintf(INDENT2 "logicalSize=%dx%d\n", displayInfo.logicalWidth,
5679 displayInfo.logicalHeight);
5680 displayInfo.transform.dump(dump, "transform", INDENT4);
5681 } else {
5682 dump += INDENT2 "No DisplayInfo found!\n";
5683 }
5684
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08005685 if (!windowHandles.empty()) {
Arthur Hungb92218b2018-08-14 12:00:21 +08005686 dump += INDENT2 "Windows:\n";
5687 for (size_t i = 0; i < windowHandles.size(); i++) {
chaviw98318de2021-05-19 16:45:23 -05005688 const sp<WindowInfoHandle>& windowHandle = windowHandles[i];
5689 const WindowInfo* windowInfo = windowHandle->getInfo();
Michael Wrightd02c5b62014-02-10 15:10:22 -08005690
Bernardo Rufino0f6a36e2020-11-11 10:10:59 +00005691 dump += StringPrintf(INDENT3 "%zu: name='%s', id=%" PRId32 ", displayId=%d, "
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08005692 "inputConfig=%s, alpha=%.2f, "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07005693 "frame=[%d,%d][%d,%d], globalScale=%f, "
Bernardo Rufino49d99e42021-01-18 15:16:59 +00005694 "applicationInfo.name=%s, "
5695 "applicationInfo.token=%s, "
chaviw1ff3d1e2020-07-01 15:53:47 -07005696 "touchableRegion=",
Bernardo Rufino0f6a36e2020-11-11 10:10:59 +00005697 i, windowInfo->name.c_str(), windowInfo->id,
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08005698 windowInfo->displayId,
5699 windowInfo->inputConfig.string().c_str(),
5700 windowInfo->alpha, windowInfo->frameLeft,
5701 windowInfo->frameTop, windowInfo->frameRight,
5702 windowInfo->frameBottom, windowInfo->globalScaleFactor,
Bernardo Rufino49d99e42021-01-18 15:16:59 +00005703 windowInfo->applicationInfo.name.c_str(),
Siarhei Vishniakou63b63612023-04-12 11:00:23 -07005704 binderToString(windowInfo->applicationInfo.token).c_str());
Bernardo Rufino53fc31e2020-11-03 11:01:07 +00005705 dump += dumpRegion(windowInfo->touchableRegion);
Prabir Pradhane59c6dc2023-06-13 19:53:03 +00005706 dump += StringPrintf(", ownerPid=%s, ownerUid=%s, dispatchingTimeout=%" PRId64
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08005707 "ms, hasToken=%s, "
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07005708 "touchOcclusionMode=%s\n",
Prabir Pradhane59c6dc2023-06-13 19:53:03 +00005709 windowInfo->ownerPid.toString().c_str(),
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00005710 windowInfo->ownerUid.toString().c_str(),
Bernardo Rufinoc2f1fad2020-11-04 17:30:57 +00005711 millis(windowInfo->dispatchingTimeout),
Siarhei Vishniakou63b63612023-04-12 11:00:23 -07005712 binderToString(windowInfo->token).c_str(),
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07005713 toString(windowInfo->touchOcclusionMode).c_str());
chaviw85b44202020-07-24 11:46:21 -07005714 windowInfo->transform.dump(dump, "transform", INDENT4);
Arthur Hungb92218b2018-08-14 12:00:21 +08005715 }
5716 } else {
5717 dump += INDENT2 "Windows: <none>\n";
5718 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005719 }
5720 } else {
Arthur Hungb92218b2018-08-14 12:00:21 +08005721 dump += INDENT "Displays: <none>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005722 }
5723
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08005724 if (!mGlobalMonitorsByDisplay.empty()) {
5725 for (const auto& [displayId, monitors] : mGlobalMonitorsByDisplay) {
5726 dump += StringPrintf(INDENT "Global monitors on display %d:\n", displayId);
Michael Wright3dd60e22019-03-27 22:06:44 +00005727 dumpMonitors(dump, monitors);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07005728 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005729 } else {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08005730 dump += INDENT "Global Monitors: <none>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005731 }
5732
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08005733 const nsecs_t currentTime = now();
Michael Wrightd02c5b62014-02-10 15:10:22 -08005734
5735 // Dump recently dispatched or dropped events from oldest to newest.
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07005736 if (!mRecentQueue.empty()) {
5737 dump += StringPrintf(INDENT "RecentQueue: length=%zu\n", mRecentQueue.size());
Siarhei Vishniakou4c9d6ff2023-04-18 11:23:20 -07005738 for (const std::shared_ptr<EventEntry>& entry : mRecentQueue) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005739 dump += INDENT2;
Siarhei Vishniakou14411c92020-09-18 21:15:05 -05005740 dump += entry->getDescription();
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07005741 dump += StringPrintf(", age=%" PRId64 "ms\n", ns2ms(currentTime - entry->eventTime));
Michael Wrightd02c5b62014-02-10 15:10:22 -08005742 }
5743 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005744 dump += INDENT "RecentQueue: <empty>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005745 }
5746
5747 // Dump event currently being dispatched.
5748 if (mPendingEvent) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005749 dump += INDENT "PendingEvent:\n";
5750 dump += INDENT2;
Siarhei Vishniakou14411c92020-09-18 21:15:05 -05005751 dump += mPendingEvent->getDescription();
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07005752 dump += StringPrintf(", age=%" PRId64 "ms\n",
5753 ns2ms(currentTime - mPendingEvent->eventTime));
Michael Wrightd02c5b62014-02-10 15:10:22 -08005754 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005755 dump += INDENT "PendingEvent: <none>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005756 }
5757
5758 // Dump inbound events from oldest to newest.
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07005759 if (!mInboundQueue.empty()) {
5760 dump += StringPrintf(INDENT "InboundQueue: length=%zu\n", mInboundQueue.size());
Siarhei Vishniakou4c9d6ff2023-04-18 11:23:20 -07005761 for (const std::shared_ptr<EventEntry>& entry : mInboundQueue) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005762 dump += INDENT2;
Siarhei Vishniakou14411c92020-09-18 21:15:05 -05005763 dump += entry->getDescription();
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07005764 dump += StringPrintf(", age=%" PRId64 "ms\n", ns2ms(currentTime - entry->eventTime));
Michael Wrightd02c5b62014-02-10 15:10:22 -08005765 }
5766 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005767 dump += INDENT "InboundQueue: <empty>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005768 }
5769
Siarhei Vishniakou4700f822020-03-24 19:05:54 -07005770 if (!mReplacedKeys.empty()) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005771 dump += INDENT "ReplacedKeys:\n";
Michael Wright3cec4462022-11-24 22:05:46 +00005772 for (const auto& [replacement, newKeyCode] : mReplacedKeys) {
Siarhei Vishniakou4700f822020-03-24 19:05:54 -07005773 dump += StringPrintf(INDENT2 "originalKeyCode=%d, deviceId=%d -> newKeyCode=%d\n",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07005774 replacement.keyCode, replacement.deviceId, newKeyCode);
Michael Wright78f24442014-08-06 15:55:28 -07005775 }
5776 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005777 dump += INDENT "ReplacedKeys: <empty>\n";
Michael Wright78f24442014-08-06 15:55:28 -07005778 }
5779
Prabir Pradhancef936d2021-07-21 16:17:52 +00005780 if (!mCommandQueue.empty()) {
5781 dump += StringPrintf(INDENT "CommandQueue: size=%zu\n", mCommandQueue.size());
5782 } else {
5783 dump += INDENT "CommandQueue: <empty>\n";
5784 }
5785
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005786 if (!mConnectionsByToken.empty()) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005787 dump += INDENT "Connections:\n";
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005788 for (const auto& [token, connection] : mConnectionsByToken) {
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07005789 dump += StringPrintf(INDENT2 "%i: channelName='%s', windowName='%s', "
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005790 "status=%s, monitor=%s, responsive=%s\n",
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005791 connection->inputChannel->getFd().get(),
5792 connection->getInputChannelName().c_str(),
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08005793 connection->getWindowName().c_str(),
5794 ftl::enum_string(connection->status).c_str(),
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005795 toString(connection->monitor), toString(connection->responsive));
Michael Wrightd02c5b62014-02-10 15:10:22 -08005796
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07005797 if (!connection->outboundQueue.empty()) {
5798 dump += StringPrintf(INDENT3 "OutboundQueue: length=%zu\n",
5799 connection->outboundQueue.size());
Siarhei Vishniakou14411c92020-09-18 21:15:05 -05005800 dump += dumpQueue(connection->outboundQueue, currentTime);
5801
Michael Wrightd02c5b62014-02-10 15:10:22 -08005802 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005803 dump += INDENT3 "OutboundQueue: <empty>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005804 }
5805
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07005806 if (!connection->waitQueue.empty()) {
5807 dump += StringPrintf(INDENT3 "WaitQueue: length=%zu\n",
5808 connection->waitQueue.size());
Siarhei Vishniakou14411c92020-09-18 21:15:05 -05005809 dump += dumpQueue(connection->waitQueue, currentTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005810 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005811 dump += INDENT3 "WaitQueue: <empty>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005812 }
5813 }
5814 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005815 dump += INDENT "Connections: <none>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005816 }
5817
5818 if (isAppSwitchPendingLocked()) {
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07005819 dump += StringPrintf(INDENT "AppSwitch: pending, due in %" PRId64 "ms\n",
5820 ns2ms(mAppSwitchDueTime - now()));
Michael Wrightd02c5b62014-02-10 15:10:22 -08005821 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005822 dump += INDENT "AppSwitch: not pending\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005823 }
5824
Antonio Kantek15beb512022-06-13 22:35:41 +00005825 if (!mTouchModePerDisplay.empty()) {
5826 dump += INDENT "TouchModePerDisplay:\n";
5827 for (const auto& [displayId, touchMode] : mTouchModePerDisplay) {
5828 dump += StringPrintf(INDENT2 "Display: %" PRId32 " TouchMode: %s\n", displayId,
5829 std::to_string(touchMode).c_str());
5830 }
5831 } else {
5832 dump += INDENT "TouchModePerDisplay: <none>\n";
5833 }
5834
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005835 dump += INDENT "Configuration:\n";
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07005836 dump += StringPrintf(INDENT2 "KeyRepeatDelay: %" PRId64 "ms\n", ns2ms(mConfig.keyRepeatDelay));
5837 dump += StringPrintf(INDENT2 "KeyRepeatTimeout: %" PRId64 "ms\n",
5838 ns2ms(mConfig.keyRepeatTimeout));
Siarhei Vishniakouf2652122021-03-05 21:39:46 +00005839 dump += mLatencyTracker.dump(INDENT2);
Siarhei Vishniakoua04181f2021-03-26 05:56:49 +00005840 dump += mLatencyAggregator.dump(INDENT2);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005841}
5842
Siarhei Vishniakou4c9d6ff2023-04-18 11:23:20 -07005843void InputDispatcher::dumpMonitors(std::string& dump, const std::vector<Monitor>& monitors) const {
Michael Wright3dd60e22019-03-27 22:06:44 +00005844 const size_t numMonitors = monitors.size();
5845 for (size_t i = 0; i < numMonitors; i++) {
5846 const Monitor& monitor = monitors[i];
Siarhei Vishniakouce5ab082020-07-09 17:03:21 -05005847 const std::shared_ptr<InputChannel>& channel = monitor.inputChannel;
Michael Wright3dd60e22019-03-27 22:06:44 +00005848 dump += StringPrintf(INDENT2 "%zu: '%s', ", i, channel->getName().c_str());
5849 dump += "\n";
5850 }
5851}
5852
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005853class LooperEventCallback : public LooperCallback {
5854public:
5855 LooperEventCallback(std::function<int(int events)> callback) : mCallback(callback) {}
5856 int handleEvent(int /*fd*/, int events, void* /*data*/) override { return mCallback(events); }
5857
5858private:
5859 std::function<int(int events)> mCallback;
5860};
5861
Siarhei Vishniakoueedd0fc2021-03-12 09:50:36 +00005862Result<std::unique_ptr<InputChannel>> InputDispatcher::createInputChannel(const std::string& name) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00005863 if (DEBUG_CHANNEL_CREATION) {
5864 ALOGD("channel '%s' ~ createInputChannel", name.c_str());
5865 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005866
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005867 std::unique_ptr<InputChannel> serverChannel;
Garfield Tan15601662020-09-22 15:32:38 -07005868 std::unique_ptr<InputChannel> clientChannel;
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005869 status_t result = InputChannel::openInputChannelPair(name, serverChannel, clientChannel);
Garfield Tan15601662020-09-22 15:32:38 -07005870
5871 if (result) {
5872 return base::Error(result) << "Failed to open input channel pair with name " << name;
5873 }
5874
Michael Wrightd02c5b62014-02-10 15:10:22 -08005875 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08005876 std::scoped_lock _l(mLock);
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005877 const sp<IBinder>& token = serverChannel->getConnectionToken();
Garfield Tan15601662020-09-22 15:32:38 -07005878 int fd = serverChannel->getFd();
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07005879 std::shared_ptr<Connection> connection =
5880 std::make_shared<Connection>(std::move(serverChannel), /*monitor=*/false,
5881 mIdGenerator);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005882
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005883 if (mConnectionsByToken.find(token) != mConnectionsByToken.end()) {
5884 ALOGE("Created a new connection, but the token %p is already known", token.get());
5885 }
5886 mConnectionsByToken.emplace(token, connection);
5887
5888 std::function<int(int events)> callback = std::bind(&InputDispatcher::handleReceiveCallback,
5889 this, std::placeholders::_1, token);
5890
Siarhei Vishniakouaed7ad02022-08-03 15:04:33 -07005891 mLooper->addFd(fd, 0, ALOOPER_EVENT_INPUT, sp<LooperEventCallback>::make(callback),
5892 nullptr);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005893 } // release lock
5894
5895 // Wake the looper because some connections have changed.
5896 mLooper->wake();
Garfield Tan15601662020-09-22 15:32:38 -07005897 return clientChannel;
Michael Wrightd02c5b62014-02-10 15:10:22 -08005898}
5899
Siarhei Vishniakoueedd0fc2021-03-12 09:50:36 +00005900Result<std::unique_ptr<InputChannel>> InputDispatcher::createInputMonitor(int32_t displayId,
Siarhei Vishniakoueedd0fc2021-03-12 09:50:36 +00005901 const std::string& name,
Prabir Pradhane59c6dc2023-06-13 19:53:03 +00005902 gui::Pid pid) {
Garfield Tan15601662020-09-22 15:32:38 -07005903 std::shared_ptr<InputChannel> serverChannel;
5904 std::unique_ptr<InputChannel> clientChannel;
5905 status_t result = openInputChannelPair(name, serverChannel, clientChannel);
5906 if (result) {
5907 return base::Error(result) << "Failed to open input channel pair with name " << name;
5908 }
5909
Michael Wright3dd60e22019-03-27 22:06:44 +00005910 { // acquire lock
5911 std::scoped_lock _l(mLock);
5912
5913 if (displayId < 0) {
Garfield Tan15601662020-09-22 15:32:38 -07005914 return base::Error(BAD_VALUE) << "Attempted to create input monitor with name " << name
5915 << " without a specified display.";
Michael Wright3dd60e22019-03-27 22:06:44 +00005916 }
5917
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07005918 std::shared_ptr<Connection> connection =
5919 std::make_shared<Connection>(serverChannel, /*monitor=*/true, mIdGenerator);
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005920 const sp<IBinder>& token = serverChannel->getConnectionToken();
Garfield Tan15601662020-09-22 15:32:38 -07005921 const int fd = serverChannel->getFd();
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005922
5923 if (mConnectionsByToken.find(token) != mConnectionsByToken.end()) {
5924 ALOGE("Created a new connection, but the token %p is already known", token.get());
5925 }
5926 mConnectionsByToken.emplace(token, connection);
5927 std::function<int(int events)> callback = std::bind(&InputDispatcher::handleReceiveCallback,
5928 this, std::placeholders::_1, token);
Michael Wright3dd60e22019-03-27 22:06:44 +00005929
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08005930 mGlobalMonitorsByDisplay[displayId].emplace_back(serverChannel, pid);
Michael Wright3dd60e22019-03-27 22:06:44 +00005931
Siarhei Vishniakouaed7ad02022-08-03 15:04:33 -07005932 mLooper->addFd(fd, 0, ALOOPER_EVENT_INPUT, sp<LooperEventCallback>::make(callback),
5933 nullptr);
Michael Wright3dd60e22019-03-27 22:06:44 +00005934 }
Garfield Tan15601662020-09-22 15:32:38 -07005935
Michael Wright3dd60e22019-03-27 22:06:44 +00005936 // Wake the looper because some connections have changed.
5937 mLooper->wake();
Garfield Tan15601662020-09-22 15:32:38 -07005938 return clientChannel;
Michael Wright3dd60e22019-03-27 22:06:44 +00005939}
5940
Garfield Tan15601662020-09-22 15:32:38 -07005941status_t InputDispatcher::removeInputChannel(const sp<IBinder>& connectionToken) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08005942 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08005943 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005944
Harry Cutts33476232023-01-30 19:57:29 +00005945 status_t status = removeInputChannelLocked(connectionToken, /*notify=*/false);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005946 if (status) {
5947 return status;
5948 }
5949 } // release lock
5950
5951 // Wake the poll loop because removing the connection may have changed the current
5952 // synchronization state.
5953 mLooper->wake();
5954 return OK;
5955}
5956
Garfield Tan15601662020-09-22 15:32:38 -07005957status_t InputDispatcher::removeInputChannelLocked(const sp<IBinder>& connectionToken,
5958 bool notify) {
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07005959 std::shared_ptr<Connection> connection = getConnectionLocked(connectionToken);
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07005960 if (connection == nullptr) {
Siarhei Vishniakoud706a282021-02-13 00:08:48 +00005961 // Connection can be removed via socket hang up or an explicit call to 'removeInputChannel'
Michael Wrightd02c5b62014-02-10 15:10:22 -08005962 return BAD_VALUE;
5963 }
5964
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07005965 removeConnectionLocked(connection);
Robert Carr5c8a0262018-10-03 16:30:44 -07005966
Michael Wrightd02c5b62014-02-10 15:10:22 -08005967 if (connection->monitor) {
Siarhei Vishniakouadefc3e2020-09-02 22:28:29 -05005968 removeMonitorChannelLocked(connectionToken);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005969 }
5970
Siarhei Vishniakouadefc3e2020-09-02 22:28:29 -05005971 mLooper->removeFd(connection->inputChannel->getFd());
Michael Wrightd02c5b62014-02-10 15:10:22 -08005972
5973 nsecs_t currentTime = now();
5974 abortBrokenDispatchCycleLocked(currentTime, connection, notify);
5975
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08005976 connection->status = Connection::Status::ZOMBIE;
Michael Wrightd02c5b62014-02-10 15:10:22 -08005977 return OK;
5978}
5979
Siarhei Vishniakouadefc3e2020-09-02 22:28:29 -05005980void InputDispatcher::removeMonitorChannelLocked(const sp<IBinder>& connectionToken) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08005981 for (auto it = mGlobalMonitorsByDisplay.begin(); it != mGlobalMonitorsByDisplay.end();) {
5982 auto& [displayId, monitors] = *it;
5983 std::erase_if(monitors, [connectionToken](const Monitor& monitor) {
5984 return monitor.inputChannel->getConnectionToken() == connectionToken;
5985 });
Michael Wright3dd60e22019-03-27 22:06:44 +00005986
Michael Wright3dd60e22019-03-27 22:06:44 +00005987 if (monitors.empty()) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08005988 it = mGlobalMonitorsByDisplay.erase(it);
Arthur Hung2fbf37f2018-09-13 18:16:41 +08005989 } else {
5990 ++it;
5991 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005992 }
5993}
5994
Michael Wright3dd60e22019-03-27 22:06:44 +00005995status_t InputDispatcher::pilferPointers(const sp<IBinder>& token) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08005996 std::scoped_lock _l(mLock);
Vaibhav Devmurari6abcf8f2022-06-06 10:08:05 +00005997 return pilferPointersLocked(token);
5998}
Michael Wright3dd60e22019-03-27 22:06:44 +00005999
Vaibhav Devmurari6abcf8f2022-06-06 10:08:05 +00006000status_t InputDispatcher::pilferPointersLocked(const sp<IBinder>& token) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006001 const std::shared_ptr<InputChannel> requestingChannel = getInputChannelLocked(token);
6002 if (!requestingChannel) {
6003 ALOGW("Attempted to pilfer pointers from an un-registered channel or invalid token");
6004 return BAD_VALUE;
Michael Wright3dd60e22019-03-27 22:06:44 +00006005 }
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006006
Siarhei Vishniakou40b8fbd2022-11-04 10:50:26 -07006007 auto [statePtr, windowPtr, displayId] = findTouchStateWindowAndDisplayLocked(token);
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07006008 if (statePtr == nullptr || windowPtr == nullptr) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006009 ALOGW("Attempted to pilfer points from a channel without any on-going pointer streams."
6010 " Ignoring.");
6011 return BAD_VALUE;
6012 }
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07006013 std::set<int32_t> deviceIds = windowPtr->getTouchingDeviceIds();
6014 if (deviceIds.size() != 1) {
6015 LOG(WARNING) << "Can't pilfer. Currently touching devices: " << dumpSet(deviceIds)
6016 << " in window: " << windowPtr->dump();
6017 return BAD_VALUE;
6018 }
6019 const int32_t deviceId = *deviceIds.begin();
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006020
6021 TouchState& state = *statePtr;
Vaibhav Devmurariff798f32022-05-09 23:45:04 +00006022 TouchedWindow& window = *windowPtr;
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006023 // Send cancel events to all the input channels we're stealing from.
Michael Wrightfb04fd52022-11-24 22:31:11 +00006024 CancelationOptions options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS,
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006025 "input channel stole pointer stream");
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07006026 options.deviceId = deviceId;
Siarhei Vishniakou40b8fbd2022-11-04 10:50:26 -07006027 options.displayId = displayId;
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07006028 std::bitset<MAX_POINTER_ID + 1> pointerIds = window.getTouchingPointers(deviceId);
6029 options.pointerIds = pointerIds;
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006030 std::string canceledWindows;
Vaibhav Devmurariff798f32022-05-09 23:45:04 +00006031 for (const TouchedWindow& w : state.windows) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006032 const std::shared_ptr<InputChannel> channel =
Vaibhav Devmurariff798f32022-05-09 23:45:04 +00006033 getInputChannelLocked(w.windowHandle->getToken());
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006034 if (channel != nullptr && channel->getConnectionToken() != token) {
6035 synthesizeCancelationEventsForInputChannelLocked(channel, options);
6036 canceledWindows += canceledWindows.empty() ? "[" : ", ";
6037 canceledWindows += channel->getName();
6038 }
6039 }
6040 canceledWindows += canceledWindows.empty() ? "[]" : "]";
6041 ALOGI("Channel %s is stealing touch from %s", requestingChannel->getName().c_str(),
6042 canceledWindows.c_str());
6043
Prabir Pradhane680f9b2022-02-04 04:24:00 -08006044 // Prevent the gesture from being sent to any other windows.
Vaibhav Devmurariff798f32022-05-09 23:45:04 +00006045 // This only blocks relevant pointers to be sent to other windows
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07006046 window.addPilferingPointers(deviceId, pointerIds);
Vaibhav Devmurariff798f32022-05-09 23:45:04 +00006047
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07006048 state.cancelPointersForWindowsExcept(deviceId, pointerIds, token);
Michael Wright3dd60e22019-03-27 22:06:44 +00006049 return OK;
6050}
6051
Prabir Pradhan99987712020-11-10 18:43:05 -08006052void InputDispatcher::requestPointerCapture(const sp<IBinder>& windowToken, bool enabled) {
6053 { // acquire lock
6054 std::scoped_lock _l(mLock);
6055 if (DEBUG_FOCUS) {
chaviw98318de2021-05-19 16:45:23 -05006056 const sp<WindowInfoHandle> windowHandle = getWindowHandleLocked(windowToken);
Prabir Pradhan99987712020-11-10 18:43:05 -08006057 ALOGI("Request to %s Pointer Capture from: %s.", enabled ? "enable" : "disable",
6058 windowHandle != nullptr ? windowHandle->getName().c_str()
6059 : "token without window");
6060 }
6061
Vishnu Nairc519ff72021-01-21 08:23:08 -08006062 const sp<IBinder> focusedToken = mFocusResolver.getFocusedWindowToken(mFocusedDisplayId);
Prabir Pradhan99987712020-11-10 18:43:05 -08006063 if (focusedToken != windowToken) {
6064 ALOGW("Ignoring request to %s Pointer Capture: window does not have focus.",
6065 enabled ? "enable" : "disable");
6066 return;
6067 }
6068
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00006069 if (enabled == mCurrentPointerCaptureRequest.enable) {
Prabir Pradhan99987712020-11-10 18:43:05 -08006070 ALOGW("Ignoring request to %s Pointer Capture: "
6071 "window has %s requested pointer capture.",
6072 enabled ? "enable" : "disable", enabled ? "already" : "not");
6073 return;
6074 }
6075
Christine Franksb768bb42021-11-29 12:11:31 -08006076 if (enabled) {
6077 if (std::find(mIneligibleDisplaysForPointerCapture.begin(),
6078 mIneligibleDisplaysForPointerCapture.end(),
6079 mFocusedDisplayId) != mIneligibleDisplaysForPointerCapture.end()) {
6080 ALOGW("Ignoring request to enable Pointer Capture: display is not eligible");
6081 return;
6082 }
6083 }
6084
Prabir Pradhan99987712020-11-10 18:43:05 -08006085 setPointerCaptureLocked(enabled);
6086 } // release lock
6087
6088 // Wake the thread to process command entries.
6089 mLooper->wake();
6090}
6091
Christine Franksb768bb42021-11-29 12:11:31 -08006092void InputDispatcher::setDisplayEligibilityForPointerCapture(int32_t displayId, bool isEligible) {
6093 { // acquire lock
6094 std::scoped_lock _l(mLock);
6095 std::erase(mIneligibleDisplaysForPointerCapture, displayId);
6096 if (!isEligible) {
6097 mIneligibleDisplaysForPointerCapture.push_back(displayId);
6098 }
6099 } // release lock
6100}
6101
Prabir Pradhane59c6dc2023-06-13 19:53:03 +00006102std::optional<gui::Pid> InputDispatcher::findMonitorPidByTokenLocked(const sp<IBinder>& token) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006103 for (const auto& [_, monitors] : mGlobalMonitorsByDisplay) {
Michael Wright3dd60e22019-03-27 22:06:44 +00006104 for (const Monitor& monitor : monitors) {
Siarhei Vishniakou26d3cfb2019-10-15 17:02:32 -07006105 if (monitor.inputChannel->getConnectionToken() == token) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006106 return monitor.pid;
Michael Wright3dd60e22019-03-27 22:06:44 +00006107 }
6108 }
6109 }
6110 return std::nullopt;
6111}
6112
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07006113std::shared_ptr<Connection> InputDispatcher::getConnectionLocked(
6114 const sp<IBinder>& inputConnectionToken) const {
Siarhei Vishniakoud0d71b62019-10-14 14:50:45 -07006115 if (inputConnectionToken == nullptr) {
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07006116 return nullptr;
Arthur Hung3b413f22018-10-26 18:05:34 +08006117 }
6118
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00006119 for (const auto& [token, connection] : mConnectionsByToken) {
6120 if (token == inputConnectionToken) {
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07006121 return connection;
Michael Wrightd02c5b62014-02-10 15:10:22 -08006122 }
6123 }
Robert Carr4e670e52018-08-15 13:26:12 -07006124
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07006125 return nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08006126}
6127
Siarhei Vishniakouad991402020-10-28 11:40:09 -05006128std::string InputDispatcher::getConnectionNameLocked(const sp<IBinder>& connectionToken) const {
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07006129 std::shared_ptr<Connection> connection = getConnectionLocked(connectionToken);
Siarhei Vishniakouad991402020-10-28 11:40:09 -05006130 if (connection == nullptr) {
6131 return "<nullptr>";
6132 }
6133 return connection->getInputChannelName();
6134}
6135
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07006136void InputDispatcher::removeConnectionLocked(const std::shared_ptr<Connection>& connection) {
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006137 mAnrTracker.eraseToken(connection->inputChannel->getConnectionToken());
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00006138 mConnectionsByToken.erase(connection->inputChannel->getConnectionToken());
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07006139}
6140
Prabir Pradhancef936d2021-07-21 16:17:52 +00006141void InputDispatcher::doDispatchCycleFinishedCommand(nsecs_t finishTime,
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07006142 const std::shared_ptr<Connection>& connection,
6143 uint32_t seq, bool handled,
6144 nsecs_t consumeTime) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00006145 // Handle post-event policy actions.
6146 std::deque<DispatchEntry*>::iterator dispatchEntryIt = connection->findWaitQueueEntry(seq);
6147 if (dispatchEntryIt == connection->waitQueue.end()) {
6148 return;
6149 }
6150 DispatchEntry* dispatchEntry = *dispatchEntryIt;
6151 const nsecs_t eventDuration = finishTime - dispatchEntry->deliveryTime;
6152 if (eventDuration > SLOW_EVENT_PROCESSING_WARNING_TIMEOUT) {
6153 ALOGI("%s spent %" PRId64 "ms processing %s", connection->getWindowName().c_str(),
6154 ns2ms(eventDuration), dispatchEntry->eventEntry->getDescription().c_str());
6155 }
6156 if (shouldReportFinishedEvent(*dispatchEntry, *connection)) {
6157 mLatencyTracker.trackFinishedEvent(dispatchEntry->eventEntry->id,
6158 connection->inputChannel->getConnectionToken(),
6159 dispatchEntry->deliveryTime, consumeTime, finishTime);
6160 }
6161
6162 bool restartEvent;
6163 if (dispatchEntry->eventEntry->type == EventEntry::Type::KEY) {
6164 KeyEntry& keyEntry = static_cast<KeyEntry&>(*(dispatchEntry->eventEntry));
6165 restartEvent =
6166 afterKeyEventLockedInterruptable(connection, dispatchEntry, keyEntry, handled);
6167 } else if (dispatchEntry->eventEntry->type == EventEntry::Type::MOTION) {
6168 MotionEntry& motionEntry = static_cast<MotionEntry&>(*(dispatchEntry->eventEntry));
6169 restartEvent = afterMotionEventLockedInterruptable(connection, dispatchEntry, motionEntry,
6170 handled);
6171 } else {
6172 restartEvent = false;
6173 }
6174
6175 // Dequeue the event and start the next cycle.
6176 // Because the lock might have been released, it is possible that the
6177 // contents of the wait queue to have been drained, so we need to double-check
6178 // a few things.
6179 dispatchEntryIt = connection->findWaitQueueEntry(seq);
6180 if (dispatchEntryIt != connection->waitQueue.end()) {
6181 dispatchEntry = *dispatchEntryIt;
6182 connection->waitQueue.erase(dispatchEntryIt);
6183 const sp<IBinder>& connectionToken = connection->inputChannel->getConnectionToken();
6184 mAnrTracker.erase(dispatchEntry->timeoutTime, connectionToken);
6185 if (!connection->responsive) {
6186 connection->responsive = isConnectionResponsive(*connection);
6187 if (connection->responsive) {
6188 // The connection was unresponsive, and now it's responsive.
6189 processConnectionResponsiveLocked(*connection);
6190 }
6191 }
6192 traceWaitQueueLength(*connection);
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08006193 if (restartEvent && connection->status == Connection::Status::NORMAL) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00006194 connection->outboundQueue.push_front(dispatchEntry);
6195 traceOutboundQueueLength(*connection);
6196 } else {
6197 releaseDispatchEntry(dispatchEntry);
6198 }
6199 }
6200
6201 // Start the next dispatch cycle for this connection.
6202 startDispatchCycleLocked(now(), connection);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006203}
6204
Prabir Pradhancef936d2021-07-21 16:17:52 +00006205void InputDispatcher::sendFocusChangedCommandLocked(const sp<IBinder>& oldToken,
6206 const sp<IBinder>& newToken) {
6207 auto command = [this, oldToken, newToken]() REQUIRES(mLock) {
6208 scoped_unlock unlock(mLock);
Prabir Pradhana41d2442023-04-20 21:30:40 +00006209 mPolicy.notifyFocusChanged(oldToken, newToken);
Prabir Pradhancef936d2021-07-21 16:17:52 +00006210 };
6211 postCommandLocked(std::move(command));
Michael Wrightd02c5b62014-02-10 15:10:22 -08006212}
6213
Prabir Pradhancef936d2021-07-21 16:17:52 +00006214void InputDispatcher::sendDropWindowCommandLocked(const sp<IBinder>& token, float x, float y) {
6215 auto command = [this, token, x, y]() REQUIRES(mLock) {
6216 scoped_unlock unlock(mLock);
Prabir Pradhana41d2442023-04-20 21:30:40 +00006217 mPolicy.notifyDropWindow(token, x, y);
Prabir Pradhancef936d2021-07-21 16:17:52 +00006218 };
6219 postCommandLocked(std::move(command));
Robert Carrf759f162018-11-13 12:57:11 -08006220}
6221
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07006222void InputDispatcher::onAnrLocked(const std::shared_ptr<Connection>& connection) {
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006223 if (connection == nullptr) {
6224 LOG_ALWAYS_FATAL("Caller must check for nullness");
6225 }
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006226 // Since we are allowing the policy to extend the timeout, maybe the waitQueue
6227 // is already healthy again. Don't raise ANR in this situation
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006228 if (connection->waitQueue.empty()) {
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006229 ALOGI("Not raising ANR because the connection %s has recovered",
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006230 connection->inputChannel->getName().c_str());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006231 return;
6232 }
6233 /**
6234 * The "oldestEntry" is the entry that was first sent to the application. That entry, however,
6235 * may not be the one that caused the timeout to occur. One possibility is that window timeout
6236 * has changed. This could cause newer entries to time out before the already dispatched
6237 * entries. In that situation, the newest entries caused ANR. But in all likelihood, the app
6238 * processes the events linearly. So providing information about the oldest entry seems to be
6239 * most useful.
6240 */
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006241 DispatchEntry* oldestEntry = *connection->waitQueue.begin();
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006242 const nsecs_t currentWait = now() - oldestEntry->deliveryTime;
6243 std::string reason =
6244 android::base::StringPrintf("%s is not responding. Waited %" PRId64 "ms for %s",
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006245 connection->inputChannel->getName().c_str(),
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006246 ns2ms(currentWait),
6247 oldestEntry->eventEntry->getDescription().c_str());
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006248 sp<IBinder> connectionToken = connection->inputChannel->getConnectionToken();
Siarhei Vishniakou2b4782c2020-11-07 01:51:18 -06006249 updateLastAnrStateLocked(getWindowHandleLocked(connectionToken), reason);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006250
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006251 processConnectionUnresponsiveLocked(*connection, std::move(reason));
6252
6253 // Stop waking up for events on this connection, it is already unresponsive
6254 cancelEventsForAnrLocked(connection);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006255}
6256
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05006257void InputDispatcher::onAnrLocked(std::shared_ptr<InputApplicationHandle> application) {
6258 std::string reason =
6259 StringPrintf("%s does not have a focused window", application->getName().c_str());
6260 updateLastAnrStateLocked(*application, reason);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006261
Prabir Pradhancef936d2021-07-21 16:17:52 +00006262 auto command = [this, application = std::move(application)]() REQUIRES(mLock) {
6263 scoped_unlock unlock(mLock);
Prabir Pradhana41d2442023-04-20 21:30:40 +00006264 mPolicy.notifyNoFocusedWindowAnr(application);
Prabir Pradhancef936d2021-07-21 16:17:52 +00006265 };
6266 postCommandLocked(std::move(command));
Bernardo Rufino2e1f6512020-10-08 13:42:07 +00006267}
6268
chaviw98318de2021-05-19 16:45:23 -05006269void InputDispatcher::updateLastAnrStateLocked(const sp<WindowInfoHandle>& window,
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006270 const std::string& reason) {
6271 const std::string windowLabel = getApplicationWindowLabel(nullptr, window);
6272 updateLastAnrStateLocked(windowLabel, reason);
6273}
6274
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05006275void InputDispatcher::updateLastAnrStateLocked(const InputApplicationHandle& application,
6276 const std::string& reason) {
6277 const std::string windowLabel = getApplicationWindowLabel(&application, nullptr);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006278 updateLastAnrStateLocked(windowLabel, reason);
6279}
6280
6281void InputDispatcher::updateLastAnrStateLocked(const std::string& windowLabel,
6282 const std::string& reason) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08006283 // Capture a record of the InputDispatcher state at the time of the ANR.
Yi Kong9b14ac62018-07-17 13:48:38 -07006284 time_t t = time(nullptr);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006285 struct tm tm;
6286 localtime_r(&t, &tm);
6287 char timestr[64];
6288 strftime(timestr, sizeof(timestr), "%F %T", &tm);
Siarhei Vishniakoub1a16272020-05-06 16:09:19 -07006289 mLastAnrState.clear();
6290 mLastAnrState += INDENT "ANR:\n";
6291 mLastAnrState += StringPrintf(INDENT2 "Time: %s\n", timestr);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006292 mLastAnrState += StringPrintf(INDENT2 "Reason: %s\n", reason.c_str());
6293 mLastAnrState += StringPrintf(INDENT2 "Window: %s\n", windowLabel.c_str());
Siarhei Vishniakoub1a16272020-05-06 16:09:19 -07006294 dumpDispatchStateLocked(mLastAnrState);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006295}
6296
Prabir Pradhancef936d2021-07-21 16:17:52 +00006297void InputDispatcher::doInterceptKeyBeforeDispatchingCommand(const sp<IBinder>& focusedWindowToken,
6298 KeyEntry& entry) {
6299 const KeyEvent event = createKeyEvent(entry);
6300 nsecs_t delay = 0;
6301 { // release lock
6302 scoped_unlock unlock(mLock);
6303 android::base::Timer t;
Prabir Pradhana41d2442023-04-20 21:30:40 +00006304 delay = mPolicy.interceptKeyBeforeDispatching(focusedWindowToken, event, entry.policyFlags);
Prabir Pradhancef936d2021-07-21 16:17:52 +00006305 if (t.duration() > SLOW_INTERCEPTION_THRESHOLD) {
6306 ALOGW("Excessive delay in interceptKeyBeforeDispatching; took %s ms",
6307 std::to_string(t.duration().count()).c_str());
6308 }
6309 } // acquire lock
Michael Wrightd02c5b62014-02-10 15:10:22 -08006310
6311 if (delay < 0) {
Michael Wright5caf55a2022-11-24 22:31:42 +00006312 entry.interceptKeyResult = KeyEntry::InterceptKeyResult::SKIP;
Prabir Pradhancef936d2021-07-21 16:17:52 +00006313 } else if (delay == 0) {
Michael Wright5caf55a2022-11-24 22:31:42 +00006314 entry.interceptKeyResult = KeyEntry::InterceptKeyResult::CONTINUE;
Michael Wrightd02c5b62014-02-10 15:10:22 -08006315 } else {
Michael Wright5caf55a2022-11-24 22:31:42 +00006316 entry.interceptKeyResult = KeyEntry::InterceptKeyResult::TRY_AGAIN_LATER;
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006317 entry.interceptKeyWakeupTime = now() + delay;
Michael Wrightd02c5b62014-02-10 15:10:22 -08006318 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08006319}
6320
Prabir Pradhancef936d2021-07-21 16:17:52 +00006321void InputDispatcher::sendWindowUnresponsiveCommandLocked(const sp<IBinder>& token,
Prabir Pradhane59c6dc2023-06-13 19:53:03 +00006322 std::optional<gui::Pid> pid,
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006323 std::string reason) {
Prabir Pradhanedd96402022-02-15 01:46:16 -08006324 auto command = [this, token, pid, reason = std::move(reason)]() REQUIRES(mLock) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00006325 scoped_unlock unlock(mLock);
Prabir Pradhana41d2442023-04-20 21:30:40 +00006326 mPolicy.notifyWindowUnresponsive(token, pid, reason);
Prabir Pradhancef936d2021-07-21 16:17:52 +00006327 };
6328 postCommandLocked(std::move(command));
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006329}
6330
Prabir Pradhanedd96402022-02-15 01:46:16 -08006331void InputDispatcher::sendWindowResponsiveCommandLocked(const sp<IBinder>& token,
Prabir Pradhane59c6dc2023-06-13 19:53:03 +00006332 std::optional<gui::Pid> pid) {
Prabir Pradhanedd96402022-02-15 01:46:16 -08006333 auto command = [this, token, pid]() REQUIRES(mLock) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00006334 scoped_unlock unlock(mLock);
Prabir Pradhana41d2442023-04-20 21:30:40 +00006335 mPolicy.notifyWindowResponsive(token, pid);
Prabir Pradhancef936d2021-07-21 16:17:52 +00006336 };
6337 postCommandLocked(std::move(command));
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006338}
6339
6340/**
6341 * Tell the policy that a connection has become unresponsive so that it can start ANR.
6342 * Check whether the connection of interest is a monitor or a window, and add the corresponding
6343 * command entry to the command queue.
6344 */
6345void InputDispatcher::processConnectionUnresponsiveLocked(const Connection& connection,
6346 std::string reason) {
6347 const sp<IBinder>& connectionToken = connection.inputChannel->getConnectionToken();
Prabir Pradhane59c6dc2023-06-13 19:53:03 +00006348 std::optional<gui::Pid> pid;
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006349 if (connection.monitor) {
6350 ALOGW("Monitor %s is unresponsive: %s", connection.inputChannel->getName().c_str(),
6351 reason.c_str());
Prabir Pradhanedd96402022-02-15 01:46:16 -08006352 pid = findMonitorPidByTokenLocked(connectionToken);
6353 } else {
6354 // The connection is a window
6355 ALOGW("Window %s is unresponsive: %s", connection.inputChannel->getName().c_str(),
6356 reason.c_str());
6357 const sp<WindowInfoHandle> handle = getWindowHandleLocked(connectionToken);
6358 if (handle != nullptr) {
6359 pid = handle->getInfo()->ownerPid;
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006360 }
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006361 }
Prabir Pradhanedd96402022-02-15 01:46:16 -08006362 sendWindowUnresponsiveCommandLocked(connectionToken, pid, std::move(reason));
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006363}
6364
6365/**
6366 * Tell the policy that a connection has become responsive so that it can stop ANR.
6367 */
6368void InputDispatcher::processConnectionResponsiveLocked(const Connection& connection) {
6369 const sp<IBinder>& connectionToken = connection.inputChannel->getConnectionToken();
Prabir Pradhane59c6dc2023-06-13 19:53:03 +00006370 std::optional<gui::Pid> pid;
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006371 if (connection.monitor) {
Prabir Pradhanedd96402022-02-15 01:46:16 -08006372 pid = findMonitorPidByTokenLocked(connectionToken);
6373 } else {
6374 // The connection is a window
6375 const sp<WindowInfoHandle> handle = getWindowHandleLocked(connectionToken);
6376 if (handle != nullptr) {
6377 pid = handle->getInfo()->ownerPid;
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006378 }
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006379 }
Prabir Pradhanedd96402022-02-15 01:46:16 -08006380 sendWindowResponsiveCommandLocked(connectionToken, pid);
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006381}
6382
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07006383bool InputDispatcher::afterKeyEventLockedInterruptable(
6384 const std::shared_ptr<Connection>& connection, DispatchEntry* dispatchEntry,
6385 KeyEntry& keyEntry, bool handled) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006386 if (keyEntry.flags & AKEY_EVENT_FLAG_FALLBACK) {
Prabir Pradhanf93562f2018-11-29 12:13:37 -08006387 if (!handled) {
6388 // Report the key as unhandled, since the fallback was not handled.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006389 mReporter->reportUnhandledKey(keyEntry.id);
Prabir Pradhanf93562f2018-11-29 12:13:37 -08006390 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006391 return false;
6392 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08006393
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006394 // Get the fallback key state.
6395 // Clear it out after dispatching the UP.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006396 int32_t originalKeyCode = keyEntry.keyCode;
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006397 std::optional<int32_t> fallbackKeyCode = connection->inputState.getFallbackKey(originalKeyCode);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006398 if (keyEntry.action == AKEY_EVENT_ACTION_UP) {
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006399 connection->inputState.removeFallbackKey(originalKeyCode);
6400 }
6401
6402 if (handled || !dispatchEntry->hasForegroundTarget()) {
6403 // If the application handles the original key for which we previously
6404 // generated a fallback or if the window is not a foreground window,
6405 // then cancel the associated fallback key, if any.
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006406 if (fallbackKeyCode) {
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006407 // Dispatch the unhandled key to the policy with the cancel flag.
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006408 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
6409 ALOGD("Unhandled key event: Asking policy to cancel fallback action. "
6410 "keyCode=%d, action=%d, repeatCount=%d, policyFlags=0x%08x",
6411 keyEntry.keyCode, keyEntry.action, keyEntry.repeatCount,
6412 keyEntry.policyFlags);
6413 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006414 KeyEvent event = createKeyEvent(keyEntry);
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006415 event.setFlags(event.getFlags() | AKEY_EVENT_FLAG_CANCELED);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006416
6417 mLock.unlock();
6418
Prabir Pradhana41d2442023-04-20 21:30:40 +00006419 if (const auto unhandledKeyFallback =
6420 mPolicy.dispatchUnhandledKey(connection->inputChannel->getConnectionToken(),
6421 event, keyEntry.policyFlags);
6422 unhandledKeyFallback) {
6423 event = *unhandledKeyFallback;
6424 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08006425
6426 mLock.lock();
6427
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006428 // Cancel the fallback key.
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006429 if (*fallbackKeyCode != AKEYCODE_UNKNOWN) {
Michael Wrightfb04fd52022-11-24 22:31:11 +00006430 CancelationOptions options(CancelationOptions::Mode::CANCEL_FALLBACK_EVENTS,
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006431 "application handled the original non-fallback key "
6432 "or is no longer a foreground target, "
6433 "canceling previously dispatched fallback key");
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006434 options.keyCode = *fallbackKeyCode;
Michael Wrightd02c5b62014-02-10 15:10:22 -08006435 synthesizeCancelationEventsForConnectionLocked(connection, options);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006436 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006437 connection->inputState.removeFallbackKey(originalKeyCode);
6438 }
6439 } else {
6440 // If the application did not handle a non-fallback key, first check
6441 // that we are in a good state to perform unhandled key event processing
6442 // Then ask the policy what to do with it.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006443 bool initialDown = keyEntry.action == AKEY_EVENT_ACTION_DOWN && keyEntry.repeatCount == 0;
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006444 if (!fallbackKeyCode && !initialDown) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006445 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
6446 ALOGD("Unhandled key event: Skipping unhandled key event processing "
6447 "since this is not an initial down. "
6448 "keyCode=%d, action=%d, repeatCount=%d, policyFlags=0x%08x",
6449 originalKeyCode, keyEntry.action, keyEntry.repeatCount, keyEntry.policyFlags);
6450 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006451 return false;
6452 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08006453
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006454 // Dispatch the unhandled key to the policy.
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006455 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
6456 ALOGD("Unhandled key event: Asking policy to perform fallback action. "
6457 "keyCode=%d, action=%d, repeatCount=%d, policyFlags=0x%08x",
6458 keyEntry.keyCode, keyEntry.action, keyEntry.repeatCount, keyEntry.policyFlags);
6459 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006460 KeyEvent event = createKeyEvent(keyEntry);
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006461
6462 mLock.unlock();
6463
Prabir Pradhana41d2442023-04-20 21:30:40 +00006464 bool fallback = false;
6465 if (auto fb = mPolicy.dispatchUnhandledKey(connection->inputChannel->getConnectionToken(),
6466 event, keyEntry.policyFlags);
6467 fb) {
6468 fallback = true;
6469 event = *fb;
6470 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006471
6472 mLock.lock();
6473
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08006474 if (connection->status != Connection::Status::NORMAL) {
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006475 connection->inputState.removeFallbackKey(originalKeyCode);
6476 return false;
6477 }
6478
6479 // Latch the fallback keycode for this key on an initial down.
6480 // The fallback keycode cannot change at any other point in the lifecycle.
6481 if (initialDown) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08006482 if (fallback) {
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006483 *fallbackKeyCode = event.getKeyCode();
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006484 } else {
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006485 *fallbackKeyCode = AKEYCODE_UNKNOWN;
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006486 }
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006487 connection->inputState.setFallbackKey(originalKeyCode, *fallbackKeyCode);
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006488 }
6489
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006490 ALOG_ASSERT(fallbackKeyCode);
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006491
6492 // Cancel the fallback key if the policy decides not to send it anymore.
6493 // We will continue to dispatch the key to the policy but we will no
6494 // longer dispatch a fallback key to the application.
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006495 if (*fallbackKeyCode != AKEYCODE_UNKNOWN &&
6496 (!fallback || *fallbackKeyCode != event.getKeyCode())) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006497 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
6498 if (fallback) {
6499 ALOGD("Unhandled key event: Policy requested to send key %d"
6500 "as a fallback for %d, but on the DOWN it had requested "
6501 "to send %d instead. Fallback canceled.",
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006502 event.getKeyCode(), originalKeyCode, *fallbackKeyCode);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006503 } else {
6504 ALOGD("Unhandled key event: Policy did not request fallback for %d, "
6505 "but on the DOWN it had requested to send %d. "
6506 "Fallback canceled.",
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006507 originalKeyCode, *fallbackKeyCode);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006508 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006509 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006510
Michael Wrightfb04fd52022-11-24 22:31:11 +00006511 CancelationOptions options(CancelationOptions::Mode::CANCEL_FALLBACK_EVENTS,
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006512 "canceling fallback, policy no longer desires it");
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006513 options.keyCode = *fallbackKeyCode;
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006514 synthesizeCancelationEventsForConnectionLocked(connection, options);
6515
6516 fallback = false;
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006517 *fallbackKeyCode = AKEYCODE_UNKNOWN;
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006518 if (keyEntry.action != AKEY_EVENT_ACTION_UP) {
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006519 connection->inputState.setFallbackKey(originalKeyCode, *fallbackKeyCode);
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006520 }
6521 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08006522
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006523 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
6524 {
6525 std::string msg;
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006526 const std::map<int32_t, int32_t>& fallbackKeys =
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006527 connection->inputState.getFallbackKeys();
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006528 for (const auto& [key, value] : fallbackKeys) {
6529 msg += StringPrintf(", %d->%d", key, value);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006530 }
6531 ALOGD("Unhandled key event: %zu currently tracked fallback keys%s.",
6532 fallbackKeys.size(), msg.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08006533 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006534 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006535
6536 if (fallback) {
6537 // Restart the dispatch cycle using the fallback key.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006538 keyEntry.eventTime = event.getEventTime();
6539 keyEntry.deviceId = event.getDeviceId();
6540 keyEntry.source = event.getSource();
6541 keyEntry.displayId = event.getDisplayId();
6542 keyEntry.flags = event.getFlags() | AKEY_EVENT_FLAG_FALLBACK;
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006543 keyEntry.keyCode = *fallbackKeyCode;
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006544 keyEntry.scanCode = event.getScanCode();
6545 keyEntry.metaState = event.getMetaState();
6546 keyEntry.repeatCount = event.getRepeatCount();
6547 keyEntry.downTime = event.getDownTime();
6548 keyEntry.syntheticRepeat = false;
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006549
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006550 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
6551 ALOGD("Unhandled key event: Dispatching fallback key. "
6552 "originalKeyCode=%d, fallbackKeyCode=%d, fallbackMetaState=%08x",
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006553 originalKeyCode, *fallbackKeyCode, keyEntry.metaState);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006554 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006555 return true; // restart the event
6556 } else {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006557 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
6558 ALOGD("Unhandled key event: No fallback key.");
6559 }
Prabir Pradhanf93562f2018-11-29 12:13:37 -08006560
6561 // Report the key as unhandled, since there is no fallback key.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006562 mReporter->reportUnhandledKey(keyEntry.id);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006563 }
6564 }
6565 return false;
6566}
6567
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07006568bool InputDispatcher::afterMotionEventLockedInterruptable(
6569 const std::shared_ptr<Connection>& connection, DispatchEntry* dispatchEntry,
6570 MotionEntry& motionEntry, bool handled) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08006571 return false;
6572}
6573
Michael Wrightd02c5b62014-02-10 15:10:22 -08006574void InputDispatcher::traceInboundQueueLengthLocked() {
6575 if (ATRACE_ENABLED()) {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07006576 ATRACE_INT("iq", mInboundQueue.size());
Michael Wrightd02c5b62014-02-10 15:10:22 -08006577 }
6578}
6579
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00006580void InputDispatcher::traceOutboundQueueLength(const Connection& connection) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08006581 if (ATRACE_ENABLED()) {
6582 char counterName[40];
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00006583 snprintf(counterName, sizeof(counterName), "oq:%s", connection.getWindowName().c_str());
6584 ATRACE_INT(counterName, connection.outboundQueue.size());
Michael Wrightd02c5b62014-02-10 15:10:22 -08006585 }
6586}
6587
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00006588void InputDispatcher::traceWaitQueueLength(const Connection& connection) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08006589 if (ATRACE_ENABLED()) {
6590 char counterName[40];
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00006591 snprintf(counterName, sizeof(counterName), "wq:%s", connection.getWindowName().c_str());
6592 ATRACE_INT(counterName, connection.waitQueue.size());
Michael Wrightd02c5b62014-02-10 15:10:22 -08006593 }
6594}
6595
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08006596void InputDispatcher::dump(std::string& dump) {
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08006597 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006598
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08006599 dump += "Input Dispatcher State:\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08006600 dumpDispatchStateLocked(dump);
6601
Siarhei Vishniakoub1a16272020-05-06 16:09:19 -07006602 if (!mLastAnrState.empty()) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08006603 dump += "\nInput Dispatcher State at time of last ANR:\n";
Siarhei Vishniakoub1a16272020-05-06 16:09:19 -07006604 dump += mLastAnrState;
Michael Wrightd02c5b62014-02-10 15:10:22 -08006605 }
6606}
6607
6608void InputDispatcher::monitor() {
6609 // Acquire and release the lock to ensure that the dispatcher has not deadlocked.
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08006610 std::unique_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006611 mLooper->wake();
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08006612 mDispatcherIsAlive.wait(_l);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006613}
6614
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -08006615/**
6616 * Wake up the dispatcher and wait until it processes all events and commands.
6617 * The notification of mDispatcherEnteredIdle is guaranteed to happen after wake(), so
6618 * this method can be safely called from any thread, as long as you've ensured that
6619 * the work you are interested in completing has already been queued.
6620 */
Siarhei Vishniakoua66d65e2023-06-16 10:32:51 -07006621bool InputDispatcher::waitForIdle() const {
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -08006622 /**
6623 * Timeout should represent the longest possible time that a device might spend processing
6624 * events and commands.
6625 */
6626 constexpr std::chrono::duration TIMEOUT = 100ms;
6627 std::unique_lock lock(mLock);
6628 mLooper->wake();
6629 std::cv_status result = mDispatcherEnteredIdle.wait_for(lock, TIMEOUT);
6630 return result == std::cv_status::no_timeout;
6631}
6632
Vishnu Naire798b472020-07-23 13:52:21 -07006633/**
6634 * Sets focus to the window identified by the token. This must be called
6635 * after updating any input window handles.
6636 *
6637 * Params:
6638 * request.token - input channel token used to identify the window that should gain focus.
6639 * request.focusedToken - the token that the caller expects currently to be focused. If the
6640 * specified token does not match the currently focused window, this request will be dropped.
6641 * If the specified focused token matches the currently focused window, the call will succeed.
6642 * Set this to "null" if this call should succeed no matter what the currently focused token is.
6643 * request.timestamp - SYSTEM_TIME_MONOTONIC timestamp in nanos set by the client (wm)
6644 * when requesting the focus change. This determines which request gets
6645 * precedence if there is a focus change request from another source such as pointer down.
6646 */
Vishnu Nair958da932020-08-21 17:12:37 -07006647void InputDispatcher::setFocusedWindow(const FocusRequest& request) {
6648 { // acquire lock
6649 std::scoped_lock _l(mLock);
Vishnu Nairc519ff72021-01-21 08:23:08 -08006650 std::optional<FocusResolver::FocusChanges> changes =
6651 mFocusResolver.setFocusedWindow(request, getWindowHandlesLocked(request.displayId));
6652 if (changes) {
6653 onFocusChangedLocked(*changes);
Vishnu Nair958da932020-08-21 17:12:37 -07006654 }
6655 } // release lock
6656 // Wake up poll loop since it may need to make new input dispatching choices.
6657 mLooper->wake();
6658}
6659
Vishnu Nairc519ff72021-01-21 08:23:08 -08006660void InputDispatcher::onFocusChangedLocked(const FocusResolver::FocusChanges& changes) {
6661 if (changes.oldFocus) {
6662 std::shared_ptr<InputChannel> focusedInputChannel = getInputChannelLocked(changes.oldFocus);
Vishnu Nair7d3d00d2020-08-03 11:20:42 -07006663 if (focusedInputChannel) {
Michael Wrightfb04fd52022-11-24 22:31:11 +00006664 CancelationOptions options(CancelationOptions::Mode::CANCEL_NON_POINTER_EVENTS,
Vishnu Nair7d3d00d2020-08-03 11:20:42 -07006665 "focus left window");
6666 synthesizeCancelationEventsForInputChannelLocked(focusedInputChannel, options);
Harry Cutts33476232023-01-30 19:57:29 +00006667 enqueueFocusEventLocked(changes.oldFocus, /*hasFocus=*/false, changes.reason);
Vishnu Nair7d3d00d2020-08-03 11:20:42 -07006668 }
Vishnu Nair7d3d00d2020-08-03 11:20:42 -07006669 }
Vishnu Nairc519ff72021-01-21 08:23:08 -08006670 if (changes.newFocus) {
Harry Cutts33476232023-01-30 19:57:29 +00006671 enqueueFocusEventLocked(changes.newFocus, /*hasFocus=*/true, changes.reason);
Vishnu Nair7d3d00d2020-08-03 11:20:42 -07006672 }
6673
Prabir Pradhan99987712020-11-10 18:43:05 -08006674 // If a window has pointer capture, then it must have focus. We need to ensure that this
6675 // contract is upheld when pointer capture is being disabled due to a loss of window focus.
6676 // If the window loses focus before it loses pointer capture, then the window can be in a state
6677 // where it has pointer capture but not focus, violating the contract. Therefore we must
6678 // dispatch the pointer capture event before the focus event. Since focus events are added to
6679 // the front of the queue (above), we add the pointer capture event to the front of the queue
6680 // after the focus events are added. This ensures the pointer capture event ends up at the
6681 // front.
6682 disablePointerCaptureForcedLocked();
6683
Vishnu Nairc519ff72021-01-21 08:23:08 -08006684 if (mFocusedDisplayId == changes.displayId) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00006685 sendFocusChangedCommandLocked(changes.oldFocus, changes.newFocus);
Vishnu Nair7d3d00d2020-08-03 11:20:42 -07006686 }
6687}
Vishnu Nair958da932020-08-21 17:12:37 -07006688
Prabir Pradhan99987712020-11-10 18:43:05 -08006689void InputDispatcher::disablePointerCaptureForcedLocked() {
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00006690 if (!mCurrentPointerCaptureRequest.enable && !mWindowTokenWithPointerCapture) {
Prabir Pradhan99987712020-11-10 18:43:05 -08006691 return;
6692 }
6693
6694 ALOGD_IF(DEBUG_FOCUS, "Disabling Pointer Capture because the window lost focus.");
6695
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00006696 if (mCurrentPointerCaptureRequest.enable) {
Prabir Pradhan99987712020-11-10 18:43:05 -08006697 setPointerCaptureLocked(false);
6698 }
6699
6700 if (!mWindowTokenWithPointerCapture) {
6701 // No need to send capture changes because no window has capture.
6702 return;
6703 }
6704
6705 if (mPendingEvent != nullptr) {
6706 // Move the pending event to the front of the queue. This will give the chance
6707 // for the pending event to be dropped if it is a captured event.
6708 mInboundQueue.push_front(mPendingEvent);
6709 mPendingEvent = nullptr;
6710 }
6711
6712 auto entry = std::make_unique<PointerCaptureChangedEntry>(mIdGenerator.nextId(), now(),
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00006713 mCurrentPointerCaptureRequest);
Prabir Pradhan99987712020-11-10 18:43:05 -08006714 mInboundQueue.push_front(std::move(entry));
6715}
6716
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00006717void InputDispatcher::setPointerCaptureLocked(bool enable) {
6718 mCurrentPointerCaptureRequest.enable = enable;
6719 mCurrentPointerCaptureRequest.seq++;
6720 auto command = [this, request = mCurrentPointerCaptureRequest]() REQUIRES(mLock) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00006721 scoped_unlock unlock(mLock);
Prabir Pradhana41d2442023-04-20 21:30:40 +00006722 mPolicy.setPointerCapture(request);
Prabir Pradhancef936d2021-07-21 16:17:52 +00006723 };
6724 postCommandLocked(std::move(command));
Prabir Pradhan99987712020-11-10 18:43:05 -08006725}
6726
Vishnu Nair599f1412021-06-21 10:39:58 -07006727void InputDispatcher::displayRemoved(int32_t displayId) {
6728 { // acquire lock
6729 std::scoped_lock _l(mLock);
6730 // Set an empty list to remove all handles from the specific display.
6731 setInputWindowsLocked(/* window handles */ {}, displayId);
6732 setFocusedApplicationLocked(displayId, nullptr);
6733 // Call focus resolver to clean up stale requests. This must be called after input windows
6734 // have been removed for the removed display.
6735 mFocusResolver.displayRemoved(displayId);
Christine Franksb768bb42021-11-29 12:11:31 -08006736 // Reset pointer capture eligibility, regardless of previous state.
6737 std::erase(mIneligibleDisplaysForPointerCapture, displayId);
Antonio Kantek15beb512022-06-13 22:35:41 +00006738 // Remove the associated touch mode state.
6739 mTouchModePerDisplay.erase(displayId);
Siarhei Vishniakou5c02a712023-05-15 15:45:02 -07006740 mVerifiersByDisplay.erase(displayId);
Vishnu Nair599f1412021-06-21 10:39:58 -07006741 } // release lock
6742
6743 // Wake up poll loop since it may need to make new input dispatching choices.
6744 mLooper->wake();
6745}
6746
Patrick Williamsd828f302023-04-28 17:52:08 -05006747void InputDispatcher::onWindowInfosChanged(const gui::WindowInfosUpdate& update) {
chaviw15fab6f2021-06-07 14:15:52 -05006748 // The listener sends the windows as a flattened array. Separate the windows by display for
6749 // more convenient parsing.
6750 std::unordered_map<int32_t, std::vector<sp<WindowInfoHandle>>> handlesPerDisplay;
Patrick Williamsd828f302023-04-28 17:52:08 -05006751 for (const auto& info : update.windowInfos) {
chaviw15fab6f2021-06-07 14:15:52 -05006752 handlesPerDisplay.emplace(info.displayId, std::vector<sp<WindowInfoHandle>>());
Siarhei Vishniakouaed7ad02022-08-03 15:04:33 -07006753 handlesPerDisplay[info.displayId].push_back(sp<WindowInfoHandle>::make(info));
chaviw15fab6f2021-06-07 14:15:52 -05006754 }
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07006755
6756 { // acquire lock
6757 std::scoped_lock _l(mLock);
Prabir Pradhan814fe082022-07-22 20:22:18 +00006758
6759 // Ensure that we have an entry created for all existing displays so that if a displayId has
6760 // no windows, we can tell that the windows were removed from the display.
6761 for (const auto& [displayId, _] : mWindowHandlesByDisplay) {
6762 handlesPerDisplay[displayId];
6763 }
6764
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07006765 mDisplayInfos.clear();
Patrick Williamsd828f302023-04-28 17:52:08 -05006766 for (const auto& displayInfo : update.displayInfos) {
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07006767 mDisplayInfos.emplace(displayInfo.displayId, displayInfo);
6768 }
6769
6770 for (const auto& [displayId, handles] : handlesPerDisplay) {
6771 setInputWindowsLocked(handles, displayId);
6772 }
Patrick Williams9464b2c2023-05-23 11:22:04 -05006773
6774 if (update.vsyncId < mWindowInfosVsyncId) {
6775 ALOGE("Received out of order window infos update. Last update vsync id: %" PRId64
6776 ", current update vsync id: %" PRId64,
6777 mWindowInfosVsyncId, update.vsyncId);
6778 }
6779 mWindowInfosVsyncId = update.vsyncId;
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07006780 }
6781 // Wake up poll loop since it may need to make new input dispatching choices.
6782 mLooper->wake();
chaviw15fab6f2021-06-07 14:15:52 -05006783}
6784
Vishnu Nair062a8672021-09-03 16:07:44 -07006785bool InputDispatcher::shouldDropInput(
6786 const EventEntry& entry, const sp<android::gui::WindowInfoHandle>& windowHandle) const {
Prabir Pradhan51e7db02022-02-07 06:02:57 -08006787 if (windowHandle->getInfo()->inputConfig.test(WindowInfo::InputConfig::DROP_INPUT) ||
6788 (windowHandle->getInfo()->inputConfig.test(
6789 WindowInfo::InputConfig::DROP_INPUT_IF_OBSCURED) &&
Vishnu Nair062a8672021-09-03 16:07:44 -07006790 isWindowObscuredLocked(windowHandle))) {
Prabir Pradhan51e7db02022-02-07 06:02:57 -08006791 ALOGW("Dropping %s event targeting %s as requested by the input configuration {%s} on "
6792 "display %" PRId32 ".",
Vishnu Nair062a8672021-09-03 16:07:44 -07006793 ftl::enum_string(entry.type).c_str(), windowHandle->getName().c_str(),
Prabir Pradhan51e7db02022-02-07 06:02:57 -08006794 windowHandle->getInfo()->inputConfig.string().c_str(),
Vishnu Nair062a8672021-09-03 16:07:44 -07006795 windowHandle->getInfo()->displayId);
6796 return true;
6797 }
6798 return false;
6799}
6800
Siarhei Vishniakou18050092021-09-01 13:32:49 -07006801void InputDispatcher::DispatcherWindowListener::onWindowInfosChanged(
Patrick Williamsd828f302023-04-28 17:52:08 -05006802 const gui::WindowInfosUpdate& update) {
6803 mDispatcher.onWindowInfosChanged(update);
Siarhei Vishniakou18050092021-09-01 13:32:49 -07006804}
6805
Arthur Hungdfd528e2021-12-08 13:23:04 +00006806void InputDispatcher::cancelCurrentTouch() {
6807 {
6808 std::scoped_lock _l(mLock);
6809 ALOGD("Canceling all ongoing pointer gestures on all displays.");
Michael Wrightfb04fd52022-11-24 22:31:11 +00006810 CancelationOptions options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS,
Arthur Hungdfd528e2021-12-08 13:23:04 +00006811 "cancel current touch");
6812 synthesizeCancelationEventsForAllConnectionsLocked(options);
6813
6814 mTouchStatesByDisplay.clear();
Arthur Hungdfd528e2021-12-08 13:23:04 +00006815 }
6816 // Wake up poll loop since there might be work to do.
6817 mLooper->wake();
6818}
6819
Prabir Pradhan87112a72023-04-20 19:13:39 +00006820void InputDispatcher::requestRefreshConfiguration() {
Prabir Pradhana41d2442023-04-20 21:30:40 +00006821 InputDispatcherConfiguration config = mPolicy.getDispatcherConfiguration();
Prabir Pradhan87112a72023-04-20 19:13:39 +00006822
6823 std::scoped_lock _l(mLock);
6824 mConfig = config;
6825}
6826
Prabir Pradhan1376fcd2022-01-21 09:56:35 -08006827void InputDispatcher::setMonitorDispatchingTimeoutForTest(std::chrono::nanoseconds timeout) {
6828 std::scoped_lock _l(mLock);
6829 mMonitorDispatchingTimeout = timeout;
6830}
6831
Arthur Hungc539dbb2022-12-08 07:45:36 +00006832void InputDispatcher::slipWallpaperTouch(ftl::Flags<InputTarget::Flags> targetFlags,
6833 const sp<WindowInfoHandle>& oldWindowHandle,
6834 const sp<WindowInfoHandle>& newWindowHandle,
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07006835 TouchState& state, int32_t deviceId, int32_t pointerId,
Siarhei Vishniakoubf880522023-05-01 11:03:22 -07006836 std::vector<InputTarget>& targets) const {
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08006837 std::bitset<MAX_POINTER_ID + 1> pointerIds;
6838 pointerIds.set(pointerId);
Arthur Hungc539dbb2022-12-08 07:45:36 +00006839 const bool oldHasWallpaper = oldWindowHandle->getInfo()->inputConfig.test(
6840 gui::WindowInfo::InputConfig::DUPLICATE_TOUCH_TO_WALLPAPER);
6841 const bool newHasWallpaper = targetFlags.test(InputTarget::Flags::FOREGROUND) &&
6842 newWindowHandle->getInfo()->inputConfig.test(
6843 gui::WindowInfo::InputConfig::DUPLICATE_TOUCH_TO_WALLPAPER);
6844 const sp<WindowInfoHandle> oldWallpaper =
6845 oldHasWallpaper ? state.getWallpaperWindow() : nullptr;
6846 const sp<WindowInfoHandle> newWallpaper =
6847 newHasWallpaper ? findWallpaperWindowBelow(newWindowHandle) : nullptr;
6848 if (oldWallpaper == newWallpaper) {
6849 return;
6850 }
6851
6852 if (oldWallpaper != nullptr) {
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08006853 const TouchedWindow& oldTouchedWindow = state.getTouchedWindow(oldWallpaper);
6854 addWindowTargetLocked(oldWallpaper,
6855 oldTouchedWindow.targetFlags |
6856 InputTarget::Flags::DISPATCH_AS_SLIPPERY_EXIT,
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07006857 pointerIds, oldTouchedWindow.getDownTimeInTarget(deviceId), targets);
6858 state.removeTouchingPointerFromWindow(deviceId, pointerId, oldWallpaper);
Arthur Hungc539dbb2022-12-08 07:45:36 +00006859 }
6860
6861 if (newWallpaper != nullptr) {
6862 state.addOrUpdateWindow(newWallpaper,
6863 InputTarget::Flags::DISPATCH_AS_SLIPPERY_ENTER |
6864 InputTarget::Flags::WINDOW_IS_OBSCURED |
6865 InputTarget::Flags::WINDOW_IS_PARTIALLY_OBSCURED,
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07006866 deviceId, pointerIds);
Arthur Hungc539dbb2022-12-08 07:45:36 +00006867 }
6868}
6869
6870void InputDispatcher::transferWallpaperTouch(ftl::Flags<InputTarget::Flags> oldTargetFlags,
6871 ftl::Flags<InputTarget::Flags> newTargetFlags,
6872 const sp<WindowInfoHandle> fromWindowHandle,
6873 const sp<WindowInfoHandle> toWindowHandle,
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07006874 TouchState& state, int32_t deviceId,
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08006875 std::bitset<MAX_POINTER_ID + 1> pointerIds) {
Arthur Hungc539dbb2022-12-08 07:45:36 +00006876 const bool oldHasWallpaper = oldTargetFlags.test(InputTarget::Flags::FOREGROUND) &&
6877 fromWindowHandle->getInfo()->inputConfig.test(
6878 gui::WindowInfo::InputConfig::DUPLICATE_TOUCH_TO_WALLPAPER);
6879 const bool newHasWallpaper = newTargetFlags.test(InputTarget::Flags::FOREGROUND) &&
6880 toWindowHandle->getInfo()->inputConfig.test(
6881 gui::WindowInfo::InputConfig::DUPLICATE_TOUCH_TO_WALLPAPER);
6882
6883 const sp<WindowInfoHandle> oldWallpaper =
6884 oldHasWallpaper ? state.getWallpaperWindow() : nullptr;
6885 const sp<WindowInfoHandle> newWallpaper =
6886 newHasWallpaper ? findWallpaperWindowBelow(toWindowHandle) : nullptr;
6887 if (oldWallpaper == newWallpaper) {
6888 return;
6889 }
6890
6891 if (oldWallpaper != nullptr) {
6892 CancelationOptions options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS,
6893 "transferring touch focus to another window");
6894 state.removeWindowByToken(oldWallpaper->getToken());
6895 synthesizeCancelationEventsForWindowLocked(oldWallpaper, options);
6896 }
6897
6898 if (newWallpaper != nullptr) {
6899 nsecs_t downTimeInTarget = now();
6900 ftl::Flags<InputTarget::Flags> wallpaperFlags =
6901 oldTargetFlags & (InputTarget::Flags::SPLIT | InputTarget::Flags::DISPATCH_AS_IS);
6902 wallpaperFlags |= InputTarget::Flags::WINDOW_IS_OBSCURED |
6903 InputTarget::Flags::WINDOW_IS_PARTIALLY_OBSCURED;
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07006904 state.addOrUpdateWindow(newWallpaper, wallpaperFlags, deviceId, pointerIds,
6905 downTimeInTarget);
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07006906 std::shared_ptr<Connection> wallpaperConnection =
6907 getConnectionLocked(newWallpaper->getToken());
Arthur Hungc539dbb2022-12-08 07:45:36 +00006908 if (wallpaperConnection != nullptr) {
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07006909 std::shared_ptr<Connection> toConnection =
6910 getConnectionLocked(toWindowHandle->getToken());
Arthur Hungc539dbb2022-12-08 07:45:36 +00006911 toConnection->inputState.mergePointerStateTo(wallpaperConnection->inputState);
6912 synthesizePointerDownEventsForConnectionLocked(downTimeInTarget, wallpaperConnection,
6913 wallpaperFlags);
6914 }
6915 }
6916}
6917
6918sp<WindowInfoHandle> InputDispatcher::findWallpaperWindowBelow(
6919 const sp<WindowInfoHandle>& windowHandle) const {
6920 const std::vector<sp<WindowInfoHandle>>& windowHandles =
6921 getWindowHandlesLocked(windowHandle->getInfo()->displayId);
6922 bool foundWindow = false;
6923 for (const sp<WindowInfoHandle>& otherHandle : windowHandles) {
6924 if (!foundWindow && otherHandle != windowHandle) {
6925 continue;
6926 }
6927 if (windowHandle == otherHandle) {
6928 foundWindow = true;
6929 continue;
6930 }
6931
6932 if (otherHandle->getInfo()->inputConfig.test(WindowInfo::InputConfig::IS_WALLPAPER)) {
6933 return otherHandle;
6934 }
6935 }
6936 return nullptr;
6937}
6938
Garfield Tane84e6f92019-08-29 17:28:41 -07006939} // namespace android::inputdispatcher