blob: 8be72f67a9be7f5c53750de69fa3716fd11c9861 [file] [log] [blame]
Michael Wrightd02c5b62014-02-10 15:10:22 -08001/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "InputDispatcher"
18#define ATRACE_TAG ATRACE_TAG_INPUT
19
John Recke0710582019-09-26 13:46:12 -070020#define LOG_NDEBUG 1
Michael Wrightd02c5b62014-02-10 15:10:22 -080021
Michael Wright2b3c3302018-03-02 17:19:13 +000022#include <android-base/chrono_utils.h>
Siarhei Vishniakoud010b012023-01-18 15:00:53 -080023#include <android-base/logging.h>
Peter Collingbourneb04b9b82021-02-08 12:09:47 -080024#include <android-base/properties.h>
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -080025#include <android-base/stringprintf.h>
Siarhei Vishniakou70622952020-07-30 11:17:23 -050026#include <android/os/IInputConstants.h>
Robert Carr4e670e52018-08-15 13:26:12 -070027#include <binder/Binder.h>
Ameer Armalycff4fa52023-10-04 23:45:11 +000028#include <com_android_input_flags.h>
Dominik Laskowski75788452021-02-09 18:51:25 -080029#include <ftl/enum.h>
Siarhei Vishniakou5c02a712023-05-15 15:45:02 -070030#include <log/log_event_list.h>
Siarhei Vishniakou31977182022-09-30 08:51:23 -070031#if defined(__ANDROID__)
chaviw15fab6f2021-06-07 14:15:52 -050032#include <gui/SurfaceComposerClient.h>
Siarhei Vishniakou31977182022-09-30 08:51:23 -070033#endif
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -080034#include <input/InputDevice.h>
Siarhei Vishniakou6e1e9872022-11-08 17:51:35 -080035#include <input/PrintTools.h>
Prabir Pradhana37bad12023-08-18 15:55:32 +000036#include <input/TraceTools.h>
tyiu1573a672023-02-21 22:38:32 +000037#include <openssl/mem.h>
Garfield Tan0fc2fa72019-08-29 17:22:15 -070038#include <powermanager/PowerManager.h>
Michael Wright44753b12020-07-08 13:48:11 +010039#include <unistd.h>
Garfield Tan0fc2fa72019-08-29 17:22:15 -070040#include <utils/Trace.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080041
Michael Wright44753b12020-07-08 13:48:11 +010042#include <cerrno>
43#include <cinttypes>
44#include <climits>
45#include <cstddef>
46#include <ctime>
47#include <queue>
48#include <sstream>
49
Asmita Poddardd9a6cd2023-09-26 15:35:12 +000050#include "../InputDeviceMetricsSource.h"
51
Michael Wright44753b12020-07-08 13:48:11 +010052#include "Connection.h"
Arthur Hung1a1007b2022-05-11 07:15:01 +000053#include "DebugConfig.h"
Chris Yef59a2f42020-10-16 12:55:26 -070054#include "InputDispatcher.h"
Michael Wright44753b12020-07-08 13:48:11 +010055
Michael Wrightd02c5b62014-02-10 15:10:22 -080056#define INDENT " "
57#define INDENT2 " "
58#define INDENT3 " "
59#define INDENT4 " "
60
Siarhei Vishniakou253f4642022-11-09 13:42:06 -080061using namespace android::ftl::flag_operators;
Siarhei Vishniakou23740b92023-04-21 11:30:20 -070062using android::base::Error;
Peter Collingbourneb04b9b82021-02-08 12:09:47 -080063using android::base::HwTimeoutMultiplier;
Siarhei Vishniakoueedd0fc2021-03-12 09:50:36 +000064using android::base::Result;
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -080065using android::base::StringPrintf;
Prabir Pradhan48f8cb92021-08-26 14:05:36 -070066using android::gui::DisplayInfo;
chaviw98318de2021-05-19 16:45:23 -050067using android::gui::FocusRequest;
68using android::gui::TouchOcclusionMode;
69using android::gui::WindowInfo;
70using android::gui::WindowInfoHandle;
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -080071using android::os::InputEventInjectionResult;
72using android::os::InputEventInjectionSync;
Ameer Armalycff4fa52023-10-04 23:45:11 +000073namespace input_flags = com::android::input::flags;
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -080074
Garfield Tane84e6f92019-08-29 17:28:41 -070075namespace android::inputdispatcher {
Michael Wrightd02c5b62014-02-10 15:10:22 -080076
Prabir Pradhancef936d2021-07-21 16:17:52 +000077namespace {
Prabir Pradhancef936d2021-07-21 16:17:52 +000078// Temporarily releases a held mutex for the lifetime of the instance.
79// Named to match std::scoped_lock
80class scoped_unlock {
81public:
82 explicit scoped_unlock(std::mutex& mutex) : mMutex(mutex) { mMutex.unlock(); }
83 ~scoped_unlock() { mMutex.lock(); }
84
85private:
86 std::mutex& mMutex;
87};
88
Michael Wrightd02c5b62014-02-10 15:10:22 -080089// Default input dispatching timeout if there is no focused application or paused window
90// from which to determine an appropriate dispatching timeout.
Peter Collingbourneb04b9b82021-02-08 12:09:47 -080091const std::chrono::duration DEFAULT_INPUT_DISPATCHING_TIMEOUT = std::chrono::milliseconds(
92 android::os::IInputConstants::UNMULTIPLIED_DEFAULT_DISPATCHING_TIMEOUT_MILLIS *
93 HwTimeoutMultiplier());
Michael Wrightd02c5b62014-02-10 15:10:22 -080094
95// Amount of time to allow for all pending events to be processed when an app switch
96// key is on the way. This is used to preempt input dispatch and drop input events
97// when an application takes too long to respond and the user has pressed an app switch key.
Michael Wright2b3c3302018-03-02 17:19:13 +000098constexpr nsecs_t APP_SWITCH_TIMEOUT = 500 * 1000000LL; // 0.5sec
Michael Wrightd02c5b62014-02-10 15:10:22 -080099
Siarhei Vishniakou289e9242022-02-15 14:50:16 -0800100const std::chrono::duration STALE_EVENT_TIMEOUT = std::chrono::seconds(10) * HwTimeoutMultiplier();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800101
Michael Wrightd02c5b62014-02-10 15:10:22 -0800102// 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 +0000103constexpr nsecs_t SLOW_EVENT_PROCESSING_WARNING_TIMEOUT = 2000 * 1000000LL; // 2sec
104
105// Log a warning when an interception call takes longer than this to process.
106constexpr std::chrono::milliseconds SLOW_INTERCEPTION_THRESHOLD = 50ms;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800107
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700108// Additional key latency in case a connection is still processing some motion events.
109// This will help with the case when a user touched a button that opens a new window,
110// and gives us the chance to dispatch the key to this new window.
111constexpr std::chrono::nanoseconds KEY_WAITING_FOR_EVENTS_TIMEOUT = 500ms;
112
Michael Wrightd02c5b62014-02-10 15:10:22 -0800113// Number of recent events to keep for debugging purposes.
Michael Wright2b3c3302018-03-02 17:19:13 +0000114constexpr size_t RECENT_QUEUE_MAX_SIZE = 10;
115
Antonio Kantekea47acb2021-12-23 12:41:25 -0800116// Event log tags. See EventLogTags.logtags for reference.
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +0000117constexpr int LOGTAG_INPUT_INTERACTION = 62000;
118constexpr int LOGTAG_INPUT_FOCUS = 62001;
Arthur Hungb3307ee2021-10-14 10:57:37 +0000119constexpr int LOGTAG_INPUT_CANCEL = 62003;
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +0000120
Prabir Pradhan33e3baa2022-12-06 20:30:22 +0000121const ui::Transform kIdentityTransform;
122
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000123inline nsecs_t now() {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800124 return systemTime(SYSTEM_TIME_MONOTONIC);
125}
126
Siarhei Vishniakoud38a1e02023-07-18 11:55:17 -0700127bool isEmpty(const std::stringstream& ss) {
128 return ss.rdbuf()->in_avail() == 0;
129}
130
Siarhei Vishniakou63b63612023-04-12 11:00:23 -0700131inline const std::string binderToString(const sp<IBinder>& binder) {
Bernardo Rufino49d99e42021-01-18 15:16:59 +0000132 if (binder == nullptr) {
133 return "<null>";
134 }
135 return StringPrintf("%p", binder.get());
136}
137
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +0000138static std::string uidString(const gui::Uid& uid) {
139 return uid.toString();
140}
141
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700142Result<void> checkKeyAction(int32_t action) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800143 switch (action) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700144 case AKEY_EVENT_ACTION_DOWN:
145 case AKEY_EVENT_ACTION_UP:
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700146 return {};
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700147 default:
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700148 return Error() << "Key event has invalid action code " << action;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800149 }
150}
151
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700152Result<void> validateKeyEvent(int32_t action) {
153 return checkKeyAction(action);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800154}
155
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700156Result<void> checkMotionAction(int32_t action, int32_t actionButton, int32_t pointerCount) {
Siarhei Vishniakou2f61bdc2022-12-02 08:55:51 -0800157 switch (MotionEvent::getActionMasked(action)) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700158 case AMOTION_EVENT_ACTION_DOWN:
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700159 case AMOTION_EVENT_ACTION_UP: {
160 if (pointerCount != 1) {
161 return Error() << "invalid pointer count " << pointerCount;
162 }
163 return {};
164 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700165 case AMOTION_EVENT_ACTION_MOVE:
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700166 case AMOTION_EVENT_ACTION_HOVER_ENTER:
167 case AMOTION_EVENT_ACTION_HOVER_MOVE:
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700168 case AMOTION_EVENT_ACTION_HOVER_EXIT: {
169 if (pointerCount < 1) {
170 return Error() << "invalid pointer count " << pointerCount;
171 }
172 return {};
173 }
Siarhei Vishniakou2f61bdc2022-12-02 08:55:51 -0800174 case AMOTION_EVENT_ACTION_CANCEL:
175 case AMOTION_EVENT_ACTION_OUTSIDE:
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700176 case AMOTION_EVENT_ACTION_SCROLL:
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700177 return {};
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700178 case AMOTION_EVENT_ACTION_POINTER_DOWN:
179 case AMOTION_EVENT_ACTION_POINTER_UP: {
Siarhei Vishniakou2f61bdc2022-12-02 08:55:51 -0800180 const int32_t index = MotionEvent::getActionIndex(action);
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700181 if (index < 0) {
182 return Error() << "invalid index " << index << " for "
183 << MotionEvent::actionToString(action);
184 }
185 if (index >= pointerCount) {
186 return Error() << "invalid index " << index << " for pointerCount " << pointerCount;
187 }
188 if (pointerCount <= 1) {
189 return Error() << "invalid pointer count " << pointerCount << " for "
190 << MotionEvent::actionToString(action);
191 }
192 return {};
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700193 }
194 case AMOTION_EVENT_ACTION_BUTTON_PRESS:
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700195 case AMOTION_EVENT_ACTION_BUTTON_RELEASE: {
196 if (actionButton == 0) {
197 return Error() << "action button should be nonzero for "
198 << MotionEvent::actionToString(action);
199 }
200 return {};
201 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700202 default:
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700203 return Error() << "invalid action " << action;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800204 }
205}
206
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000207int64_t millis(std::chrono::nanoseconds t) {
Siarhei Vishniakouc1ae5562020-06-30 14:22:57 -0500208 return std::chrono::duration_cast<std::chrono::milliseconds>(t).count();
209}
210
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700211Result<void> validateMotionEvent(int32_t action, int32_t actionButton, size_t pointerCount,
212 const PointerProperties* pointerProperties) {
213 Result<void> actionCheck = checkMotionAction(action, actionButton, pointerCount);
214 if (!actionCheck.ok()) {
215 return actionCheck;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800216 }
217 if (pointerCount < 1 || pointerCount > MAX_POINTERS) {
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700218 return Error() << "Motion event has invalid pointer count " << pointerCount
219 << "; value must be between 1 and " << MAX_POINTERS << ".";
Michael Wrightd02c5b62014-02-10 15:10:22 -0800220 }
Siarhei Vishniakou8a878352023-01-30 14:05:01 -0800221 std::bitset<MAX_POINTER_ID + 1> pointerIdBits;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800222 for (size_t i = 0; i < pointerCount; i++) {
223 int32_t id = pointerProperties[i].id;
224 if (id < 0 || id > MAX_POINTER_ID) {
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700225 return Error() << "Motion event has invalid pointer id " << id
226 << "; value must be between 0 and " << MAX_POINTER_ID;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800227 }
Siarhei Vishniakou8a878352023-01-30 14:05:01 -0800228 if (pointerIdBits.test(id)) {
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700229 return Error() << "Motion event has duplicate pointer id " << id;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800230 }
Siarhei Vishniakou8a878352023-01-30 14:05:01 -0800231 pointerIdBits.set(id);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800232 }
Siarhei Vishniakou23740b92023-04-21 11:30:20 -0700233 return {};
234}
235
236Result<void> validateInputEvent(const InputEvent& event) {
237 switch (event.getType()) {
238 case InputEventType::KEY: {
239 const KeyEvent& key = static_cast<const KeyEvent&>(event);
240 const int32_t action = key.getAction();
241 return validateKeyEvent(action);
242 }
243 case InputEventType::MOTION: {
244 const MotionEvent& motion = static_cast<const MotionEvent&>(event);
245 const int32_t action = motion.getAction();
246 const size_t pointerCount = motion.getPointerCount();
247 const PointerProperties* pointerProperties = motion.getPointerProperties();
248 const int32_t actionButton = motion.getActionButton();
249 return validateMotionEvent(action, actionButton, pointerCount, pointerProperties);
250 }
251 default: {
252 return {};
253 }
254 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800255}
256
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000257std::string dumpRegion(const Region& region) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800258 if (region.isEmpty()) {
Bernardo Rufino53fc31e2020-11-03 11:01:07 +0000259 return "<empty>";
Michael Wrightd02c5b62014-02-10 15:10:22 -0800260 }
261
Bernardo Rufino53fc31e2020-11-03 11:01:07 +0000262 std::string dump;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800263 bool first = true;
264 Region::const_iterator cur = region.begin();
265 Region::const_iterator const tail = region.end();
266 while (cur != tail) {
267 if (first) {
268 first = false;
269 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -0800270 dump += "|";
Michael Wrightd02c5b62014-02-10 15:10:22 -0800271 }
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -0800272 dump += StringPrintf("[%d,%d][%d,%d]", cur->left, cur->top, cur->right, cur->bottom);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800273 cur++;
274 }
Bernardo Rufino53fc31e2020-11-03 11:01:07 +0000275 return dump;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800276}
277
Prabir Pradhan8c90d782023-09-15 21:16:44 +0000278std::string dumpQueue(const std::deque<std::unique_ptr<DispatchEntry>>& queue,
279 nsecs_t currentTime) {
Siarhei Vishniakou14411c92020-09-18 21:15:05 -0500280 constexpr size_t maxEntries = 50; // max events to print
281 constexpr size_t skipBegin = maxEntries / 2;
282 const size_t skipEnd = queue.size() - maxEntries / 2;
283 // skip from maxEntries / 2 ... size() - maxEntries/2
284 // only print from 0 .. skipBegin and then from skipEnd .. size()
285
286 std::string dump;
287 for (size_t i = 0; i < queue.size(); i++) {
288 const DispatchEntry& entry = *queue[i];
289 if (i >= skipBegin && i < skipEnd) {
290 dump += StringPrintf(INDENT4 "<skipped %zu entries>\n", skipEnd - skipBegin);
291 i = skipEnd - 1; // it will be incremented to "skipEnd" by 'continue'
292 continue;
293 }
294 dump.append(INDENT4);
295 dump += entry.eventEntry->getDescription();
Siarhei Vishniakou253f4642022-11-09 13:42:06 -0800296 dump += StringPrintf(", seq=%" PRIu32 ", targetFlags=%s, resolvedAction=%d, age=%" PRId64
297 "ms",
298 entry.seq, entry.targetFlags.string().c_str(), entry.resolvedAction,
Siarhei Vishniakou14411c92020-09-18 21:15:05 -0500299 ns2ms(currentTime - entry.eventEntry->eventTime));
300 if (entry.deliveryTime != 0) {
301 // This entry was delivered, so add information on how long we've been waiting
302 dump += StringPrintf(", wait=%" PRId64 "ms", ns2ms(currentTime - entry.deliveryTime));
303 }
304 dump.append("\n");
305 }
306 return dump;
307}
308
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -0700309/**
310 * Find the entry in std::unordered_map by key, and return it.
311 * If the entry is not found, return a default constructed entry.
312 *
313 * Useful when the entries are vectors, since an empty vector will be returned
314 * if the entry is not found.
315 * Also useful when the entries are sp<>. If an entry is not found, nullptr is returned.
316 */
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -0700317template <typename K, typename V>
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000318V getValueByKey(const std::unordered_map<K, V>& map, K key) {
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -0700319 auto it = map.find(key);
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -0700320 return it != map.end() ? it->second : V{};
Tiger Huang721e26f2018-07-24 22:26:19 +0800321}
322
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000323bool haveSameToken(const sp<WindowInfoHandle>& first, const sp<WindowInfoHandle>& second) {
chaviwaf87b3e2019-10-01 16:59:28 -0700324 if (first == second) {
325 return true;
326 }
327
328 if (first == nullptr || second == nullptr) {
329 return false;
330 }
331
332 return first->getToken() == second->getToken();
333}
334
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000335bool haveSameApplicationToken(const WindowInfo* first, const WindowInfo* second) {
Bernardo Rufino1ff9d592021-01-18 16:58:57 +0000336 if (first == nullptr || second == nullptr) {
337 return false;
338 }
339 return first->applicationInfo.token != nullptr &&
340 first->applicationInfo.token == second->applicationInfo.token;
341}
342
Siarhei Vishniakou8a878352023-01-30 14:05:01 -0800343template <typename T>
344size_t firstMarkedBit(T set) {
345 // TODO: replace with std::countr_zero from <bit> when that's available
346 LOG_ALWAYS_FATAL_IF(set.none());
347 size_t i = 0;
348 while (!set.test(i)) {
349 i++;
350 }
351 return i;
352}
353
Siarhei Vishniakou253f4642022-11-09 13:42:06 -0800354std::unique_ptr<DispatchEntry> createDispatchEntry(
355 const InputTarget& inputTarget, std::shared_ptr<EventEntry> eventEntry,
356 ftl::Flags<InputTarget::Flags> inputTargetFlags) {
chaviw1ff3d1e2020-07-01 15:53:47 -0700357 if (inputTarget.useDefaultPointerTransform()) {
358 const ui::Transform& transform = inputTarget.getDefaultPointerTransform();
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700359 return std::make_unique<DispatchEntry>(eventEntry, inputTargetFlags, transform,
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700360 inputTarget.displayTransform,
361 inputTarget.globalScaleFactor);
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000362 }
363
364 ALOG_ASSERT(eventEntry->type == EventEntry::Type::MOTION);
365 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(*eventEntry);
366
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700367 std::vector<PointerCoords> pointerCoords;
Siarhei Vishniakouedd61202023-10-18 11:22:40 -0700368 pointerCoords.resize(motionEntry.getPointerCount());
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000369
370 // Use the first pointer information to normalize all other pointers. This could be any pointer
371 // as long as all other pointers are normalized to the same value and the final DispatchEntry
chaviw1ff3d1e2020-07-01 15:53:47 -0700372 // uses the transform for the normalized pointer.
373 const ui::Transform& firstPointerTransform =
Siarhei Vishniakou8a878352023-01-30 14:05:01 -0800374 inputTarget.pointerTransforms[firstMarkedBit(inputTarget.pointerIds)];
chaviw1ff3d1e2020-07-01 15:53:47 -0700375 ui::Transform inverseFirstTransform = firstPointerTransform.inverse();
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000376
377 // Iterate through all pointers in the event to normalize against the first.
Siarhei Vishniakouedd61202023-10-18 11:22:40 -0700378 for (uint32_t pointerIndex = 0; pointerIndex < motionEntry.getPointerCount(); pointerIndex++) {
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000379 const PointerProperties& pointerProperties = motionEntry.pointerProperties[pointerIndex];
380 uint32_t pointerId = uint32_t(pointerProperties.id);
chaviw1ff3d1e2020-07-01 15:53:47 -0700381 const ui::Transform& currTransform = inputTarget.pointerTransforms[pointerId];
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000382
383 pointerCoords[pointerIndex].copyFrom(motionEntry.pointerCoords[pointerIndex]);
chaviw1ff3d1e2020-07-01 15:53:47 -0700384 // First, apply the current pointer's transform to update the coordinates into
385 // window space.
386 pointerCoords[pointerIndex].transform(currTransform);
387 // Next, apply the inverse transform of the normalized coordinates so the
388 // current coordinates are transformed into the normalized coordinate space.
389 pointerCoords[pointerIndex].transform(inverseFirstTransform);
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000390 }
391
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700392 std::unique_ptr<MotionEntry> combinedMotionEntry =
393 std::make_unique<MotionEntry>(motionEntry.id, motionEntry.eventTime,
394 motionEntry.deviceId, motionEntry.source,
395 motionEntry.displayId, motionEntry.policyFlags,
396 motionEntry.action, motionEntry.actionButton,
397 motionEntry.flags, motionEntry.metaState,
398 motionEntry.buttonState, motionEntry.classification,
399 motionEntry.edgeFlags, motionEntry.xPrecision,
400 motionEntry.yPrecision, motionEntry.xCursorPosition,
401 motionEntry.yCursorPosition, motionEntry.downTime,
Siarhei Vishniakouedd61202023-10-18 11:22:40 -0700402 motionEntry.pointerProperties, pointerCoords);
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000403
404 if (motionEntry.injectionState) {
405 combinedMotionEntry->injectionState = motionEntry.injectionState;
406 combinedMotionEntry->injectionState->refCount += 1;
407 }
408
409 std::unique_ptr<DispatchEntry> dispatchEntry =
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700410 std::make_unique<DispatchEntry>(std::move(combinedMotionEntry), inputTargetFlags,
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700411 firstPointerTransform, inputTarget.displayTransform,
412 inputTarget.globalScaleFactor);
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000413 return dispatchEntry;
414}
415
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000416status_t openInputChannelPair(const std::string& name, std::shared_ptr<InputChannel>& serverChannel,
417 std::unique_ptr<InputChannel>& clientChannel) {
Garfield Tan15601662020-09-22 15:32:38 -0700418 std::unique_ptr<InputChannel> uniqueServerChannel;
419 status_t result = InputChannel::openInputChannelPair(name, uniqueServerChannel, clientChannel);
420
421 serverChannel = std::move(uniqueServerChannel);
422 return result;
423}
424
Siarhei Vishniakoue41c4512020-09-08 19:35:58 -0500425template <typename T>
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000426bool sharedPointersEqual(const std::shared_ptr<T>& lhs, const std::shared_ptr<T>& rhs) {
Siarhei Vishniakoue41c4512020-09-08 19:35:58 -0500427 if (lhs == nullptr && rhs == nullptr) {
428 return true;
429 }
430 if (lhs == nullptr || rhs == nullptr) {
431 return false;
432 }
433 return *lhs == *rhs;
434}
435
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000436KeyEvent createKeyEvent(const KeyEntry& entry) {
Siarhei Vishniakou2e2ea992020-12-15 02:57:19 +0000437 KeyEvent event;
438 event.initialize(entry.id, entry.deviceId, entry.source, entry.displayId, INVALID_HMAC,
439 entry.action, entry.flags, entry.keyCode, entry.scanCode, entry.metaState,
440 entry.repeatCount, entry.downTime, entry.eventTime);
441 return event;
442}
443
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000444bool shouldReportMetricsForConnection(const Connection& connection) {
Siarhei Vishniakouf2652122021-03-05 21:39:46 +0000445 // Do not keep track of gesture monitors. They receive every event and would disproportionately
446 // affect the statistics.
447 if (connection.monitor) {
448 return false;
449 }
450 // If the connection is experiencing ANR, let's skip it. We have separate ANR metrics
451 if (!connection.responsive) {
452 return false;
453 }
454 return true;
455}
456
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000457bool shouldReportFinishedEvent(const DispatchEntry& dispatchEntry, const Connection& connection) {
Siarhei Vishniakouf2652122021-03-05 21:39:46 +0000458 const EventEntry& eventEntry = *dispatchEntry.eventEntry;
459 const int32_t& inputEventId = eventEntry.id;
460 if (inputEventId != dispatchEntry.resolvedEventId) {
461 // Event was transmuted
462 return false;
463 }
464 if (inputEventId == android::os::IInputConstants::INVALID_INPUT_EVENT_ID) {
465 return false;
466 }
467 // Only track latency for events that originated from hardware
468 if (eventEntry.isSynthesized()) {
469 return false;
470 }
471 const EventEntry::Type& inputEventEntryType = eventEntry.type;
472 if (inputEventEntryType == EventEntry::Type::KEY) {
473 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(eventEntry);
474 if (keyEntry.flags & AKEY_EVENT_FLAG_CANCELED) {
475 return false;
476 }
477 } else if (inputEventEntryType == EventEntry::Type::MOTION) {
478 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(eventEntry);
479 if (motionEntry.action == AMOTION_EVENT_ACTION_CANCEL ||
480 motionEntry.action == AMOTION_EVENT_ACTION_HOVER_EXIT) {
481 return false;
482 }
483 } else {
484 // Not a key or a motion
485 return false;
486 }
487 if (!shouldReportMetricsForConnection(connection)) {
488 return false;
489 }
490 return true;
491}
492
Prabir Pradhancef936d2021-07-21 16:17:52 +0000493/**
494 * Connection is responsive if it has no events in the waitQueue that are older than the
495 * current time.
496 */
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000497bool isConnectionResponsive(const Connection& connection) {
Prabir Pradhancef936d2021-07-21 16:17:52 +0000498 const nsecs_t currentTime = now();
Prabir Pradhan8c90d782023-09-15 21:16:44 +0000499 for (const auto& dispatchEntry : connection.waitQueue) {
500 if (dispatchEntry->timeoutTime < currentTime) {
Prabir Pradhancef936d2021-07-21 16:17:52 +0000501 return false;
502 }
503 }
504 return true;
505}
506
Antonio Kantekf16f2832021-09-28 04:39:20 +0000507// Returns true if the event type passed as argument represents a user activity.
508bool isUserActivityEvent(const EventEntry& eventEntry) {
509 switch (eventEntry.type) {
Josep del Riob3981622023-04-18 15:49:45 +0000510 case EventEntry::Type::CONFIGURATION_CHANGED:
511 case EventEntry::Type::DEVICE_RESET:
512 case EventEntry::Type::DRAG:
Antonio Kantekf16f2832021-09-28 04:39:20 +0000513 case EventEntry::Type::FOCUS:
514 case EventEntry::Type::POINTER_CAPTURE_CHANGED:
Antonio Kantekf16f2832021-09-28 04:39:20 +0000515 case EventEntry::Type::SENSOR:
Josep del Riob3981622023-04-18 15:49:45 +0000516 case EventEntry::Type::TOUCH_MODE_CHANGED:
Antonio Kantekf16f2832021-09-28 04:39:20 +0000517 return false;
Antonio Kantekf16f2832021-09-28 04:39:20 +0000518 case EventEntry::Type::KEY:
519 case EventEntry::Type::MOTION:
520 return true;
521 }
522}
523
Prabir Pradhan3f90d312021-11-19 03:57:24 -0800524// Returns true if the given window can accept pointer events at the given display location.
Prabir Pradhan82e081e2022-12-06 09:50:09 +0000525bool windowAcceptsTouchAt(const WindowInfo& windowInfo, int32_t displayId, float x, float y,
Prabir Pradhan33e3baa2022-12-06 20:30:22 +0000526 bool isStylus, const ui::Transform& displayTransform) {
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -0800527 const auto inputConfig = windowInfo.inputConfig;
528 if (windowInfo.displayId != displayId ||
529 inputConfig.test(WindowInfo::InputConfig::NOT_VISIBLE)) {
Prabir Pradhan3f90d312021-11-19 03:57:24 -0800530 return false;
531 }
Prabir Pradhand65552b2021-10-07 11:23:50 -0700532 const bool windowCanInterceptTouch = isStylus && windowInfo.interceptsStylus();
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -0800533 if (inputConfig.test(WindowInfo::InputConfig::NOT_TOUCHABLE) && !windowCanInterceptTouch) {
Prabir Pradhan3f90d312021-11-19 03:57:24 -0800534 return false;
535 }
Prabir Pradhan33e3baa2022-12-06 20:30:22 +0000536
537 // Window Manager works in the logical display coordinate space. When it specifies bounds for a
538 // window as (l, t, r, b), the range of x in [l, r) and y in [t, b) are considered to be inside
539 // the window. Points on the right and bottom edges should not be inside the window, so we need
540 // to be careful about performing a hit test when the display is rotated, since the "right" and
541 // "bottom" of the window will be different in the display (un-rotated) space compared to in the
542 // logical display in which WM determined the bounds. Perform the hit test in the logical
543 // display space to ensure these edges are considered correctly in all orientations.
544 const auto touchableRegion = displayTransform.transform(windowInfo.touchableRegion);
545 const auto p = displayTransform.transform(x, y);
546 if (!touchableRegion.contains(std::floor(p.x), std::floor(p.y))) {
Prabir Pradhan3f90d312021-11-19 03:57:24 -0800547 return false;
548 }
549 return true;
550}
551
Prabir Pradhand65552b2021-10-07 11:23:50 -0700552bool isPointerFromStylus(const MotionEntry& entry, int32_t pointerIndex) {
553 return isFromSource(entry.source, AINPUT_SOURCE_STYLUS) &&
Prabir Pradhane5626962022-10-27 20:30:53 +0000554 isStylusToolType(entry.pointerProperties[pointerIndex].toolType);
Prabir Pradhand65552b2021-10-07 11:23:50 -0700555}
556
Siarhei Vishniakou253f4642022-11-09 13:42:06 -0800557// Determines if the given window can be targeted as InputTarget::Flags::FOREGROUND.
Prabir Pradhan6dfbf262022-03-14 15:24:30 +0000558// Foreground events are only sent to "foreground targetable" windows, but not all gestures sent to
559// such window are necessarily targeted with the flag. For example, an event with ACTION_OUTSIDE can
560// be sent to such a window, but it is not a foreground event and doesn't use
Siarhei Vishniakou253f4642022-11-09 13:42:06 -0800561// InputTarget::Flags::FOREGROUND.
Prabir Pradhan6dfbf262022-03-14 15:24:30 +0000562bool canReceiveForegroundTouches(const WindowInfo& info) {
563 // A non-touchable window can still receive touch events (e.g. in the case of
564 // STYLUS_INTERCEPTOR), so prevent such windows from receiving foreground events for touches.
565 return !info.inputConfig.test(gui::WindowInfo::InputConfig::NOT_TOUCHABLE) && !info.isSpy();
566}
567
Prabir Pradhanaeebeb42023-06-13 19:53:03 +0000568bool isWindowOwnedBy(const sp<WindowInfoHandle>& windowHandle, gui::Pid pid, gui::Uid uid) {
Antonio Kantek48710e42022-03-24 14:19:30 -0700569 if (windowHandle == nullptr) {
570 return false;
571 }
572 const WindowInfo* windowInfo = windowHandle->getInfo();
573 if (pid == windowInfo->ownerPid && uid == windowInfo->ownerUid) {
574 return true;
575 }
576 return false;
577}
578
Prabir Pradhan5735a322022-04-11 17:23:34 +0000579// Checks targeted injection using the window's owner's uid.
580// Returns an empty string if an entry can be sent to the given window, or an error message if the
581// entry is a targeted injection whose uid target doesn't match the window owner.
582std::optional<std::string> verifyTargetedInjection(const sp<WindowInfoHandle>& window,
583 const EventEntry& entry) {
584 if (entry.injectionState == nullptr || !entry.injectionState->targetUid) {
585 // The event was not injected, or the injected event does not target a window.
586 return {};
587 }
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +0000588 const auto uid = *entry.injectionState->targetUid;
Prabir Pradhan5735a322022-04-11 17:23:34 +0000589 if (window == nullptr) {
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +0000590 return StringPrintf("No valid window target for injection into uid %s.",
591 uid.toString().c_str());
Prabir Pradhan5735a322022-04-11 17:23:34 +0000592 }
593 if (entry.injectionState->targetUid != window->getInfo()->ownerUid) {
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +0000594 return StringPrintf("Injected event targeted at uid %s would be dispatched to window '%s' "
595 "owned by uid %s.",
596 uid.toString().c_str(), window->getName().c_str(),
597 window->getInfo()->ownerUid.toString().c_str());
Prabir Pradhan5735a322022-04-11 17:23:34 +0000598 }
599 return {};
600}
601
Prabir Pradhan82e081e2022-12-06 09:50:09 +0000602std::pair<float, float> resolveTouchedPosition(const MotionEntry& entry) {
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -0700603 const bool isFromMouse = isFromSource(entry.source, AINPUT_SOURCE_MOUSE);
604 // Always dispatch mouse events to cursor position.
605 if (isFromMouse) {
Prabir Pradhan82e081e2022-12-06 09:50:09 +0000606 return {entry.xCursorPosition, entry.yCursorPosition};
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -0700607 }
608
Siarhei Vishniakou5b9766d2023-07-18 14:06:29 -0700609 const int32_t pointerIndex = MotionEvent::getActionIndex(entry.action);
Prabir Pradhan82e081e2022-12-06 09:50:09 +0000610 return {entry.pointerCoords[pointerIndex].getAxisValue(AMOTION_EVENT_AXIS_X),
611 entry.pointerCoords[pointerIndex].getAxisValue(AMOTION_EVENT_AXIS_Y)};
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -0700612}
613
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -0700614std::optional<nsecs_t> getDownTime(const EventEntry& eventEntry) {
615 if (eventEntry.type == EventEntry::Type::KEY) {
616 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(eventEntry);
617 return keyEntry.downTime;
618 } else if (eventEntry.type == EventEntry::Type::MOTION) {
619 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(eventEntry);
620 return motionEntry.downTime;
621 }
622 return std::nullopt;
623}
624
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +0000625/**
626 * Compare the old touch state to the new touch state, and generate the corresponding touched
627 * windows (== input targets).
628 * If a window had the hovering pointer, but now it doesn't, produce HOVER_EXIT for that window.
629 * If the pointer just entered the new window, produce HOVER_ENTER.
630 * For pointers remaining in the window, produce HOVER_MOVE.
631 */
632std::vector<TouchedWindow> getHoveringWindowsLocked(const TouchState* oldState,
633 const TouchState& newTouchState,
634 const MotionEntry& entry) {
635 std::vector<TouchedWindow> out;
636 const int32_t maskedAction = MotionEvent::getActionMasked(entry.action);
Siarhei Vishniakou2899c552023-07-10 18:20:46 -0700637
638 if (maskedAction == AMOTION_EVENT_ACTION_SCROLL) {
639 // ACTION_SCROLL events should not affect the hovering pointer dispatch
640 return {};
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +0000641 }
642
643 // We should consider all hovering pointers here. But for now, just use the first one
644 const int32_t pointerId = entry.pointerProperties[0].id;
645
646 std::set<sp<WindowInfoHandle>> oldWindows;
647 if (oldState != nullptr) {
648 oldWindows = oldState->getWindowsWithHoveringPointer(entry.deviceId, pointerId);
649 }
650
651 std::set<sp<WindowInfoHandle>> newWindows =
652 newTouchState.getWindowsWithHoveringPointer(entry.deviceId, pointerId);
653
654 // If the pointer is no longer in the new window set, send HOVER_EXIT.
655 for (const sp<WindowInfoHandle>& oldWindow : oldWindows) {
656 if (newWindows.find(oldWindow) == newWindows.end()) {
657 TouchedWindow touchedWindow;
658 touchedWindow.windowHandle = oldWindow;
659 touchedWindow.targetFlags = InputTarget::Flags::DISPATCH_AS_HOVER_EXIT;
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +0000660 out.push_back(touchedWindow);
661 }
662 }
663
664 for (const sp<WindowInfoHandle>& newWindow : newWindows) {
665 TouchedWindow touchedWindow;
666 touchedWindow.windowHandle = newWindow;
667 if (oldWindows.find(newWindow) == oldWindows.end()) {
668 // Any windows that have this pointer now, and didn't have it before, should get
669 // HOVER_ENTER
670 touchedWindow.targetFlags = InputTarget::Flags::DISPATCH_AS_HOVER_ENTER;
671 } else {
672 // This pointer was already sent to the window. Use ACTION_HOVER_MOVE.
Siarhei Vishniakouc2eb8502023-04-11 18:33:36 -0700673 if (CC_UNLIKELY(maskedAction != AMOTION_EVENT_ACTION_HOVER_MOVE)) {
Daniel Norman7487dfa2023-08-02 16:39:45 -0700674 android::base::LogSeverity severity = android::base::LogSeverity::FATAL;
Ameer Armalycff4fa52023-10-04 23:45:11 +0000675 if (!input_flags::a11y_crash_on_inconsistent_event_stream() &&
676 entry.flags & AMOTION_EVENT_FLAG_IS_ACCESSIBILITY_EVENT) {
Daniel Norman7487dfa2023-08-02 16:39:45 -0700677 // The Accessibility injected touch exploration event stream
678 // has known inconsistencies, so log ERROR instead of
679 // crashing the device with FATAL.
Daniel Norman7487dfa2023-08-02 16:39:45 -0700680 severity = android::base::LogSeverity::ERROR;
681 }
682 LOG(severity) << "Expected ACTION_HOVER_MOVE instead of " << entry.getDescription();
Siarhei Vishniakouc2eb8502023-04-11 18:33:36 -0700683 }
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +0000684 touchedWindow.targetFlags = InputTarget::Flags::DISPATCH_AS_IS;
685 }
Siarhei Vishniakou0836a302023-05-03 13:54:30 -0700686 touchedWindow.addHoveringPointer(entry.deviceId, pointerId);
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +0000687 if (canReceiveForegroundTouches(*newWindow->getInfo())) {
688 touchedWindow.targetFlags |= InputTarget::Flags::FOREGROUND;
689 }
690 out.push_back(touchedWindow);
691 }
692 return out;
693}
694
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -0800695template <typename T>
696std::vector<T>& operator+=(std::vector<T>& left, const std::vector<T>& right) {
697 left.insert(left.end(), right.begin(), right.end());
698 return left;
699}
700
Harry Cuttsb166c002023-05-09 13:06:05 +0000701// Filter windows in a TouchState and targets in a vector to remove untrusted windows/targets from
702// both.
703void filterUntrustedTargets(TouchState& touchState, std::vector<InputTarget>& targets) {
704 std::erase_if(touchState.windows, [&](const TouchedWindow& window) {
705 if (!window.windowHandle->getInfo()->inputConfig.test(
706 WindowInfo::InputConfig::TRUSTED_OVERLAY)) {
707 // In addition to TouchState, erase this window from the input targets! We don't have a
708 // good way to do this today except by adding a nested loop.
709 // TODO(b/282025641): simplify this code once InputTargets are being identified
710 // separately from TouchedWindows.
711 std::erase_if(targets, [&](const InputTarget& target) {
712 return target.inputChannel->getConnectionToken() == window.windowHandle->getToken();
713 });
714 return true;
715 }
716 return false;
717 });
718}
719
Siarhei Vishniakouce1fd472023-09-18 18:38:07 -0700720/**
721 * In general, touch should be always split between windows. Some exceptions:
722 * 1. Don't split touch if all of the below is true:
723 * (a) we have an active pointer down *and*
724 * (b) a new pointer is going down that's from the same device *and*
725 * (c) the window that's receiving the current pointer does not support split touch.
726 * 2. Don't split mouse events
727 */
728bool shouldSplitTouch(const TouchState& touchState, const MotionEntry& entry) {
729 if (isFromSource(entry.source, AINPUT_SOURCE_MOUSE)) {
730 // We should never split mouse events
731 return false;
732 }
733 for (const TouchedWindow& touchedWindow : touchState.windows) {
734 if (touchedWindow.windowHandle->getInfo()->isSpy()) {
735 // Spy windows should not affect whether or not touch is split.
736 continue;
737 }
738 if (touchedWindow.windowHandle->getInfo()->supportsSplitTouch()) {
739 continue;
740 }
741 if (touchedWindow.windowHandle->getInfo()->inputConfig.test(
742 gui::WindowInfo::InputConfig::IS_WALLPAPER)) {
743 // Wallpaper window should not affect whether or not touch is split
744 continue;
745 }
746
747 if (touchedWindow.hasTouchingPointers(entry.deviceId)) {
748 return false;
749 }
750 }
751 return true;
752}
753
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000754} // namespace
755
Michael Wrightd02c5b62014-02-10 15:10:22 -0800756// --- InputDispatcher ---
757
Prabir Pradhana41d2442023-04-20 21:30:40 +0000758InputDispatcher::InputDispatcher(InputDispatcherPolicyInterface& policy)
Garfield Tan00f511d2019-06-12 16:55:40 -0700759 : mPolicy(policy),
760 mPendingEvent(nullptr),
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700761 mLastDropReason(DropReason::NOT_DROPPED),
Garfield Tanff1f1bb2020-01-28 13:24:04 -0800762 mIdGenerator(IdGenerator::Source::INPUT_DISPATCHER),
Garfield Tan00f511d2019-06-12 16:55:40 -0700763 mAppSwitchSawKeyDown(false),
Colin Cross5b799302022-10-18 21:52:41 -0700764 mAppSwitchDueTime(LLONG_MAX),
Garfield Tan00f511d2019-06-12 16:55:40 -0700765 mNextUnblockedEvent(nullptr),
Prabir Pradhan1376fcd2022-01-21 09:56:35 -0800766 mMonitorDispatchingTimeout(DEFAULT_INPUT_DISPATCHING_TIMEOUT),
Garfield Tan00f511d2019-06-12 16:55:40 -0700767 mDispatchEnabled(false),
768 mDispatchFrozen(false),
769 mInputFilterEnabled(false),
Bernardo Rufinoea97d182020-08-19 14:43:14 +0100770 mMaximumObscuringOpacityForTouch(1.0f),
Siarhei Vishniakou2508b872020-12-03 16:33:53 -1000771 mFocusedDisplayId(ADISPLAY_ID_DEFAULT),
Prabir Pradhan99987712020-11-10 18:43:05 -0800772 mWindowTokenWithPointerCapture(nullptr),
Siarhei Vishniakoua04181f2021-03-26 05:56:49 +0000773 mLatencyAggregator(),
Antonio Kantek15beb512022-06-13 22:35:41 +0000774 mLatencyTracker(&mLatencyAggregator) {
Siarhei Vishniakouaed7ad02022-08-03 15:04:33 -0700775 mLooper = sp<Looper>::make(false);
Prabir Pradhanf93562f2018-11-29 12:13:37 -0800776 mReporter = createInputReporter();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800777
Siarhei Vishniakouaed7ad02022-08-03 15:04:33 -0700778 mWindowInfoListener = sp<DispatcherWindowListener>::make(*this);
Siarhei Vishniakou31977182022-09-30 08:51:23 -0700779#if defined(__ANDROID__)
Siarhei Vishniakou18050092021-09-01 13:32:49 -0700780 SurfaceComposerClient::getDefault()->addWindowInfosListener(mWindowInfoListener);
Siarhei Vishniakou31977182022-09-30 08:51:23 -0700781#endif
Yi Kong9b14ac62018-07-17 13:48:38 -0700782 mKeyRepeatState.lastKeyEntry = nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800783}
784
785InputDispatcher::~InputDispatcher() {
Prabir Pradhancef936d2021-07-21 16:17:52 +0000786 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800787
Prabir Pradhancef936d2021-07-21 16:17:52 +0000788 resetKeyRepeatLocked();
789 releasePendingEventLocked();
790 drainInboundQueueLocked();
791 mCommandQueue.clear();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800792
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +0000793 while (!mConnectionsByToken.empty()) {
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -0700794 std::shared_ptr<Connection> connection = mConnectionsByToken.begin()->second;
Harry Cutts33476232023-01-30 19:57:29 +0000795 removeInputChannelLocked(connection->inputChannel->getConnectionToken(), /*notify=*/false);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800796 }
797}
798
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700799status_t InputDispatcher::start() {
Prabir Pradhan5a57cff2019-10-31 18:40:33 -0700800 if (mThread) {
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700801 return ALREADY_EXISTS;
802 }
Prabir Pradhan5a57cff2019-10-31 18:40:33 -0700803 mThread = std::make_unique<InputThread>(
804 "InputDispatcher", [this]() { dispatchOnce(); }, [this]() { mLooper->wake(); });
805 return OK;
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700806}
807
808status_t InputDispatcher::stop() {
Prabir Pradhan5a57cff2019-10-31 18:40:33 -0700809 if (mThread && mThread->isCallingThread()) {
810 ALOGE("InputDispatcher cannot be stopped from its own thread!");
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700811 return INVALID_OPERATION;
812 }
Prabir Pradhan5a57cff2019-10-31 18:40:33 -0700813 mThread.reset();
814 return OK;
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700815}
816
Michael Wrightd02c5b62014-02-10 15:10:22 -0800817void InputDispatcher::dispatchOnce() {
Colin Cross5b799302022-10-18 21:52:41 -0700818 nsecs_t nextWakeupTime = LLONG_MAX;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800819 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -0800820 std::scoped_lock _l(mLock);
821 mDispatcherIsAlive.notify_all();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800822
823 // Run a dispatch loop if there are no pending commands.
824 // The dispatch loop might enqueue commands to run afterwards.
825 if (!haveCommandsLocked()) {
826 dispatchOnceInnerLocked(&nextWakeupTime);
827 }
828
829 // Run all pending commands if there are any.
830 // If any commands were run then force the next poll to wake up immediately.
Prabir Pradhancef936d2021-07-21 16:17:52 +0000831 if (runCommandsLockedInterruptable()) {
Colin Cross5b799302022-10-18 21:52:41 -0700832 nextWakeupTime = LLONG_MIN;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800833 }
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -0800834
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700835 // If we are still waiting for ack on some events,
836 // we might have to wake up earlier to check if an app is anr'ing.
837 const nsecs_t nextAnrCheck = processAnrsLocked();
838 nextWakeupTime = std::min(nextWakeupTime, nextAnrCheck);
839
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -0800840 // We are about to enter an infinitely long sleep, because we have no commands or
841 // pending or queued events
Colin Cross5b799302022-10-18 21:52:41 -0700842 if (nextWakeupTime == LLONG_MAX) {
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -0800843 mDispatcherEnteredIdle.notify_all();
844 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800845 } // release lock
846
847 // Wait for callback or timeout or wake. (make sure we round up, not down)
848 nsecs_t currentTime = now();
849 int timeoutMillis = toMillisecondTimeoutDelay(currentTime, nextWakeupTime);
850 mLooper->pollOnce(timeoutMillis);
851}
852
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700853/**
Siarhei Vishniakouf56b2692020-09-08 19:43:33 -0500854 * Raise ANR if there is no focused window.
855 * Before the ANR is raised, do a final state check:
856 * 1. The currently focused application must be the same one we are waiting for.
857 * 2. Ensure we still don't have a focused window.
858 */
859void InputDispatcher::processNoFocusedWindowAnrLocked() {
860 // Check if the application that we are waiting for is still focused.
861 std::shared_ptr<InputApplicationHandle> focusedApplication =
862 getValueByKey(mFocusedApplicationHandlesByDisplay, mAwaitedApplicationDisplayId);
863 if (focusedApplication == nullptr ||
864 focusedApplication->getApplicationToken() !=
865 mAwaitedFocusedApplication->getApplicationToken()) {
866 // Unexpected because we should have reset the ANR timer when focused application changed
867 ALOGE("Waited for a focused window, but focused application has already changed to %s",
868 focusedApplication->getName().c_str());
869 return; // The focused application has changed.
870 }
871
chaviw98318de2021-05-19 16:45:23 -0500872 const sp<WindowInfoHandle>& focusedWindowHandle =
Siarhei Vishniakouf56b2692020-09-08 19:43:33 -0500873 getFocusedWindowHandleLocked(mAwaitedApplicationDisplayId);
874 if (focusedWindowHandle != nullptr) {
875 return; // We now have a focused window. No need for ANR.
876 }
877 onAnrLocked(mAwaitedFocusedApplication);
878}
879
880/**
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700881 * Check if any of the connections' wait queues have events that are too old.
882 * If we waited for events to be ack'ed for more than the window timeout, raise an ANR.
883 * Return the time at which we should wake up next.
884 */
885nsecs_t InputDispatcher::processAnrsLocked() {
886 const nsecs_t currentTime = now();
Colin Cross5b799302022-10-18 21:52:41 -0700887 nsecs_t nextAnrCheck = LLONG_MAX;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700888 // Check if we are waiting for a focused window to appear. Raise ANR if waited too long
889 if (mNoFocusedWindowTimeoutTime.has_value() && mAwaitedFocusedApplication != nullptr) {
890 if (currentTime >= *mNoFocusedWindowTimeoutTime) {
Siarhei Vishniakouf56b2692020-09-08 19:43:33 -0500891 processNoFocusedWindowAnrLocked();
Chris Yea209fde2020-07-22 13:54:51 -0700892 mAwaitedFocusedApplication.reset();
Siarhei Vishniakouf56b2692020-09-08 19:43:33 -0500893 mNoFocusedWindowTimeoutTime = std::nullopt;
Colin Cross5b799302022-10-18 21:52:41 -0700894 return LLONG_MIN;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700895 } else {
Siarhei Vishniakou38a6d272020-10-20 20:29:33 -0500896 // Keep waiting. We will drop the event when mNoFocusedWindowTimeoutTime comes.
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700897 nextAnrCheck = *mNoFocusedWindowTimeoutTime;
898 }
899 }
900
901 // Check if any connection ANRs are due
902 nextAnrCheck = std::min(nextAnrCheck, mAnrTracker.firstTimeout());
903 if (currentTime < nextAnrCheck) { // most likely scenario
904 return nextAnrCheck; // everything is normal. Let's check again at nextAnrCheck
905 }
906
907 // If we reached here, we have an unresponsive connection.
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -0700908 std::shared_ptr<Connection> connection = getConnectionLocked(mAnrTracker.firstToken());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700909 if (connection == nullptr) {
910 ALOGE("Could not find connection for entry %" PRId64, mAnrTracker.firstTimeout());
911 return nextAnrCheck;
912 }
913 connection->responsive = false;
914 // Stop waking up for this unresponsive connection
915 mAnrTracker.eraseToken(connection->inputChannel->getConnectionToken());
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +0000916 onAnrLocked(connection);
Colin Cross5b799302022-10-18 21:52:41 -0700917 return LLONG_MIN;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700918}
919
Prabir Pradhan1376fcd2022-01-21 09:56:35 -0800920std::chrono::nanoseconds InputDispatcher::getDispatchingTimeoutLocked(
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -0700921 const std::shared_ptr<Connection>& connection) {
Prabir Pradhan1376fcd2022-01-21 09:56:35 -0800922 if (connection->monitor) {
923 return mMonitorDispatchingTimeout;
924 }
925 const sp<WindowInfoHandle> window =
926 getWindowHandleLocked(connection->inputChannel->getConnectionToken());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700927 if (window != nullptr) {
Siarhei Vishniakou70622952020-07-30 11:17:23 -0500928 return window->getDispatchingTimeout(DEFAULT_INPUT_DISPATCHING_TIMEOUT);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700929 }
Siarhei Vishniakou70622952020-07-30 11:17:23 -0500930 return DEFAULT_INPUT_DISPATCHING_TIMEOUT;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700931}
932
Michael Wrightd02c5b62014-02-10 15:10:22 -0800933void InputDispatcher::dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) {
934 nsecs_t currentTime = now();
935
Jeff Browndc5992e2014-04-11 01:27:26 -0700936 // Reset the key repeat timer whenever normal dispatch is suspended while the
937 // device is in a non-interactive state. This is to ensure that we abort a key
938 // repeat if the device is just coming out of sleep.
939 if (!mDispatchEnabled) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800940 resetKeyRepeatLocked();
941 }
942
943 // If dispatching is frozen, do not process timeouts or try to deliver any new events.
944 if (mDispatchFrozen) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +0100945 if (DEBUG_FOCUS) {
946 ALOGD("Dispatch frozen. Waiting some more.");
947 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800948 return;
949 }
950
951 // Optimize latency of app switches.
952 // Essentially we start a short timeout when an app switch key (HOME / ENDCALL) has
953 // been pressed. When it expires, we preempt dispatch and drop all other pending events.
Siarhei Vishniakou6520a582023-10-27 21:53:45 -0700954 bool isAppSwitchDue;
955 if (!input_flags::remove_app_switch_drops()) {
956 isAppSwitchDue = mAppSwitchDueTime <= currentTime;
957 if (mAppSwitchDueTime < *nextWakeupTime) {
958 *nextWakeupTime = mAppSwitchDueTime;
959 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800960 }
961
962 // Ready to start a new event.
963 // If we don't already have a pending event, go grab one.
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700964 if (!mPendingEvent) {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -0700965 if (mInboundQueue.empty()) {
Siarhei Vishniakou6520a582023-10-27 21:53:45 -0700966 if (!input_flags::remove_app_switch_drops()) {
967 if (isAppSwitchDue) {
968 // The inbound queue is empty so the app switch key we were waiting
969 // for will never arrive. Stop waiting for it.
970 resetPendingAppSwitchLocked(false);
971 isAppSwitchDue = false;
972 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800973 }
974
975 // Synthesize a key repeat if appropriate.
976 if (mKeyRepeatState.lastKeyEntry) {
977 if (currentTime >= mKeyRepeatState.nextRepeatTime) {
978 mPendingEvent = synthesizeKeyRepeatLocked(currentTime);
979 } else {
980 if (mKeyRepeatState.nextRepeatTime < *nextWakeupTime) {
981 *nextWakeupTime = mKeyRepeatState.nextRepeatTime;
982 }
983 }
984 }
985
986 // Nothing to do if there is no pending event.
987 if (!mPendingEvent) {
988 return;
989 }
990 } else {
991 // Inbound queue has at least one entry.
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -0700992 mPendingEvent = mInboundQueue.front();
993 mInboundQueue.pop_front();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800994 traceInboundQueueLengthLocked();
995 }
996
997 // Poke user activity for this event.
998 if (mPendingEvent->policyFlags & POLICY_FLAG_PASS_TO_USER) {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700999 pokeUserActivityLocked(*mPendingEvent);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001000 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001001 }
1002
1003 // Now we have an event to dispatch.
1004 // All events are eventually dequeued and processed this way, even if we intend to drop them.
Yi Kong9b14ac62018-07-17 13:48:38 -07001005 ALOG_ASSERT(mPendingEvent != nullptr);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001006 bool done = false;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001007 DropReason dropReason = DropReason::NOT_DROPPED;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001008 if (!(mPendingEvent->policyFlags & POLICY_FLAG_PASS_TO_USER)) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001009 dropReason = DropReason::POLICY;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001010 } else if (!mDispatchEnabled) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001011 dropReason = DropReason::DISABLED;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001012 }
1013
1014 if (mNextUnblockedEvent == mPendingEvent) {
Yi Kong9b14ac62018-07-17 13:48:38 -07001015 mNextUnblockedEvent = nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001016 }
1017
1018 switch (mPendingEvent->type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001019 case EventEntry::Type::CONFIGURATION_CHANGED: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001020 const ConfigurationChangedEntry& typedEntry =
1021 static_cast<const ConfigurationChangedEntry&>(*mPendingEvent);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001022 done = dispatchConfigurationChangedLocked(currentTime, typedEntry);
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001023 dropReason = DropReason::NOT_DROPPED; // configuration changes are never dropped
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001024 break;
1025 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001026
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001027 case EventEntry::Type::DEVICE_RESET: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001028 const DeviceResetEntry& typedEntry =
1029 static_cast<const DeviceResetEntry&>(*mPendingEvent);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001030 done = dispatchDeviceResetLocked(currentTime, typedEntry);
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001031 dropReason = DropReason::NOT_DROPPED; // device resets are never dropped
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001032 break;
1033 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001034
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001035 case EventEntry::Type::FOCUS: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001036 std::shared_ptr<FocusEntry> typedEntry =
1037 std::static_pointer_cast<FocusEntry>(mPendingEvent);
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001038 dispatchFocusLocked(currentTime, typedEntry);
1039 done = true;
1040 dropReason = DropReason::NOT_DROPPED; // focus events are never dropped
1041 break;
1042 }
1043
Antonio Kantek7242d8b2021-08-05 16:07:20 -07001044 case EventEntry::Type::TOUCH_MODE_CHANGED: {
1045 const auto typedEntry = std::static_pointer_cast<TouchModeEntry>(mPendingEvent);
1046 dispatchTouchModeChangeLocked(currentTime, typedEntry);
1047 done = true;
1048 dropReason = DropReason::NOT_DROPPED; // touch mode events are never dropped
1049 break;
1050 }
1051
Prabir Pradhan99987712020-11-10 18:43:05 -08001052 case EventEntry::Type::POINTER_CAPTURE_CHANGED: {
1053 const auto typedEntry =
1054 std::static_pointer_cast<PointerCaptureChangedEntry>(mPendingEvent);
1055 dispatchPointerCaptureChangedLocked(currentTime, typedEntry, dropReason);
1056 done = true;
1057 break;
1058 }
1059
arthurhungb89ccb02020-12-30 16:19:01 +08001060 case EventEntry::Type::DRAG: {
1061 std::shared_ptr<DragEntry> typedEntry =
1062 std::static_pointer_cast<DragEntry>(mPendingEvent);
1063 dispatchDragLocked(currentTime, typedEntry);
1064 done = true;
1065 break;
1066 }
1067
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001068 case EventEntry::Type::KEY: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001069 std::shared_ptr<KeyEntry> keyEntry = std::static_pointer_cast<KeyEntry>(mPendingEvent);
Siarhei Vishniakou6520a582023-10-27 21:53:45 -07001070 if (!input_flags::remove_app_switch_drops()) {
1071 if (isAppSwitchDue) {
1072 if (isAppSwitchKeyEvent(*keyEntry)) {
1073 resetPendingAppSwitchLocked(true);
1074 isAppSwitchDue = false;
1075 } else if (dropReason == DropReason::NOT_DROPPED) {
1076 dropReason = DropReason::APP_SWITCH;
1077 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001078 }
1079 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001080 if (dropReason == DropReason::NOT_DROPPED && isStaleEvent(currentTime, *keyEntry)) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001081 dropReason = DropReason::STALE;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001082 }
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001083 if (dropReason == DropReason::NOT_DROPPED && mNextUnblockedEvent) {
1084 dropReason = DropReason::BLOCKED;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001085 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001086 done = dispatchKeyLocked(currentTime, keyEntry, &dropReason, nextWakeupTime);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001087 break;
1088 }
1089
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001090 case EventEntry::Type::MOTION: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001091 std::shared_ptr<MotionEntry> motionEntry =
1092 std::static_pointer_cast<MotionEntry>(mPendingEvent);
Siarhei Vishniakou6520a582023-10-27 21:53:45 -07001093 if (!input_flags::remove_app_switch_drops()) {
1094 if (dropReason == DropReason::NOT_DROPPED && isAppSwitchDue) {
1095 dropReason = DropReason::APP_SWITCH;
1096 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001097 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001098 if (dropReason == DropReason::NOT_DROPPED && isStaleEvent(currentTime, *motionEntry)) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001099 dropReason = DropReason::STALE;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001100 }
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001101 if (dropReason == DropReason::NOT_DROPPED && mNextUnblockedEvent) {
1102 dropReason = DropReason::BLOCKED;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001103 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001104 done = dispatchMotionLocked(currentTime, motionEntry, &dropReason, nextWakeupTime);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001105 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001106 }
Chris Yef59a2f42020-10-16 12:55:26 -07001107
1108 case EventEntry::Type::SENSOR: {
1109 std::shared_ptr<SensorEntry> sensorEntry =
1110 std::static_pointer_cast<SensorEntry>(mPendingEvent);
Siarhei Vishniakou6520a582023-10-27 21:53:45 -07001111 if (!input_flags::remove_app_switch_drops()) {
1112 if (dropReason == DropReason::NOT_DROPPED && isAppSwitchDue) {
1113 dropReason = DropReason::APP_SWITCH;
1114 }
Chris Yef59a2f42020-10-16 12:55:26 -07001115 }
1116 // Sensor timestamps use SYSTEM_TIME_BOOTTIME time base, so we can't use
1117 // 'currentTime' here, get SYSTEM_TIME_BOOTTIME instead.
1118 nsecs_t bootTime = systemTime(SYSTEM_TIME_BOOTTIME);
1119 if (dropReason == DropReason::NOT_DROPPED && isStaleEvent(bootTime, *sensorEntry)) {
1120 dropReason = DropReason::STALE;
1121 }
1122 dispatchSensorLocked(currentTime, sensorEntry, &dropReason, nextWakeupTime);
1123 done = true;
1124 break;
1125 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001126 }
1127
1128 if (done) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001129 if (dropReason != DropReason::NOT_DROPPED) {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001130 dropInboundEventLocked(*mPendingEvent, dropReason);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001131 }
Michael Wright3a981722015-06-10 15:26:13 +01001132 mLastDropReason = dropReason;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001133
1134 releasePendingEventLocked();
Colin Cross5b799302022-10-18 21:52:41 -07001135 *nextWakeupTime = LLONG_MIN; // force next poll to wake up immediately
Michael Wrightd02c5b62014-02-10 15:10:22 -08001136 }
1137}
1138
Siarhei Vishniakou289e9242022-02-15 14:50:16 -08001139bool InputDispatcher::isStaleEvent(nsecs_t currentTime, const EventEntry& entry) {
Siarhei Vishniakoua7333112023-10-27 13:33:29 -07001140 return mPolicy.isStaleEvent(currentTime, entry.eventTime);
Siarhei Vishniakou289e9242022-02-15 14:50:16 -08001141}
1142
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001143/**
1144 * Return true if the events preceding this incoming motion event should be dropped
1145 * Return false otherwise (the default behaviour)
1146 */
1147bool InputDispatcher::shouldPruneInboundQueueLocked(const MotionEntry& motionEntry) {
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001148 const bool isPointerDownEvent = motionEntry.action == AMOTION_EVENT_ACTION_DOWN &&
Prabir Pradhanaa561d12021-09-24 06:57:33 -07001149 isFromSource(motionEntry.source, AINPUT_SOURCE_CLASS_POINTER);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001150
1151 // Optimize case where the current application is unresponsive and the user
1152 // decides to touch a window in a different application.
1153 // If the application takes too long to catch up then we drop all events preceding
1154 // the touch into the other window.
1155 if (isPointerDownEvent && mAwaitedFocusedApplication != nullptr) {
Siarhei Vishniakou9306c382022-09-30 15:30:31 -07001156 const int32_t displayId = motionEntry.displayId;
1157 const auto [x, y] = resolveTouchedPosition(motionEntry);
Harry Cutts33476232023-01-30 19:57:29 +00001158 const bool isStylus = isPointerFromStylus(motionEntry, /*pointerIndex=*/0);
Siarhei Vishniakou9306c382022-09-30 15:30:31 -07001159
Siarhei Vishniakoue1ada272022-11-03 10:47:08 -07001160 sp<WindowInfoHandle> touchedWindowHandle =
1161 findTouchedWindowAtLocked(displayId, x, y, isStylus);
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001162 if (touchedWindowHandle != nullptr &&
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001163 touchedWindowHandle->getApplicationToken() !=
1164 mAwaitedFocusedApplication->getApplicationToken()) {
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001165 // User touched a different application than the one we are waiting on.
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001166 ALOGI("Pruning input queue because user touched a different application while waiting "
1167 "for %s",
1168 mAwaitedFocusedApplication->getName().c_str());
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001169 return true;
1170 }
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001171
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08001172 // Alternatively, maybe there's a spy window that could handle this event.
1173 const std::vector<sp<WindowInfoHandle>> touchedSpies =
1174 findTouchedSpyWindowsAtLocked(displayId, x, y, isStylus);
1175 for (const auto& windowHandle : touchedSpies) {
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07001176 const std::shared_ptr<Connection> connection =
1177 getConnectionLocked(windowHandle->getToken());
Siarhei Vishniakou34ed4d42020-06-18 00:43:02 +00001178 if (connection != nullptr && connection->responsive) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08001179 // This spy window could take more input. Drop all events preceding this
1180 // event, so that the spy window can get a chance to receive the stream.
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001181 ALOGW("Pruning the input queue because %s is unresponsive, but we have a "
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08001182 "responsive spy window that may handle the event.",
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001183 mAwaitedFocusedApplication->getName().c_str());
1184 return true;
1185 }
1186 }
1187 }
1188
1189 // Prevent getting stuck: if we have a pending key event, and some motion events that have not
1190 // yet been processed by some connections, the dispatcher will wait for these motion
1191 // events to be processed before dispatching the key event. This is because these motion events
1192 // may cause a new window to be launched, which the user might expect to receive focus.
1193 // To prevent waiting forever for such events, just send the key to the currently focused window
1194 if (isPointerDownEvent && mKeyIsWaitingForEventsTimeout) {
1195 ALOGD("Received a new pointer down event, stop waiting for events to process and "
1196 "just send the pending key event to the focused window.");
1197 mKeyIsWaitingForEventsTimeout = now();
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001198 }
1199 return false;
1200}
1201
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001202bool InputDispatcher::enqueueInboundEventLocked(std::unique_ptr<EventEntry> newEntry) {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001203 bool needWake = mInboundQueue.empty();
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001204 mInboundQueue.push_back(std::move(newEntry));
1205 EventEntry& entry = *(mInboundQueue.back());
Michael Wrightd02c5b62014-02-10 15:10:22 -08001206 traceInboundQueueLengthLocked();
1207
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001208 switch (entry.type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001209 case EventEntry::Type::KEY: {
Prabir Pradhan5735a322022-04-11 17:23:34 +00001210 LOG_ALWAYS_FATAL_IF((entry.policyFlags & POLICY_FLAG_TRUSTED) == 0,
1211 "Unexpected untrusted event.");
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001212 // Optimize app switch latency.
1213 // If the application takes too long to catch up then we drop all events preceding
1214 // the app switch key.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001215 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(entry);
Siarhei Vishniakou6520a582023-10-27 21:53:45 -07001216
1217 if (!input_flags::remove_app_switch_drops()) {
1218 if (isAppSwitchKeyEvent(keyEntry)) {
1219 if (keyEntry.action == AKEY_EVENT_ACTION_DOWN) {
1220 mAppSwitchSawKeyDown = true;
1221 } else if (keyEntry.action == AKEY_EVENT_ACTION_UP) {
1222 if (mAppSwitchSawKeyDown) {
1223 if (DEBUG_APP_SWITCH) {
1224 ALOGD("App switch is pending!");
1225 }
1226 mAppSwitchDueTime = keyEntry.eventTime + APP_SWITCH_TIMEOUT;
1227 mAppSwitchSawKeyDown = false;
1228 needWake = true;
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001229 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001230 }
1231 }
1232 }
Arthur Hung2ee6d0b2022-03-03 20:19:38 +08001233 // If a new up event comes in, and the pending event with same key code has been asked
1234 // to try again later because of the policy. We have to reset the intercept key wake up
1235 // time for it may have been handled in the policy and could be dropped.
1236 if (keyEntry.action == AKEY_EVENT_ACTION_UP && mPendingEvent &&
1237 mPendingEvent->type == EventEntry::Type::KEY) {
1238 KeyEntry& pendingKey = static_cast<KeyEntry&>(*mPendingEvent);
1239 if (pendingKey.keyCode == keyEntry.keyCode &&
1240 pendingKey.interceptKeyResult ==
Michael Wright5caf55a2022-11-24 22:31:42 +00001241 KeyEntry::InterceptKeyResult::TRY_AGAIN_LATER) {
1242 pendingKey.interceptKeyResult = KeyEntry::InterceptKeyResult::UNKNOWN;
Arthur Hung2ee6d0b2022-03-03 20:19:38 +08001243 pendingKey.interceptKeyWakeupTime = 0;
1244 needWake = true;
1245 }
1246 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001247 break;
1248 }
1249
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001250 case EventEntry::Type::MOTION: {
Prabir Pradhan5735a322022-04-11 17:23:34 +00001251 LOG_ALWAYS_FATAL_IF((entry.policyFlags & POLICY_FLAG_TRUSTED) == 0,
1252 "Unexpected untrusted event.");
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001253 if (shouldPruneInboundQueueLocked(static_cast<MotionEntry&>(entry))) {
1254 mNextUnblockedEvent = mInboundQueue.back();
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001255 needWake = true;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001256 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001257 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001258 }
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001259 case EventEntry::Type::FOCUS: {
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001260 LOG_ALWAYS_FATAL("Focus events should be inserted using enqueueFocusEventLocked");
1261 break;
1262 }
Antonio Kantek7242d8b2021-08-05 16:07:20 -07001263 case EventEntry::Type::TOUCH_MODE_CHANGED:
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001264 case EventEntry::Type::CONFIGURATION_CHANGED:
Prabir Pradhan99987712020-11-10 18:43:05 -08001265 case EventEntry::Type::DEVICE_RESET:
Chris Yef59a2f42020-10-16 12:55:26 -07001266 case EventEntry::Type::SENSOR:
arthurhungb89ccb02020-12-30 16:19:01 +08001267 case EventEntry::Type::POINTER_CAPTURE_CHANGED:
1268 case EventEntry::Type::DRAG: {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001269 // nothing to do
1270 break;
1271 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001272 }
1273
1274 return needWake;
1275}
1276
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001277void InputDispatcher::addRecentEventLocked(std::shared_ptr<EventEntry> entry) {
Chris Yef59a2f42020-10-16 12:55:26 -07001278 // Do not store sensor event in recent queue to avoid flooding the queue.
1279 if (entry->type != EventEntry::Type::SENSOR) {
1280 mRecentQueue.push_back(entry);
1281 }
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001282 if (mRecentQueue.size() > RECENT_QUEUE_MAX_SIZE) {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001283 mRecentQueue.pop_front();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001284 }
1285}
1286
Siarhei Vishniakoue1ada272022-11-03 10:47:08 -07001287sp<WindowInfoHandle> InputDispatcher::findTouchedWindowAtLocked(int32_t displayId, float x, float y,
1288 bool isStylus,
1289 bool ignoreDragWindow) const {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001290 // Traverse windows from front to back to find touched window.
Prabir Pradhan07e05b62021-11-19 03:57:24 -08001291 const auto& windowHandles = getWindowHandlesLocked(displayId);
chaviw98318de2021-05-19 16:45:23 -05001292 for (const sp<WindowInfoHandle>& windowHandle : windowHandles) {
arthurhung6d4bed92021-03-17 11:59:33 +08001293 if (ignoreDragWindow && haveSameToken(windowHandle, mDragState->dragWindow)) {
arthurhungb89ccb02020-12-30 16:19:01 +08001294 continue;
1295 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001296
Prabir Pradhan3f90d312021-11-19 03:57:24 -08001297 const WindowInfo& info = *windowHandle->getInfo();
Prabir Pradhan33e3baa2022-12-06 20:30:22 +00001298 if (!info.isSpy() &&
1299 windowAcceptsTouchAt(info, displayId, x, y, isStylus, getTransformLocked(displayId))) {
Siarhei Vishniakoue1ada272022-11-03 10:47:08 -07001300 return windowHandle;
1301 }
1302 }
1303 return nullptr;
1304}
1305
1306std::vector<InputTarget> InputDispatcher::findOutsideTargetsLocked(
Siarhei Vishniakou70f3d8c2023-09-19 15:36:52 -07001307 int32_t displayId, const sp<WindowInfoHandle>& touchedWindow, int32_t pointerId) const {
Siarhei Vishniakoue1ada272022-11-03 10:47:08 -07001308 if (touchedWindow == nullptr) {
1309 return {};
1310 }
1311 // Traverse windows from front to back until we encounter the touched window.
1312 std::vector<InputTarget> outsideTargets;
1313 const auto& windowHandles = getWindowHandlesLocked(displayId);
1314 for (const sp<WindowInfoHandle>& windowHandle : windowHandles) {
1315 if (windowHandle == touchedWindow) {
1316 // Stop iterating once we found a touched window. Any WATCH_OUTSIDE_TOUCH window
1317 // below the touched window will not get ACTION_OUTSIDE event.
1318 return outsideTargets;
Prabir Pradhan3f90d312021-11-19 03:57:24 -08001319 }
Tiger Huang85b8c5e2019-01-17 18:34:54 +08001320
Siarhei Vishniakoue1ada272022-11-03 10:47:08 -07001321 const WindowInfo& info = *windowHandle->getInfo();
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08001322 if (info.inputConfig.test(WindowInfo::InputConfig::WATCH_OUTSIDE_TOUCH)) {
Siarhei Vishniakou70f3d8c2023-09-19 15:36:52 -07001323 std::bitset<MAX_POINTER_ID + 1> pointerIds;
1324 pointerIds.set(pointerId);
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07001325 addPointerWindowTargetLocked(windowHandle, InputTarget::Flags::DISPATCH_AS_OUTSIDE,
1326 pointerIds,
1327 /*firstDownTimeInTarget=*/std::nullopt, outsideTargets);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001328 }
1329 }
Siarhei Vishniakoue1ada272022-11-03 10:47:08 -07001330 return outsideTargets;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001331}
1332
Prabir Pradhand65552b2021-10-07 11:23:50 -07001333std::vector<sp<WindowInfoHandle>> InputDispatcher::findTouchedSpyWindowsAtLocked(
Prabir Pradhan82e081e2022-12-06 09:50:09 +00001334 int32_t displayId, float x, float y, bool isStylus) const {
Prabir Pradhan07e05b62021-11-19 03:57:24 -08001335 // Traverse windows from front to back and gather the touched spy windows.
1336 std::vector<sp<WindowInfoHandle>> spyWindows;
1337 const auto& windowHandles = getWindowHandlesLocked(displayId);
1338 for (const sp<WindowInfoHandle>& windowHandle : windowHandles) {
1339 const WindowInfo& info = *windowHandle->getInfo();
1340
Prabir Pradhan33e3baa2022-12-06 20:30:22 +00001341 if (!windowAcceptsTouchAt(info, displayId, x, y, isStylus, getTransformLocked(displayId))) {
Prabir Pradhan07e05b62021-11-19 03:57:24 -08001342 continue;
1343 }
1344 if (!info.isSpy()) {
1345 // The first touched non-spy window was found, so return the spy windows touched so far.
1346 return spyWindows;
1347 }
1348 spyWindows.push_back(windowHandle);
1349 }
1350 return spyWindows;
1351}
1352
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001353void InputDispatcher::dropInboundEventLocked(const EventEntry& entry, DropReason dropReason) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001354 const char* reason;
1355 switch (dropReason) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001356 case DropReason::POLICY:
Prabir Pradhan65613802023-02-22 23:36:58 +00001357 if (debugInboundEventDetails()) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001358 ALOGD("Dropped event because policy consumed it.");
1359 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001360 reason = "inbound event was dropped because the policy consumed it";
1361 break;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001362 case DropReason::DISABLED:
1363 if (mLastDropReason != DropReason::DISABLED) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001364 ALOGI("Dropped event because input dispatch is disabled.");
1365 }
1366 reason = "inbound event was dropped because input dispatch is disabled";
1367 break;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001368 case DropReason::APP_SWITCH:
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001369 ALOGI("Dropped event because of pending overdue app switch.");
1370 reason = "inbound event was dropped because of pending overdue app switch";
1371 break;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001372 case DropReason::BLOCKED:
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001373 ALOGI("Dropped event because the current application is not responding and the user "
1374 "has started interacting with a different application.");
1375 reason = "inbound event was dropped because the current application is not responding "
1376 "and the user has started interacting with a different application";
1377 break;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001378 case DropReason::STALE:
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001379 ALOGI("Dropped event because it is stale.");
1380 reason = "inbound event was dropped because it is stale";
1381 break;
Prabir Pradhan99987712020-11-10 18:43:05 -08001382 case DropReason::NO_POINTER_CAPTURE:
1383 ALOGI("Dropped event because there is no window with Pointer Capture.");
1384 reason = "inbound event was dropped because there is no window with Pointer Capture";
1385 break;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001386 case DropReason::NOT_DROPPED: {
1387 LOG_ALWAYS_FATAL("Should not be dropping a NOT_DROPPED event");
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001388 return;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001389 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001390 }
1391
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001392 switch (entry.type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001393 case EventEntry::Type::KEY: {
Michael Wrightfb04fd52022-11-24 22:31:11 +00001394 CancelationOptions options(CancelationOptions::Mode::CANCEL_NON_POINTER_EVENTS, reason);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001395 synthesizeCancelationEventsForAllConnectionsLocked(options);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001396 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001397 }
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001398 case EventEntry::Type::MOTION: {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001399 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(entry);
1400 if (motionEntry.source & AINPUT_SOURCE_CLASS_POINTER) {
Michael Wrightfb04fd52022-11-24 22:31:11 +00001401 CancelationOptions options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS, reason);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001402 synthesizeCancelationEventsForAllConnectionsLocked(options);
1403 } else {
Michael Wrightfb04fd52022-11-24 22:31:11 +00001404 CancelationOptions options(CancelationOptions::Mode::CANCEL_NON_POINTER_EVENTS,
1405 reason);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001406 synthesizeCancelationEventsForAllConnectionsLocked(options);
1407 }
1408 break;
1409 }
Chris Yef59a2f42020-10-16 12:55:26 -07001410 case EventEntry::Type::SENSOR: {
1411 break;
1412 }
arthurhungb89ccb02020-12-30 16:19:01 +08001413 case EventEntry::Type::POINTER_CAPTURE_CHANGED:
1414 case EventEntry::Type::DRAG: {
Prabir Pradhan99987712020-11-10 18:43:05 -08001415 break;
1416 }
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001417 case EventEntry::Type::FOCUS:
Antonio Kantek7242d8b2021-08-05 16:07:20 -07001418 case EventEntry::Type::TOUCH_MODE_CHANGED:
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001419 case EventEntry::Type::CONFIGURATION_CHANGED:
1420 case EventEntry::Type::DEVICE_RESET: {
Dominik Laskowski75788452021-02-09 18:51:25 -08001421 LOG_ALWAYS_FATAL("Should not drop %s events", ftl::enum_string(entry.type).c_str());
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001422 break;
1423 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001424 }
1425}
1426
Siarhei Vishniakou61291d42019-02-11 18:13:20 -08001427static bool isAppSwitchKeyCode(int32_t keyCode) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001428 return keyCode == AKEYCODE_HOME || keyCode == AKEYCODE_ENDCALL ||
1429 keyCode == AKEYCODE_APP_SWITCH;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001430}
1431
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001432bool InputDispatcher::isAppSwitchKeyEvent(const KeyEntry& keyEntry) {
1433 return !(keyEntry.flags & AKEY_EVENT_FLAG_CANCELED) && isAppSwitchKeyCode(keyEntry.keyCode) &&
1434 (keyEntry.policyFlags & POLICY_FLAG_TRUSTED) &&
1435 (keyEntry.policyFlags & POLICY_FLAG_PASS_TO_USER);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001436}
1437
Siarhei Vishniakou4c9d6ff2023-04-18 11:23:20 -07001438bool InputDispatcher::isAppSwitchPendingLocked() const {
Colin Cross5b799302022-10-18 21:52:41 -07001439 return mAppSwitchDueTime != LLONG_MAX;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001440}
1441
1442void InputDispatcher::resetPendingAppSwitchLocked(bool handled) {
Colin Cross5b799302022-10-18 21:52:41 -07001443 mAppSwitchDueTime = LLONG_MAX;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001444
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001445 if (DEBUG_APP_SWITCH) {
1446 if (handled) {
1447 ALOGD("App switch has arrived.");
1448 } else {
1449 ALOGD("App switch was abandoned.");
1450 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001451 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001452}
1453
Michael Wrightd02c5b62014-02-10 15:10:22 -08001454bool InputDispatcher::haveCommandsLocked() const {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001455 return !mCommandQueue.empty();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001456}
1457
Prabir Pradhancef936d2021-07-21 16:17:52 +00001458bool InputDispatcher::runCommandsLockedInterruptable() {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001459 if (mCommandQueue.empty()) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001460 return false;
1461 }
1462
1463 do {
Prabir Pradhancef936d2021-07-21 16:17:52 +00001464 auto command = std::move(mCommandQueue.front());
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001465 mCommandQueue.pop_front();
Prabir Pradhancef936d2021-07-21 16:17:52 +00001466 // Commands are run with the lock held, but may release and re-acquire the lock from within.
1467 command();
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001468 } while (!mCommandQueue.empty());
Michael Wrightd02c5b62014-02-10 15:10:22 -08001469 return true;
1470}
1471
Prabir Pradhancef936d2021-07-21 16:17:52 +00001472void InputDispatcher::postCommandLocked(Command&& command) {
1473 mCommandQueue.push_back(command);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001474}
1475
1476void InputDispatcher::drainInboundQueueLocked() {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001477 while (!mInboundQueue.empty()) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001478 std::shared_ptr<EventEntry> entry = mInboundQueue.front();
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001479 mInboundQueue.pop_front();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001480 releaseInboundEventLocked(entry);
1481 }
1482 traceInboundQueueLengthLocked();
1483}
1484
1485void InputDispatcher::releasePendingEventLocked() {
1486 if (mPendingEvent) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001487 releaseInboundEventLocked(mPendingEvent);
Yi Kong9b14ac62018-07-17 13:48:38 -07001488 mPendingEvent = nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001489 }
1490}
1491
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001492void InputDispatcher::releaseInboundEventLocked(std::shared_ptr<EventEntry> entry) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001493 InjectionState* injectionState = entry->injectionState;
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001494 if (injectionState && injectionState->injectionResult == InputEventInjectionResult::PENDING) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001495 if (DEBUG_DISPATCH_CYCLE) {
1496 ALOGD("Injected inbound event was dropped.");
1497 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001498 setInjectionResult(*entry, InputEventInjectionResult::FAILED);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001499 }
1500 if (entry == mNextUnblockedEvent) {
Yi Kong9b14ac62018-07-17 13:48:38 -07001501 mNextUnblockedEvent = nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001502 }
1503 addRecentEventLocked(entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001504}
1505
1506void InputDispatcher::resetKeyRepeatLocked() {
1507 if (mKeyRepeatState.lastKeyEntry) {
Yi Kong9b14ac62018-07-17 13:48:38 -07001508 mKeyRepeatState.lastKeyEntry = nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001509 }
1510}
1511
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001512std::shared_ptr<KeyEntry> InputDispatcher::synthesizeKeyRepeatLocked(nsecs_t currentTime) {
1513 std::shared_ptr<KeyEntry> entry = mKeyRepeatState.lastKeyEntry;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001514
Michael Wright2e732952014-09-24 13:26:59 -07001515 uint32_t policyFlags = entry->policyFlags &
1516 (POLICY_FLAG_RAW_MASK | POLICY_FLAG_PASS_TO_USER | POLICY_FLAG_TRUSTED);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001517
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001518 std::shared_ptr<KeyEntry> newEntry =
1519 std::make_unique<KeyEntry>(mIdGenerator.nextId(), currentTime, entry->deviceId,
1520 entry->source, entry->displayId, policyFlags, entry->action,
1521 entry->flags, entry->keyCode, entry->scanCode,
1522 entry->metaState, entry->repeatCount + 1, entry->downTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001523
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001524 newEntry->syntheticRepeat = true;
1525 mKeyRepeatState.lastKeyEntry = newEntry;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001526 mKeyRepeatState.nextRepeatTime = currentTime + mConfig.keyRepeatDelay;
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001527 return newEntry;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001528}
1529
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001530bool InputDispatcher::dispatchConfigurationChangedLocked(nsecs_t currentTime,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001531 const ConfigurationChangedEntry& entry) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001532 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
1533 ALOGD("dispatchConfigurationChanged - eventTime=%" PRId64, entry.eventTime);
1534 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001535
1536 // Reset key repeating in case a keyboard device was added or removed or something.
1537 resetKeyRepeatLocked();
1538
1539 // Enqueue a command to run outside the lock to tell the policy that the configuration changed.
Prabir Pradhancef936d2021-07-21 16:17:52 +00001540 auto command = [this, eventTime = entry.eventTime]() REQUIRES(mLock) {
1541 scoped_unlock unlock(mLock);
Prabir Pradhana41d2442023-04-20 21:30:40 +00001542 mPolicy.notifyConfigurationChanged(eventTime);
Prabir Pradhancef936d2021-07-21 16:17:52 +00001543 };
1544 postCommandLocked(std::move(command));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001545 return true;
1546}
1547
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001548bool InputDispatcher::dispatchDeviceResetLocked(nsecs_t currentTime,
1549 const DeviceResetEntry& entry) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001550 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
1551 ALOGD("dispatchDeviceReset - eventTime=%" PRId64 ", deviceId=%d", entry.eventTime,
1552 entry.deviceId);
1553 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001554
liushenxiang42232912021-05-21 20:24:09 +08001555 // Reset key repeating in case a keyboard device was disabled or enabled.
1556 if (mKeyRepeatState.lastKeyEntry && mKeyRepeatState.lastKeyEntry->deviceId == entry.deviceId) {
1557 resetKeyRepeatLocked();
1558 }
1559
Michael Wrightfb04fd52022-11-24 22:31:11 +00001560 CancelationOptions options(CancelationOptions::Mode::CANCEL_ALL_EVENTS, "device was reset");
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001561 options.deviceId = entry.deviceId;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001562 synthesizeCancelationEventsForAllConnectionsLocked(options);
Siarhei Vishniakou0686f0c2023-05-02 11:56:15 -07001563
1564 // Remove all active pointers from this device
1565 for (auto& [_, touchState] : mTouchStatesByDisplay) {
1566 touchState.removeAllPointersForDevice(entry.deviceId);
1567 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001568 return true;
1569}
1570
Vishnu Nairad321cd2020-08-20 16:40:21 -07001571void InputDispatcher::enqueueFocusEventLocked(const sp<IBinder>& windowToken, bool hasFocus,
Vishnu Nairc519ff72021-01-21 08:23:08 -08001572 const std::string& reason) {
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001573 if (mPendingEvent != nullptr) {
1574 // Move the pending event to the front of the queue. This will give the chance
1575 // for the pending event to get dispatched to the newly focused window
1576 mInboundQueue.push_front(mPendingEvent);
1577 mPendingEvent = nullptr;
1578 }
1579
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001580 std::unique_ptr<FocusEntry> focusEntry =
1581 std::make_unique<FocusEntry>(mIdGenerator.nextId(), now(), windowToken, hasFocus,
1582 reason);
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001583
1584 // This event should go to the front of the queue, but behind all other focus events
1585 // Find the last focus event, and insert right after it
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001586 std::deque<std::shared_ptr<EventEntry>>::reverse_iterator it =
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001587 std::find_if(mInboundQueue.rbegin(), mInboundQueue.rend(),
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001588 [](const std::shared_ptr<EventEntry>& event) {
1589 return event->type == EventEntry::Type::FOCUS;
1590 });
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001591
1592 // Maintain the order of focus events. Insert the entry after all other focus events.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001593 mInboundQueue.insert(it.base(), std::move(focusEntry));
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001594}
1595
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001596void InputDispatcher::dispatchFocusLocked(nsecs_t currentTime, std::shared_ptr<FocusEntry> entry) {
Siarhei Vishniakouce5ab082020-07-09 17:03:21 -05001597 std::shared_ptr<InputChannel> channel = getInputChannelLocked(entry->connectionToken);
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001598 if (channel == nullptr) {
1599 return; // Window has gone away
1600 }
1601 InputTarget target;
1602 target.inputChannel = channel;
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08001603 target.flags = InputTarget::Flags::DISPATCH_AS_IS;
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001604 entry->dispatchInProgress = true;
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00001605 std::string message = std::string("Focus ") + (entry->hasFocus ? "entering " : "leaving ") +
1606 channel->getName();
Vishnu Nair7d3d00d2020-08-03 11:20:42 -07001607 std::string reason = std::string("reason=").append(entry->reason);
1608 android_log_event_list(LOGTAG_INPUT_FOCUS) << message << reason << LOG_ID_EVENTS;
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001609 dispatchEventLocked(currentTime, entry, {target});
1610}
1611
Prabir Pradhan99987712020-11-10 18:43:05 -08001612void InputDispatcher::dispatchPointerCaptureChangedLocked(
1613 nsecs_t currentTime, const std::shared_ptr<PointerCaptureChangedEntry>& entry,
1614 DropReason& dropReason) {
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001615 dropReason = DropReason::NOT_DROPPED;
1616
Prabir Pradhan99987712020-11-10 18:43:05 -08001617 const bool haveWindowWithPointerCapture = mWindowTokenWithPointerCapture != nullptr;
Prabir Pradhan99987712020-11-10 18:43:05 -08001618 sp<IBinder> token;
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001619
1620 if (entry->pointerCaptureRequest.enable) {
1621 // Enable Pointer Capture.
1622 if (haveWindowWithPointerCapture &&
1623 (entry->pointerCaptureRequest == mCurrentPointerCaptureRequest)) {
Prabir Pradhan7092e262022-05-03 16:51:09 +00001624 // This can happen if pointer capture is disabled and re-enabled before we notify the
1625 // app of the state change, so there is no need to notify the app.
1626 ALOGI("Skipping dispatch of Pointer Capture being enabled: no state change.");
1627 return;
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001628 }
1629 if (!mCurrentPointerCaptureRequest.enable) {
Prabir Pradhan99987712020-11-10 18:43:05 -08001630 // This can happen if a window requests capture and immediately releases capture.
1631 ALOGW("No window requested Pointer Capture.");
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001632 dropReason = DropReason::NO_POINTER_CAPTURE;
Prabir Pradhan99987712020-11-10 18:43:05 -08001633 return;
1634 }
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001635 if (entry->pointerCaptureRequest.seq != mCurrentPointerCaptureRequest.seq) {
1636 ALOGI("Skipping dispatch of Pointer Capture being enabled: sequence number mismatch.");
1637 return;
1638 }
1639
Vishnu Nairc519ff72021-01-21 08:23:08 -08001640 token = mFocusResolver.getFocusedWindowToken(mFocusedDisplayId);
Prabir Pradhan99987712020-11-10 18:43:05 -08001641 LOG_ALWAYS_FATAL_IF(!token, "Cannot find focused window for Pointer Capture.");
1642 mWindowTokenWithPointerCapture = token;
1643 } else {
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001644 // Disable Pointer Capture.
1645 // We do not check if the sequence number matches for requests to disable Pointer Capture
1646 // for two reasons:
1647 // 1. Pointer Capture can be disabled by a focus change, which means we can get two entries
1648 // to disable capture with the same sequence number: one generated by
1649 // disablePointerCaptureForcedLocked() and another as an acknowledgement of Pointer
1650 // Capture being disabled in InputReader.
1651 // 2. We respect any request to disable Pointer Capture generated by InputReader, since the
1652 // actual Pointer Capture state that affects events being generated by input devices is
1653 // in InputReader.
1654 if (!haveWindowWithPointerCapture) {
1655 // Pointer capture was already forcefully disabled because of focus change.
1656 dropReason = DropReason::NOT_DROPPED;
1657 return;
1658 }
Prabir Pradhan99987712020-11-10 18:43:05 -08001659 token = mWindowTokenWithPointerCapture;
1660 mWindowTokenWithPointerCapture = nullptr;
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001661 if (mCurrentPointerCaptureRequest.enable) {
Prabir Pradhan7d030382020-12-21 07:58:35 -08001662 setPointerCaptureLocked(false);
1663 }
Prabir Pradhan99987712020-11-10 18:43:05 -08001664 }
1665
1666 auto channel = getInputChannelLocked(token);
1667 if (channel == nullptr) {
1668 // Window has gone away, clean up Pointer Capture state.
1669 mWindowTokenWithPointerCapture = nullptr;
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001670 if (mCurrentPointerCaptureRequest.enable) {
Prabir Pradhan7d030382020-12-21 07:58:35 -08001671 setPointerCaptureLocked(false);
1672 }
Prabir Pradhan99987712020-11-10 18:43:05 -08001673 return;
1674 }
1675 InputTarget target;
1676 target.inputChannel = channel;
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08001677 target.flags = InputTarget::Flags::DISPATCH_AS_IS;
Prabir Pradhan99987712020-11-10 18:43:05 -08001678 entry->dispatchInProgress = true;
1679 dispatchEventLocked(currentTime, entry, {target});
1680
1681 dropReason = DropReason::NOT_DROPPED;
1682}
1683
Antonio Kantek7242d8b2021-08-05 16:07:20 -07001684void InputDispatcher::dispatchTouchModeChangeLocked(nsecs_t currentTime,
1685 const std::shared_ptr<TouchModeEntry>& entry) {
1686 const std::vector<sp<WindowInfoHandle>>& windowHandles =
Antonio Kantek15beb512022-06-13 22:35:41 +00001687 getWindowHandlesLocked(entry->displayId);
Antonio Kantek7242d8b2021-08-05 16:07:20 -07001688 if (windowHandles.empty()) {
1689 return;
1690 }
1691 const std::vector<InputTarget> inputTargets =
1692 getInputTargetsFromWindowHandlesLocked(windowHandles);
1693 if (inputTargets.empty()) {
1694 return;
1695 }
1696 entry->dispatchInProgress = true;
1697 dispatchEventLocked(currentTime, entry, inputTargets);
1698}
1699
1700std::vector<InputTarget> InputDispatcher::getInputTargetsFromWindowHandlesLocked(
1701 const std::vector<sp<WindowInfoHandle>>& windowHandles) const {
1702 std::vector<InputTarget> inputTargets;
1703 for (const sp<WindowInfoHandle>& handle : windowHandles) {
Antonio Kantek7242d8b2021-08-05 16:07:20 -07001704 const sp<IBinder>& token = handle->getToken();
1705 if (token == nullptr) {
1706 continue;
1707 }
1708 std::shared_ptr<InputChannel> channel = getInputChannelLocked(token);
1709 if (channel == nullptr) {
1710 continue; // Window has gone away
1711 }
1712 InputTarget target;
1713 target.inputChannel = channel;
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08001714 target.flags = InputTarget::Flags::DISPATCH_AS_IS;
Antonio Kantek7242d8b2021-08-05 16:07:20 -07001715 inputTargets.push_back(target);
1716 }
1717 return inputTargets;
1718}
1719
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001720bool InputDispatcher::dispatchKeyLocked(nsecs_t currentTime, std::shared_ptr<KeyEntry> entry,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001721 DropReason* dropReason, nsecs_t* nextWakeupTime) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001722 // Preprocessing.
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001723 if (!entry->dispatchInProgress) {
1724 if (entry->repeatCount == 0 && entry->action == AKEY_EVENT_ACTION_DOWN &&
1725 (entry->policyFlags & POLICY_FLAG_TRUSTED) &&
1726 (!(entry->policyFlags & POLICY_FLAG_DISABLE_KEY_REPEAT))) {
1727 if (mKeyRepeatState.lastKeyEntry &&
Chris Ye2ad95392020-09-01 13:44:44 -07001728 mKeyRepeatState.lastKeyEntry->keyCode == entry->keyCode &&
Michael Wrightd02c5b62014-02-10 15:10:22 -08001729 // We have seen two identical key downs in a row which indicates that the device
1730 // driver is automatically generating key repeats itself. We take note of the
1731 // repeat here, but we disable our own next key repeat timer since it is clear that
1732 // we will not need to synthesize key repeats ourselves.
Chris Ye2ad95392020-09-01 13:44:44 -07001733 mKeyRepeatState.lastKeyEntry->deviceId == entry->deviceId) {
1734 // Make sure we don't get key down from a different device. If a different
1735 // device Id has same key pressed down, the new device Id will replace the
1736 // current one to hold the key repeat with repeat count reset.
1737 // In the future when got a KEY_UP on the device id, drop it and do not
1738 // stop the key repeat on current device.
Michael Wrightd02c5b62014-02-10 15:10:22 -08001739 entry->repeatCount = mKeyRepeatState.lastKeyEntry->repeatCount + 1;
1740 resetKeyRepeatLocked();
Colin Cross5b799302022-10-18 21:52:41 -07001741 mKeyRepeatState.nextRepeatTime = LLONG_MAX; // don't generate repeats ourselves
Michael Wrightd02c5b62014-02-10 15:10:22 -08001742 } else {
1743 // Not a repeat. Save key down state in case we do see a repeat later.
1744 resetKeyRepeatLocked();
1745 mKeyRepeatState.nextRepeatTime = entry->eventTime + mConfig.keyRepeatTimeout;
1746 }
1747 mKeyRepeatState.lastKeyEntry = entry;
Chris Ye2ad95392020-09-01 13:44:44 -07001748 } else if (entry->action == AKEY_EVENT_ACTION_UP && mKeyRepeatState.lastKeyEntry &&
1749 mKeyRepeatState.lastKeyEntry->deviceId != entry->deviceId) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001750 // The key on device 'deviceId' is still down, do not stop key repeat
Prabir Pradhan65613802023-02-22 23:36:58 +00001751 if (debugInboundEventDetails()) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001752 ALOGD("deviceId=%d got KEY_UP as stale", entry->deviceId);
1753 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001754 } else if (!entry->syntheticRepeat) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001755 resetKeyRepeatLocked();
1756 }
1757
1758 if (entry->repeatCount == 1) {
1759 entry->flags |= AKEY_EVENT_FLAG_LONG_PRESS;
1760 } else {
1761 entry->flags &= ~AKEY_EVENT_FLAG_LONG_PRESS;
1762 }
1763
1764 entry->dispatchInProgress = true;
1765
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001766 logOutboundKeyDetails("dispatchKey - ", *entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001767 }
1768
1769 // Handle case where the policy asked us to try again later last time.
Michael Wright5caf55a2022-11-24 22:31:42 +00001770 if (entry->interceptKeyResult == KeyEntry::InterceptKeyResult::TRY_AGAIN_LATER) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001771 if (currentTime < entry->interceptKeyWakeupTime) {
1772 if (entry->interceptKeyWakeupTime < *nextWakeupTime) {
1773 *nextWakeupTime = entry->interceptKeyWakeupTime;
1774 }
1775 return false; // wait until next wakeup
1776 }
Michael Wright5caf55a2022-11-24 22:31:42 +00001777 entry->interceptKeyResult = KeyEntry::InterceptKeyResult::UNKNOWN;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001778 entry->interceptKeyWakeupTime = 0;
1779 }
1780
1781 // Give the policy a chance to intercept the key.
Michael Wright5caf55a2022-11-24 22:31:42 +00001782 if (entry->interceptKeyResult == KeyEntry::InterceptKeyResult::UNKNOWN) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001783 if (entry->policyFlags & POLICY_FLAG_PASS_TO_USER) {
Vishnu Nairad321cd2020-08-20 16:40:21 -07001784 sp<IBinder> focusedWindowToken =
Vishnu Nairc519ff72021-01-21 08:23:08 -08001785 mFocusResolver.getFocusedWindowToken(getTargetDisplayId(*entry));
Prabir Pradhancef936d2021-07-21 16:17:52 +00001786
1787 auto command = [this, focusedWindowToken, entry]() REQUIRES(mLock) {
1788 doInterceptKeyBeforeDispatchingCommand(focusedWindowToken, *entry);
1789 };
1790 postCommandLocked(std::move(command));
Josep del Riob3981622023-04-18 15:49:45 +00001791 // Poke user activity for keys not passed to user
1792 pokeUserActivityLocked(*entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001793 return false; // wait for the command to run
1794 } else {
Michael Wright5caf55a2022-11-24 22:31:42 +00001795 entry->interceptKeyResult = KeyEntry::InterceptKeyResult::CONTINUE;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001796 }
Michael Wright5caf55a2022-11-24 22:31:42 +00001797 } else if (entry->interceptKeyResult == KeyEntry::InterceptKeyResult::SKIP) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001798 if (*dropReason == DropReason::NOT_DROPPED) {
1799 *dropReason = DropReason::POLICY;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001800 }
1801 }
1802
1803 // Clean up if dropping the event.
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001804 if (*dropReason != DropReason::NOT_DROPPED) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001805 setInjectionResult(*entry,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001806 *dropReason == DropReason::POLICY ? InputEventInjectionResult::SUCCEEDED
1807 : InputEventInjectionResult::FAILED);
Garfield Tan6a5a14e2020-01-28 13:24:04 -08001808 mReporter->reportDroppedKey(entry->id);
Josep del Riob3981622023-04-18 15:49:45 +00001809 // Poke user activity for undispatched keys
1810 pokeUserActivityLocked(*entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001811 return true;
1812 }
1813
1814 // Identify targets.
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07001815 InputEventInjectionResult injectionResult;
1816 sp<WindowInfoHandle> focusedWindow =
1817 findFocusedWindowTargetLocked(currentTime, *entry, nextWakeupTime,
1818 /*byref*/ injectionResult);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001819 if (injectionResult == InputEventInjectionResult::PENDING) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001820 return false;
1821 }
1822
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001823 setInjectionResult(*entry, injectionResult);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001824 if (injectionResult != InputEventInjectionResult::SUCCEEDED) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001825 return true;
1826 }
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07001827 LOG_ALWAYS_FATAL_IF(focusedWindow == nullptr);
1828
1829 std::vector<InputTarget> inputTargets;
1830 addWindowTargetLocked(focusedWindow,
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08001831 InputTarget::Flags::FOREGROUND | InputTarget::Flags::DISPATCH_AS_IS,
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07001832 getDownTime(*entry), inputTargets);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001833
Arthur Hung2fbf37f2018-09-13 18:16:41 +08001834 // Add monitor channels from event's or focused display.
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001835 addGlobalMonitoringTargetsLocked(inputTargets, getTargetDisplayId(*entry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001836
1837 // Dispatch the key.
1838 dispatchEventLocked(currentTime, entry, inputTargets);
1839 return true;
1840}
1841
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001842void InputDispatcher::logOutboundKeyDetails(const char* prefix, const KeyEntry& entry) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001843 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
1844 ALOGD("%seventTime=%" PRId64 ", deviceId=%d, source=0x%x, displayId=%" PRId32 ", "
1845 "policyFlags=0x%x, action=0x%x, flags=0x%x, keyCode=0x%x, scanCode=0x%x, "
1846 "metaState=0x%x, repeatCount=%d, downTime=%" PRId64,
1847 prefix, entry.eventTime, entry.deviceId, entry.source, entry.displayId,
1848 entry.policyFlags, entry.action, entry.flags, entry.keyCode, entry.scanCode,
1849 entry.metaState, entry.repeatCount, entry.downTime);
1850 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001851}
1852
Prabir Pradhancef936d2021-07-21 16:17:52 +00001853void InputDispatcher::dispatchSensorLocked(nsecs_t currentTime,
1854 const std::shared_ptr<SensorEntry>& entry,
Chris Yef59a2f42020-10-16 12:55:26 -07001855 DropReason* dropReason, nsecs_t* nextWakeupTime) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001856 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
1857 ALOGD("notifySensorEvent eventTime=%" PRId64 ", hwTimestamp=%" PRId64 ", deviceId=%d, "
1858 "source=0x%x, sensorType=%s",
1859 entry->eventTime, entry->hwTimestamp, entry->deviceId, entry->source,
Dominik Laskowski75788452021-02-09 18:51:25 -08001860 ftl::enum_string(entry->sensorType).c_str());
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001861 }
Prabir Pradhancef936d2021-07-21 16:17:52 +00001862 auto command = [this, entry]() REQUIRES(mLock) {
1863 scoped_unlock unlock(mLock);
1864
1865 if (entry->accuracyChanged) {
Prabir Pradhana41d2442023-04-20 21:30:40 +00001866 mPolicy.notifySensorAccuracy(entry->deviceId, entry->sensorType, entry->accuracy);
Prabir Pradhancef936d2021-07-21 16:17:52 +00001867 }
Prabir Pradhana41d2442023-04-20 21:30:40 +00001868 mPolicy.notifySensorEvent(entry->deviceId, entry->sensorType, entry->accuracy,
1869 entry->hwTimestamp, entry->values);
Prabir Pradhancef936d2021-07-21 16:17:52 +00001870 };
1871 postCommandLocked(std::move(command));
Chris Yef59a2f42020-10-16 12:55:26 -07001872}
1873
1874bool InputDispatcher::flushSensor(int deviceId, InputDeviceSensorType sensorType) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001875 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
1876 ALOGD("flushSensor deviceId=%d, sensorType=%s", deviceId,
Dominik Laskowski75788452021-02-09 18:51:25 -08001877 ftl::enum_string(sensorType).c_str());
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001878 }
Chris Yef59a2f42020-10-16 12:55:26 -07001879 { // acquire lock
1880 std::scoped_lock _l(mLock);
1881
1882 for (auto it = mInboundQueue.begin(); it != mInboundQueue.end(); it++) {
1883 std::shared_ptr<EventEntry> entry = *it;
1884 if (entry->type == EventEntry::Type::SENSOR) {
1885 it = mInboundQueue.erase(it);
1886 releaseInboundEventLocked(entry);
1887 }
1888 }
1889 }
1890 return true;
1891}
1892
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001893bool InputDispatcher::dispatchMotionLocked(nsecs_t currentTime, std::shared_ptr<MotionEntry> entry,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001894 DropReason* dropReason, nsecs_t* nextWakeupTime) {
Michael Wright3dd60e22019-03-27 22:06:44 +00001895 ATRACE_CALL();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001896 // Preprocessing.
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001897 if (!entry->dispatchInProgress) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001898 entry->dispatchInProgress = true;
1899
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001900 logOutboundMotionDetails("dispatchMotion - ", *entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001901 }
1902
1903 // Clean up if dropping the event.
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001904 if (*dropReason != DropReason::NOT_DROPPED) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001905 setInjectionResult(*entry,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001906 *dropReason == DropReason::POLICY ? InputEventInjectionResult::SUCCEEDED
1907 : InputEventInjectionResult::FAILED);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001908 return true;
1909 }
1910
Prabir Pradhanaa561d12021-09-24 06:57:33 -07001911 const bool isPointerEvent = isFromSource(entry->source, AINPUT_SOURCE_CLASS_POINTER);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001912
1913 // Identify targets.
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08001914 std::vector<InputTarget> inputTargets;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001915
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001916 InputEventInjectionResult injectionResult;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001917 if (isPointerEvent) {
1918 // Pointer event. (eg. touchscreen)
Vaibhav Devmurari6abcf8f2022-06-06 10:08:05 +00001919
1920 if (mDragState &&
1921 (entry->action & AMOTION_EVENT_ACTION_MASK) == AMOTION_EVENT_ACTION_POINTER_DOWN) {
1922 // If drag and drop ongoing and pointer down occur: pilfer drag window pointers
1923 pilferPointersLocked(mDragState->dragWindow->getToken());
1924 }
1925
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08001926 inputTargets =
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07001927 findTouchedWindowTargetsLocked(currentTime, *entry, /*byref*/ injectionResult);
Siarhei Vishniakou8619eb32022-12-01 21:30:59 -08001928 LOG_ALWAYS_FATAL_IF(injectionResult != InputEventInjectionResult::SUCCEEDED &&
1929 !inputTargets.empty());
Michael Wrightd02c5b62014-02-10 15:10:22 -08001930 } else {
1931 // Non touch event. (eg. trackball)
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07001932 sp<WindowInfoHandle> focusedWindow =
1933 findFocusedWindowTargetLocked(currentTime, *entry, nextWakeupTime, injectionResult);
1934 if (injectionResult == InputEventInjectionResult::SUCCEEDED) {
1935 LOG_ALWAYS_FATAL_IF(focusedWindow == nullptr);
1936 addWindowTargetLocked(focusedWindow,
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08001937 InputTarget::Flags::FOREGROUND |
1938 InputTarget::Flags::DISPATCH_AS_IS,
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07001939 getDownTime(*entry), inputTargets);
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07001940 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001941 }
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001942 if (injectionResult == InputEventInjectionResult::PENDING) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001943 return false;
1944 }
1945
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001946 setInjectionResult(*entry, injectionResult);
Prabir Pradhan5735a322022-04-11 17:23:34 +00001947 if (injectionResult == InputEventInjectionResult::TARGET_MISMATCH) {
Siarhei Vishniakou767917f2020-03-24 20:49:09 -07001948 return true;
1949 }
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001950 if (injectionResult != InputEventInjectionResult::SUCCEEDED) {
Michael Wrightfb04fd52022-11-24 22:31:11 +00001951 CancelationOptions::Mode mode(
1952 isPointerEvent ? CancelationOptions::Mode::CANCEL_POINTER_EVENTS
1953 : CancelationOptions::Mode::CANCEL_NON_POINTER_EVENTS);
Siarhei Vishniakou767917f2020-03-24 20:49:09 -07001954 CancelationOptions options(mode, "input event injection failed");
1955 synthesizeCancelationEventsForMonitorsLocked(options);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001956 return true;
1957 }
1958
Arthur Hung2fbf37f2018-09-13 18:16:41 +08001959 // Add monitor channels from event's or focused display.
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001960 addGlobalMonitoringTargetsLocked(inputTargets, getTargetDisplayId(*entry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001961
1962 // Dispatch the motion.
Michael Wrightd02c5b62014-02-10 15:10:22 -08001963 dispatchEventLocked(currentTime, entry, inputTargets);
1964 return true;
1965}
1966
chaviw98318de2021-05-19 16:45:23 -05001967void InputDispatcher::enqueueDragEventLocked(const sp<WindowInfoHandle>& windowHandle,
Arthur Hung54745652022-04-20 07:17:41 +00001968 bool isExiting, const int32_t rawX,
1969 const int32_t rawY) {
1970 const vec2 xy = windowHandle->getInfo()->transform.transform(vec2(rawX, rawY));
arthurhungb89ccb02020-12-30 16:19:01 +08001971 std::unique_ptr<DragEntry> dragEntry =
Arthur Hung54745652022-04-20 07:17:41 +00001972 std::make_unique<DragEntry>(mIdGenerator.nextId(), now(), windowHandle->getToken(),
1973 isExiting, xy.x, xy.y);
arthurhungb89ccb02020-12-30 16:19:01 +08001974
1975 enqueueInboundEventLocked(std::move(dragEntry));
1976}
1977
1978void InputDispatcher::dispatchDragLocked(nsecs_t currentTime, std::shared_ptr<DragEntry> entry) {
1979 std::shared_ptr<InputChannel> channel = getInputChannelLocked(entry->connectionToken);
1980 if (channel == nullptr) {
1981 return; // Window has gone away
1982 }
1983 InputTarget target;
1984 target.inputChannel = channel;
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08001985 target.flags = InputTarget::Flags::DISPATCH_AS_IS;
arthurhungb89ccb02020-12-30 16:19:01 +08001986 entry->dispatchInProgress = true;
1987 dispatchEventLocked(currentTime, entry, {target});
1988}
1989
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001990void InputDispatcher::logOutboundMotionDetails(const char* prefix, const MotionEntry& entry) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001991 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
Siarhei Vishniakou0b0374d2022-11-17 17:40:53 -08001992 ALOGD("%seventTime=%" PRId64 ", deviceId=%d, source=%s, displayId=%" PRId32
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001993 ", policyFlags=0x%x, "
Siarhei Vishniakouca205502021-07-16 21:31:58 +00001994 "action=%s, actionButton=0x%x, flags=0x%x, "
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001995 "metaState=0x%x, buttonState=0x%x,"
1996 "edgeFlags=0x%x, xPrecision=%f, yPrecision=%f, downTime=%" PRId64,
Siarhei Vishniakou0b0374d2022-11-17 17:40:53 -08001997 prefix, entry.eventTime, entry.deviceId,
1998 inputEventSourceToString(entry.source).c_str(), entry.displayId, entry.policyFlags,
1999 MotionEvent::actionToString(entry.action).c_str(), entry.actionButton, entry.flags,
2000 entry.metaState, entry.buttonState, entry.edgeFlags, entry.xPrecision,
2001 entry.yPrecision, entry.downTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002002
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07002003 for (uint32_t i = 0; i < entry.getPointerCount(); i++) {
Siarhei Vishniakou09a8fe42022-07-21 17:27:03 -07002004 ALOGD(" Pointer %d: id=%d, toolType=%s, "
Prabir Pradhan61a5d242021-07-26 16:41:09 +00002005 "x=%f, y=%f, pressure=%f, size=%f, "
2006 "touchMajor=%f, touchMinor=%f, toolMajor=%f, toolMinor=%f, "
2007 "orientation=%f",
Siarhei Vishniakou09a8fe42022-07-21 17:27:03 -07002008 i, entry.pointerProperties[i].id,
2009 ftl::enum_string(entry.pointerProperties[i].toolType).c_str(),
Prabir Pradhan61a5d242021-07-26 16:41:09 +00002010 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_X),
2011 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_Y),
2012 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_PRESSURE),
2013 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_SIZE),
2014 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR),
2015 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR),
2016 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR),
2017 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR),
2018 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION));
2019 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002020 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002021}
2022
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07002023void InputDispatcher::dispatchEventLocked(nsecs_t currentTime,
2024 std::shared_ptr<EventEntry> eventEntry,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002025 const std::vector<InputTarget>& inputTargets) {
Michael Wright3dd60e22019-03-27 22:06:44 +00002026 ATRACE_CALL();
Prabir Pradhan61a5d242021-07-26 16:41:09 +00002027 if (DEBUG_DISPATCH_CYCLE) {
2028 ALOGD("dispatchEventToCurrentInputTargets");
2029 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002030
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00002031 processInteractionsLocked(*eventEntry, inputTargets);
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00002032
Michael Wrightd02c5b62014-02-10 15:10:22 -08002033 ALOG_ASSERT(eventEntry->dispatchInProgress); // should already have been set to true
2034
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002035 pokeUserActivityLocked(*eventEntry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002036
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08002037 for (const InputTarget& inputTarget : inputTargets) {
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07002038 std::shared_ptr<Connection> connection =
Siarhei Vishniakou26d3cfb2019-10-15 17:02:32 -07002039 getConnectionLocked(inputTarget.inputChannel->getConnectionToken());
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07002040 if (connection != nullptr) {
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08002041 prepareDispatchCycleLocked(currentTime, connection, eventEntry, inputTarget);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002042 } else {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01002043 if (DEBUG_FOCUS) {
2044 ALOGD("Dropping event delivery to target with channel '%s' because it "
2045 "is no longer registered with the input dispatcher.",
2046 inputTarget.inputChannel->getName().c_str());
2047 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002048 }
2049 }
2050}
2051
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07002052void InputDispatcher::cancelEventsForAnrLocked(const std::shared_ptr<Connection>& connection) {
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002053 // We will not be breaking any connections here, even if the policy wants us to abort dispatch.
2054 // If the policy decides to close the app, we will get a channel removal event via
2055 // unregisterInputChannel, and will clean up the connection that way. We are already not
2056 // sending new pointers to the connection when it blocked, but focused events will continue to
2057 // pile up.
2058 ALOGW("Canceling events for %s because it is unresponsive",
2059 connection->inputChannel->getName().c_str());
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08002060 if (connection->status == Connection::Status::NORMAL) {
Michael Wrightfb04fd52022-11-24 22:31:11 +00002061 CancelationOptions options(CancelationOptions::Mode::CANCEL_ALL_EVENTS,
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002062 "application not responding");
2063 synthesizeCancelationEventsForConnectionLocked(connection, options);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002064 }
2065}
2066
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002067void InputDispatcher::resetNoFocusedWindowTimeoutLocked() {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01002068 if (DEBUG_FOCUS) {
2069 ALOGD("Resetting ANR timeouts.");
2070 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002071
2072 // Reset input target wait timeout.
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002073 mNoFocusedWindowTimeoutTime = std::nullopt;
Chris Yea209fde2020-07-22 13:54:51 -07002074 mAwaitedFocusedApplication.reset();
Michael Wrightd02c5b62014-02-10 15:10:22 -08002075}
2076
Tiger Huang721e26f2018-07-24 22:26:19 +08002077/**
2078 * Get the display id that the given event should go to. If this event specifies a valid display id,
2079 * then it should be dispatched to that display. Otherwise, the event goes to the focused display.
2080 * Focused display is the display that the user most recently interacted with.
2081 */
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002082int32_t InputDispatcher::getTargetDisplayId(const EventEntry& entry) {
Tiger Huang721e26f2018-07-24 22:26:19 +08002083 int32_t displayId;
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002084 switch (entry.type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07002085 case EventEntry::Type::KEY: {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002086 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(entry);
2087 displayId = keyEntry.displayId;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002088 break;
2089 }
Siarhei Vishniakou49483272019-10-22 13:13:47 -07002090 case EventEntry::Type::MOTION: {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002091 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(entry);
2092 displayId = motionEntry.displayId;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002093 break;
2094 }
Antonio Kantekf16f2832021-09-28 04:39:20 +00002095 case EventEntry::Type::TOUCH_MODE_CHANGED:
Prabir Pradhan99987712020-11-10 18:43:05 -08002096 case EventEntry::Type::POINTER_CAPTURE_CHANGED:
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01002097 case EventEntry::Type::FOCUS:
Siarhei Vishniakou49483272019-10-22 13:13:47 -07002098 case EventEntry::Type::CONFIGURATION_CHANGED:
Chris Yef59a2f42020-10-16 12:55:26 -07002099 case EventEntry::Type::DEVICE_RESET:
arthurhungb89ccb02020-12-30 16:19:01 +08002100 case EventEntry::Type::SENSOR:
2101 case EventEntry::Type::DRAG: {
Dominik Laskowski75788452021-02-09 18:51:25 -08002102 ALOGE("%s events do not have a target display", ftl::enum_string(entry.type).c_str());
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002103 return ADISPLAY_ID_NONE;
2104 }
Tiger Huang721e26f2018-07-24 22:26:19 +08002105 }
2106 return displayId == ADISPLAY_ID_NONE ? mFocusedDisplayId : displayId;
2107}
2108
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002109bool InputDispatcher::shouldWaitToSendKeyLocked(nsecs_t currentTime,
2110 const char* focusedWindowName) {
2111 if (mAnrTracker.empty()) {
2112 // already processed all events that we waited for
2113 mKeyIsWaitingForEventsTimeout = std::nullopt;
2114 return false;
2115 }
2116
2117 if (!mKeyIsWaitingForEventsTimeout.has_value()) {
2118 // Start the timer
Siarhei Vishniakoud706a282021-02-13 00:08:48 +00002119 // Wait to send key because there are unprocessed events that may cause focus to change
Siarhei Vishniakou70622952020-07-30 11:17:23 -05002120 mKeyIsWaitingForEventsTimeout = currentTime +
2121 std::chrono::duration_cast<std::chrono::nanoseconds>(KEY_WAITING_FOR_EVENTS_TIMEOUT)
2122 .count();
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002123 return true;
2124 }
2125
2126 // We still have pending events, and already started the timer
2127 if (currentTime < *mKeyIsWaitingForEventsTimeout) {
2128 return true; // Still waiting
2129 }
2130
2131 // Waited too long, and some connection still hasn't processed all motions
2132 // Just send the key to the focused window
2133 ALOGW("Dispatching key to %s even though there are other unprocessed events",
2134 focusedWindowName);
2135 mKeyIsWaitingForEventsTimeout = std::nullopt;
2136 return false;
2137}
2138
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002139sp<WindowInfoHandle> InputDispatcher::findFocusedWindowTargetLocked(
2140 nsecs_t currentTime, const EventEntry& entry, nsecs_t* nextWakeupTime,
2141 InputEventInjectionResult& outInjectionResult) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002142 std::string reason;
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002143 outInjectionResult = InputEventInjectionResult::FAILED; // Default result
Michael Wrightd02c5b62014-02-10 15:10:22 -08002144
Tiger Huang721e26f2018-07-24 22:26:19 +08002145 int32_t displayId = getTargetDisplayId(entry);
chaviw98318de2021-05-19 16:45:23 -05002146 sp<WindowInfoHandle> focusedWindowHandle = getFocusedWindowHandleLocked(displayId);
Chris Yea209fde2020-07-22 13:54:51 -07002147 std::shared_ptr<InputApplicationHandle> focusedApplicationHandle =
Tiger Huang721e26f2018-07-24 22:26:19 +08002148 getValueByKey(mFocusedApplicationHandlesByDisplay, displayId);
2149
Michael Wrightd02c5b62014-02-10 15:10:22 -08002150 // If there is no currently focused window and no focused application
2151 // then drop the event.
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002152 if (focusedWindowHandle == nullptr && focusedApplicationHandle == nullptr) {
2153 ALOGI("Dropping %s event because there is no focused window or focused application in "
2154 "display %" PRId32 ".",
Dominik Laskowski75788452021-02-09 18:51:25 -08002155 ftl::enum_string(entry.type).c_str(), displayId);
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002156 return nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002157 }
2158
Vishnu Nair062a8672021-09-03 16:07:44 -07002159 // Drop key events if requested by input feature
2160 if (focusedWindowHandle != nullptr && shouldDropInput(entry, focusedWindowHandle)) {
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002161 return nullptr;
Vishnu Nair062a8672021-09-03 16:07:44 -07002162 }
2163
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002164 // Compatibility behavior: raise ANR if there is a focused application, but no focused window.
2165 // Only start counting when we have a focused event to dispatch. The ANR is canceled if we
2166 // start interacting with another application via touch (app switch). This code can be removed
2167 // if the "no focused window ANR" is moved to the policy. Input doesn't know whether
2168 // an app is expected to have a focused window.
2169 if (focusedWindowHandle == nullptr && focusedApplicationHandle != nullptr) {
2170 if (!mNoFocusedWindowTimeoutTime.has_value()) {
2171 // We just discovered that there's no focused window. Start the ANR timer
Siarhei Vishniakouc1ae5562020-06-30 14:22:57 -05002172 std::chrono::nanoseconds timeout = focusedApplicationHandle->getDispatchingTimeout(
2173 DEFAULT_INPUT_DISPATCHING_TIMEOUT);
2174 mNoFocusedWindowTimeoutTime = currentTime + timeout.count();
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002175 mAwaitedFocusedApplication = focusedApplicationHandle;
Siarhei Vishniakouf56b2692020-09-08 19:43:33 -05002176 mAwaitedApplicationDisplayId = displayId;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002177 ALOGW("Waiting because no window has focus but %s may eventually add a "
2178 "window when it finishes starting up. Will wait for %" PRId64 "ms",
Siarhei Vishniakouc1ae5562020-06-30 14:22:57 -05002179 mAwaitedFocusedApplication->getName().c_str(), millis(timeout));
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002180 *nextWakeupTime = *mNoFocusedWindowTimeoutTime;
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002181 outInjectionResult = InputEventInjectionResult::PENDING;
2182 return nullptr;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002183 } else if (currentTime > *mNoFocusedWindowTimeoutTime) {
2184 // Already raised ANR. Drop the event
2185 ALOGE("Dropping %s event because there is no focused window",
Dominik Laskowski75788452021-02-09 18:51:25 -08002186 ftl::enum_string(entry.type).c_str());
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002187 return nullptr;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002188 } else {
2189 // Still waiting for the focused window
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002190 outInjectionResult = InputEventInjectionResult::PENDING;
2191 return nullptr;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002192 }
2193 }
2194
2195 // we have a valid, non-null focused window
2196 resetNoFocusedWindowTimeoutLocked();
2197
Prabir Pradhan5735a322022-04-11 17:23:34 +00002198 // Verify targeted injection.
2199 if (const auto err = verifyTargetedInjection(focusedWindowHandle, entry); err) {
2200 ALOGW("Dropping injected event: %s", (*err).c_str());
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002201 outInjectionResult = InputEventInjectionResult::TARGET_MISMATCH;
2202 return nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002203 }
2204
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08002205 if (focusedWindowHandle->getInfo()->inputConfig.test(
2206 WindowInfo::InputConfig::PAUSE_DISPATCHING)) {
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002207 ALOGI("Waiting because %s is paused", focusedWindowHandle->getName().c_str());
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002208 outInjectionResult = InputEventInjectionResult::PENDING;
2209 return nullptr;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002210 }
2211
2212 // If the event is a key event, then we must wait for all previous events to
2213 // complete before delivering it because previous events may have the
2214 // side-effect of transferring focus to a different window and we want to
2215 // ensure that the following keys are sent to the new window.
2216 //
2217 // Suppose the user touches a button in a window then immediately presses "A".
2218 // If the button causes a pop-up window to appear then we want to ensure that
2219 // the "A" key is delivered to the new pop-up window. This is because users
2220 // often anticipate pending UI changes when typing on a keyboard.
2221 // To obtain this behavior, we must serialize key events with respect to all
2222 // prior input events.
2223 if (entry.type == EventEntry::Type::KEY) {
2224 if (shouldWaitToSendKeyLocked(currentTime, focusedWindowHandle->getName().c_str())) {
2225 *nextWakeupTime = *mKeyIsWaitingForEventsTimeout;
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002226 outInjectionResult = InputEventInjectionResult::PENDING;
2227 return nullptr;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002228 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002229 }
2230
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002231 outInjectionResult = InputEventInjectionResult::SUCCEEDED;
2232 return focusedWindowHandle;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002233}
2234
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002235/**
2236 * Given a list of monitors, remove the ones we cannot find a connection for, and the ones
2237 * that are currently unresponsive.
2238 */
Prabir Pradhan0a99c922021-09-03 08:27:53 -07002239std::vector<Monitor> InputDispatcher::selectResponsiveMonitorsLocked(
2240 const std::vector<Monitor>& monitors) const {
2241 std::vector<Monitor> responsiveMonitors;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002242 std::copy_if(monitors.begin(), monitors.end(), std::back_inserter(responsiveMonitors),
Prabir Pradhan0a99c922021-09-03 08:27:53 -07002243 [this](const Monitor& monitor) REQUIRES(mLock) {
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07002244 std::shared_ptr<Connection> connection =
Prabir Pradhan0a99c922021-09-03 08:27:53 -07002245 getConnectionLocked(monitor.inputChannel->getConnectionToken());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002246 if (connection == nullptr) {
2247 ALOGE("Could not find connection for monitor %s",
Prabir Pradhan0a99c922021-09-03 08:27:53 -07002248 monitor.inputChannel->getName().c_str());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002249 return false;
2250 }
2251 if (!connection->responsive) {
2252 ALOGW("Unresponsive monitor %s will not get the new gesture",
2253 connection->inputChannel->getName().c_str());
2254 return false;
2255 }
2256 return true;
2257 });
2258 return responsiveMonitors;
2259}
2260
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002261std::vector<InputTarget> InputDispatcher::findTouchedWindowTargetsLocked(
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002262 nsecs_t currentTime, const MotionEntry& entry,
Siarhei Vishniakou4fe57392022-10-25 13:44:30 -07002263 InputEventInjectionResult& outInjectionResult) {
Michael Wright3dd60e22019-03-27 22:06:44 +00002264 ATRACE_CALL();
Michael Wrightd02c5b62014-02-10 15:10:22 -08002265
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002266 std::vector<InputTarget> targets;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002267 // For security reasons, we defer updating the touch state until we are sure that
2268 // event injection will be allowed.
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002269 const int32_t displayId = entry.displayId;
2270 const int32_t action = entry.action;
Siarhei Vishniakoubf880522023-05-01 11:03:22 -07002271 const int32_t maskedAction = MotionEvent::getActionMasked(action);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002272
2273 // Update the touch state as needed based on the properties of the touch event.
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002274 outInjectionResult = InputEventInjectionResult::PENDING;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002275
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002276 // Copy current touch state into tempTouchState.
2277 // This state will be used to update mTouchStatesByDisplay at the end of this function.
2278 // If no state for the specified display exists, then our initial state will be empty.
Yi Kong9b14ac62018-07-17 13:48:38 -07002279 const TouchState* oldState = nullptr;
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002280 TouchState tempTouchState;
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002281 if (const auto it = mTouchStatesByDisplay.find(displayId); it != mTouchStatesByDisplay.end()) {
2282 oldState = &(it->second);
Prabir Pradhane680f9b2022-02-04 04:24:00 -08002283 tempTouchState = *oldState;
Jeff Brownf086ddb2014-02-11 14:28:48 -08002284 }
2285
Siarhei Vishniakou64a98532022-10-25 15:20:24 -07002286 bool isSplit = shouldSplitTouch(tempTouchState, entry);
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002287
2288 const bool isHoverAction = (maskedAction == AMOTION_EVENT_ACTION_HOVER_MOVE ||
2289 maskedAction == AMOTION_EVENT_ACTION_HOVER_ENTER ||
2290 maskedAction == AMOTION_EVENT_ACTION_HOVER_EXIT);
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002291 // A DOWN could be generated from POINTER_DOWN if the initial pointers did not land into any
2292 // touchable windows.
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002293 const bool wasDown = oldState != nullptr && oldState->isDown(entry.deviceId);
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002294 const bool isDown = (maskedAction == AMOTION_EVENT_ACTION_DOWN) ||
2295 (maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN && !wasDown);
Siarhei Vishniakoua235c042023-05-02 09:59:09 -07002296 const bool newGesture = isDown || maskedAction == AMOTION_EVENT_ACTION_SCROLL ||
2297 maskedAction == AMOTION_EVENT_ACTION_HOVER_ENTER ||
2298 maskedAction == AMOTION_EVENT_ACTION_HOVER_MOVE;
Prabir Pradhanaa561d12021-09-24 06:57:33 -07002299 const bool isFromMouse = isFromSource(entry.source, AINPUT_SOURCE_MOUSE);
Siarhei Vishniakou5cee1e32022-11-29 12:35:39 -08002300
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002301 if (newGesture) {
2302 isSplit = false;
Siarhei Vishniakouf372b812023-02-14 18:06:51 -08002303 }
2304
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002305 if (isDown && tempTouchState.hasHoveringPointers(entry.deviceId)) {
2306 // Compatibility behaviour: ACTION_DOWN causes HOVER_EXIT to get generated.
2307 tempTouchState.clearHoveringPointers(entry.deviceId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002308 }
2309
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +00002310 if (isHoverAction) {
2311 // For hover actions, we will treat 'tempTouchState' as a new state, so let's erase
2312 // all of the existing hovering pointers and recompute.
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002313 tempTouchState.clearHoveringPointers(entry.deviceId);
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +00002314 }
2315
Michael Wrightd02c5b62014-02-10 15:10:22 -08002316 if (newGesture || (isSplit && maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN)) {
2317 /* Case 1: New splittable pointer going down, or need target for hover or scroll. */
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07002318 const auto [x, y] = resolveTouchedPosition(entry);
Siarhei Vishniakou5b9766d2023-07-18 14:06:29 -07002319 const int32_t pointerIndex = MotionEvent::getActionIndex(action);
Siarhei Vishniakou70f3d8c2023-09-19 15:36:52 -07002320 const int32_t pointerId = entry.pointerProperties[pointerIndex].id;
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002321 // Outside targets should be added upon first dispatched DOWN event. That means, this should
2322 // be a pointer that would generate ACTION_DOWN, *and* touch should not already be down.
Prabir Pradhand65552b2021-10-07 11:23:50 -07002323 const bool isStylus = isPointerFromStylus(entry, pointerIndex);
Siarhei Vishniakoue1ada272022-11-03 10:47:08 -07002324 sp<WindowInfoHandle> newTouchedWindowHandle =
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002325 findTouchedWindowAtLocked(displayId, x, y, isStylus);
Michael Wright3dd60e22019-03-27 22:06:44 +00002326
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002327 if (isDown) {
Siarhei Vishniakou70f3d8c2023-09-19 15:36:52 -07002328 targets += findOutsideTargetsLocked(displayId, newTouchedWindowHandle, pointerId);
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002329 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002330 // Handle the case where we did not find a window.
Yi Kong9b14ac62018-07-17 13:48:38 -07002331 if (newTouchedWindowHandle == nullptr) {
Prabir Pradhan82e081e2022-12-06 09:50:09 +00002332 ALOGD("No new touched window at (%.1f, %.1f) in display %" PRId32, x, y, displayId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002333 // Try to assign the pointer to the first foreground window we find, if there is one.
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002334 newTouchedWindowHandle = tempTouchState.getFirstForegroundWindowHandle();
Michael Wright3dd60e22019-03-27 22:06:44 +00002335 }
2336
Prabir Pradhan5735a322022-04-11 17:23:34 +00002337 // Verify targeted injection.
2338 if (const auto err = verifyTargetedInjection(newTouchedWindowHandle, entry); err) {
2339 ALOGW("Dropping injected touch event: %s", (*err).c_str());
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002340 outInjectionResult = os::InputEventInjectionResult::TARGET_MISMATCH;
Prabir Pradhan5735a322022-04-11 17:23:34 +00002341 newTouchedWindowHandle = nullptr;
Siarhei Vishniakou8619eb32022-12-01 21:30:59 -08002342 return {};
Prabir Pradhan5735a322022-04-11 17:23:34 +00002343 }
2344
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002345 // Figure out whether splitting will be allowed for this window.
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002346 if (newTouchedWindowHandle != nullptr) {
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002347 if (newTouchedWindowHandle->getInfo()->supportsSplitTouch()) {
2348 // New window supports splitting, but we should never split mouse events.
2349 isSplit = !isFromMouse;
2350 } else if (isSplit) {
2351 // New window does not support splitting but we have already split events.
2352 // Ignore the new window.
Siarhei Vishniakou25537f82023-07-18 14:35:47 -07002353 LOG(INFO) << "Skipping " << newTouchedWindowHandle->getName()
2354 << " because it doesn't support split touch";
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002355 newTouchedWindowHandle = nullptr;
2356 }
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002357 } else {
2358 // No window is touched, so set split to true. This will allow the next pointer down to
Prabir Pradhan713bb3e2021-12-20 02:07:40 -08002359 // be delivered to a new window which supports split touch. Pointers from a mouse device
2360 // should never be split.
Siarhei Vishniakou64a98532022-10-25 15:20:24 -07002361 isSplit = !isFromMouse;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002362 }
2363
Prabir Pradhan07e05b62021-11-19 03:57:24 -08002364 std::vector<sp<WindowInfoHandle>> newTouchedWindows =
Prabir Pradhand65552b2021-10-07 11:23:50 -07002365 findTouchedSpyWindowsAtLocked(displayId, x, y, isStylus);
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002366 if (newTouchedWindowHandle != nullptr) {
Prabir Pradhan07e05b62021-11-19 03:57:24 -08002367 // Process the foreground window first so that it is the first to receive the event.
2368 newTouchedWindows.insert(newTouchedWindows.begin(), newTouchedWindowHandle);
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002369 }
2370
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002371 if (newTouchedWindows.empty()) {
Prabir Pradhan82e081e2022-12-06 09:50:09 +00002372 ALOGI("Dropping event because there is no touchable window at (%.1f, %.1f) on display "
2373 "%d.",
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002374 x, y, displayId);
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002375 outInjectionResult = InputEventInjectionResult::FAILED;
Siarhei Vishniakou8619eb32022-12-01 21:30:59 -08002376 return {};
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002377 }
2378
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002379 for (const sp<WindowInfoHandle>& windowHandle : newTouchedWindows) {
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07002380 if (!canWindowReceiveMotionLocked(windowHandle, entry)) {
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002381 continue;
2382 }
2383
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002384 if (isHoverAction) {
Siarhei Vishniakoub681c202023-05-01 11:22:33 -07002385 // The "windowHandle" is the target of this hovering pointer.
2386 tempTouchState.addHoveringPointerToWindow(windowHandle, entry.deviceId, pointerId);
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +00002387 }
2388
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002389 // Set target flags.
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002390 ftl::Flags<InputTarget::Flags> targetFlags = InputTarget::Flags::DISPATCH_AS_IS;
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002391
Prabir Pradhan6dfbf262022-03-14 15:24:30 +00002392 if (canReceiveForegroundTouches(*windowHandle->getInfo())) {
2393 // There should only be one touched window that can be "foreground" for the pointer.
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002394 targetFlags |= InputTarget::Flags::FOREGROUND;
Prabir Pradhan07e05b62021-11-19 03:57:24 -08002395 }
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002396
2397 if (isSplit) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002398 targetFlags |= InputTarget::Flags::SPLIT;
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002399 }
2400 if (isWindowObscuredAtPointLocked(windowHandle, x, y)) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002401 targetFlags |= InputTarget::Flags::WINDOW_IS_OBSCURED;
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002402 } else if (isWindowObscuredLocked(windowHandle)) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002403 targetFlags |= InputTarget::Flags::WINDOW_IS_PARTIALLY_OBSCURED;
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002404 }
Michael Wright3dd60e22019-03-27 22:06:44 +00002405
2406 // Update the temporary touch state.
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002407
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +00002408 if (!isHoverAction) {
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002409 std::bitset<MAX_POINTER_ID + 1> pointerIds;
Siarhei Vishniakou70f3d8c2023-09-19 15:36:52 -07002410 pointerIds.set(pointerId);
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002411 const bool isDownOrPointerDown = maskedAction == AMOTION_EVENT_ACTION_DOWN ||
2412 maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN;
2413 tempTouchState.addOrUpdateWindow(windowHandle, targetFlags, entry.deviceId,
2414 pointerIds,
2415 isDownOrPointerDown
2416 ? std::make_optional(entry.eventTime)
2417 : std::nullopt);
2418 // If this is the pointer going down and the touched window has a wallpaper
2419 // then also add the touched wallpaper windows so they are locked in for the
2420 // duration of the touch gesture. We do not collect wallpapers during HOVER_MOVE or
2421 // SCROLL because the wallpaper engine only supports touch events. We would need to
2422 // add a mechanism similar to View.onGenericMotionEvent to enable wallpapers to
2423 // handle these events.
2424 if (isDownOrPointerDown && targetFlags.test(InputTarget::Flags::FOREGROUND) &&
Arthur Hungc539dbb2022-12-08 07:45:36 +00002425 windowHandle->getInfo()->inputConfig.test(
2426 gui::WindowInfo::InputConfig::DUPLICATE_TOUCH_TO_WALLPAPER)) {
2427 sp<WindowInfoHandle> wallpaper = findWallpaperWindowBelow(windowHandle);
2428 if (wallpaper != nullptr) {
2429 ftl::Flags<InputTarget::Flags> wallpaperFlags =
2430 InputTarget::Flags::WINDOW_IS_OBSCURED |
2431 InputTarget::Flags::WINDOW_IS_PARTIALLY_OBSCURED |
2432 InputTarget::Flags::DISPATCH_AS_IS;
2433 if (isSplit) {
2434 wallpaperFlags |= InputTarget::Flags::SPLIT;
2435 }
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07002436 tempTouchState.addOrUpdateWindow(wallpaper, wallpaperFlags, entry.deviceId,
2437 pointerIds, entry.eventTime);
Arthur Hungc539dbb2022-12-08 07:45:36 +00002438 }
2439 }
2440 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002441 }
Vaibhav Devmurariff798f32022-05-09 23:45:04 +00002442
Siarhei Vishniakou060f82b2023-01-27 06:39:14 -08002443 // If a window is already pilfering some pointers, give it this new pointer as well and
2444 // make it pilfering. This will prevent other non-spy windows from getting this pointer,
2445 // which is a specific behaviour that we want.
Siarhei Vishniakou060f82b2023-01-27 06:39:14 -08002446 for (TouchedWindow& touchedWindow : tempTouchState.windows) {
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07002447 if (touchedWindow.hasTouchingPointer(entry.deviceId, pointerId) &&
2448 touchedWindow.hasPilferingPointers(entry.deviceId)) {
Siarhei Vishniakou060f82b2023-01-27 06:39:14 -08002449 // This window is already pilfering some pointers, and this new pointer is also
2450 // going to it. Therefore, take over this pointer and don't give it to anyone
2451 // else.
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07002452 touchedWindow.addPilferingPointer(entry.deviceId, pointerId);
Vaibhav Devmurariff798f32022-05-09 23:45:04 +00002453 }
2454 }
Siarhei Vishniakou060f82b2023-01-27 06:39:14 -08002455
2456 // Restrict all pilfered pointers to the pilfering windows.
2457 tempTouchState.cancelPointersForNonPilferingWindows();
Michael Wrightd02c5b62014-02-10 15:10:22 -08002458 } else {
2459 /* Case 2: Pointer move, up, cancel or non-splittable pointer down. */
2460
2461 // If the pointer is not currently down, then ignore the event.
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002462 if (!tempTouchState.isDown(entry.deviceId) &&
2463 maskedAction != AMOTION_EVENT_ACTION_HOVER_EXIT) {
2464 LOG(INFO) << "Dropping event because the pointer for device " << entry.deviceId
2465 << " is not down or we previously "
Siarhei Vishniakouf372b812023-02-14 18:06:51 -08002466 "dropped the pointer down event in display "
2467 << displayId << ": " << entry.getDescription();
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002468 outInjectionResult = InputEventInjectionResult::FAILED;
Siarhei Vishniakou8619eb32022-12-01 21:30:59 -08002469 return {};
Michael Wrightd02c5b62014-02-10 15:10:22 -08002470 }
2471
Siarhei Vishniakoua235c042023-05-02 09:59:09 -07002472 // If the pointer is not currently hovering, then ignore the event.
2473 if (maskedAction == AMOTION_EVENT_ACTION_HOVER_EXIT) {
2474 const int32_t pointerId = entry.pointerProperties[0].id;
2475 if (oldState == nullptr ||
2476 oldState->getWindowsWithHoveringPointer(entry.deviceId, pointerId).empty()) {
2477 LOG(INFO) << "Dropping event because the hovering pointer is not in any windows in "
2478 "display "
2479 << displayId << ": " << entry.getDescription();
2480 outInjectionResult = InputEventInjectionResult::FAILED;
2481 return {};
2482 }
2483 tempTouchState.removeHoveringPointer(entry.deviceId, pointerId);
2484 }
2485
arthurhung6d4bed92021-03-17 11:59:33 +08002486 addDragEventLocked(entry);
arthurhungb89ccb02020-12-30 16:19:01 +08002487
Michael Wrightd02c5b62014-02-10 15:10:22 -08002488 // Check whether touches should slip outside of the current foreground window.
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07002489 if (maskedAction == AMOTION_EVENT_ACTION_MOVE && entry.getPointerCount() == 1 &&
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002490 tempTouchState.isSlippery()) {
Siarhei Vishniakou9306c382022-09-30 15:30:31 -07002491 const auto [x, y] = resolveTouchedPosition(entry);
Harry Cutts33476232023-01-30 19:57:29 +00002492 const bool isStylus = isPointerFromStylus(entry, /*pointerIndex=*/0);
chaviw98318de2021-05-19 16:45:23 -05002493 sp<WindowInfoHandle> oldTouchedWindowHandle =
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002494 tempTouchState.getFirstForegroundWindowHandle();
Siarhei Vishniakou0f6558d2023-04-21 12:05:13 -07002495 LOG_ALWAYS_FATAL_IF(oldTouchedWindowHandle == nullptr);
Siarhei Vishniakoue1ada272022-11-03 10:47:08 -07002496 sp<WindowInfoHandle> newTouchedWindowHandle =
2497 findTouchedWindowAtLocked(displayId, x, y, isStylus);
Vishnu Nair062a8672021-09-03 16:07:44 -07002498
Prabir Pradhan5735a322022-04-11 17:23:34 +00002499 // Verify targeted injection.
2500 if (const auto err = verifyTargetedInjection(newTouchedWindowHandle, entry); err) {
2501 ALOGW("Dropping injected event: %s", (*err).c_str());
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002502 outInjectionResult = os::InputEventInjectionResult::TARGET_MISMATCH;
Siarhei Vishniakou8619eb32022-12-01 21:30:59 -08002503 return {};
Prabir Pradhan5735a322022-04-11 17:23:34 +00002504 }
2505
Vishnu Nair062a8672021-09-03 16:07:44 -07002506 // Drop touch events if requested by input feature
2507 if (newTouchedWindowHandle != nullptr &&
2508 shouldDropInput(entry, newTouchedWindowHandle)) {
2509 newTouchedWindowHandle = nullptr;
2510 }
2511
Siarhei Vishniakouafa08cc2023-05-08 22:35:50 -07002512 if (newTouchedWindowHandle != nullptr &&
2513 !haveSameToken(oldTouchedWindowHandle, newTouchedWindowHandle)) {
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002514 ALOGI("Touch is slipping out of window %s into window %s in display %" PRId32,
Siarhei Vishniakou0f6558d2023-04-21 12:05:13 -07002515 oldTouchedWindowHandle->getName().c_str(),
2516 newTouchedWindowHandle->getName().c_str(), displayId);
2517
Michael Wrightd02c5b62014-02-10 15:10:22 -08002518 // Make a slippery exit from the old window.
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08002519 std::bitset<MAX_POINTER_ID + 1> pointerIds;
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002520 const int32_t pointerId = entry.pointerProperties[0].id;
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08002521 pointerIds.set(pointerId);
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002522
2523 const TouchedWindow& touchedWindow =
2524 tempTouchState.getTouchedWindow(oldTouchedWindowHandle);
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002525 addPointerWindowTargetLocked(oldTouchedWindowHandle,
2526 InputTarget::Flags::DISPATCH_AS_SLIPPERY_EXIT,
2527 pointerIds,
2528 touchedWindow.getDownTimeInTarget(entry.deviceId),
2529 targets);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002530
2531 // Make a slippery entrance into the new window.
2532 if (newTouchedWindowHandle->getInfo()->supportsSplitTouch()) {
Prabir Pradhan713bb3e2021-12-20 02:07:40 -08002533 isSplit = !isFromMouse;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002534 }
2535
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002536 ftl::Flags<InputTarget::Flags> targetFlags =
2537 InputTarget::Flags::DISPATCH_AS_SLIPPERY_ENTER;
Prabir Pradhan6dfbf262022-03-14 15:24:30 +00002538 if (canReceiveForegroundTouches(*newTouchedWindowHandle->getInfo())) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002539 targetFlags |= InputTarget::Flags::FOREGROUND;
Prabir Pradhan6dfbf262022-03-14 15:24:30 +00002540 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002541 if (isSplit) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002542 targetFlags |= InputTarget::Flags::SPLIT;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002543 }
2544 if (isWindowObscuredAtPointLocked(newTouchedWindowHandle, x, y)) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002545 targetFlags |= InputTarget::Flags::WINDOW_IS_OBSCURED;
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10002546 } else if (isWindowObscuredLocked(newTouchedWindowHandle)) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002547 targetFlags |= InputTarget::Flags::WINDOW_IS_PARTIALLY_OBSCURED;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002548 }
2549
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07002550 tempTouchState.addOrUpdateWindow(newTouchedWindowHandle, targetFlags,
2551 entry.deviceId, pointerIds, entry.eventTime);
Arthur Hungc539dbb2022-12-08 07:45:36 +00002552
2553 // Check if the wallpaper window should deliver the corresponding event.
2554 slipWallpaperTouch(targetFlags, oldTouchedWindowHandle, newTouchedWindowHandle,
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07002555 tempTouchState, entry.deviceId, pointerId, targets);
2556 tempTouchState.removeTouchingPointerFromWindow(entry.deviceId, pointerId,
2557 oldTouchedWindowHandle);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002558 }
2559 }
Arthur Hung96483742022-11-15 03:30:48 +00002560
2561 // Update the pointerIds for non-splittable when it received pointer down.
2562 if (!isSplit && maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN) {
2563 // If no split, we suppose all touched windows should receive pointer down.
Siarhei Vishniakou5b9766d2023-07-18 14:06:29 -07002564 const int32_t pointerIndex = MotionEvent::getActionIndex(action);
Arthur Hung96483742022-11-15 03:30:48 +00002565 for (size_t i = 0; i < tempTouchState.windows.size(); i++) {
2566 TouchedWindow& touchedWindow = tempTouchState.windows[i];
2567 // Ignore drag window for it should just track one pointer.
2568 if (mDragState && mDragState->dragWindow == touchedWindow.windowHandle) {
2569 continue;
2570 }
Siarhei Vishniakou5b9766d2023-07-18 14:06:29 -07002571 std::bitset<MAX_POINTER_ID + 1> touchingPointers;
2572 touchingPointers.set(entry.pointerProperties[pointerIndex].id);
2573 touchedWindow.addTouchingPointers(entry.deviceId, touchingPointers);
Arthur Hung96483742022-11-15 03:30:48 +00002574 }
2575 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002576 }
2577
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002578 // Update dispatching for hover enter and exit.
Sam Dubeyf886dec2023-01-27 13:28:19 +00002579 {
2580 std::vector<TouchedWindow> hoveringWindows =
2581 getHoveringWindowsLocked(oldState, tempTouchState, entry);
2582 for (const TouchedWindow& touchedWindow : hoveringWindows) {
Siarhei Vishniakoud5876ba2023-05-15 17:58:34 -07002583 std::optional<InputTarget> target =
2584 createInputTargetLocked(touchedWindow.windowHandle, touchedWindow.targetFlags,
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07002585 touchedWindow.getDownTimeInTarget(entry.deviceId));
Siarhei Vishniakoud5876ba2023-05-15 17:58:34 -07002586 if (!target) {
2587 continue;
2588 }
2589 // Hardcode to single hovering pointer for now.
2590 std::bitset<MAX_POINTER_ID + 1> pointerIds;
2591 pointerIds.set(entry.pointerProperties[0].id);
2592 target->addPointers(pointerIds, touchedWindow.windowHandle->getInfo()->transform);
2593 targets.push_back(*target);
Sam Dubeyf886dec2023-01-27 13:28:19 +00002594 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002595 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002596
Prabir Pradhan5735a322022-04-11 17:23:34 +00002597 // Ensure that all touched windows are valid for injection.
2598 if (entry.injectionState != nullptr) {
2599 std::string errs;
2600 for (const TouchedWindow& touchedWindow : tempTouchState.windows) {
Prabir Pradhan5735a322022-04-11 17:23:34 +00002601 const auto err = verifyTargetedInjection(touchedWindow.windowHandle, entry);
2602 if (err) errs += "\n - " + *err;
2603 }
2604 if (!errs.empty()) {
2605 ALOGW("Dropping targeted injection: At least one touched window is not owned by uid "
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00002606 "%s:%s",
2607 entry.injectionState->targetUid->toString().c_str(), errs.c_str());
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -07002608 outInjectionResult = InputEventInjectionResult::TARGET_MISMATCH;
Siarhei Vishniakou8619eb32022-12-01 21:30:59 -08002609 return {};
Prabir Pradhan5735a322022-04-11 17:23:34 +00002610 }
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002611 }
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002612
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002613 // Check whether windows listening for outside touches are owned by the same UID. If the owner
2614 // has a different UID, then we will not reveal coordinate information to this window.
Michael Wrightd02c5b62014-02-10 15:10:22 -08002615 if (maskedAction == AMOTION_EVENT_ACTION_DOWN) {
chaviw98318de2021-05-19 16:45:23 -05002616 sp<WindowInfoHandle> foregroundWindowHandle =
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002617 tempTouchState.getFirstForegroundWindowHandle();
Michael Wright3dd60e22019-03-27 22:06:44 +00002618 if (foregroundWindowHandle) {
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00002619 const auto foregroundWindowUid = foregroundWindowHandle->getInfo()->ownerUid;
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002620 for (InputTarget& target : targets) {
2621 if (target.flags.test(InputTarget::Flags::DISPATCH_AS_OUTSIDE)) {
2622 sp<WindowInfoHandle> targetWindow =
2623 getWindowHandleLocked(target.inputChannel->getConnectionToken());
2624 if (targetWindow->getInfo()->ownerUid != foregroundWindowUid) {
2625 target.flags |= InputTarget::Flags::ZERO_COORDS;
Michael Wright3dd60e22019-03-27 22:06:44 +00002626 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002627 }
2628 }
2629 }
2630 }
2631
Harry Cuttsb166c002023-05-09 13:06:05 +00002632 // If this is a touchpad navigation gesture, it needs to only be sent to trusted targets, as we
2633 // only want the system UI to handle these gestures.
2634 const bool isTouchpadNavGesture = isFromSource(entry.source, AINPUT_SOURCE_MOUSE) &&
2635 entry.classification == MotionClassification::MULTI_FINGER_SWIPE;
2636 if (isTouchpadNavGesture) {
2637 filterUntrustedTargets(/* byref */ tempTouchState, /* byref */ targets);
2638 }
2639
Siarhei Vishniakoua235c042023-05-02 09:59:09 -07002640 // Output targets from the touch state.
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002641 for (const TouchedWindow& touchedWindow : tempTouchState.windows) {
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002642 std::bitset<MAX_POINTER_ID + 1> touchingPointers =
2643 touchedWindow.getTouchingPointers(entry.deviceId);
2644 if (touchingPointers.none()) {
Siarhei Vishniakoue0431e42023-01-28 17:01:39 -08002645 continue;
2646 }
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002647 addPointerWindowTargetLocked(touchedWindow.windowHandle, touchedWindow.targetFlags,
2648 touchingPointers,
2649 touchedWindow.getDownTimeInTarget(entry.deviceId), targets);
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +00002650 }
Sam Dubey39d37cf2022-12-07 18:05:35 +00002651
Siarhei Vishniakou580fb3a2023-05-05 15:02:20 -07002652 // During targeted injection, only allow owned targets to receive events
2653 std::erase_if(targets, [&](const InputTarget& target) {
2654 LOG_ALWAYS_FATAL_IF(target.windowHandle == nullptr);
2655 const auto err = verifyTargetedInjection(target.windowHandle, entry);
2656 if (err) {
2657 LOG(WARNING) << "Dropping injected event from " << target.windowHandle->getName()
2658 << ": " << (*err);
2659 return true;
2660 }
2661 return false;
2662 });
2663
Siarhei Vishniakoua235c042023-05-02 09:59:09 -07002664 if (targets.empty()) {
2665 LOG(INFO) << "Dropping event because no targets were found: " << entry.getDescription();
2666 outInjectionResult = InputEventInjectionResult::FAILED;
2667 return {};
2668 }
2669
2670 // If we only have windows getting ACTION_OUTSIDE, then drop the event, because there is no
2671 // window that is actually receiving the entire gesture.
2672 if (std::all_of(targets.begin(), targets.end(), [](const InputTarget& target) {
2673 return target.flags.test(InputTarget::Flags::DISPATCH_AS_OUTSIDE);
2674 })) {
2675 LOG(INFO) << "Dropping event because all windows would just receive ACTION_OUTSIDE: "
2676 << entry.getDescription();
2677 outInjectionResult = InputEventInjectionResult::FAILED;
2678 return {};
2679 }
2680
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +00002681 outInjectionResult = InputEventInjectionResult::SUCCEEDED;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002682
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002683 for (TouchedWindow& touchedWindow : tempTouchState.windows) {
2684 // Targets that we entered in a slippery way will now become AS-IS targets
2685 if (touchedWindow.targetFlags.test(InputTarget::Flags::DISPATCH_AS_SLIPPERY_ENTER)) {
2686 touchedWindow.targetFlags.clear(InputTarget::Flags::DISPATCH_AS_SLIPPERY_ENTER);
2687 touchedWindow.targetFlags |= InputTarget::Flags::DISPATCH_AS_IS;
Siarhei Vishniakou79c32662022-10-25 17:56:25 -07002688 }
Siarhei Vishniakou79c32662022-10-25 17:56:25 -07002689 }
2690
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002691 // Update final pieces of touch state if the injector had permission.
Siarhei Vishniakou79c32662022-10-25 17:56:25 -07002692 if (isHoverAction) {
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002693 if (oldState && oldState->isDown(entry.deviceId)) {
2694 // Started hovering, but the device is already down: reject the hover event
2695 LOG(ERROR) << "Got hover event " << entry.getDescription()
2696 << " but the device is already down " << oldState->dump();
2697 outInjectionResult = InputEventInjectionResult::FAILED;
2698 return {};
Siarhei Vishniakou767917f2020-03-24 20:49:09 -07002699 }
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +00002700 } else if (maskedAction == AMOTION_EVENT_ACTION_UP) {
2701 // Pointer went up.
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07002702 tempTouchState.removeTouchingPointer(entry.deviceId, entry.pointerProperties[0].id);
Siarhei Vishniakoub581f7f2022-12-07 20:23:06 +00002703 } else if (maskedAction == AMOTION_EVENT_ACTION_CANCEL) {
Siarhei Vishniakou79c32662022-10-25 17:56:25 -07002704 // All pointers up or canceled.
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002705 tempTouchState.removeAllPointersForDevice(entry.deviceId);
Siarhei Vishniakou79c32662022-10-25 17:56:25 -07002706 } else if (maskedAction == AMOTION_EVENT_ACTION_POINTER_UP) {
2707 // One pointer went up.
Siarhei Vishniakou5b9766d2023-07-18 14:06:29 -07002708 const int32_t pointerIndex = MotionEvent::getActionIndex(action);
2709 const uint32_t pointerId = entry.pointerProperties[pointerIndex].id;
2710 tempTouchState.removeTouchingPointer(entry.deviceId, pointerId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002711 }
2712
Siarhei Vishniakou79c32662022-10-25 17:56:25 -07002713 // Save changes unless the action was scroll in which case the temporary touch
2714 // state was only valid for this one action.
2715 if (maskedAction != AMOTION_EVENT_ACTION_SCROLL) {
Siarhei Vishniakou40b8fbd2022-11-04 10:50:26 -07002716 if (displayId >= 0) {
Siarhei Vishniakouf372b812023-02-14 18:06:51 -08002717 tempTouchState.clearWindowsWithoutPointers();
Siarhei Vishniakou79c32662022-10-25 17:56:25 -07002718 mTouchStatesByDisplay[displayId] = tempTouchState;
2719 } else {
2720 mTouchStatesByDisplay.erase(displayId);
2721 }
2722 }
2723
Siarhei Vishniakou0b0374d2022-11-17 17:40:53 -08002724 if (tempTouchState.windows.empty()) {
2725 mTouchStatesByDisplay.erase(displayId);
2726 }
2727
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08002728 return targets;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002729}
2730
arthurhung6d4bed92021-03-17 11:59:33 +08002731void InputDispatcher::finishDragAndDrop(int32_t displayId, float x, float y) {
Prabir Pradhand65552b2021-10-07 11:23:50 -07002732 // Prevent stylus interceptor windows from affecting drag and drop behavior for now, until we
2733 // have an explicit reason to support it.
2734 constexpr bool isStylus = false;
2735
Siarhei Vishniakoue1ada272022-11-03 10:47:08 -07002736 sp<WindowInfoHandle> dropWindow =
Harry Cutts33476232023-01-30 19:57:29 +00002737 findTouchedWindowAtLocked(displayId, x, y, isStylus, /*ignoreDragWindow=*/true);
arthurhung6d4bed92021-03-17 11:59:33 +08002738 if (dropWindow) {
2739 vec2 local = dropWindow->getInfo()->transform.transform(x, y);
Prabir Pradhancef936d2021-07-21 16:17:52 +00002740 sendDropWindowCommandLocked(dropWindow->getToken(), local.x, local.y);
Arthur Hung6d0571e2021-04-09 20:18:16 +08002741 } else {
Arthur Hung54745652022-04-20 07:17:41 +00002742 ALOGW("No window found when drop.");
Prabir Pradhancef936d2021-07-21 16:17:52 +00002743 sendDropWindowCommandLocked(nullptr, 0, 0);
arthurhung6d4bed92021-03-17 11:59:33 +08002744 }
2745 mDragState.reset();
2746}
2747
2748void InputDispatcher::addDragEventLocked(const MotionEntry& entry) {
Arthur Hung3915c1f2022-05-31 07:17:17 +00002749 if (!mDragState || mDragState->dragWindow->getInfo()->displayId != entry.displayId) {
arthurhungb89ccb02020-12-30 16:19:01 +08002750 return;
2751 }
2752
arthurhung6d4bed92021-03-17 11:59:33 +08002753 if (!mDragState->isStartDrag) {
2754 mDragState->isStartDrag = true;
2755 mDragState->isStylusButtonDownAtStart =
2756 (entry.buttonState & AMOTION_EVENT_BUTTON_STYLUS_PRIMARY) != 0;
2757 }
2758
Arthur Hung54745652022-04-20 07:17:41 +00002759 // Find the pointer index by id.
2760 int32_t pointerIndex = 0;
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07002761 for (; static_cast<uint32_t>(pointerIndex) < entry.getPointerCount(); pointerIndex++) {
Arthur Hung54745652022-04-20 07:17:41 +00002762 const PointerProperties& pointerProperties = entry.pointerProperties[pointerIndex];
2763 if (pointerProperties.id == mDragState->pointerId) {
2764 break;
arthurhung6d4bed92021-03-17 11:59:33 +08002765 }
Arthur Hung54745652022-04-20 07:17:41 +00002766 }
arthurhung6d4bed92021-03-17 11:59:33 +08002767
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07002768 if (uint32_t(pointerIndex) == entry.getPointerCount()) {
Arthur Hung54745652022-04-20 07:17:41 +00002769 LOG_ALWAYS_FATAL("Should find a valid pointer index by id %d", mDragState->pointerId);
Arthur Hung54745652022-04-20 07:17:41 +00002770 }
2771
2772 const int32_t maskedAction = entry.action & AMOTION_EVENT_ACTION_MASK;
2773 const int32_t x = entry.pointerCoords[pointerIndex].getX();
2774 const int32_t y = entry.pointerCoords[pointerIndex].getY();
2775
2776 switch (maskedAction) {
2777 case AMOTION_EVENT_ACTION_MOVE: {
2778 // Handle the special case : stylus button no longer pressed.
2779 bool isStylusButtonDown =
2780 (entry.buttonState & AMOTION_EVENT_BUTTON_STYLUS_PRIMARY) != 0;
2781 if (mDragState->isStylusButtonDownAtStart && !isStylusButtonDown) {
2782 finishDragAndDrop(entry.displayId, x, y);
2783 return;
2784 }
2785
2786 // Prevent stylus interceptor windows from affecting drag and drop behavior for now,
2787 // until we have an explicit reason to support it.
2788 constexpr bool isStylus = false;
2789
Siarhei Vishniakoue1ada272022-11-03 10:47:08 -07002790 sp<WindowInfoHandle> hoverWindowHandle =
2791 findTouchedWindowAtLocked(entry.displayId, x, y, isStylus,
2792 /*ignoreDragWindow=*/true);
Arthur Hung54745652022-04-20 07:17:41 +00002793 // enqueue drag exit if needed.
2794 if (hoverWindowHandle != mDragState->dragHoverWindowHandle &&
2795 !haveSameToken(hoverWindowHandle, mDragState->dragHoverWindowHandle)) {
2796 if (mDragState->dragHoverWindowHandle != nullptr) {
Harry Cutts33476232023-01-30 19:57:29 +00002797 enqueueDragEventLocked(mDragState->dragHoverWindowHandle, /*isExiting=*/true, x,
Arthur Hung54745652022-04-20 07:17:41 +00002798 y);
2799 }
2800 mDragState->dragHoverWindowHandle = hoverWindowHandle;
2801 }
2802 // enqueue drag location if needed.
2803 if (hoverWindowHandle != nullptr) {
Harry Cutts33476232023-01-30 19:57:29 +00002804 enqueueDragEventLocked(hoverWindowHandle, /*isExiting=*/false, x, y);
Arthur Hung54745652022-04-20 07:17:41 +00002805 }
2806 break;
2807 }
2808
2809 case AMOTION_EVENT_ACTION_POINTER_UP:
Siarhei Vishniakou5b9766d2023-07-18 14:06:29 -07002810 if (MotionEvent::getActionIndex(entry.action) != pointerIndex) {
Arthur Hung54745652022-04-20 07:17:41 +00002811 break;
2812 }
2813 // The drag pointer is up.
2814 [[fallthrough]];
2815 case AMOTION_EVENT_ACTION_UP:
2816 finishDragAndDrop(entry.displayId, x, y);
2817 break;
2818 case AMOTION_EVENT_ACTION_CANCEL: {
2819 ALOGD("Receiving cancel when drag and drop.");
2820 sendDropWindowCommandLocked(nullptr, 0, 0);
2821 mDragState.reset();
2822 break;
2823 }
arthurhungb89ccb02020-12-30 16:19:01 +08002824 }
2825}
2826
Siarhei Vishniakou6c377b32023-05-15 17:03:39 -07002827std::optional<InputTarget> InputDispatcher::createInputTargetLocked(
2828 const sp<android::gui::WindowInfoHandle>& windowHandle,
2829 ftl::Flags<InputTarget::Flags> targetFlags,
2830 std::optional<nsecs_t> firstDownTimeInTarget) const {
2831 std::shared_ptr<InputChannel> inputChannel = getInputChannelLocked(windowHandle->getToken());
2832 if (inputChannel == nullptr) {
2833 ALOGW("Not creating InputTarget for %s, no input channel", windowHandle->getName().c_str());
2834 return {};
2835 }
2836 InputTarget inputTarget;
2837 inputTarget.inputChannel = inputChannel;
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00002838 inputTarget.windowHandle = windowHandle;
Siarhei Vishniakou6c377b32023-05-15 17:03:39 -07002839 inputTarget.flags = targetFlags;
2840 inputTarget.globalScaleFactor = windowHandle->getInfo()->globalScaleFactor;
2841 inputTarget.firstDownTimeInTarget = firstDownTimeInTarget;
2842 const auto& displayInfoIt = mDisplayInfos.find(windowHandle->getInfo()->displayId);
2843 if (displayInfoIt != mDisplayInfos.end()) {
2844 inputTarget.displayTransform = displayInfoIt->second.transform;
2845 } else {
Siarhei Vishniakou580fb3a2023-05-05 15:02:20 -07002846 // DisplayInfo not found for this window on display windowHandle->getInfo()->displayId.
Siarhei Vishniakou6c377b32023-05-15 17:03:39 -07002847 // TODO(b/198444055): Make this an error message after 'setInputWindows' API is removed.
2848 }
2849 return inputTarget;
2850}
2851
chaviw98318de2021-05-19 16:45:23 -05002852void InputDispatcher::addWindowTargetLocked(const sp<WindowInfoHandle>& windowHandle,
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002853 ftl::Flags<InputTarget::Flags> targetFlags,
Vaibhav Devmurari882bd9b2022-06-23 14:54:54 +00002854 std::optional<nsecs_t> firstDownTimeInTarget,
Siarhei Vishniakouf75cddb2022-10-25 10:42:16 -07002855 std::vector<InputTarget>& inputTargets) const {
Chavi Weingarten65f98b82020-01-16 18:56:50 +00002856 std::vector<InputTarget>::iterator it =
2857 std::find_if(inputTargets.begin(), inputTargets.end(),
2858 [&windowHandle](const InputTarget& inputTarget) {
2859 return inputTarget.inputChannel->getConnectionToken() ==
2860 windowHandle->getToken();
2861 });
Chavi Weingarten97b8eec2020-01-09 18:09:08 +00002862
chaviw98318de2021-05-19 16:45:23 -05002863 const WindowInfo* windowInfo = windowHandle->getInfo();
Chavi Weingarten65f98b82020-01-16 18:56:50 +00002864
2865 if (it == inputTargets.end()) {
Siarhei Vishniakou6c377b32023-05-15 17:03:39 -07002866 std::optional<InputTarget> target =
2867 createInputTargetLocked(windowHandle, targetFlags, firstDownTimeInTarget);
2868 if (!target) {
Chavi Weingarten65f98b82020-01-16 18:56:50 +00002869 return;
2870 }
Siarhei Vishniakou6c377b32023-05-15 17:03:39 -07002871 inputTargets.push_back(*target);
Chavi Weingarten65f98b82020-01-16 18:56:50 +00002872 it = inputTargets.end() - 1;
2873 }
2874
Siarhei Vishniakou23d73fb2023-10-29 13:27:46 -07002875 if (it->flags != targetFlags) {
2876 LOG(ERROR) << "Flags don't match! targetFlags=" << targetFlags.string() << ", it=" << *it;
2877 }
2878 if (it->globalScaleFactor != windowInfo->globalScaleFactor) {
2879 LOG(ERROR) << "Mismatch! it->globalScaleFactor=" << it->globalScaleFactor
2880 << ", windowInfo->globalScaleFactor=" << windowInfo->globalScaleFactor;
2881 }
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07002882}
2883
2884void InputDispatcher::addPointerWindowTargetLocked(
2885 const sp<android::gui::WindowInfoHandle>& windowHandle,
2886 ftl::Flags<InputTarget::Flags> targetFlags, std::bitset<MAX_POINTER_ID + 1> pointerIds,
2887 std::optional<nsecs_t> firstDownTimeInTarget, std::vector<InputTarget>& inputTargets) const
2888 REQUIRES(mLock) {
2889 if (pointerIds.none()) {
2890 for (const auto& target : inputTargets) {
2891 LOG(INFO) << "Target: " << target;
2892 }
2893 LOG(FATAL) << "No pointers specified for " << windowHandle->getName();
2894 return;
2895 }
2896 std::vector<InputTarget>::iterator it =
2897 std::find_if(inputTargets.begin(), inputTargets.end(),
2898 [&windowHandle](const InputTarget& inputTarget) {
2899 return inputTarget.inputChannel->getConnectionToken() ==
2900 windowHandle->getToken();
2901 });
2902
2903 // This is a hack, because the actual entry could potentially be an ACTION_DOWN event that
2904 // causes a HOVER_EXIT to be generated. That means that the same entry of ACTION_DOWN would
2905 // have DISPATCH_AS_HOVER_EXIT and DISPATCH_AS_IS. And therefore, we have to create separate
2906 // input targets for hovering pointers and for touching pointers.
2907 // If we picked an existing input target above, but it's for HOVER_EXIT - let's use a new
2908 // target instead.
2909 if (it != inputTargets.end() && it->flags.test(InputTarget::Flags::DISPATCH_AS_HOVER_EXIT)) {
2910 // Force the code below to create a new input target
2911 it = inputTargets.end();
2912 }
2913
2914 const WindowInfo* windowInfo = windowHandle->getInfo();
2915
2916 if (it == inputTargets.end()) {
2917 std::optional<InputTarget> target =
2918 createInputTargetLocked(windowHandle, targetFlags, firstDownTimeInTarget);
2919 if (!target) {
2920 return;
2921 }
2922 inputTargets.push_back(*target);
2923 it = inputTargets.end() - 1;
2924 }
2925
Siarhei Vishniakou4bd0b7c2023-10-27 00:51:14 -07002926 if (it->flags != targetFlags) {
Siarhei Vishniakou23d73fb2023-10-29 13:27:46 -07002927 LOG(ERROR) << "Flags don't match! targetFlags=" << targetFlags.string() << ", it=" << *it;
Siarhei Vishniakou4bd0b7c2023-10-27 00:51:14 -07002928 }
Siarhei Vishniakou23d73fb2023-10-29 13:27:46 -07002929 if (it->globalScaleFactor != windowInfo->globalScaleFactor) {
2930 LOG(ERROR) << "Mismatch! it->globalScaleFactor=" << it->globalScaleFactor
2931 << ", windowInfo->globalScaleFactor=" << windowInfo->globalScaleFactor;
2932 }
Chavi Weingarten65f98b82020-01-16 18:56:50 +00002933
chaviw1ff3d1e2020-07-01 15:53:47 -07002934 it->addPointers(pointerIds, windowInfo->transform);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002935}
2936
Michael Wright3dd60e22019-03-27 22:06:44 +00002937void InputDispatcher::addGlobalMonitoringTargetsLocked(std::vector<InputTarget>& inputTargets,
Prabir Pradhan0a99c922021-09-03 08:27:53 -07002938 int32_t displayId) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002939 auto monitorsIt = mGlobalMonitorsByDisplay.find(displayId);
2940 if (monitorsIt == mGlobalMonitorsByDisplay.end()) return;
Michael Wright3dd60e22019-03-27 22:06:44 +00002941
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002942 for (const Monitor& monitor : selectResponsiveMonitorsLocked(monitorsIt->second)) {
2943 InputTarget target;
2944 target.inputChannel = monitor.inputChannel;
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002945 target.flags = InputTarget::Flags::DISPATCH_AS_IS;
Vaibhav Devmurari882bd9b2022-06-23 14:54:54 +00002946 // target.firstDownTimeInTarget is not set for global monitors. It is only required in split
2947 // touch and global monitoring works as intended even without setting firstDownTimeInTarget
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002948 if (const auto& it = mDisplayInfos.find(displayId); it != mDisplayInfos.end()) {
2949 target.displayTransform = it->second.transform;
Arthur Hung2fbf37f2018-09-13 18:16:41 +08002950 }
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002951 target.setDefaultPointerTransform(target.displayTransform);
2952 inputTargets.push_back(target);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002953 }
2954}
2955
Robert Carrc9bf1d32020-04-13 17:21:08 -07002956/**
2957 * Indicate whether one window handle should be considered as obscuring
2958 * another window handle. We only check a few preconditions. Actually
2959 * checking the bounds is left to the caller.
2960 */
chaviw98318de2021-05-19 16:45:23 -05002961static bool canBeObscuredBy(const sp<WindowInfoHandle>& windowHandle,
2962 const sp<WindowInfoHandle>& otherHandle) {
Robert Carrc9bf1d32020-04-13 17:21:08 -07002963 // Compare by token so cloned layers aren't counted
2964 if (haveSameToken(windowHandle, otherHandle)) {
2965 return false;
2966 }
2967 auto info = windowHandle->getInfo();
2968 auto otherInfo = otherHandle->getInfo();
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08002969 if (otherInfo->inputConfig.test(WindowInfo::InputConfig::NOT_VISIBLE)) {
Robert Carrc9bf1d32020-04-13 17:21:08 -07002970 return false;
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08002971 } else if (otherInfo->alpha == 0 &&
2972 otherInfo->inputConfig.test(WindowInfo::InputConfig::NOT_TOUCHABLE)) {
Bernardo Rufino653d2e02020-10-20 17:32:40 +00002973 // Those act as if they were invisible, so we don't need to flag them.
2974 // We do want to potentially flag touchable windows even if they have 0
2975 // opacity, since they can consume touches and alter the effects of the
2976 // user interaction (eg. apps that rely on
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08002977 // Flags::WINDOW_IS_PARTIALLY_OBSCURED should still be told about those
Bernardo Rufino653d2e02020-10-20 17:32:40 +00002978 // windows), hence we also check for FLAG_NOT_TOUCHABLE.
2979 return false;
Bernardo Rufino8007daf2020-09-22 09:40:01 +00002980 } else if (info->ownerUid == otherInfo->ownerUid) {
2981 // If ownerUid is the same we don't generate occlusion events as there
2982 // is no security boundary within an uid.
Robert Carrc9bf1d32020-04-13 17:21:08 -07002983 return false;
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08002984 } else if (otherInfo->inputConfig.test(gui::WindowInfo::InputConfig::TRUSTED_OVERLAY)) {
Robert Carrc9bf1d32020-04-13 17:21:08 -07002985 return false;
2986 } else if (otherInfo->displayId != info->displayId) {
2987 return false;
2988 }
2989 return true;
2990}
2991
Bernardo Rufinoea97d182020-08-19 14:43:14 +01002992/**
2993 * Returns touch occlusion information in the form of TouchOcclusionInfo. To check if the touch is
2994 * untrusted, one should check:
2995 *
2996 * 1. If result.hasBlockingOcclusion is true.
2997 * If it's, it means the touch should be blocked due to a window with occlusion mode of
2998 * BLOCK_UNTRUSTED.
2999 *
3000 * 2. If result.obscuringOpacity > mMaximumObscuringOpacityForTouch.
3001 * If it is (and 1 is false), then the touch should be blocked because a stack of windows
3002 * (possibly only one) with occlusion mode of USE_OPACITY from one UID resulted in a composed
3003 * obscuring opacity above the threshold. Note that if there was no window of occlusion mode
3004 * USE_OPACITY, result.obscuringOpacity would've been 0 and since
3005 * mMaximumObscuringOpacityForTouch >= 0, the condition above would never be true.
3006 *
3007 * If neither of those is true, then it means the touch can be allowed.
3008 */
3009InputDispatcher::TouchOcclusionInfo InputDispatcher::computeTouchOcclusionInfoLocked(
chaviw98318de2021-05-19 16:45:23 -05003010 const sp<WindowInfoHandle>& windowHandle, int32_t x, int32_t y) const {
3011 const WindowInfo* windowInfo = windowHandle->getInfo();
Bernardo Rufino4bae0ac2020-10-14 18:33:46 +00003012 int32_t displayId = windowInfo->displayId;
chaviw98318de2021-05-19 16:45:23 -05003013 const std::vector<sp<WindowInfoHandle>>& windowHandles = getWindowHandlesLocked(displayId);
Bernardo Rufinoea97d182020-08-19 14:43:14 +01003014 TouchOcclusionInfo info;
3015 info.hasBlockingOcclusion = false;
3016 info.obscuringOpacity = 0;
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00003017 info.obscuringUid = gui::Uid::INVALID;
3018 std::map<gui::Uid, float> opacityByUid;
chaviw98318de2021-05-19 16:45:23 -05003019 for (const sp<WindowInfoHandle>& otherHandle : windowHandles) {
Bernardo Rufinoea97d182020-08-19 14:43:14 +01003020 if (windowHandle == otherHandle) {
3021 break; // All future windows are below us. Exit early.
3022 }
chaviw98318de2021-05-19 16:45:23 -05003023 const WindowInfo* otherInfo = otherHandle->getInfo();
Bernardo Rufino1ff9d592021-01-18 16:58:57 +00003024 if (canBeObscuredBy(windowHandle, otherHandle) && otherInfo->frameContainsPoint(x, y) &&
3025 !haveSameApplicationToken(windowInfo, otherInfo)) {
Bernardo Rufino4bae0ac2020-10-14 18:33:46 +00003026 if (DEBUG_TOUCH_OCCLUSION) {
3027 info.debugInfo.push_back(
Harry Cutts101ee9b2023-07-06 18:04:14 +00003028 dumpWindowForTouchOcclusion(otherInfo, /*isTouchedWindow=*/false));
Bernardo Rufino4bae0ac2020-10-14 18:33:46 +00003029 }
Bernardo Rufinoea97d182020-08-19 14:43:14 +01003030 // canBeObscuredBy() has returned true above, which means this window is untrusted, so
3031 // we perform the checks below to see if the touch can be propagated or not based on the
3032 // window's touch occlusion mode
3033 if (otherInfo->touchOcclusionMode == TouchOcclusionMode::BLOCK_UNTRUSTED) {
3034 info.hasBlockingOcclusion = true;
3035 info.obscuringUid = otherInfo->ownerUid;
3036 info.obscuringPackage = otherInfo->packageName;
3037 break;
3038 }
3039 if (otherInfo->touchOcclusionMode == TouchOcclusionMode::USE_OPACITY) {
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00003040 const auto uid = otherInfo->ownerUid;
Bernardo Rufinoea97d182020-08-19 14:43:14 +01003041 float opacity =
3042 (opacityByUid.find(uid) == opacityByUid.end()) ? 0 : opacityByUid[uid];
3043 // Given windows A and B:
3044 // opacity(A, B) = 1 - [1 - opacity(A)] * [1 - opacity(B)]
3045 opacity = 1 - (1 - opacity) * (1 - otherInfo->alpha);
3046 opacityByUid[uid] = opacity;
3047 if (opacity > info.obscuringOpacity) {
3048 info.obscuringOpacity = opacity;
3049 info.obscuringUid = uid;
3050 info.obscuringPackage = otherInfo->packageName;
3051 }
3052 }
3053 }
3054 }
Bernardo Rufino4bae0ac2020-10-14 18:33:46 +00003055 if (DEBUG_TOUCH_OCCLUSION) {
Harry Cutts101ee9b2023-07-06 18:04:14 +00003056 info.debugInfo.push_back(dumpWindowForTouchOcclusion(windowInfo, /*isTouchedWindow=*/true));
Bernardo Rufino4bae0ac2020-10-14 18:33:46 +00003057 }
Bernardo Rufinoea97d182020-08-19 14:43:14 +01003058 return info;
3059}
3060
chaviw98318de2021-05-19 16:45:23 -05003061std::string InputDispatcher::dumpWindowForTouchOcclusion(const WindowInfo* info,
Bernardo Rufino4bae0ac2020-10-14 18:33:46 +00003062 bool isTouchedWindow) const {
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00003063 return StringPrintf(INDENT2 "* %spackage=%s/%s, id=%" PRId32 ", mode=%s, alpha=%.2f, "
Prabir Pradhan51e7db02022-02-07 06:02:57 -08003064 "frame=[%" PRId32 ",%" PRId32 "][%" PRId32 ",%" PRId32
3065 "], touchableRegion=%s, window={%s}, inputConfig={%s}, "
3066 "hasToken=%s, applicationInfo.name=%s, applicationInfo.token=%s\n",
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08003067 isTouchedWindow ? "[TOUCHED] " : "", info->packageName.c_str(),
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00003068 info->ownerUid.toString().c_str(), info->id,
Chavi Weingarten7f019192023-08-08 20:39:01 +00003069 toString(info->touchOcclusionMode).c_str(), info->alpha, info->frame.left,
3070 info->frame.top, info->frame.right, info->frame.bottom,
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00003071 dumpRegion(info->touchableRegion).c_str(), info->name.c_str(),
3072 info->inputConfig.string().c_str(), toString(info->token != nullptr),
3073 info->applicationInfo.name.c_str(),
Siarhei Vishniakou63b63612023-04-12 11:00:23 -07003074 binderToString(info->applicationInfo.token).c_str());
Bernardo Rufino4bae0ac2020-10-14 18:33:46 +00003075}
3076
Bernardo Rufinoea97d182020-08-19 14:43:14 +01003077bool InputDispatcher::isTouchTrustedLocked(const TouchOcclusionInfo& occlusionInfo) const {
3078 if (occlusionInfo.hasBlockingOcclusion) {
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00003079 ALOGW("Untrusted touch due to occlusion by %s/%s", occlusionInfo.obscuringPackage.c_str(),
3080 occlusionInfo.obscuringUid.toString().c_str());
Bernardo Rufinoea97d182020-08-19 14:43:14 +01003081 return false;
3082 }
3083 if (occlusionInfo.obscuringOpacity > mMaximumObscuringOpacityForTouch) {
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00003084 ALOGW("Untrusted touch due to occlusion by %s/%s (obscuring opacity = "
Bernardo Rufinoea97d182020-08-19 14:43:14 +01003085 "%.2f, maximum allowed = %.2f)",
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00003086 occlusionInfo.obscuringPackage.c_str(), occlusionInfo.obscuringUid.toString().c_str(),
Bernardo Rufinoea97d182020-08-19 14:43:14 +01003087 occlusionInfo.obscuringOpacity, mMaximumObscuringOpacityForTouch);
3088 return false;
3089 }
3090 return true;
3091}
3092
chaviw98318de2021-05-19 16:45:23 -05003093bool InputDispatcher::isWindowObscuredAtPointLocked(const sp<WindowInfoHandle>& windowHandle,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003094 int32_t x, int32_t y) const {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003095 int32_t displayId = windowHandle->getInfo()->displayId;
chaviw98318de2021-05-19 16:45:23 -05003096 const std::vector<sp<WindowInfoHandle>>& windowHandles = getWindowHandlesLocked(displayId);
3097 for (const sp<WindowInfoHandle>& otherHandle : windowHandles) {
Robert Carrc9bf1d32020-04-13 17:21:08 -07003098 if (windowHandle == otherHandle) {
3099 break; // All future windows are below us. Exit early.
Michael Wrightd02c5b62014-02-10 15:10:22 -08003100 }
chaviw98318de2021-05-19 16:45:23 -05003101 const WindowInfo* otherInfo = otherHandle->getInfo();
Robert Carrc9bf1d32020-04-13 17:21:08 -07003102 if (canBeObscuredBy(windowHandle, otherHandle) &&
minchelif28cc4e2020-03-19 11:18:11 +08003103 otherInfo->frameContainsPoint(x, y)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003104 return true;
3105 }
3106 }
3107 return false;
3108}
3109
chaviw98318de2021-05-19 16:45:23 -05003110bool InputDispatcher::isWindowObscuredLocked(const sp<WindowInfoHandle>& windowHandle) const {
Michael Wrightcdcd8f22016-03-22 16:52:13 -07003111 int32_t displayId = windowHandle->getInfo()->displayId;
chaviw98318de2021-05-19 16:45:23 -05003112 const std::vector<sp<WindowInfoHandle>>& windowHandles = getWindowHandlesLocked(displayId);
3113 const WindowInfo* windowInfo = windowHandle->getInfo();
3114 for (const sp<WindowInfoHandle>& otherHandle : windowHandles) {
Robert Carrc9bf1d32020-04-13 17:21:08 -07003115 if (windowHandle == otherHandle) {
3116 break; // All future windows are below us. Exit early.
Michael Wrightcdcd8f22016-03-22 16:52:13 -07003117 }
chaviw98318de2021-05-19 16:45:23 -05003118 const WindowInfo* otherInfo = otherHandle->getInfo();
Robert Carrc9bf1d32020-04-13 17:21:08 -07003119 if (canBeObscuredBy(windowHandle, otherHandle) &&
minchelif28cc4e2020-03-19 11:18:11 +08003120 otherInfo->overlaps(windowInfo)) {
Michael Wrightcdcd8f22016-03-22 16:52:13 -07003121 return true;
3122 }
3123 }
3124 return false;
3125}
3126
Siarhei Vishniakou61291d42019-02-11 18:13:20 -08003127std::string InputDispatcher::getApplicationWindowLabel(
chaviw98318de2021-05-19 16:45:23 -05003128 const InputApplicationHandle* applicationHandle, const sp<WindowInfoHandle>& windowHandle) {
Yi Kong9b14ac62018-07-17 13:48:38 -07003129 if (applicationHandle != nullptr) {
3130 if (windowHandle != nullptr) {
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07003131 return applicationHandle->getName() + " - " + windowHandle->getName();
Michael Wrightd02c5b62014-02-10 15:10:22 -08003132 } else {
3133 return applicationHandle->getName();
3134 }
Yi Kong9b14ac62018-07-17 13:48:38 -07003135 } else if (windowHandle != nullptr) {
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07003136 return windowHandle->getInfo()->applicationInfo.name + " - " + windowHandle->getName();
Michael Wrightd02c5b62014-02-10 15:10:22 -08003137 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08003138 return "<unknown application or window>";
Michael Wrightd02c5b62014-02-10 15:10:22 -08003139 }
3140}
3141
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003142void InputDispatcher::pokeUserActivityLocked(const EventEntry& eventEntry) {
Antonio Kantekf16f2832021-09-28 04:39:20 +00003143 if (!isUserActivityEvent(eventEntry)) {
3144 // Not poking user activity if the event type does not represent a user activity
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01003145 return;
3146 }
Tiger Huang721e26f2018-07-24 22:26:19 +08003147 int32_t displayId = getTargetDisplayId(eventEntry);
chaviw98318de2021-05-19 16:45:23 -05003148 sp<WindowInfoHandle> focusedWindowHandle = getFocusedWindowHandleLocked(displayId);
Josep del Riob3981622023-04-18 15:49:45 +00003149 const WindowInfo* windowDisablingUserActivityInfo = nullptr;
Tiger Huang721e26f2018-07-24 22:26:19 +08003150 if (focusedWindowHandle != nullptr) {
chaviw98318de2021-05-19 16:45:23 -05003151 const WindowInfo* info = focusedWindowHandle->getInfo();
Prabir Pradhan51e7db02022-02-07 06:02:57 -08003152 if (info->inputConfig.test(WindowInfo::InputConfig::DISABLE_USER_ACTIVITY)) {
Josep del Riob3981622023-04-18 15:49:45 +00003153 windowDisablingUserActivityInfo = info;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003154 }
3155 }
3156
3157 int32_t eventType = USER_ACTIVITY_EVENT_OTHER;
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003158 switch (eventEntry.type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003159 case EventEntry::Type::MOTION: {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003160 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(eventEntry);
3161 if (motionEntry.action == AMOTION_EVENT_ACTION_CANCEL) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003162 return;
3163 }
Josep del Riob3981622023-04-18 15:49:45 +00003164 if (windowDisablingUserActivityInfo != nullptr) {
3165 if (DEBUG_DISPATCH_CYCLE) {
3166 ALOGD("Not poking user activity: disabled by window '%s'.",
3167 windowDisablingUserActivityInfo->name.c_str());
3168 }
3169 return;
3170 }
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003171 if (MotionEvent::isTouchEvent(motionEntry.source, motionEntry.action)) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003172 eventType = USER_ACTIVITY_EVENT_TOUCH;
3173 }
3174 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003175 }
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003176 case EventEntry::Type::KEY: {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003177 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(eventEntry);
3178 if (keyEntry.flags & AKEY_EVENT_FLAG_CANCELED) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003179 return;
3180 }
Josep del Riob3981622023-04-18 15:49:45 +00003181 // If the key code is unknown, we don't consider it user activity
3182 if (keyEntry.keyCode == AKEYCODE_UNKNOWN) {
3183 return;
3184 }
3185 // Don't inhibit events that were intercepted or are not passed to
3186 // the apps, like system shortcuts
3187 if (windowDisablingUserActivityInfo != nullptr &&
3188 keyEntry.interceptKeyResult != KeyEntry::InterceptKeyResult::SKIP &&
3189 keyEntry.policyFlags & POLICY_FLAG_PASS_TO_USER) {
3190 if (DEBUG_DISPATCH_CYCLE) {
3191 ALOGD("Not poking user activity: disabled by window '%s'.",
3192 windowDisablingUserActivityInfo->name.c_str());
3193 }
3194 return;
3195 }
3196
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003197 eventType = USER_ACTIVITY_EVENT_BUTTON;
3198 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003199 }
Antonio Kantekf16f2832021-09-28 04:39:20 +00003200 default: {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003201 LOG_ALWAYS_FATAL("%s events are not user activity",
Dominik Laskowski75788452021-02-09 18:51:25 -08003202 ftl::enum_string(eventEntry.type).c_str());
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003203 break;
3204 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003205 }
3206
Prabir Pradhancef936d2021-07-21 16:17:52 +00003207 auto command = [this, eventTime = eventEntry.eventTime, eventType, displayId]()
3208 REQUIRES(mLock) {
3209 scoped_unlock unlock(mLock);
Prabir Pradhana41d2442023-04-20 21:30:40 +00003210 mPolicy.pokeUserActivity(eventTime, eventType, displayId);
Prabir Pradhancef936d2021-07-21 16:17:52 +00003211 };
3212 postCommandLocked(std::move(command));
Michael Wrightd02c5b62014-02-10 15:10:22 -08003213}
3214
3215void InputDispatcher::prepareDispatchCycleLocked(nsecs_t currentTime,
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003216 const std::shared_ptr<Connection>& connection,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003217 std::shared_ptr<EventEntry> eventEntry,
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08003218 const InputTarget& inputTarget) {
Prabir Pradhan2dac8b82023-09-06 01:11:51 +00003219 ATRACE_NAME_IF(ATRACE_ENABLED(),
3220 StringPrintf("prepareDispatchCycleLocked(inputChannel=%s, id=0x%" PRIx32 ")",
3221 connection->getInputChannelName().c_str(), eventEntry->id));
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003222 if (DEBUG_DISPATCH_CYCLE) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003223 ALOGD("channel '%s' ~ prepareDispatchCycle - flags=%s, "
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08003224 "globalScaleFactor=%f, pointerIds=%s %s",
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003225 connection->getInputChannelName().c_str(), inputTarget.flags.string().c_str(),
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08003226 inputTarget.globalScaleFactor, bitsetToString(inputTarget.pointerIds).c_str(),
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003227 inputTarget.getPointerInfoString().c_str());
3228 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003229
3230 // Skip this event if the connection status is not normal.
3231 // We don't want to enqueue additional outbound events if the connection is broken.
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08003232 if (connection->status != Connection::Status::NORMAL) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003233 if (DEBUG_DISPATCH_CYCLE) {
3234 ALOGD("channel '%s' ~ Dropping event because the channel status is %s",
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08003235 connection->getInputChannelName().c_str(),
3236 ftl::enum_string(connection->status).c_str());
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003237 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003238 return;
3239 }
3240
3241 // Split a motion event if needed.
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003242 if (inputTarget.flags.test(InputTarget::Flags::SPLIT)) {
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08003243 LOG_ALWAYS_FATAL_IF(eventEntry->type != EventEntry::Type::MOTION,
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003244 "Entry type %s should not have Flags::SPLIT",
Dominik Laskowski75788452021-02-09 18:51:25 -08003245 ftl::enum_string(eventEntry->type).c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08003246
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003247 const MotionEntry& originalMotionEntry = static_cast<const MotionEntry&>(*eventEntry);
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07003248 if (inputTarget.pointerIds.count() != originalMotionEntry.getPointerCount()) {
Siarhei Vishniakou16e4fa02023-02-16 17:48:56 -08003249 if (!inputTarget.firstDownTimeInTarget.has_value()) {
3250 logDispatchStateLocked();
3251 LOG(FATAL) << "Splitting motion events requires a down time to be set for the "
3252 "target on connection "
3253 << connection->getInputChannelName() << " for "
3254 << originalMotionEntry.getDescription();
3255 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003256 std::unique_ptr<MotionEntry> splitMotionEntry =
Vaibhav Devmurari882bd9b2022-06-23 14:54:54 +00003257 splitMotionEvent(originalMotionEntry, inputTarget.pointerIds,
3258 inputTarget.firstDownTimeInTarget.value());
Michael Wrightd02c5b62014-02-10 15:10:22 -08003259 if (!splitMotionEntry) {
3260 return; // split event was dropped
3261 }
Arthur Hungb3307ee2021-10-14 10:57:37 +00003262 if (splitMotionEntry->action == AMOTION_EVENT_ACTION_CANCEL) {
3263 std::string reason = std::string("reason=pointer cancel on split window");
3264 android_log_event_list(LOGTAG_INPUT_CANCEL)
3265 << connection->getInputChannelName().c_str() << reason << LOG_ID_EVENTS;
3266 }
Siarhei Vishniakou86587282019-09-09 18:20:15 +01003267 if (DEBUG_FOCUS) {
3268 ALOGD("channel '%s' ~ Split motion event.",
3269 connection->getInputChannelName().c_str());
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003270 logOutboundMotionDetails(" ", *splitMotionEntry);
Siarhei Vishniakou86587282019-09-09 18:20:15 +01003271 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003272 enqueueDispatchEntriesLocked(currentTime, connection, std::move(splitMotionEntry),
3273 inputTarget);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003274 return;
3275 }
3276 }
3277
3278 // Not splitting. Enqueue dispatch entries for the event as is.
3279 enqueueDispatchEntriesLocked(currentTime, connection, eventEntry, inputTarget);
3280}
3281
3282void InputDispatcher::enqueueDispatchEntriesLocked(nsecs_t currentTime,
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003283 const std::shared_ptr<Connection>& connection,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003284 std::shared_ptr<EventEntry> eventEntry,
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08003285 const InputTarget& inputTarget) {
Prabir Pradhan2dac8b82023-09-06 01:11:51 +00003286 ATRACE_NAME_IF(ATRACE_ENABLED(),
3287 StringPrintf("enqueueDispatchEntriesLocked(inputChannel=%s, id=0x%" PRIx32 ")",
3288 connection->getInputChannelName().c_str(), eventEntry->id));
Siarhei Vishniakou5cee1e32022-11-29 12:35:39 -08003289 LOG_ALWAYS_FATAL_IF(!inputTarget.flags.any(InputTarget::DISPATCH_MASK),
3290 "No dispatch flags are set for %s", eventEntry->getDescription().c_str());
Michael Wright3dd60e22019-03-27 22:06:44 +00003291
hongzuo liu95785e22022-09-06 02:51:35 +00003292 const bool wasEmpty = connection->outboundQueue.empty();
Michael Wrightd02c5b62014-02-10 15:10:22 -08003293
3294 // Enqueue dispatch entries for the requested modes.
chaviw8c9cf542019-03-25 13:02:48 -07003295 enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003296 InputTarget::Flags::DISPATCH_AS_HOVER_EXIT);
chaviw8c9cf542019-03-25 13:02:48 -07003297 enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003298 InputTarget::Flags::DISPATCH_AS_OUTSIDE);
chaviw8c9cf542019-03-25 13:02:48 -07003299 enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003300 InputTarget::Flags::DISPATCH_AS_HOVER_ENTER);
chaviw8c9cf542019-03-25 13:02:48 -07003301 enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003302 InputTarget::Flags::DISPATCH_AS_IS);
chaviw8c9cf542019-03-25 13:02:48 -07003303 enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003304 InputTarget::Flags::DISPATCH_AS_SLIPPERY_EXIT);
chaviw8c9cf542019-03-25 13:02:48 -07003305 enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003306 InputTarget::Flags::DISPATCH_AS_SLIPPERY_ENTER);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003307
3308 // If the outbound queue was previously empty, start the dispatch cycle going.
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07003309 if (wasEmpty && !connection->outboundQueue.empty()) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003310 startDispatchCycleLocked(currentTime, connection);
3311 }
3312}
3313
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003314void InputDispatcher::enqueueDispatchEntryLocked(const std::shared_ptr<Connection>& connection,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003315 std::shared_ptr<EventEntry> eventEntry,
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08003316 const InputTarget& inputTarget,
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003317 ftl::Flags<InputTarget::Flags> dispatchMode) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003318 ftl::Flags<InputTarget::Flags> inputTargetFlags = inputTarget.flags;
3319 if (!inputTargetFlags.any(dispatchMode)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003320 return;
3321 }
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003322
3323 inputTargetFlags.clear(InputTarget::DISPATCH_MASK);
3324 inputTargetFlags |= dispatchMode;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003325
3326 // This is a new event.
3327 // Enqueue a new dispatch entry onto the outbound queue for this connection.
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08003328 std::unique_ptr<DispatchEntry> dispatchEntry =
Chavi Weingarten65f98b82020-01-16 18:56:50 +00003329 createDispatchEntry(inputTarget, eventEntry, inputTargetFlags);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003330
Chavi Weingarten65f98b82020-01-16 18:56:50 +00003331 // Use the eventEntry from dispatchEntry since the entry may have changed and can now be a
3332 // different EventEntry than what was passed in.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003333 EventEntry& newEntry = *(dispatchEntry->eventEntry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003334 // Apply target flags and update the connection's input state.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003335 switch (newEntry.type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003336 case EventEntry::Type::KEY: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003337 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(newEntry);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003338 if (!connection->inputState.trackKey(keyEntry, dispatchEntry->resolvedAction,
3339 dispatchEntry->resolvedFlags)) {
Siarhei Vishniakouc94dafe2023-05-26 10:24:19 -07003340 LOG(WARNING) << "channel " << connection->getInputChannelName()
3341 << "~ dropping inconsistent event: " << *dispatchEntry;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003342 return; // skip the inconsistent event
3343 }
3344 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003345 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003346
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003347 case EventEntry::Type::MOTION: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003348 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(newEntry);
Garfield Tanff1f1bb2020-01-28 13:24:04 -08003349 // Assign a default value to dispatchEntry that will never be generated by InputReader,
3350 // and assign a InputDispatcher value if it doesn't change in the if-else chain below.
3351 constexpr int32_t DEFAULT_RESOLVED_EVENT_ID =
3352 static_cast<int32_t>(IdGenerator::Source::OTHER);
3353 dispatchEntry->resolvedEventId = DEFAULT_RESOLVED_EVENT_ID;
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003354 if (dispatchMode.test(InputTarget::Flags::DISPATCH_AS_OUTSIDE)) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003355 dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_OUTSIDE;
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003356 } else if (dispatchMode.test(InputTarget::Flags::DISPATCH_AS_HOVER_EXIT)) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003357 dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_HOVER_EXIT;
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003358 } else if (dispatchMode.test(InputTarget::Flags::DISPATCH_AS_HOVER_ENTER)) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003359 dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_HOVER_ENTER;
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003360 } else if (dispatchMode.test(InputTarget::Flags::DISPATCH_AS_SLIPPERY_EXIT)) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003361 dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_CANCEL;
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003362 } else if (dispatchMode.test(InputTarget::Flags::DISPATCH_AS_SLIPPERY_ENTER)) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003363 dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_DOWN;
3364 } else {
Garfield Tanff1f1bb2020-01-28 13:24:04 -08003365 dispatchEntry->resolvedEventId = motionEntry.id;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003366 }
3367 if (dispatchEntry->resolvedAction == AMOTION_EVENT_ACTION_HOVER_MOVE &&
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003368 !connection->inputState.isHovering(motionEntry.deviceId, motionEntry.source,
3369 motionEntry.displayId)) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003370 if (DEBUG_DISPATCH_CYCLE) {
3371 ALOGD("channel '%s' ~ enqueueDispatchEntryLocked: filling in missing hover "
3372 "enter event",
3373 connection->getInputChannelName().c_str());
3374 }
Siarhei Vishniakouf2652122021-03-05 21:39:46 +00003375 // We keep the 'resolvedEventId' here equal to the original 'motionEntry.id' because
3376 // this is a one-to-one event conversion.
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003377 dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_HOVER_ENTER;
3378 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003379
Siarhei Vishniakou1ae72f12023-01-29 12:55:30 -08003380 if (dispatchEntry->resolvedAction == AMOTION_EVENT_ACTION_CANCEL) {
3381 dispatchEntry->resolvedFlags |= AMOTION_EVENT_FLAG_CANCELED;
3382 }
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003383 if (dispatchEntry->targetFlags.test(InputTarget::Flags::WINDOW_IS_OBSCURED)) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003384 dispatchEntry->resolvedFlags |= AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED;
3385 }
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003386 if (dispatchEntry->targetFlags.test(InputTarget::Flags::WINDOW_IS_PARTIALLY_OBSCURED)) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003387 dispatchEntry->resolvedFlags |= AMOTION_EVENT_FLAG_WINDOW_IS_PARTIALLY_OBSCURED;
3388 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003389
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07003390 // Check if we need to cancel any of the ongoing gestures. We don't support multiple
3391 // devices being active at the same time in the same window, so if a new device is
3392 // active, cancel the gesture from the old device.
3393
3394 std::unique_ptr<EventEntry> cancelEvent =
3395 connection->inputState
3396 .cancelConflictingInputStream(motionEntry,
3397 dispatchEntry->resolvedAction);
3398 if (cancelEvent != nullptr) {
3399 LOG(INFO) << "Canceling pointers for device " << motionEntry.deviceId << " in "
3400 << connection->getInputChannelName() << " with event "
3401 << cancelEvent->getDescription();
3402 std::unique_ptr<DispatchEntry> cancelDispatchEntry =
3403 createDispatchEntry(inputTarget, std::move(cancelEvent),
3404 InputTarget::Flags::DISPATCH_AS_IS);
3405
3406 // Send these cancel events to the queue before sending the event from the new
3407 // device.
3408 connection->outboundQueue.emplace_back(std::move(cancelDispatchEntry));
3409 }
3410
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003411 if (!connection->inputState.trackMotion(motionEntry, dispatchEntry->resolvedAction,
3412 dispatchEntry->resolvedFlags)) {
Siarhei Vishniakouc94dafe2023-05-26 10:24:19 -07003413 LOG(WARNING) << "channel " << connection->getInputChannelName()
3414 << "~ dropping inconsistent event: " << *dispatchEntry;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003415 return; // skip the inconsistent event
3416 }
3417
Garfield Tanff1f1bb2020-01-28 13:24:04 -08003418 dispatchEntry->resolvedEventId =
3419 dispatchEntry->resolvedEventId == DEFAULT_RESOLVED_EVENT_ID
3420 ? mIdGenerator.nextId()
3421 : motionEntry.id;
3422 if (ATRACE_ENABLED() && dispatchEntry->resolvedEventId != motionEntry.id) {
3423 std::string message = StringPrintf("Transmute MotionEvent(id=0x%" PRIx32
3424 ") to MotionEvent(id=0x%" PRIx32 ").",
3425 motionEntry.id, dispatchEntry->resolvedEventId);
3426 ATRACE_NAME(message.c_str());
3427 }
3428
Prabir Pradhan47cf0a02021-03-11 20:30:57 -08003429 if ((motionEntry.flags & AMOTION_EVENT_FLAG_NO_FOCUS_CHANGE) &&
3430 (motionEntry.policyFlags & POLICY_FLAG_TRUSTED)) {
3431 // Skip reporting pointer down outside focus to the policy.
3432 break;
3433 }
3434
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003435 dispatchPointerDownOutsideFocus(motionEntry.source, dispatchEntry->resolvedAction,
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08003436 inputTarget.inputChannel->getConnectionToken());
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003437
3438 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003439 }
Prabir Pradhan99987712020-11-10 18:43:05 -08003440 case EventEntry::Type::FOCUS:
Antonio Kantek7242d8b2021-08-05 16:07:20 -07003441 case EventEntry::Type::TOUCH_MODE_CHANGED:
arthurhungb89ccb02020-12-30 16:19:01 +08003442 case EventEntry::Type::POINTER_CAPTURE_CHANGED:
3443 case EventEntry::Type::DRAG: {
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01003444 break;
3445 }
Chris Yef59a2f42020-10-16 12:55:26 -07003446 case EventEntry::Type::SENSOR: {
3447 LOG_ALWAYS_FATAL("SENSOR events should not go to apps via input channel");
3448 break;
3449 }
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003450 case EventEntry::Type::CONFIGURATION_CHANGED:
3451 case EventEntry::Type::DEVICE_RESET: {
3452 LOG_ALWAYS_FATAL("%s events should not go to apps",
Dominik Laskowski75788452021-02-09 18:51:25 -08003453 ftl::enum_string(newEntry.type).c_str());
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003454 break;
3455 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003456 }
3457
3458 // Remember that we are waiting for this dispatch to complete.
3459 if (dispatchEntry->hasForegroundTarget()) {
Chavi Weingarten65f98b82020-01-16 18:56:50 +00003460 incrementPendingForegroundDispatches(newEntry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003461 }
3462
3463 // Enqueue the dispatch entry.
Prabir Pradhan8c90d782023-09-15 21:16:44 +00003464 connection->outboundQueue.emplace_back(std::move(dispatchEntry));
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00003465 traceOutboundQueueLength(*connection);
chaviw8c9cf542019-03-25 13:02:48 -07003466}
3467
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003468/**
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00003469 * This function is for debugging and metrics collection. It has two roles.
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003470 *
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00003471 * The first role is to log input interaction with windows, which helps determine what the user was
3472 * interacting with. For example, if user is touching launcher, we will see an input_interaction log
3473 * that user started interacting with launcher window, as well as any other window that received
3474 * that gesture, such as the wallpaper or other spy windows. A new input_interaction is only logged
3475 * when the set of tokens that received the event changes. It is not logged again as long as the
3476 * user is interacting with the same windows.
3477 *
3478 * The second role is to track input device activity for metrics collection. For each input event,
3479 * we report the set of UIDs that the input device interacted with to the policy. Unlike for the
3480 * input_interaction logs, the device interaction is reported even when the set of interaction
3481 * tokens do not change.
3482 *
3483 * For these purposes, we do not count ACTION_OUTSIDE, ACTION_UP and ACTION_CANCEL actions as
3484 * interaction. This includes up and cancel events for both keys and motions.
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003485 */
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00003486void InputDispatcher::processInteractionsLocked(const EventEntry& entry,
3487 const std::vector<InputTarget>& targets) {
3488 int32_t deviceId;
3489 nsecs_t eventTime;
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003490 // Skip ACTION_UP events, and all events other than keys and motions
3491 if (entry.type == EventEntry::Type::KEY) {
3492 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(entry);
3493 if (keyEntry.action == AKEY_EVENT_ACTION_UP) {
3494 return;
3495 }
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00003496 deviceId = keyEntry.deviceId;
3497 eventTime = keyEntry.eventTime;
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003498 } else if (entry.type == EventEntry::Type::MOTION) {
3499 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(entry);
3500 if (motionEntry.action == AMOTION_EVENT_ACTION_UP ||
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00003501 motionEntry.action == AMOTION_EVENT_ACTION_CANCEL ||
3502 MotionEvent::getActionMasked(motionEntry.action) == AMOTION_EVENT_ACTION_POINTER_UP) {
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003503 return;
3504 }
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00003505 deviceId = motionEntry.deviceId;
3506 eventTime = motionEntry.eventTime;
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003507 } else {
3508 return; // Not a key or a motion
3509 }
3510
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00003511 std::set<gui::Uid> interactionUids;
Prabir Pradhan6a9a8312021-04-23 11:59:31 -07003512 std::unordered_set<sp<IBinder>, StrongPointerHash<IBinder>> newConnectionTokens;
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003513 std::vector<std::shared_ptr<Connection>> newConnections;
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003514 for (const InputTarget& target : targets) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003515 if (target.flags.test(InputTarget::Flags::DISPATCH_AS_OUTSIDE)) {
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003516 continue; // Skip windows that receive ACTION_OUTSIDE
3517 }
3518
3519 sp<IBinder> token = target.inputChannel->getConnectionToken();
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003520 std::shared_ptr<Connection> connection = getConnectionLocked(token);
Siarhei Vishniakoud706a282021-02-13 00:08:48 +00003521 if (connection == nullptr) {
3522 continue;
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003523 }
3524 newConnectionTokens.insert(std::move(token));
3525 newConnections.emplace_back(connection);
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00003526 if (target.windowHandle) {
3527 interactionUids.emplace(target.windowHandle->getInfo()->ownerUid);
3528 }
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003529 }
Prabir Pradhan8ede1d12023-05-08 19:37:44 +00003530
3531 auto command = [this, deviceId, eventTime, uids = std::move(interactionUids)]()
3532 REQUIRES(mLock) {
3533 scoped_unlock unlock(mLock);
3534 mPolicy.notifyDeviceInteraction(deviceId, eventTime, uids);
3535 };
3536 postCommandLocked(std::move(command));
3537
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003538 if (newConnectionTokens == mInteractionConnectionTokens) {
3539 return; // no change
3540 }
3541 mInteractionConnectionTokens = newConnectionTokens;
3542
Siarhei Vishniakoud706a282021-02-13 00:08:48 +00003543 std::string targetList;
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003544 for (const std::shared_ptr<Connection>& connection : newConnections) {
Siarhei Vishniakoud706a282021-02-13 00:08:48 +00003545 targetList += connection->getWindowName() + ", ";
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003546 }
Siarhei Vishniakoud706a282021-02-13 00:08:48 +00003547 std::string message = "Interaction with: " + targetList;
3548 if (targetList.empty()) {
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003549 message += "<none>";
3550 }
3551 android_log_event_list(LOGTAG_INPUT_INTERACTION) << message << LOG_ID_EVENTS;
3552}
3553
chaviwfd6d3512019-03-25 13:23:49 -07003554void InputDispatcher::dispatchPointerDownOutsideFocus(uint32_t source, int32_t action,
Vishnu Nairad321cd2020-08-20 16:40:21 -07003555 const sp<IBinder>& token) {
chaviw8c9cf542019-03-25 13:02:48 -07003556 int32_t maskedAction = action & AMOTION_EVENT_ACTION_MASK;
chaviwfd6d3512019-03-25 13:23:49 -07003557 uint32_t maskedSource = source & AINPUT_SOURCE_CLASS_MASK;
3558 if (maskedSource != AINPUT_SOURCE_CLASS_POINTER || maskedAction != AMOTION_EVENT_ACTION_DOWN) {
chaviw8c9cf542019-03-25 13:02:48 -07003559 return;
3560 }
3561
Vishnu Nairc519ff72021-01-21 08:23:08 -08003562 sp<IBinder> focusedToken = mFocusResolver.getFocusedWindowToken(mFocusedDisplayId);
Vishnu Nairad321cd2020-08-20 16:40:21 -07003563 if (focusedToken == token) {
3564 // ignore since token is focused
chaviw8c9cf542019-03-25 13:02:48 -07003565 return;
3566 }
3567
Prabir Pradhancef936d2021-07-21 16:17:52 +00003568 auto command = [this, token]() REQUIRES(mLock) {
3569 scoped_unlock unlock(mLock);
Prabir Pradhana41d2442023-04-20 21:30:40 +00003570 mPolicy.onPointerDownOutsideFocus(token);
Prabir Pradhancef936d2021-07-21 16:17:52 +00003571 };
3572 postCommandLocked(std::move(command));
Michael Wrightd02c5b62014-02-10 15:10:22 -08003573}
3574
Siarhei Vishniakoucce7e112022-10-25 13:31:17 -07003575status_t InputDispatcher::publishMotionEvent(Connection& connection,
3576 DispatchEntry& dispatchEntry) const {
3577 const EventEntry& eventEntry = *(dispatchEntry.eventEntry);
3578 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(eventEntry);
3579
3580 PointerCoords scaledCoords[MAX_POINTERS];
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07003581 const PointerCoords* usingCoords = motionEntry.pointerCoords.data();
Siarhei Vishniakoucce7e112022-10-25 13:31:17 -07003582
3583 // Set the X and Y offset and X and Y scale depending on the input source.
3584 if ((motionEntry.source & AINPUT_SOURCE_CLASS_POINTER) &&
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003585 !(dispatchEntry.targetFlags.test(InputTarget::Flags::ZERO_COORDS))) {
Siarhei Vishniakoucce7e112022-10-25 13:31:17 -07003586 float globalScaleFactor = dispatchEntry.globalScaleFactor;
3587 if (globalScaleFactor != 1.0f) {
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07003588 for (uint32_t i = 0; i < motionEntry.getPointerCount(); i++) {
Siarhei Vishniakoucce7e112022-10-25 13:31:17 -07003589 scaledCoords[i] = motionEntry.pointerCoords[i];
3590 // Don't apply window scale here since we don't want scale to affect raw
3591 // coordinates. The scale will be sent back to the client and applied
3592 // later when requesting relative coordinates.
Harry Cutts33476232023-01-30 19:57:29 +00003593 scaledCoords[i].scale(globalScaleFactor, /*windowXScale=*/1, /*windowYScale=*/1);
Siarhei Vishniakoucce7e112022-10-25 13:31:17 -07003594 }
3595 usingCoords = scaledCoords;
3596 }
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08003597 } else if (dispatchEntry.targetFlags.test(InputTarget::Flags::ZERO_COORDS)) {
Siarhei Vishniakoucce7e112022-10-25 13:31:17 -07003598 // We don't want the dispatch target to know the coordinates
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07003599 for (uint32_t i = 0; i < motionEntry.getPointerCount(); i++) {
Siarhei Vishniakoucce7e112022-10-25 13:31:17 -07003600 scaledCoords[i].clear();
3601 }
3602 usingCoords = scaledCoords;
3603 }
3604
3605 std::array<uint8_t, 32> hmac = getSignature(motionEntry, dispatchEntry);
3606
3607 // Publish the motion event.
3608 return connection.inputPublisher
3609 .publishMotionEvent(dispatchEntry.seq, dispatchEntry.resolvedEventId,
3610 motionEntry.deviceId, motionEntry.source, motionEntry.displayId,
3611 std::move(hmac), dispatchEntry.resolvedAction,
3612 motionEntry.actionButton, dispatchEntry.resolvedFlags,
3613 motionEntry.edgeFlags, motionEntry.metaState,
3614 motionEntry.buttonState, motionEntry.classification,
3615 dispatchEntry.transform, motionEntry.xPrecision,
3616 motionEntry.yPrecision, motionEntry.xCursorPosition,
3617 motionEntry.yCursorPosition, dispatchEntry.rawTransform,
3618 motionEntry.downTime, motionEntry.eventTime,
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07003619 motionEntry.getPointerCount(), motionEntry.pointerProperties.data(),
Siarhei Vishniakoucce7e112022-10-25 13:31:17 -07003620 usingCoords);
3621}
3622
Michael Wrightd02c5b62014-02-10 15:10:22 -08003623void InputDispatcher::startDispatchCycleLocked(nsecs_t currentTime,
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003624 const std::shared_ptr<Connection>& connection) {
Prabir Pradhan2dac8b82023-09-06 01:11:51 +00003625 ATRACE_NAME_IF(ATRACE_ENABLED(),
3626 StringPrintf("startDispatchCycleLocked(inputChannel=%s)",
3627 connection->getInputChannelName().c_str()));
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003628 if (DEBUG_DISPATCH_CYCLE) {
3629 ALOGD("channel '%s' ~ startDispatchCycle", connection->getInputChannelName().c_str());
3630 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003631
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08003632 while (connection->status == Connection::Status::NORMAL && !connection->outboundQueue.empty()) {
Prabir Pradhan8c90d782023-09-15 21:16:44 +00003633 std::unique_ptr<DispatchEntry>& dispatchEntry = connection->outboundQueue.front();
Michael Wrightd02c5b62014-02-10 15:10:22 -08003634 dispatchEntry->deliveryTime = currentTime;
Prabir Pradhan1376fcd2022-01-21 09:56:35 -08003635 const std::chrono::nanoseconds timeout = getDispatchingTimeoutLocked(connection);
Siarhei Vishniakou70622952020-07-30 11:17:23 -05003636 dispatchEntry->timeoutTime = currentTime + timeout.count();
Michael Wrightd02c5b62014-02-10 15:10:22 -08003637
3638 // Publish the event.
3639 status_t status;
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003640 const EventEntry& eventEntry = *(dispatchEntry->eventEntry);
3641 switch (eventEntry.type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003642 case EventEntry::Type::KEY: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003643 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(eventEntry);
3644 std::array<uint8_t, 32> hmac = getSignature(keyEntry, *dispatchEntry);
Siarhei Vishniakoud010b012023-01-18 15:00:53 -08003645 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
Siarhei Vishniakou827d1ac2023-07-21 16:37:51 -07003646 LOG(INFO) << "Publishing " << *dispatchEntry << " to "
3647 << connection->getInputChannelName();
Siarhei Vishniakoud010b012023-01-18 15:00:53 -08003648 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003649
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003650 // Publish the key event.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003651 status = connection->inputPublisher
3652 .publishKeyEvent(dispatchEntry->seq,
3653 dispatchEntry->resolvedEventId, keyEntry.deviceId,
3654 keyEntry.source, keyEntry.displayId,
3655 std::move(hmac), dispatchEntry->resolvedAction,
3656 dispatchEntry->resolvedFlags, keyEntry.keyCode,
3657 keyEntry.scanCode, keyEntry.metaState,
3658 keyEntry.repeatCount, keyEntry.downTime,
3659 keyEntry.eventTime);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003660 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003661 }
3662
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003663 case EventEntry::Type::MOTION: {
Siarhei Vishniakoud010b012023-01-18 15:00:53 -08003664 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
Siarhei Vishniakou827d1ac2023-07-21 16:37:51 -07003665 LOG(INFO) << "Publishing " << *dispatchEntry << " to "
3666 << connection->getInputChannelName();
Siarhei Vishniakoud010b012023-01-18 15:00:53 -08003667 }
Siarhei Vishniakoucce7e112022-10-25 13:31:17 -07003668 status = publishMotionEvent(*connection, *dispatchEntry);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003669 break;
3670 }
Prabir Pradhan99987712020-11-10 18:43:05 -08003671
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01003672 case EventEntry::Type::FOCUS: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003673 const FocusEntry& focusEntry = static_cast<const FocusEntry&>(eventEntry);
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01003674 status = connection->inputPublisher.publishFocusEvent(dispatchEntry->seq,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003675 focusEntry.id,
Antonio Kantek3cfec7b2021-11-05 18:26:17 -07003676 focusEntry.hasFocus);
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01003677 break;
3678 }
3679
Antonio Kantek7242d8b2021-08-05 16:07:20 -07003680 case EventEntry::Type::TOUCH_MODE_CHANGED: {
3681 const TouchModeEntry& touchModeEntry =
3682 static_cast<const TouchModeEntry&>(eventEntry);
3683 status = connection->inputPublisher
3684 .publishTouchModeEvent(dispatchEntry->seq, touchModeEntry.id,
3685 touchModeEntry.inTouchMode);
3686
3687 break;
3688 }
3689
Prabir Pradhan99987712020-11-10 18:43:05 -08003690 case EventEntry::Type::POINTER_CAPTURE_CHANGED: {
3691 const auto& captureEntry =
3692 static_cast<const PointerCaptureChangedEntry&>(eventEntry);
3693 status = connection->inputPublisher
3694 .publishCaptureEvent(dispatchEntry->seq, captureEntry.id,
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00003695 captureEntry.pointerCaptureRequest.enable);
Prabir Pradhan99987712020-11-10 18:43:05 -08003696 break;
3697 }
3698
arthurhungb89ccb02020-12-30 16:19:01 +08003699 case EventEntry::Type::DRAG: {
3700 const DragEntry& dragEntry = static_cast<const DragEntry&>(eventEntry);
3701 status = connection->inputPublisher.publishDragEvent(dispatchEntry->seq,
3702 dragEntry.id, dragEntry.x,
3703 dragEntry.y,
3704 dragEntry.isExiting);
3705 break;
3706 }
3707
Siarhei Vishniakou3b37f9a2019-11-23 13:42:41 -08003708 case EventEntry::Type::CONFIGURATION_CHANGED:
Chris Yef59a2f42020-10-16 12:55:26 -07003709 case EventEntry::Type::DEVICE_RESET:
3710 case EventEntry::Type::SENSOR: {
Siarhei Vishniakou3b37f9a2019-11-23 13:42:41 -08003711 LOG_ALWAYS_FATAL("Should never start dispatch cycles for %s events",
Dominik Laskowski75788452021-02-09 18:51:25 -08003712 ftl::enum_string(eventEntry.type).c_str());
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003713 return;
Siarhei Vishniakou3b37f9a2019-11-23 13:42:41 -08003714 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003715 }
3716
3717 // Check the result.
3718 if (status) {
3719 if (status == WOULD_BLOCK) {
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07003720 if (connection->waitQueue.empty()) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003721 ALOGE("channel '%s' ~ Could not publish event because the pipe is full. "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003722 "This is unexpected because the wait queue is empty, so the pipe "
3723 "should be empty and we shouldn't have any problems writing an "
Siarhei Vishniakou09b02ac2021-04-14 22:24:04 +00003724 "event to it, status=%s(%d)",
3725 connection->getInputChannelName().c_str(), statusToString(status).c_str(),
3726 status);
Harry Cutts33476232023-01-30 19:57:29 +00003727 abortBrokenDispatchCycleLocked(currentTime, connection, /*notify=*/true);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003728 } else {
3729 // Pipe is full and we are waiting for the app to finish process some events
3730 // before sending more events to it.
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003731 if (DEBUG_DISPATCH_CYCLE) {
3732 ALOGD("channel '%s' ~ Could not publish event because the pipe is full, "
3733 "waiting for the application to catch up",
3734 connection->getInputChannelName().c_str());
3735 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003736 }
3737 } else {
3738 ALOGE("channel '%s' ~ Could not publish event due to an unexpected error, "
Siarhei Vishniakou09b02ac2021-04-14 22:24:04 +00003739 "status=%s(%d)",
3740 connection->getInputChannelName().c_str(), statusToString(status).c_str(),
3741 status);
Harry Cutts33476232023-01-30 19:57:29 +00003742 abortBrokenDispatchCycleLocked(currentTime, connection, /*notify=*/true);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003743 }
3744 return;
3745 }
3746
3747 // Re-enqueue the event on the wait queue.
Prabir Pradhan8c90d782023-09-15 21:16:44 +00003748 const nsecs_t timeoutTime = dispatchEntry->timeoutTime;
3749 connection->waitQueue.emplace_back(std::move(dispatchEntry));
3750 connection->outboundQueue.erase(connection->outboundQueue.begin());
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00003751 traceOutboundQueueLength(*connection);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003752 if (connection->responsive) {
Prabir Pradhan8c90d782023-09-15 21:16:44 +00003753 mAnrTracker.insert(timeoutTime, connection->inputChannel->getConnectionToken());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003754 }
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00003755 traceWaitQueueLength(*connection);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003756 }
3757}
3758
chaviw09c8d2d2020-08-24 15:48:26 -07003759std::array<uint8_t, 32> InputDispatcher::sign(const VerifiedInputEvent& event) const {
3760 size_t size;
3761 switch (event.type) {
3762 case VerifiedInputEvent::Type::KEY: {
3763 size = sizeof(VerifiedKeyEvent);
3764 break;
3765 }
3766 case VerifiedInputEvent::Type::MOTION: {
3767 size = sizeof(VerifiedMotionEvent);
3768 break;
3769 }
3770 }
3771 const uint8_t* start = reinterpret_cast<const uint8_t*>(&event);
3772 return mHmacKeyManager.sign(start, size);
3773}
3774
Edgar Arriagac6ae4bb2020-04-16 18:46:48 -07003775const std::array<uint8_t, 32> InputDispatcher::getSignature(
3776 const MotionEntry& motionEntry, const DispatchEntry& dispatchEntry) const {
Siarhei Vishniakoubf880522023-05-01 11:03:22 -07003777 const int32_t actionMasked = MotionEvent::getActionMasked(dispatchEntry.resolvedAction);
Prabir Pradhanb5cb9572021-09-24 06:35:16 -07003778 if (actionMasked != AMOTION_EVENT_ACTION_UP && actionMasked != AMOTION_EVENT_ACTION_DOWN) {
Edgar Arriagac6ae4bb2020-04-16 18:46:48 -07003779 // Only sign events up and down events as the purely move events
3780 // are tied to their up/down counterparts so signing would be redundant.
Prabir Pradhanb5cb9572021-09-24 06:35:16 -07003781 return INVALID_HMAC;
Edgar Arriagac6ae4bb2020-04-16 18:46:48 -07003782 }
Prabir Pradhanb5cb9572021-09-24 06:35:16 -07003783
3784 VerifiedMotionEvent verifiedEvent =
3785 verifiedMotionEventFromMotionEntry(motionEntry, dispatchEntry.rawTransform);
3786 verifiedEvent.actionMasked = actionMasked;
3787 verifiedEvent.flags = dispatchEntry.resolvedFlags & VERIFIED_MOTION_EVENT_FLAGS;
3788 return sign(verifiedEvent);
Edgar Arriagac6ae4bb2020-04-16 18:46:48 -07003789}
3790
3791const std::array<uint8_t, 32> InputDispatcher::getSignature(
3792 const KeyEntry& keyEntry, const DispatchEntry& dispatchEntry) const {
3793 VerifiedKeyEvent verifiedEvent = verifiedKeyEventFromKeyEntry(keyEntry);
3794 verifiedEvent.flags = dispatchEntry.resolvedFlags & VERIFIED_KEY_EVENT_FLAGS;
3795 verifiedEvent.action = dispatchEntry.resolvedAction;
chaviw09c8d2d2020-08-24 15:48:26 -07003796 return sign(verifiedEvent);
Edgar Arriagac6ae4bb2020-04-16 18:46:48 -07003797}
3798
Michael Wrightd02c5b62014-02-10 15:10:22 -08003799void InputDispatcher::finishDispatchCycleLocked(nsecs_t currentTime,
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003800 const std::shared_ptr<Connection>& connection,
3801 uint32_t seq, bool handled, nsecs_t consumeTime) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003802 if (DEBUG_DISPATCH_CYCLE) {
3803 ALOGD("channel '%s' ~ finishDispatchCycle - seq=%u, handled=%s",
3804 connection->getInputChannelName().c_str(), seq, toString(handled));
3805 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003806
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08003807 if (connection->status == Connection::Status::BROKEN ||
3808 connection->status == Connection::Status::ZOMBIE) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003809 return;
3810 }
3811
3812 // Notify other system components and prepare to start the next dispatch cycle.
Prabir Pradhancef936d2021-07-21 16:17:52 +00003813 auto command = [this, currentTime, connection, seq, handled, consumeTime]() REQUIRES(mLock) {
3814 doDispatchCycleFinishedCommand(currentTime, connection, seq, handled, consumeTime);
3815 };
3816 postCommandLocked(std::move(command));
Michael Wrightd02c5b62014-02-10 15:10:22 -08003817}
3818
3819void InputDispatcher::abortBrokenDispatchCycleLocked(nsecs_t currentTime,
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003820 const std::shared_ptr<Connection>& connection,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003821 bool notify) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003822 if (DEBUG_DISPATCH_CYCLE) {
Siarhei Vishniakou827d1ac2023-07-21 16:37:51 -07003823 LOG(INFO) << "channel '" << connection->getInputChannelName() << "'~ " << __func__
3824 << " - notify=" << toString(notify);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003825 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003826
3827 // Clear the dispatch queues.
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07003828 drainDispatchQueue(connection->outboundQueue);
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00003829 traceOutboundQueueLength(*connection);
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07003830 drainDispatchQueue(connection->waitQueue);
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00003831 traceWaitQueueLength(*connection);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003832
3833 // The connection appears to be unrecoverably broken.
3834 // Ignore already broken or zombie connections.
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08003835 if (connection->status == Connection::Status::NORMAL) {
3836 connection->status = Connection::Status::BROKEN;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003837
3838 if (notify) {
3839 // Notify other system components.
Prabir Pradhancef936d2021-07-21 16:17:52 +00003840 ALOGE("channel '%s' ~ Channel is unrecoverably broken and will be disposed!",
3841 connection->getInputChannelName().c_str());
3842
3843 auto command = [this, connection]() REQUIRES(mLock) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00003844 scoped_unlock unlock(mLock);
Prabir Pradhana41d2442023-04-20 21:30:40 +00003845 mPolicy.notifyInputChannelBroken(connection->inputChannel->getConnectionToken());
Prabir Pradhancef936d2021-07-21 16:17:52 +00003846 };
3847 postCommandLocked(std::move(command));
Michael Wrightd02c5b62014-02-10 15:10:22 -08003848 }
3849 }
3850}
3851
Prabir Pradhan8c90d782023-09-15 21:16:44 +00003852void InputDispatcher::drainDispatchQueue(std::deque<std::unique_ptr<DispatchEntry>>& queue) {
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07003853 while (!queue.empty()) {
Prabir Pradhan8c90d782023-09-15 21:16:44 +00003854 releaseDispatchEntry(std::move(queue.front()));
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07003855 queue.pop_front();
Michael Wrightd02c5b62014-02-10 15:10:22 -08003856 }
3857}
3858
Prabir Pradhan8c90d782023-09-15 21:16:44 +00003859void InputDispatcher::releaseDispatchEntry(std::unique_ptr<DispatchEntry> dispatchEntry) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003860 if (dispatchEntry->hasForegroundTarget()) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003861 decrementPendingForegroundDispatches(*(dispatchEntry->eventEntry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08003862 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003863}
3864
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00003865int InputDispatcher::handleReceiveCallback(int events, sp<IBinder> connectionToken) {
3866 std::scoped_lock _l(mLock);
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003867 std::shared_ptr<Connection> connection = getConnectionLocked(connectionToken);
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00003868 if (connection == nullptr) {
3869 ALOGW("Received looper callback for unknown input channel token %p. events=0x%x",
3870 connectionToken.get(), events);
3871 return 0; // remove the callback
3872 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003873
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00003874 bool notify;
3875 if (!(events & (ALOOPER_EVENT_ERROR | ALOOPER_EVENT_HANGUP))) {
3876 if (!(events & ALOOPER_EVENT_INPUT)) {
3877 ALOGW("channel '%s' ~ Received spurious callback for unhandled poll event. "
3878 "events=0x%x",
3879 connection->getInputChannelName().c_str(), events);
3880 return 1;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003881 }
3882
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00003883 nsecs_t currentTime = now();
3884 bool gotOne = false;
3885 status_t status = OK;
3886 for (;;) {
3887 Result<InputPublisher::ConsumerResponse> result =
3888 connection->inputPublisher.receiveConsumerResponse();
3889 if (!result.ok()) {
3890 status = result.error().code();
3891 break;
3892 }
3893
3894 if (std::holds_alternative<InputPublisher::Finished>(*result)) {
3895 const InputPublisher::Finished& finish =
3896 std::get<InputPublisher::Finished>(*result);
3897 finishDispatchCycleLocked(currentTime, connection, finish.seq, finish.handled,
3898 finish.consumeTime);
3899 } else if (std::holds_alternative<InputPublisher::Timeline>(*result)) {
Siarhei Vishniakouf2652122021-03-05 21:39:46 +00003900 if (shouldReportMetricsForConnection(*connection)) {
3901 const InputPublisher::Timeline& timeline =
3902 std::get<InputPublisher::Timeline>(*result);
3903 mLatencyTracker
3904 .trackGraphicsLatency(timeline.inputEventId,
3905 connection->inputChannel->getConnectionToken(),
3906 std::move(timeline.graphicsTimeline));
3907 }
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00003908 }
3909 gotOne = true;
3910 }
3911 if (gotOne) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00003912 runCommandsLockedInterruptable();
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00003913 if (status == WOULD_BLOCK) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003914 return 1;
3915 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003916 }
3917
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00003918 notify = status != DEAD_OBJECT || !connection->monitor;
3919 if (notify) {
3920 ALOGE("channel '%s' ~ Failed to receive finished signal. status=%s(%d)",
3921 connection->getInputChannelName().c_str(), statusToString(status).c_str(),
3922 status);
3923 }
3924 } else {
3925 // Monitor channels are never explicitly unregistered.
3926 // We do it automatically when the remote endpoint is closed so don't warn about them.
3927 const bool stillHaveWindowHandle =
3928 getWindowHandleLocked(connection->inputChannel->getConnectionToken()) != nullptr;
3929 notify = !connection->monitor && stillHaveWindowHandle;
3930 if (notify) {
3931 ALOGW("channel '%s' ~ Consumer closed input channel or an error occurred. events=0x%x",
3932 connection->getInputChannelName().c_str(), events);
3933 }
3934 }
3935
3936 // Remove the channel.
3937 removeInputChannelLocked(connection->inputChannel->getConnectionToken(), notify);
3938 return 0; // remove the callback
Michael Wrightd02c5b62014-02-10 15:10:22 -08003939}
3940
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003941void InputDispatcher::synthesizeCancelationEventsForAllConnectionsLocked(
Michael Wrightd02c5b62014-02-10 15:10:22 -08003942 const CancelationOptions& options) {
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00003943 for (const auto& [token, connection] : mConnectionsByToken) {
Siarhei Vishniakou2e2ea992020-12-15 02:57:19 +00003944 synthesizeCancelationEventsForConnectionLocked(connection, options);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003945 }
3946}
3947
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003948void InputDispatcher::synthesizeCancelationEventsForMonitorsLocked(
Michael Wrightfa13dcf2015-06-12 13:25:11 +01003949 const CancelationOptions& options) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08003950 for (const auto& [_, monitors] : mGlobalMonitorsByDisplay) {
Michael Wright3dd60e22019-03-27 22:06:44 +00003951 for (const Monitor& monitor : monitors) {
3952 synthesizeCancelationEventsForInputChannelLocked(monitor.inputChannel, options);
Arthur Hung2fbf37f2018-09-13 18:16:41 +08003953 }
Michael Wrightfa13dcf2015-06-12 13:25:11 +01003954 }
3955}
3956
Michael Wrightd02c5b62014-02-10 15:10:22 -08003957void InputDispatcher::synthesizeCancelationEventsForInputChannelLocked(
Siarhei Vishniakouce5ab082020-07-09 17:03:21 -05003958 const std::shared_ptr<InputChannel>& channel, const CancelationOptions& options) {
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003959 std::shared_ptr<Connection> connection = getConnectionLocked(channel->getConnectionToken());
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07003960 if (connection == nullptr) {
3961 return;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003962 }
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07003963
3964 synthesizeCancelationEventsForConnectionLocked(connection, options);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003965}
3966
3967void InputDispatcher::synthesizeCancelationEventsForConnectionLocked(
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07003968 const std::shared_ptr<Connection>& connection, const CancelationOptions& options) {
Linnan Li5af92f92023-07-14 14:36:22 +08003969 if ((options.mode == CancelationOptions::Mode::CANCEL_POINTER_EVENTS ||
3970 options.mode == CancelationOptions::Mode::CANCEL_ALL_EVENTS) &&
3971 mDragState && mDragState->dragWindow->getToken() == connection->inputChannel->getToken()) {
3972 LOG(INFO) << __func__
3973 << ": Canceling drag and drop because the pointers for the drag window are being "
3974 "canceled.";
3975 sendDropWindowCommandLocked(nullptr, /*x=*/0, /*y=*/0);
3976 mDragState.reset();
3977 }
3978
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08003979 if (connection->status == Connection::Status::BROKEN) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003980 return;
3981 }
3982
3983 nsecs_t currentTime = now();
3984
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003985 std::vector<std::unique_ptr<EventEntry>> cancelationEvents =
Siarhei Vishniakou00fca7c2019-10-29 13:05:57 -07003986 connection->inputState.synthesizeCancelationEvents(currentTime, options);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003987
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08003988 if (cancelationEvents.empty()) {
3989 return;
3990 }
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003991 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
3992 ALOGD("channel '%s' ~ Synthesized %zu cancelation events to bring channel back in sync "
Siarhei Vishniakou2e3e4432023-02-09 18:34:11 -08003993 "with reality: %s, mode=%s.",
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003994 connection->getInputChannelName().c_str(), cancelationEvents.size(), options.reason,
Siarhei Vishniakou2e3e4432023-02-09 18:34:11 -08003995 ftl::enum_string(options.mode).c_str());
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003996 }
Svet Ganov5d3bc372020-01-26 23:11:07 -08003997
Arthur Hungb3307ee2021-10-14 10:57:37 +00003998 std::string reason = std::string("reason=").append(options.reason);
3999 android_log_event_list(LOGTAG_INPUT_CANCEL)
4000 << connection->getInputChannelName().c_str() << reason << LOG_ID_EVENTS;
4001
hongzuo liu95785e22022-09-06 02:51:35 +00004002 const bool wasEmpty = connection->outboundQueue.empty();
Prabir Pradhan16463382023-10-12 23:03:19 +00004003 // The target to use if we don't find a window associated with the channel.
4004 const InputTarget fallbackTarget{.inputChannel = connection->inputChannel,
4005 .flags = InputTarget::Flags::DISPATCH_AS_IS};
4006 const auto& token = connection->inputChannel->getConnectionToken();
hongzuo liu95785e22022-09-06 02:51:35 +00004007
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08004008 for (size_t i = 0; i < cancelationEvents.size(); i++) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004009 std::unique_ptr<EventEntry> cancelationEventEntry = std::move(cancelationEvents[i]);
Prabir Pradhan112b1ad2023-09-21 09:53:53 +00004010 std::vector<InputTarget> targets{};
Prabir Pradhan112b1ad2023-09-21 09:53:53 +00004011
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08004012 switch (cancelationEventEntry->type) {
4013 case EventEntry::Type::KEY: {
Prabir Pradhan112b1ad2023-09-21 09:53:53 +00004014 const auto& keyEntry = static_cast<const KeyEntry&>(*cancelationEventEntry);
Prabir Pradhan16463382023-10-12 23:03:19 +00004015 const std::optional<int32_t> targetDisplay = keyEntry.displayId != ADISPLAY_ID_NONE
4016 ? std::make_optional(keyEntry.displayId)
4017 : std::nullopt;
4018 if (const auto& window = getWindowHandleLocked(token, targetDisplay); window) {
4019 addWindowTargetLocked(window, InputTarget::Flags::DISPATCH_AS_IS,
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07004020 keyEntry.downTime, targets);
Prabir Pradhan112b1ad2023-09-21 09:53:53 +00004021 } else {
4022 targets.emplace_back(fallbackTarget);
4023 }
4024 logOutboundKeyDetails("cancel - ", keyEntry);
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08004025 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004026 }
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08004027 case EventEntry::Type::MOTION: {
Prabir Pradhan112b1ad2023-09-21 09:53:53 +00004028 const auto& motionEntry = static_cast<const MotionEntry&>(*cancelationEventEntry);
Prabir Pradhan16463382023-10-12 23:03:19 +00004029 const std::optional<int32_t> targetDisplay =
4030 motionEntry.displayId != ADISPLAY_ID_NONE
4031 ? std::make_optional(motionEntry.displayId)
4032 : std::nullopt;
4033 if (const auto& window = getWindowHandleLocked(token, targetDisplay); window) {
Prabir Pradhan112b1ad2023-09-21 09:53:53 +00004034 std::bitset<MAX_POINTER_ID + 1> pointerIds;
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07004035 for (uint32_t pointerIndex = 0; pointerIndex < motionEntry.getPointerCount();
Prabir Pradhan112b1ad2023-09-21 09:53:53 +00004036 pointerIndex++) {
4037 pointerIds.set(motionEntry.pointerProperties[pointerIndex].id);
4038 }
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07004039 addPointerWindowTargetLocked(window, InputTarget::Flags::DISPATCH_AS_IS,
4040 pointerIds, motionEntry.downTime, targets);
Prabir Pradhan112b1ad2023-09-21 09:53:53 +00004041 } else {
4042 targets.emplace_back(fallbackTarget);
4043 const auto it = mDisplayInfos.find(motionEntry.displayId);
4044 if (it != mDisplayInfos.end()) {
4045 targets.back().displayTransform = it->second.transform;
4046 targets.back().setDefaultPointerTransform(it->second.transform);
4047 }
4048 }
4049 logOutboundMotionDetails("cancel - ", motionEntry);
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08004050 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004051 }
Prabir Pradhan99987712020-11-10 18:43:05 -08004052 case EventEntry::Type::FOCUS:
Antonio Kantek7242d8b2021-08-05 16:07:20 -07004053 case EventEntry::Type::TOUCH_MODE_CHANGED:
arthurhungb89ccb02020-12-30 16:19:01 +08004054 case EventEntry::Type::POINTER_CAPTURE_CHANGED:
4055 case EventEntry::Type::DRAG: {
Prabir Pradhan99987712020-11-10 18:43:05 -08004056 LOG_ALWAYS_FATAL("Canceling %s events is not supported",
Dominik Laskowski75788452021-02-09 18:51:25 -08004057 ftl::enum_string(cancelationEventEntry->type).c_str());
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08004058 break;
4059 }
4060 case EventEntry::Type::CONFIGURATION_CHANGED:
Chris Yef59a2f42020-10-16 12:55:26 -07004061 case EventEntry::Type::DEVICE_RESET:
4062 case EventEntry::Type::SENSOR: {
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08004063 LOG_ALWAYS_FATAL("%s event should not be found inside Connections's queue",
Dominik Laskowski75788452021-02-09 18:51:25 -08004064 ftl::enum_string(cancelationEventEntry->type).c_str());
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08004065 break;
4066 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004067 }
4068
Prabir Pradhan112b1ad2023-09-21 09:53:53 +00004069 if (targets.size() != 1) LOG(FATAL) << __func__ << ": InputTarget not created";
4070 enqueueDispatchEntryLocked(connection, std::move(cancelationEventEntry), targets[0],
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08004071 InputTarget::Flags::DISPATCH_AS_IS);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004072 }
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08004073
hongzuo liu95785e22022-09-06 02:51:35 +00004074 // If the outbound queue was previously empty, start the dispatch cycle going.
4075 if (wasEmpty && !connection->outboundQueue.empty()) {
4076 startDispatchCycleLocked(currentTime, connection);
4077 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004078}
4079
Svet Ganov5d3bc372020-01-26 23:11:07 -08004080void InputDispatcher::synthesizePointerDownEventsForConnectionLocked(
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07004081 const nsecs_t downTime, const std::shared_ptr<Connection>& connection,
Arthur Hungc539dbb2022-12-08 07:45:36 +00004082 ftl::Flags<InputTarget::Flags> targetFlags) {
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08004083 if (connection->status == Connection::Status::BROKEN) {
Svet Ganov5d3bc372020-01-26 23:11:07 -08004084 return;
4085 }
4086
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004087 std::vector<std::unique_ptr<EventEntry>> downEvents =
Vaibhav Devmurari882bd9b2022-06-23 14:54:54 +00004088 connection->inputState.synthesizePointerDownEvents(downTime);
Svet Ganov5d3bc372020-01-26 23:11:07 -08004089
4090 if (downEvents.empty()) {
4091 return;
4092 }
4093
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004094 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
Svet Ganov5d3bc372020-01-26 23:11:07 -08004095 ALOGD("channel '%s' ~ Synthesized %zu down events to ensure consistent event stream.",
4096 connection->getInputChannelName().c_str(), downEvents.size());
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004097 }
Svet Ganov5d3bc372020-01-26 23:11:07 -08004098
chaviw98318de2021-05-19 16:45:23 -05004099 sp<WindowInfoHandle> windowHandle =
Svet Ganov5d3bc372020-01-26 23:11:07 -08004100 getWindowHandleLocked(connection->inputChannel->getConnectionToken());
Svet Ganov5d3bc372020-01-26 23:11:07 -08004101
hongzuo liu95785e22022-09-06 02:51:35 +00004102 const bool wasEmpty = connection->outboundQueue.empty();
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004103 for (std::unique_ptr<EventEntry>& downEventEntry : downEvents) {
Prabir Pradhan1c29a092023-09-21 10:29:29 +00004104 std::vector<InputTarget> targets{};
Svet Ganov5d3bc372020-01-26 23:11:07 -08004105 switch (downEventEntry->type) {
4106 case EventEntry::Type::MOTION: {
Prabir Pradhan1c29a092023-09-21 10:29:29 +00004107 const auto& motionEntry = static_cast<const MotionEntry&>(*downEventEntry);
4108 if (windowHandle != nullptr) {
4109 std::bitset<MAX_POINTER_ID + 1> pointerIds;
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07004110 for (uint32_t pointerIndex = 0; pointerIndex < motionEntry.getPointerCount();
Prabir Pradhan1c29a092023-09-21 10:29:29 +00004111 pointerIndex++) {
4112 pointerIds.set(motionEntry.pointerProperties[pointerIndex].id);
4113 }
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07004114 addPointerWindowTargetLocked(windowHandle, targetFlags, pointerIds,
4115 motionEntry.downTime, targets);
Prabir Pradhan1c29a092023-09-21 10:29:29 +00004116 } else {
4117 targets.emplace_back(InputTarget{.inputChannel = connection->inputChannel,
4118 .flags = targetFlags});
4119 const auto it = mDisplayInfos.find(motionEntry.displayId);
4120 if (it != mDisplayInfos.end()) {
4121 targets.back().displayTransform = it->second.transform;
4122 targets.back().setDefaultPointerTransform(it->second.transform);
4123 }
4124 }
4125 logOutboundMotionDetails("down - ", motionEntry);
Svet Ganov5d3bc372020-01-26 23:11:07 -08004126 break;
4127 }
4128
4129 case EventEntry::Type::KEY:
4130 case EventEntry::Type::FOCUS:
Antonio Kantek7242d8b2021-08-05 16:07:20 -07004131 case EventEntry::Type::TOUCH_MODE_CHANGED:
Svet Ganov5d3bc372020-01-26 23:11:07 -08004132 case EventEntry::Type::CONFIGURATION_CHANGED:
Prabir Pradhan99987712020-11-10 18:43:05 -08004133 case EventEntry::Type::DEVICE_RESET:
Chris Yef59a2f42020-10-16 12:55:26 -07004134 case EventEntry::Type::POINTER_CAPTURE_CHANGED:
arthurhungb89ccb02020-12-30 16:19:01 +08004135 case EventEntry::Type::SENSOR:
4136 case EventEntry::Type::DRAG: {
Svet Ganov5d3bc372020-01-26 23:11:07 -08004137 LOG_ALWAYS_FATAL("%s event should not be found inside Connections's queue",
Dominik Laskowski75788452021-02-09 18:51:25 -08004138 ftl::enum_string(downEventEntry->type).c_str());
Svet Ganov5d3bc372020-01-26 23:11:07 -08004139 break;
4140 }
4141 }
4142
Prabir Pradhan1c29a092023-09-21 10:29:29 +00004143 if (targets.size() != 1) LOG(FATAL) << __func__ << ": InputTarget not created";
4144 enqueueDispatchEntryLocked(connection, std::move(downEventEntry), targets[0],
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08004145 InputTarget::Flags::DISPATCH_AS_IS);
Svet Ganov5d3bc372020-01-26 23:11:07 -08004146 }
4147
hongzuo liu95785e22022-09-06 02:51:35 +00004148 // If the outbound queue was previously empty, start the dispatch cycle going.
4149 if (wasEmpty && !connection->outboundQueue.empty()) {
4150 startDispatchCycleLocked(downTime, connection);
4151 }
Svet Ganov5d3bc372020-01-26 23:11:07 -08004152}
4153
Arthur Hungc539dbb2022-12-08 07:45:36 +00004154void InputDispatcher::synthesizeCancelationEventsForWindowLocked(
4155 const sp<WindowInfoHandle>& windowHandle, const CancelationOptions& options) {
4156 if (windowHandle != nullptr) {
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07004157 std::shared_ptr<Connection> wallpaperConnection =
4158 getConnectionLocked(windowHandle->getToken());
Arthur Hungc539dbb2022-12-08 07:45:36 +00004159 if (wallpaperConnection != nullptr) {
4160 synthesizeCancelationEventsForConnectionLocked(wallpaperConnection, options);
4161 }
4162 }
4163}
4164
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004165std::unique_ptr<MotionEntry> InputDispatcher::splitMotionEvent(
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08004166 const MotionEntry& originalMotionEntry, std::bitset<MAX_POINTER_ID + 1> pointerIds,
4167 nsecs_t splitDownTime) {
4168 ALOG_ASSERT(pointerIds.any());
Michael Wrightd02c5b62014-02-10 15:10:22 -08004169
4170 uint32_t splitPointerIndexMap[MAX_POINTERS];
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07004171 std::vector<PointerProperties> splitPointerProperties;
4172 std::vector<PointerCoords> splitPointerCoords;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004173
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07004174 uint32_t originalPointerCount = originalMotionEntry.getPointerCount();
Michael Wrightd02c5b62014-02-10 15:10:22 -08004175 uint32_t splitPointerCount = 0;
4176
4177 for (uint32_t originalPointerIndex = 0; originalPointerIndex < originalPointerCount;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004178 originalPointerIndex++) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004179 const PointerProperties& pointerProperties =
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07004180 originalMotionEntry.pointerProperties[originalPointerIndex];
Michael Wrightd02c5b62014-02-10 15:10:22 -08004181 uint32_t pointerId = uint32_t(pointerProperties.id);
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08004182 if (pointerIds.test(pointerId)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004183 splitPointerIndexMap[splitPointerCount] = originalPointerIndex;
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07004184 splitPointerProperties.push_back(pointerProperties);
4185 splitPointerCoords.push_back(originalMotionEntry.pointerCoords[originalPointerIndex]);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004186 splitPointerCount += 1;
4187 }
4188 }
4189
4190 if (splitPointerCount != pointerIds.count()) {
4191 // This is bad. We are missing some of the pointers that we expected to deliver.
4192 // Most likely this indicates that we received an ACTION_MOVE events that has
4193 // different pointer ids than we expected based on the previous ACTION_DOWN
4194 // or ACTION_POINTER_DOWN events that caused us to decide to split the pointers
4195 // in this way.
4196 ALOGW("Dropping split motion event because the pointer count is %d but "
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08004197 "we expected there to be %zu pointers. This probably means we received "
Siarhei Vishniakou16e4fa02023-02-16 17:48:56 -08004198 "a broken sequence of pointer ids from the input device: %s",
4199 splitPointerCount, pointerIds.count(), originalMotionEntry.getDescription().c_str());
Yi Kong9b14ac62018-07-17 13:48:38 -07004200 return nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004201 }
4202
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07004203 int32_t action = originalMotionEntry.action;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004204 int32_t maskedAction = action & AMOTION_EVENT_ACTION_MASK;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004205 if (maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN ||
4206 maskedAction == AMOTION_EVENT_ACTION_POINTER_UP) {
Siarhei Vishniakou5b9766d2023-07-18 14:06:29 -07004207 int32_t originalPointerIndex = MotionEvent::getActionIndex(action);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004208 const PointerProperties& pointerProperties =
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07004209 originalMotionEntry.pointerProperties[originalPointerIndex];
Michael Wrightd02c5b62014-02-10 15:10:22 -08004210 uint32_t pointerId = uint32_t(pointerProperties.id);
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08004211 if (pointerIds.test(pointerId)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004212 if (pointerIds.count() == 1) {
4213 // The first/last pointer went down/up.
4214 action = maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004215 ? AMOTION_EVENT_ACTION_DOWN
arthurhungea3f4fc2020-12-21 23:18:53 +08004216 : (originalMotionEntry.flags & AMOTION_EVENT_FLAG_CANCELED) != 0
4217 ? AMOTION_EVENT_ACTION_CANCEL
4218 : AMOTION_EVENT_ACTION_UP;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004219 } else {
4220 // A secondary pointer went down/up.
4221 uint32_t splitPointerIndex = 0;
4222 while (pointerId != uint32_t(splitPointerProperties[splitPointerIndex].id)) {
4223 splitPointerIndex += 1;
4224 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004225 action = maskedAction |
4226 (splitPointerIndex << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004227 }
4228 } else {
4229 // An unrelated pointer changed.
4230 action = AMOTION_EVENT_ACTION_MOVE;
4231 }
4232 }
4233
Siarhei Vishniakou59e302b2023-06-05 08:04:53 -07004234 if (action == AMOTION_EVENT_ACTION_DOWN && splitDownTime != originalMotionEntry.eventTime) {
4235 logDispatchStateLocked();
4236 LOG_ALWAYS_FATAL("Split motion event has mismatching downTime and eventTime for "
4237 "ACTION_DOWN, motionEntry=%s, splitDownTime=%" PRId64,
4238 originalMotionEntry.getDescription().c_str(), splitDownTime);
Vaibhav Devmurari882bd9b2022-06-23 14:54:54 +00004239 }
4240
Garfield Tanff1f1bb2020-01-28 13:24:04 -08004241 int32_t newId = mIdGenerator.nextId();
Prabir Pradhan2dac8b82023-09-06 01:11:51 +00004242 ATRACE_NAME_IF(ATRACE_ENABLED(),
4243 StringPrintf("Split MotionEvent(id=0x%" PRIx32 ") to MotionEvent(id=0x%" PRIx32
4244 ").",
4245 originalMotionEntry.id, newId));
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004246 std::unique_ptr<MotionEntry> splitMotionEntry =
4247 std::make_unique<MotionEntry>(newId, originalMotionEntry.eventTime,
4248 originalMotionEntry.deviceId, originalMotionEntry.source,
4249 originalMotionEntry.displayId,
4250 originalMotionEntry.policyFlags, action,
4251 originalMotionEntry.actionButton,
4252 originalMotionEntry.flags, originalMotionEntry.metaState,
4253 originalMotionEntry.buttonState,
4254 originalMotionEntry.classification,
4255 originalMotionEntry.edgeFlags,
4256 originalMotionEntry.xPrecision,
4257 originalMotionEntry.yPrecision,
4258 originalMotionEntry.xCursorPosition,
Vaibhav Devmurari882bd9b2022-06-23 14:54:54 +00004259 originalMotionEntry.yCursorPosition, splitDownTime,
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07004260 splitPointerProperties, splitPointerCoords);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004261
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07004262 if (originalMotionEntry.injectionState) {
4263 splitMotionEntry->injectionState = originalMotionEntry.injectionState;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004264 splitMotionEntry->injectionState->refCount += 1;
4265 }
4266
4267 return splitMotionEntry;
4268}
4269
Asmita Poddardd9a6cd2023-09-26 15:35:12 +00004270void InputDispatcher::notifyInputDevicesChanged(const NotifyInputDevicesChangedArgs& args) {
4271 std::scoped_lock _l(mLock);
4272 mLatencyTracker.setInputDevices(args.inputDeviceInfos);
4273}
4274
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004275void InputDispatcher::notifyConfigurationChanged(const NotifyConfigurationChangedArgs& args) {
Prabir Pradhan65613802023-02-22 23:36:58 +00004276 if (debugInboundEventDetails()) {
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004277 ALOGD("notifyConfigurationChanged - eventTime=%" PRId64, args.eventTime);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004278 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004279
Antonio Kantekf16f2832021-09-28 04:39:20 +00004280 bool needWake = false;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004281 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004282 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004283
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004284 std::unique_ptr<ConfigurationChangedEntry> newEntry =
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004285 std::make_unique<ConfigurationChangedEntry>(args.id, args.eventTime);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004286 needWake = enqueueInboundEventLocked(std::move(newEntry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08004287 } // release lock
4288
4289 if (needWake) {
4290 mLooper->wake();
4291 }
4292}
4293
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004294void InputDispatcher::notifyKey(const NotifyKeyArgs& args) {
Prabir Pradhan96282b02023-02-24 22:36:17 +00004295 ALOGD_IF(debugInboundEventDetails(),
4296 "notifyKey - id=%" PRIx32 ", eventTime=%" PRId64
4297 ", deviceId=%d, source=%s, displayId=%" PRId32
4298 "policyFlags=0x%x, action=%s, flags=0x%x, keyCode=%s, scanCode=0x%x, metaState=0x%x, "
4299 "downTime=%" PRId64,
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004300 args.id, args.eventTime, args.deviceId, inputEventSourceToString(args.source).c_str(),
4301 args.displayId, args.policyFlags, KeyEvent::actionToString(args.action), args.flags,
4302 KeyEvent::getLabel(args.keyCode), args.scanCode, args.metaState, args.downTime);
Siarhei Vishniakou23740b92023-04-21 11:30:20 -07004303 Result<void> keyCheck = validateKeyEvent(args.action);
4304 if (!keyCheck.ok()) {
4305 LOG(ERROR) << "invalid key event: " << keyCheck.error();
Michael Wrightd02c5b62014-02-10 15:10:22 -08004306 return;
4307 }
4308
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004309 uint32_t policyFlags = args.policyFlags;
4310 int32_t flags = args.flags;
4311 int32_t metaState = args.metaState;
Siarhei Vishniakou622bd322018-10-29 18:02:27 -07004312 // InputDispatcher tracks and generates key repeats on behalf of
4313 // whatever notifies it, so repeatCount should always be set to 0
4314 constexpr int32_t repeatCount = 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004315 if ((policyFlags & POLICY_FLAG_VIRTUAL) || (flags & AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY)) {
4316 policyFlags |= POLICY_FLAG_VIRTUAL;
4317 flags |= AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY;
4318 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004319 if (policyFlags & POLICY_FLAG_FUNCTION) {
4320 metaState |= AMETA_FUNCTION_ON;
4321 }
4322
4323 policyFlags |= POLICY_FLAG_TRUSTED;
4324
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004325 int32_t keyCode = args.keyCode;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004326 KeyEvent event;
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004327 event.initialize(args.id, args.deviceId, args.source, args.displayId, INVALID_HMAC, args.action,
4328 flags, keyCode, args.scanCode, metaState, repeatCount, args.downTime,
4329 args.eventTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004330
Michael Wright2b3c3302018-03-02 17:19:13 +00004331 android::base::Timer t;
Prabir Pradhana41d2442023-04-20 21:30:40 +00004332 mPolicy.interceptKeyBeforeQueueing(event, /*byref*/ policyFlags);
Michael Wright2b3c3302018-03-02 17:19:13 +00004333 if (t.duration() > SLOW_INTERCEPTION_THRESHOLD) {
4334 ALOGW("Excessive delay in interceptKeyBeforeQueueing; took %s ms",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004335 std::to_string(t.duration().count()).c_str());
Michael Wright2b3c3302018-03-02 17:19:13 +00004336 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004337
Antonio Kantekf16f2832021-09-28 04:39:20 +00004338 bool needWake = false;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004339 { // acquire lock
4340 mLock.lock();
4341
4342 if (shouldSendKeyToInputFilterLocked(args)) {
4343 mLock.unlock();
4344
Siarhei Vishniakouf00a4ec2021-06-16 03:55:32 +00004345 policyFlags |= POLICY_FLAG_FILTERED;
Prabir Pradhana41d2442023-04-20 21:30:40 +00004346 if (!mPolicy.filterInputEvent(event, policyFlags)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004347 return; // event was consumed by the filter
4348 }
4349
4350 mLock.lock();
4351 }
4352
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004353 std::unique_ptr<KeyEntry> newEntry =
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004354 std::make_unique<KeyEntry>(args.id, args.eventTime, args.deviceId, args.source,
4355 args.displayId, policyFlags, args.action, flags, keyCode,
4356 args.scanCode, metaState, repeatCount, args.downTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004357
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004358 needWake = enqueueInboundEventLocked(std::move(newEntry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08004359 mLock.unlock();
4360 } // release lock
4361
4362 if (needWake) {
4363 mLooper->wake();
4364 }
4365}
4366
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004367bool InputDispatcher::shouldSendKeyToInputFilterLocked(const NotifyKeyArgs& args) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004368 return mInputFilterEnabled;
4369}
4370
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004371void InputDispatcher::notifyMotion(const NotifyMotionArgs& args) {
Prabir Pradhan65613802023-02-22 23:36:58 +00004372 if (debugInboundEventDetails()) {
Prabir Pradhan96282b02023-02-24 22:36:17 +00004373 ALOGD("notifyMotion - id=%" PRIx32 " eventTime=%" PRId64 ", deviceId=%d, source=%s, "
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004374 "displayId=%" PRId32 ", policyFlags=0x%x, "
Siarhei Vishniakou6ebd0692022-10-20 15:05:45 -07004375 "action=%s, actionButton=0x%x, flags=0x%x, metaState=0x%x, buttonState=0x%x, "
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004376 "edgeFlags=0x%x, xPrecision=%f, yPrecision=%f, xCursorPosition=%f, "
4377 "yCursorPosition=%f, downTime=%" PRId64,
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004378 args.id, args.eventTime, args.deviceId, inputEventSourceToString(args.source).c_str(),
4379 args.displayId, args.policyFlags, MotionEvent::actionToString(args.action).c_str(),
4380 args.actionButton, args.flags, args.metaState, args.buttonState, args.edgeFlags,
4381 args.xPrecision, args.yPrecision, args.xCursorPosition, args.yCursorPosition,
4382 args.downTime);
Siarhei Vishniakou3218fc02023-06-15 20:41:02 -07004383 for (uint32_t i = 0; i < args.getPointerCount(); i++) {
Prabir Pradhan96282b02023-02-24 22:36:17 +00004384 ALOGD(" Pointer %d: id=%d, toolType=%s, x=%f, y=%f, pressure=%f, size=%f, "
4385 "touchMajor=%f, touchMinor=%f, toolMajor=%f, toolMinor=%f, orientation=%f",
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004386 i, args.pointerProperties[i].id,
4387 ftl::enum_string(args.pointerProperties[i].toolType).c_str(),
4388 args.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_X),
4389 args.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_Y),
4390 args.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_PRESSURE),
4391 args.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_SIZE),
4392 args.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR),
4393 args.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR),
4394 args.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR),
4395 args.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR),
4396 args.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION));
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004397 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004398 }
Siarhei Vishniakou23740b92023-04-21 11:30:20 -07004399
Siarhei Vishniakou3218fc02023-06-15 20:41:02 -07004400 Result<void> motionCheck =
4401 validateMotionEvent(args.action, args.actionButton, args.getPointerCount(),
4402 args.pointerProperties.data());
Siarhei Vishniakou23740b92023-04-21 11:30:20 -07004403 if (!motionCheck.ok()) {
4404 LOG(FATAL) << "Invalid event: " << args.dump() << "; reason: " << motionCheck.error();
4405 return;
4406 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004407
Siarhei Vishniakou5c02a712023-05-15 15:45:02 -07004408 if (DEBUG_VERIFY_EVENTS) {
4409 auto [it, _] =
4410 mVerifiersByDisplay.try_emplace(args.displayId,
4411 StringPrintf("display %" PRId32, args.displayId));
4412 Result<void> result =
Siarhei Vishniakou2d151ac2023-09-19 13:30:24 -07004413 it->second.processMovement(args.deviceId, args.source, args.action,
4414 args.getPointerCount(), args.pointerProperties.data(),
4415 args.pointerCoords.data(), args.flags);
Siarhei Vishniakou5c02a712023-05-15 15:45:02 -07004416 if (!result.ok()) {
4417 LOG(FATAL) << "Bad stream: " << result.error() << " caused by " << args.dump();
4418 }
4419 }
4420
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004421 uint32_t policyFlags = args.policyFlags;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004422 policyFlags |= POLICY_FLAG_TRUSTED;
Michael Wright2b3c3302018-03-02 17:19:13 +00004423
4424 android::base::Timer t;
Prabir Pradhana41d2442023-04-20 21:30:40 +00004425 mPolicy.interceptMotionBeforeQueueing(args.displayId, args.eventTime, policyFlags);
Michael Wright2b3c3302018-03-02 17:19:13 +00004426 if (t.duration() > SLOW_INTERCEPTION_THRESHOLD) {
4427 ALOGW("Excessive delay in interceptMotionBeforeQueueing; took %s ms",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004428 std::to_string(t.duration().count()).c_str());
Michael Wright2b3c3302018-03-02 17:19:13 +00004429 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004430
Antonio Kantekf16f2832021-09-28 04:39:20 +00004431 bool needWake = false;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004432 { // acquire lock
4433 mLock.lock();
Siarhei Vishniakou5bf25d92023-02-08 15:43:38 -08004434 if (!(policyFlags & POLICY_FLAG_PASS_TO_USER)) {
4435 // Set the flag anyway if we already have an ongoing gesture. That would allow us to
4436 // complete the processing of the current stroke.
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004437 const auto touchStateIt = mTouchStatesByDisplay.find(args.displayId);
Siarhei Vishniakou5bf25d92023-02-08 15:43:38 -08004438 if (touchStateIt != mTouchStatesByDisplay.end()) {
4439 const TouchState& touchState = touchStateIt->second;
Siarhei Vishniakou45504fe2023-05-05 16:05:10 -07004440 if (touchState.hasTouchingPointers(args.deviceId)) {
Siarhei Vishniakou5bf25d92023-02-08 15:43:38 -08004441 policyFlags |= POLICY_FLAG_PASS_TO_USER;
4442 }
4443 }
4444 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004445
4446 if (shouldSendMotionToInputFilterLocked(args)) {
Prabir Pradhan81420cc2021-09-06 10:28:50 -07004447 ui::Transform displayTransform;
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004448 if (const auto it = mDisplayInfos.find(args.displayId); it != mDisplayInfos.end()) {
Prabir Pradhan81420cc2021-09-06 10:28:50 -07004449 displayTransform = it->second.transform;
4450 }
4451
Michael Wrightd02c5b62014-02-10 15:10:22 -08004452 mLock.unlock();
4453
4454 MotionEvent event;
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004455 event.initialize(args.id, args.deviceId, args.source, args.displayId, INVALID_HMAC,
4456 args.action, args.actionButton, args.flags, args.edgeFlags,
4457 args.metaState, args.buttonState, args.classification,
4458 displayTransform, args.xPrecision, args.yPrecision,
4459 args.xCursorPosition, args.yCursorPosition, displayTransform,
Siarhei Vishniakou3218fc02023-06-15 20:41:02 -07004460 args.downTime, args.eventTime, args.getPointerCount(),
4461 args.pointerProperties.data(), args.pointerCoords.data());
Michael Wrightd02c5b62014-02-10 15:10:22 -08004462
4463 policyFlags |= POLICY_FLAG_FILTERED;
Prabir Pradhana41d2442023-04-20 21:30:40 +00004464 if (!mPolicy.filterInputEvent(event, policyFlags)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004465 return; // event was consumed by the filter
4466 }
4467
4468 mLock.lock();
4469 }
4470
4471 // Just enqueue a new motion event.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004472 std::unique_ptr<MotionEntry> newEntry =
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004473 std::make_unique<MotionEntry>(args.id, args.eventTime, args.deviceId, args.source,
4474 args.displayId, policyFlags, args.action,
4475 args.actionButton, args.flags, args.metaState,
4476 args.buttonState, args.classification, args.edgeFlags,
4477 args.xPrecision, args.yPrecision,
4478 args.xCursorPosition, args.yCursorPosition,
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07004479 args.downTime, args.pointerProperties,
4480 args.pointerCoords);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004481
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004482 if (args.id != android::os::IInputConstants::INVALID_INPUT_EVENT_ID &&
4483 IdGenerator::getSource(args.id) == IdGenerator::Source::INPUT_READER &&
Siarhei Vishniakou363e7292021-07-09 03:22:42 +00004484 !mInputFilterEnabled) {
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004485 const bool isDown = args.action == AMOTION_EVENT_ACTION_DOWN;
Asmita Poddardd9a6cd2023-09-26 15:35:12 +00004486 std::set<InputDeviceUsageSource> sources = getUsageSourcesForMotionArgs(args);
4487 mLatencyTracker.trackListener(args.id, isDown, args.eventTime, args.readTime,
4488 args.deviceId, sources);
Siarhei Vishniakou363e7292021-07-09 03:22:42 +00004489 }
4490
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004491 needWake = enqueueInboundEventLocked(std::move(newEntry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08004492 mLock.unlock();
4493 } // release lock
4494
4495 if (needWake) {
4496 mLooper->wake();
4497 }
4498}
4499
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004500void InputDispatcher::notifySensor(const NotifySensorArgs& args) {
Prabir Pradhan65613802023-02-22 23:36:58 +00004501 if (debugInboundEventDetails()) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004502 ALOGD("notifySensor - id=%" PRIx32 " eventTime=%" PRId64 ", deviceId=%d, source=0x%x, "
4503 " sensorType=%s",
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004504 args.id, args.eventTime, args.deviceId, args.source,
4505 ftl::enum_string(args.sensorType).c_str());
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004506 }
Chris Yef59a2f42020-10-16 12:55:26 -07004507
Antonio Kantekf16f2832021-09-28 04:39:20 +00004508 bool needWake = false;
Chris Yef59a2f42020-10-16 12:55:26 -07004509 { // acquire lock
4510 mLock.lock();
4511
4512 // Just enqueue a new sensor event.
4513 std::unique_ptr<SensorEntry> newEntry =
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004514 std::make_unique<SensorEntry>(args.id, args.eventTime, args.deviceId, args.source,
4515 /* policyFlags=*/0, args.hwTimestamp, args.sensorType,
4516 args.accuracy, args.accuracyChanged, args.values);
Chris Yef59a2f42020-10-16 12:55:26 -07004517
4518 needWake = enqueueInboundEventLocked(std::move(newEntry));
4519 mLock.unlock();
4520 } // release lock
4521
4522 if (needWake) {
4523 mLooper->wake();
4524 }
4525}
4526
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004527void InputDispatcher::notifyVibratorState(const NotifyVibratorStateArgs& args) {
Prabir Pradhan65613802023-02-22 23:36:58 +00004528 if (debugInboundEventDetails()) {
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004529 ALOGD("notifyVibratorState - eventTime=%" PRId64 ", device=%d, isOn=%d", args.eventTime,
4530 args.deviceId, args.isOn);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004531 }
Prabir Pradhana41d2442023-04-20 21:30:40 +00004532 mPolicy.notifyVibratorState(args.deviceId, args.isOn);
Chris Yefb552902021-02-03 17:18:37 -08004533}
4534
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004535bool InputDispatcher::shouldSendMotionToInputFilterLocked(const NotifyMotionArgs& args) {
Jackal Guof9696682018-10-05 12:23:23 +08004536 return mInputFilterEnabled;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004537}
4538
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004539void InputDispatcher::notifySwitch(const NotifySwitchArgs& args) {
Prabir Pradhan65613802023-02-22 23:36:58 +00004540 if (debugInboundEventDetails()) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004541 ALOGD("notifySwitch - eventTime=%" PRId64 ", policyFlags=0x%x, switchValues=0x%08x, "
4542 "switchMask=0x%08x",
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004543 args.eventTime, args.policyFlags, args.switchValues, args.switchMask);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004544 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004545
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004546 uint32_t policyFlags = args.policyFlags;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004547 policyFlags |= POLICY_FLAG_TRUSTED;
Prabir Pradhana41d2442023-04-20 21:30:40 +00004548 mPolicy.notifySwitch(args.eventTime, args.switchValues, args.switchMask, policyFlags);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004549}
4550
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004551void InputDispatcher::notifyDeviceReset(const NotifyDeviceResetArgs& args) {
Prabir Pradhan65613802023-02-22 23:36:58 +00004552 if (debugInboundEventDetails()) {
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004553 ALOGD("notifyDeviceReset - eventTime=%" PRId64 ", deviceId=%d", args.eventTime,
4554 args.deviceId);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004555 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004556
Antonio Kantekf16f2832021-09-28 04:39:20 +00004557 bool needWake = false;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004558 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004559 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004560
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004561 std::unique_ptr<DeviceResetEntry> newEntry =
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004562 std::make_unique<DeviceResetEntry>(args.id, args.eventTime, args.deviceId);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004563 needWake = enqueueInboundEventLocked(std::move(newEntry));
Siarhei Vishniakou1160ecd2023-06-28 15:57:47 -07004564
4565 for (auto& [_, verifier] : mVerifiersByDisplay) {
4566 verifier.resetDevice(args.deviceId);
4567 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004568 } // release lock
4569
4570 if (needWake) {
4571 mLooper->wake();
4572 }
4573}
4574
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004575void InputDispatcher::notifyPointerCaptureChanged(const NotifyPointerCaptureChangedArgs& args) {
Prabir Pradhan65613802023-02-22 23:36:58 +00004576 if (debugInboundEventDetails()) {
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004577 ALOGD("notifyPointerCaptureChanged - eventTime=%" PRId64 ", enabled=%s", args.eventTime,
4578 args.request.enable ? "true" : "false");
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004579 }
Prabir Pradhan7e186182020-11-10 13:56:45 -08004580
Antonio Kantekf16f2832021-09-28 04:39:20 +00004581 bool needWake = false;
Prabir Pradhan99987712020-11-10 18:43:05 -08004582 { // acquire lock
4583 std::scoped_lock _l(mLock);
Prabir Pradhanc392d8f2023-04-13 19:32:51 +00004584 auto entry =
4585 std::make_unique<PointerCaptureChangedEntry>(args.id, args.eventTime, args.request);
Prabir Pradhan99987712020-11-10 18:43:05 -08004586 needWake = enqueueInboundEventLocked(std::move(entry));
4587 } // release lock
4588
4589 if (needWake) {
4590 mLooper->wake();
4591 }
Prabir Pradhan7e186182020-11-10 13:56:45 -08004592}
4593
Prabir Pradhan5735a322022-04-11 17:23:34 +00004594InputEventInjectionResult InputDispatcher::injectInputEvent(const InputEvent* event,
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00004595 std::optional<gui::Uid> targetUid,
Prabir Pradhan5735a322022-04-11 17:23:34 +00004596 InputEventInjectionSync syncMode,
4597 std::chrono::milliseconds timeout,
4598 uint32_t policyFlags) {
Siarhei Vishniakou23740b92023-04-21 11:30:20 -07004599 Result<void> eventValidation = validateInputEvent(*event);
4600 if (!eventValidation.ok()) {
4601 LOG(INFO) << "Injection failed: invalid event: " << eventValidation.error();
4602 return InputEventInjectionResult::FAILED;
4603 }
4604
Prabir Pradhan65613802023-02-22 23:36:58 +00004605 if (debugInboundEventDetails()) {
Siarhei Vishniakou827d1ac2023-07-21 16:37:51 -07004606 LOG(INFO) << __func__ << ": targetUid=" << toString(targetUid, &uidString)
4607 << ", syncMode=" << ftl::enum_string(syncMode) << ", timeout=" << timeout.count()
4608 << "ms, policyFlags=0x" << std::hex << policyFlags << std::dec
4609 << ", event=" << *event;
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004610 }
Siarhei Vishniakou097c3db2020-05-06 14:18:38 -07004611 nsecs_t endTime = now() + std::chrono::duration_cast<std::chrono::nanoseconds>(timeout).count();
Michael Wrightd02c5b62014-02-10 15:10:22 -08004612
Prabir Pradhan5735a322022-04-11 17:23:34 +00004613 policyFlags |= POLICY_FLAG_INJECTED | POLICY_FLAG_TRUSTED;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004614
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004615 // For all injected events, set device id = VIRTUAL_KEYBOARD_ID. The only exception is events
Siarhei Vishniakouf00a4ec2021-06-16 03:55:32 +00004616 // that have gone through the InputFilter. If the event passed through the InputFilter, assign
4617 // the provided device id. If the InputFilter is accessibility, and it modifies or synthesizes
4618 // the injected event, it is responsible for setting POLICY_FLAG_INJECTED_FROM_ACCESSIBILITY.
4619 // For those events, we will set FLAG_IS_ACCESSIBILITY_EVENT to allow apps to distinguish them
4620 // from events that originate from actual hardware.
Siarhei Vishniakouf4043212023-09-18 19:33:03 -07004621 DeviceId resolvedDeviceId = VIRTUAL_KEYBOARD_ID;
Siarhei Vishniakouf00a4ec2021-06-16 03:55:32 +00004622 if (policyFlags & POLICY_FLAG_FILTERED) {
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004623 resolvedDeviceId = event->getDeviceId();
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004624 }
4625
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004626 std::queue<std::unique_ptr<EventEntry>> injectedEntries;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004627 switch (event->getType()) {
Siarhei Vishniakou63b63612023-04-12 11:00:23 -07004628 case InputEventType::KEY: {
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -08004629 const KeyEvent& incomingKey = static_cast<const KeyEvent&>(*event);
Siarhei Vishniakou23740b92023-04-21 11:30:20 -07004630 const int32_t action = incomingKey.getAction();
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -08004631 int32_t flags = incomingKey.getFlags();
Siarhei Vishniakouf00a4ec2021-06-16 03:55:32 +00004632 if (policyFlags & POLICY_FLAG_INJECTED_FROM_ACCESSIBILITY) {
4633 flags |= AKEY_EVENT_FLAG_IS_ACCESSIBILITY_EVENT;
4634 }
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -08004635 int32_t keyCode = incomingKey.getKeyCode();
4636 int32_t metaState = incomingKey.getMetaState();
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -08004637 KeyEvent keyEvent;
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004638 keyEvent.initialize(incomingKey.getId(), resolvedDeviceId, incomingKey.getSource(),
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -08004639 incomingKey.getDisplayId(), INVALID_HMAC, action, flags, keyCode,
4640 incomingKey.getScanCode(), metaState, incomingKey.getRepeatCount(),
4641 incomingKey.getDownTime(), incomingKey.getEventTime());
Michael Wrightd02c5b62014-02-10 15:10:22 -08004642
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004643 if (flags & AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY) {
4644 policyFlags |= POLICY_FLAG_VIRTUAL;
Michael Wright2b3c3302018-03-02 17:19:13 +00004645 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004646
4647 if (!(policyFlags & POLICY_FLAG_FILTERED)) {
4648 android::base::Timer t;
Prabir Pradhana41d2442023-04-20 21:30:40 +00004649 mPolicy.interceptKeyBeforeQueueing(keyEvent, /*byref*/ policyFlags);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004650 if (t.duration() > SLOW_INTERCEPTION_THRESHOLD) {
4651 ALOGW("Excessive delay in interceptKeyBeforeQueueing; took %s ms",
4652 std::to_string(t.duration().count()).c_str());
4653 }
4654 }
4655
4656 mLock.lock();
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004657 std::unique_ptr<KeyEntry> injectedEntry =
4658 std::make_unique<KeyEntry>(incomingKey.getId(), incomingKey.getEventTime(),
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004659 resolvedDeviceId, incomingKey.getSource(),
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004660 incomingKey.getDisplayId(), policyFlags, action,
4661 flags, keyCode, incomingKey.getScanCode(), metaState,
4662 incomingKey.getRepeatCount(),
4663 incomingKey.getDownTime());
4664 injectedEntries.push(std::move(injectedEntry));
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004665 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004666 }
4667
Siarhei Vishniakou63b63612023-04-12 11:00:23 -07004668 case InputEventType::MOTION: {
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004669 const MotionEvent& motionEvent = static_cast<const MotionEvent&>(*event);
Prabir Pradhanaa561d12021-09-24 06:57:33 -07004670 const bool isPointerEvent =
4671 isFromSource(event->getSource(), AINPUT_SOURCE_CLASS_POINTER);
4672 // If a pointer event has no displayId specified, inject it to the default display.
4673 const uint32_t displayId = isPointerEvent && (event->getDisplayId() == ADISPLAY_ID_NONE)
4674 ? ADISPLAY_ID_DEFAULT
4675 : event->getDisplayId();
Siarhei Vishniakouf00a4ec2021-06-16 03:55:32 +00004676 int32_t flags = motionEvent.getFlags();
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004677
4678 if (!(policyFlags & POLICY_FLAG_FILTERED)) {
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004679 nsecs_t eventTime = motionEvent.getEventTime();
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004680 android::base::Timer t;
Prabir Pradhana41d2442023-04-20 21:30:40 +00004681 mPolicy.interceptMotionBeforeQueueing(displayId, eventTime, /*byref*/ policyFlags);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004682 if (t.duration() > SLOW_INTERCEPTION_THRESHOLD) {
4683 ALOGW("Excessive delay in interceptMotionBeforeQueueing; took %s ms",
4684 std::to_string(t.duration().count()).c_str());
4685 }
4686 }
4687
Siarhei Vishniakouf00a4ec2021-06-16 03:55:32 +00004688 if (policyFlags & POLICY_FLAG_INJECTED_FROM_ACCESSIBILITY) {
4689 flags |= AMOTION_EVENT_FLAG_IS_ACCESSIBILITY_EVENT;
4690 }
4691
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004692 mLock.lock();
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004693 const nsecs_t* sampleEventTimes = motionEvent.getSampleEventTimes();
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07004694 const size_t pointerCount = motionEvent.getPointerCount();
4695 const std::vector<PointerProperties>
4696 pointerProperties(motionEvent.getPointerProperties(),
4697 motionEvent.getPointerProperties() + pointerCount);
4698
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004699 const PointerCoords* samplePointerCoords = motionEvent.getSamplePointerCoords();
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004700 std::unique_ptr<MotionEntry> injectedEntry =
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004701 std::make_unique<MotionEntry>(motionEvent.getId(), *sampleEventTimes,
4702 resolvedDeviceId, motionEvent.getSource(),
Siarhei Vishniakou23740b92023-04-21 11:30:20 -07004703 displayId, policyFlags, motionEvent.getAction(),
4704 motionEvent.getActionButton(), flags,
4705 motionEvent.getMetaState(),
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004706 motionEvent.getButtonState(),
4707 motionEvent.getClassification(),
4708 motionEvent.getEdgeFlags(),
4709 motionEvent.getXPrecision(),
4710 motionEvent.getYPrecision(),
4711 motionEvent.getRawXCursorPosition(),
4712 motionEvent.getRawYCursorPosition(),
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07004713 motionEvent.getDownTime(), pointerProperties,
4714 std::vector<PointerCoords>(samplePointerCoords,
4715 samplePointerCoords +
4716 pointerCount));
Prabir Pradhandaa2f142021-12-10 09:30:08 +00004717 transformMotionEntryForInjectionLocked(*injectedEntry, motionEvent.getTransform());
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004718 injectedEntries.push(std::move(injectedEntry));
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004719 for (size_t i = motionEvent.getHistorySize(); i > 0; i--) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004720 sampleEventTimes += 1;
Siarhei Vishniakou23740b92023-04-21 11:30:20 -07004721 samplePointerCoords += motionEvent.getPointerCount();
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07004722 std::unique_ptr<MotionEntry> nextInjectedEntry = std::make_unique<
4723 MotionEntry>(motionEvent.getId(), *sampleEventTimes, resolvedDeviceId,
4724 motionEvent.getSource(), displayId, policyFlags,
4725 motionEvent.getAction(), motionEvent.getActionButton(), flags,
4726 motionEvent.getMetaState(), motionEvent.getButtonState(),
4727 motionEvent.getClassification(), motionEvent.getEdgeFlags(),
4728 motionEvent.getXPrecision(), motionEvent.getYPrecision(),
4729 motionEvent.getRawXCursorPosition(),
4730 motionEvent.getRawYCursorPosition(), motionEvent.getDownTime(),
4731 pointerProperties,
4732 std::vector<PointerCoords>(samplePointerCoords,
4733 samplePointerCoords +
4734 pointerCount));
Prabir Pradhandaa2f142021-12-10 09:30:08 +00004735 transformMotionEntryForInjectionLocked(*nextInjectedEntry,
4736 motionEvent.getTransform());
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004737 injectedEntries.push(std::move(nextInjectedEntry));
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004738 }
4739 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004740 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004741
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004742 default:
Siarhei Vishniakou63b63612023-04-12 11:00:23 -07004743 LOG(WARNING) << "Cannot inject " << ftl::enum_string(event->getType()) << " events";
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004744 return InputEventInjectionResult::FAILED;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004745 }
4746
Prabir Pradhan5735a322022-04-11 17:23:34 +00004747 InjectionState* injectionState = new InjectionState(targetUid);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004748 if (syncMode == InputEventInjectionSync::NONE) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004749 injectionState->injectionIsAsync = true;
4750 }
4751
4752 injectionState->refCount += 1;
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07004753 injectedEntries.back()->injectionState = injectionState;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004754
4755 bool needWake = false;
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07004756 while (!injectedEntries.empty()) {
Siarhei Vishniakoud010b012023-01-18 15:00:53 -08004757 if (DEBUG_INJECTION) {
Siarhei Vishniakou827d1ac2023-07-21 16:37:51 -07004758 LOG(INFO) << "Injecting " << injectedEntries.front()->getDescription();
Siarhei Vishniakoud010b012023-01-18 15:00:53 -08004759 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004760 needWake |= enqueueInboundEventLocked(std::move(injectedEntries.front()));
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07004761 injectedEntries.pop();
Michael Wrightd02c5b62014-02-10 15:10:22 -08004762 }
4763
4764 mLock.unlock();
4765
4766 if (needWake) {
4767 mLooper->wake();
4768 }
4769
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004770 InputEventInjectionResult injectionResult;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004771 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004772 std::unique_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004773
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004774 if (syncMode == InputEventInjectionSync::NONE) {
4775 injectionResult = InputEventInjectionResult::SUCCEEDED;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004776 } else {
4777 for (;;) {
4778 injectionResult = injectionState->injectionResult;
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004779 if (injectionResult != InputEventInjectionResult::PENDING) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004780 break;
4781 }
4782
4783 nsecs_t remainingTimeout = endTime - now();
4784 if (remainingTimeout <= 0) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004785 if (DEBUG_INJECTION) {
4786 ALOGD("injectInputEvent - Timed out waiting for injection result "
4787 "to become available.");
4788 }
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004789 injectionResult = InputEventInjectionResult::TIMED_OUT;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004790 break;
4791 }
4792
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004793 mInjectionResultAvailable.wait_for(_l, std::chrono::nanoseconds(remainingTimeout));
Michael Wrightd02c5b62014-02-10 15:10:22 -08004794 }
4795
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004796 if (injectionResult == InputEventInjectionResult::SUCCEEDED &&
4797 syncMode == InputEventInjectionSync::WAIT_FOR_FINISHED) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004798 while (injectionState->pendingForegroundDispatches != 0) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004799 if (DEBUG_INJECTION) {
4800 ALOGD("injectInputEvent - Waiting for %d pending foreground dispatches.",
4801 injectionState->pendingForegroundDispatches);
4802 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004803 nsecs_t remainingTimeout = endTime - now();
4804 if (remainingTimeout <= 0) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004805 if (DEBUG_INJECTION) {
4806 ALOGD("injectInputEvent - Timed out waiting for pending foreground "
4807 "dispatches to finish.");
4808 }
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004809 injectionResult = InputEventInjectionResult::TIMED_OUT;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004810 break;
4811 }
4812
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004813 mInjectionSyncFinished.wait_for(_l, std::chrono::nanoseconds(remainingTimeout));
Michael Wrightd02c5b62014-02-10 15:10:22 -08004814 }
4815 }
4816 }
4817
4818 injectionState->release();
4819 } // release lock
4820
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004821 if (DEBUG_INJECTION) {
Siarhei Vishniakou827d1ac2023-07-21 16:37:51 -07004822 LOG(INFO) << "injectInputEvent - Finished with result "
4823 << ftl::enum_string(injectionResult);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004824 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004825
4826 return injectionResult;
4827}
4828
Siarhei Vishniakou54d3e182020-01-15 17:38:38 -08004829std::unique_ptr<VerifiedInputEvent> InputDispatcher::verifyInputEvent(const InputEvent& event) {
Gang Wange9087892020-01-07 12:17:14 -05004830 std::array<uint8_t, 32> calculatedHmac;
4831 std::unique_ptr<VerifiedInputEvent> result;
4832 switch (event.getType()) {
Siarhei Vishniakou63b63612023-04-12 11:00:23 -07004833 case InputEventType::KEY: {
Gang Wange9087892020-01-07 12:17:14 -05004834 const KeyEvent& keyEvent = static_cast<const KeyEvent&>(event);
4835 VerifiedKeyEvent verifiedKeyEvent = verifiedKeyEventFromKeyEvent(keyEvent);
4836 result = std::make_unique<VerifiedKeyEvent>(verifiedKeyEvent);
chaviw09c8d2d2020-08-24 15:48:26 -07004837 calculatedHmac = sign(verifiedKeyEvent);
Gang Wange9087892020-01-07 12:17:14 -05004838 break;
4839 }
Siarhei Vishniakou63b63612023-04-12 11:00:23 -07004840 case InputEventType::MOTION: {
Gang Wange9087892020-01-07 12:17:14 -05004841 const MotionEvent& motionEvent = static_cast<const MotionEvent&>(event);
4842 VerifiedMotionEvent verifiedMotionEvent =
4843 verifiedMotionEventFromMotionEvent(motionEvent);
4844 result = std::make_unique<VerifiedMotionEvent>(verifiedMotionEvent);
chaviw09c8d2d2020-08-24 15:48:26 -07004845 calculatedHmac = sign(verifiedMotionEvent);
Gang Wange9087892020-01-07 12:17:14 -05004846 break;
4847 }
4848 default: {
4849 ALOGE("Cannot verify events of type %" PRId32, event.getType());
4850 return nullptr;
4851 }
4852 }
4853 if (calculatedHmac == INVALID_HMAC) {
4854 return nullptr;
4855 }
tyiu1573a672023-02-21 22:38:32 +00004856 if (0 != CRYPTO_memcmp(calculatedHmac.data(), event.getHmac().data(), calculatedHmac.size())) {
Gang Wange9087892020-01-07 12:17:14 -05004857 return nullptr;
4858 }
4859 return result;
Siarhei Vishniakou54d3e182020-01-15 17:38:38 -08004860}
4861
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004862void InputDispatcher::setInjectionResult(EventEntry& entry,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004863 InputEventInjectionResult injectionResult) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004864 InjectionState* injectionState = entry.injectionState;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004865 if (injectionState) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004866 if (DEBUG_INJECTION) {
Siarhei Vishniakou827d1ac2023-07-21 16:37:51 -07004867 LOG(INFO) << "Setting input event injection result to "
4868 << ftl::enum_string(injectionResult);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004869 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004870
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004871 if (injectionState->injectionIsAsync && !(entry.policyFlags & POLICY_FLAG_FILTERED)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004872 // Log the outcome since the injector did not wait for the injection result.
4873 switch (injectionResult) {
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004874 case InputEventInjectionResult::SUCCEEDED:
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004875 ALOGV("Asynchronous input event injection succeeded.");
4876 break;
Prabir Pradhan5735a322022-04-11 17:23:34 +00004877 case InputEventInjectionResult::TARGET_MISMATCH:
4878 ALOGV("Asynchronous input event injection target mismatch.");
4879 break;
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004880 case InputEventInjectionResult::FAILED:
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004881 ALOGW("Asynchronous input event injection failed.");
4882 break;
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004883 case InputEventInjectionResult::TIMED_OUT:
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004884 ALOGW("Asynchronous input event injection timed out.");
4885 break;
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004886 case InputEventInjectionResult::PENDING:
4887 ALOGE("Setting result to 'PENDING' for asynchronous injection");
4888 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004889 }
4890 }
4891
4892 injectionState->injectionResult = injectionResult;
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004893 mInjectionResultAvailable.notify_all();
Michael Wrightd02c5b62014-02-10 15:10:22 -08004894 }
4895}
4896
Prabir Pradhandaa2f142021-12-10 09:30:08 +00004897void InputDispatcher::transformMotionEntryForInjectionLocked(
4898 MotionEntry& entry, const ui::Transform& injectedTransform) const {
Prabir Pradhan81420cc2021-09-06 10:28:50 -07004899 // Input injection works in the logical display coordinate space, but the input pipeline works
4900 // display space, so we need to transform the injected events accordingly.
4901 const auto it = mDisplayInfos.find(entry.displayId);
4902 if (it == mDisplayInfos.end()) return;
Prabir Pradhandaa2f142021-12-10 09:30:08 +00004903 const auto& transformToDisplay = it->second.transform.inverse() * injectedTransform;
Prabir Pradhan81420cc2021-09-06 10:28:50 -07004904
Prabir Pradhand9a2ebe2022-07-20 19:25:13 +00004905 if (entry.xCursorPosition != AMOTION_EVENT_INVALID_CURSOR_POSITION &&
4906 entry.yCursorPosition != AMOTION_EVENT_INVALID_CURSOR_POSITION) {
4907 const vec2 cursor =
4908 MotionEvent::calculateTransformedXY(entry.source, transformToDisplay,
4909 {entry.xCursorPosition, entry.yCursorPosition});
4910 entry.xCursorPosition = cursor.x;
4911 entry.yCursorPosition = cursor.y;
4912 }
Siarhei Vishniakouedd61202023-10-18 11:22:40 -07004913 for (uint32_t i = 0; i < entry.getPointerCount(); i++) {
Prabir Pradhan8e6ce222022-02-24 09:08:54 -08004914 entry.pointerCoords[i] =
4915 MotionEvent::calculateTransformedCoords(entry.source, transformToDisplay,
4916 entry.pointerCoords[i]);
Prabir Pradhan81420cc2021-09-06 10:28:50 -07004917 }
4918}
4919
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004920void InputDispatcher::incrementPendingForegroundDispatches(EventEntry& entry) {
4921 InjectionState* injectionState = entry.injectionState;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004922 if (injectionState) {
4923 injectionState->pendingForegroundDispatches += 1;
4924 }
4925}
4926
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004927void InputDispatcher::decrementPendingForegroundDispatches(EventEntry& entry) {
4928 InjectionState* injectionState = entry.injectionState;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004929 if (injectionState) {
4930 injectionState->pendingForegroundDispatches -= 1;
4931
4932 if (injectionState->pendingForegroundDispatches == 0) {
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004933 mInjectionSyncFinished.notify_all();
Michael Wrightd02c5b62014-02-10 15:10:22 -08004934 }
4935 }
4936}
4937
chaviw98318de2021-05-19 16:45:23 -05004938const std::vector<sp<WindowInfoHandle>>& InputDispatcher::getWindowHandlesLocked(
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08004939 int32_t displayId) const {
chaviw98318de2021-05-19 16:45:23 -05004940 static const std::vector<sp<WindowInfoHandle>> EMPTY_WINDOW_HANDLES;
Vishnu Nairad321cd2020-08-20 16:40:21 -07004941 auto it = mWindowHandlesByDisplay.find(displayId);
4942 return it != mWindowHandlesByDisplay.end() ? it->second : EMPTY_WINDOW_HANDLES;
Arthur Hungb92218b2018-08-14 12:00:21 +08004943}
4944
chaviw98318de2021-05-19 16:45:23 -05004945sp<WindowInfoHandle> InputDispatcher::getWindowHandleLocked(
Prabir Pradhan16463382023-10-12 23:03:19 +00004946 const sp<IBinder>& windowHandleToken, std::optional<int32_t> displayId) const {
arthurhungbe737672020-06-24 12:29:21 +08004947 if (windowHandleToken == nullptr) {
4948 return nullptr;
4949 }
4950
Prabir Pradhan16463382023-10-12 23:03:19 +00004951 if (!displayId) {
4952 // Look through all displays.
4953 for (auto& it : mWindowHandlesByDisplay) {
4954 const std::vector<sp<WindowInfoHandle>>& windowHandles = it.second;
4955 for (const sp<WindowInfoHandle>& windowHandle : windowHandles) {
4956 if (windowHandle->getToken() == windowHandleToken) {
4957 return windowHandle;
4958 }
Arthur Hungb92218b2018-08-14 12:00:21 +08004959 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004960 }
Vishnu Nairad321cd2020-08-20 16:40:21 -07004961 return nullptr;
4962 }
4963
Prabir Pradhan16463382023-10-12 23:03:19 +00004964 // Only look through the requested display.
4965 for (const sp<WindowInfoHandle>& windowHandle : getWindowHandlesLocked(*displayId)) {
Vishnu Nairad321cd2020-08-20 16:40:21 -07004966 if (windowHandle->getToken() == windowHandleToken) {
4967 return windowHandle;
4968 }
4969 }
4970 return nullptr;
4971}
4972
chaviw98318de2021-05-19 16:45:23 -05004973sp<WindowInfoHandle> InputDispatcher::getWindowHandleLocked(
4974 const sp<WindowInfoHandle>& windowHandle) const {
Mady Mellor017bcd12020-06-23 19:12:00 +00004975 for (auto& it : mWindowHandlesByDisplay) {
chaviw98318de2021-05-19 16:45:23 -05004976 const std::vector<sp<WindowInfoHandle>>& windowHandles = it.second;
4977 for (const sp<WindowInfoHandle>& handle : windowHandles) {
arthurhungbe737672020-06-24 12:29:21 +08004978 if (handle->getId() == windowHandle->getId() &&
4979 handle->getToken() == windowHandle->getToken()) {
Mady Mellor017bcd12020-06-23 19:12:00 +00004980 if (windowHandle->getInfo()->displayId != it.first) {
4981 ALOGE("Found window %s in display %" PRId32
4982 ", but it should belong to display %" PRId32,
4983 windowHandle->getName().c_str(), it.first,
4984 windowHandle->getInfo()->displayId);
4985 }
Prabir Pradhan6a9a8312021-04-23 11:59:31 -07004986 return handle;
Arthur Hungb92218b2018-08-14 12:00:21 +08004987 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004988 }
4989 }
Prabir Pradhan6a9a8312021-04-23 11:59:31 -07004990 return nullptr;
4991}
4992
chaviw98318de2021-05-19 16:45:23 -05004993sp<WindowInfoHandle> InputDispatcher::getFocusedWindowHandleLocked(int displayId) const {
Prabir Pradhan6a9a8312021-04-23 11:59:31 -07004994 sp<IBinder> focusedToken = mFocusResolver.getFocusedWindowToken(displayId);
4995 return getWindowHandleLocked(focusedToken, displayId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004996}
4997
Prabir Pradhan33e3baa2022-12-06 20:30:22 +00004998ui::Transform InputDispatcher::getTransformLocked(int32_t displayId) const {
4999 auto displayInfoIt = mDisplayInfos.find(displayId);
5000 return displayInfoIt != mDisplayInfos.end() ? displayInfoIt->second.transform
5001 : kIdentityTransform;
5002}
5003
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07005004bool InputDispatcher::canWindowReceiveMotionLocked(const sp<WindowInfoHandle>& window,
5005 const MotionEntry& motionEntry) const {
5006 const WindowInfo& info = *window->getInfo();
5007
5008 // Skip spy window targets that are not valid for targeted injection.
5009 if (const auto err = verifyTargetedInjection(window, motionEntry); err) {
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05005010 return false;
5011 }
5012
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07005013 if (info.inputConfig.test(WindowInfo::InputConfig::PAUSE_DISPATCHING)) {
5014 ALOGI("Not sending touch event to %s because it is paused", window->getName().c_str());
5015 return false;
5016 }
5017
5018 if (info.inputConfig.test(WindowInfo::InputConfig::NO_INPUT_CHANNEL)) {
5019 ALOGW("Not sending touch gesture to %s because it has config NO_INPUT_CHANNEL",
5020 window->getName().c_str());
5021 return false;
5022 }
5023
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07005024 std::shared_ptr<Connection> connection = getConnectionLocked(window->getToken());
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05005025 if (connection == nullptr) {
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07005026 ALOGW("Not sending touch to %s because there's no corresponding connection",
5027 window->getName().c_str());
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05005028 return false;
5029 }
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07005030
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05005031 if (!connection->responsive) {
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07005032 ALOGW("Not sending touch to %s because it is not responsive", window->getName().c_str());
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05005033 return false;
5034 }
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07005035
5036 // Drop events that can't be trusted due to occlusion
5037 const auto [x, y] = resolveTouchedPosition(motionEntry);
5038 TouchOcclusionInfo occlusionInfo = computeTouchOcclusionInfoLocked(window, x, y);
5039 if (!isTouchTrustedLocked(occlusionInfo)) {
5040 if (DEBUG_TOUCH_OCCLUSION) {
Prabir Pradhan82e081e2022-12-06 09:50:09 +00005041 ALOGD("Stack of obscuring windows during untrusted touch (%.1f, %.1f):", x, y);
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07005042 for (const auto& log : occlusionInfo.debugInfo) {
5043 ALOGD("%s", log.c_str());
5044 }
5045 }
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00005046 ALOGW("Dropping untrusted touch event due to %s/%s", occlusionInfo.obscuringPackage.c_str(),
5047 occlusionInfo.obscuringUid.toString().c_str());
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -07005048 return false;
5049 }
5050
5051 // Drop touch events if requested by input feature
5052 if (shouldDropInput(motionEntry, window)) {
5053 return false;
5054 }
5055
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05005056 return true;
5057}
5058
Siarhei Vishniakouce5ab082020-07-09 17:03:21 -05005059std::shared_ptr<InputChannel> InputDispatcher::getInputChannelLocked(
5060 const sp<IBinder>& token) const {
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005061 auto connectionIt = mConnectionsByToken.find(token);
5062 if (connectionIt == mConnectionsByToken.end()) {
Robert Carr5c8a0262018-10-03 16:30:44 -07005063 return nullptr;
5064 }
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005065 return connectionIt->second->inputChannel;
Robert Carr5c8a0262018-10-03 16:30:44 -07005066}
5067
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005068void InputDispatcher::updateWindowHandlesForDisplayLocked(
chaviw98318de2021-05-19 16:45:23 -05005069 const std::vector<sp<WindowInfoHandle>>& windowInfoHandles, int32_t displayId) {
5070 if (windowInfoHandles.empty()) {
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005071 // Remove all handles on a display if there are no windows left.
5072 mWindowHandlesByDisplay.erase(displayId);
5073 return;
5074 }
5075
5076 // Since we compare the pointer of input window handles across window updates, we need
5077 // to make sure the handle object for the same window stays unchanged across updates.
chaviw98318de2021-05-19 16:45:23 -05005078 const std::vector<sp<WindowInfoHandle>>& oldHandles = getWindowHandlesLocked(displayId);
5079 std::unordered_map<int32_t /*id*/, sp<WindowInfoHandle>> oldHandlesById;
5080 for (const sp<WindowInfoHandle>& handle : oldHandles) {
chaviwaf87b3e2019-10-01 16:59:28 -07005081 oldHandlesById[handle->getId()] = handle;
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005082 }
5083
chaviw98318de2021-05-19 16:45:23 -05005084 std::vector<sp<WindowInfoHandle>> newHandles;
5085 for (const sp<WindowInfoHandle>& handle : windowInfoHandles) {
chaviw98318de2021-05-19 16:45:23 -05005086 const WindowInfo* info = handle->getInfo();
Siarhei Vishniakou64452932020-11-06 17:51:32 -06005087 if (getInputChannelLocked(handle->getToken()) == nullptr) {
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005088 const bool noInputChannel =
Prabir Pradhan51e7db02022-02-07 06:02:57 -08005089 info->inputConfig.test(WindowInfo::InputConfig::NO_INPUT_CHANNEL);
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08005090 const bool canReceiveInput =
5091 !info->inputConfig.test(WindowInfo::InputConfig::NOT_TOUCHABLE) ||
5092 !info->inputConfig.test(WindowInfo::InputConfig::NOT_FOCUSABLE);
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005093 if (canReceiveInput && !noInputChannel) {
John Recke0710582019-09-26 13:46:12 -07005094 ALOGV("Window handle %s has no registered input channel",
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005095 handle->getName().c_str());
Robert Carr2984b7a2020-04-13 17:06:45 -07005096 continue;
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005097 }
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005098 }
5099
5100 if (info->displayId != displayId) {
5101 ALOGE("Window %s updated by wrong display %d, should belong to display %d",
5102 handle->getName().c_str(), displayId, info->displayId);
5103 continue;
5104 }
5105
Robert Carredd13602020-04-13 17:24:34 -07005106 if ((oldHandlesById.find(handle->getId()) != oldHandlesById.end()) &&
5107 (oldHandlesById.at(handle->getId())->getToken() == handle->getToken())) {
chaviw98318de2021-05-19 16:45:23 -05005108 const sp<WindowInfoHandle>& oldHandle = oldHandlesById.at(handle->getId());
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005109 oldHandle->updateFrom(handle);
5110 newHandles.push_back(oldHandle);
5111 } else {
5112 newHandles.push_back(handle);
5113 }
5114 }
5115
5116 // Insert or replace
5117 mWindowHandlesByDisplay[displayId] = newHandles;
5118}
5119
Arthur Hungb92218b2018-08-14 12:00:21 +08005120/**
5121 * Called from InputManagerService, update window handle list by displayId that can receive input.
5122 * A window handle contains information about InputChannel, Touch Region, Types, Focused,...
5123 * If set an empty list, remove all handles from the specific display.
5124 * For focused handle, check if need to change and send a cancel event to previous one.
5125 * For removed handle, check if need to send a cancel event if already in touch.
5126 */
Arthur Hung72d8dc32020-03-28 00:48:39 +00005127void InputDispatcher::setInputWindowsLocked(
chaviw98318de2021-05-19 16:45:23 -05005128 const std::vector<sp<WindowInfoHandle>>& windowInfoHandles, int32_t displayId) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005129 if (DEBUG_FOCUS) {
5130 std::string windowList;
chaviw98318de2021-05-19 16:45:23 -05005131 for (const sp<WindowInfoHandle>& iwh : windowInfoHandles) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005132 windowList += iwh->getName() + " ";
5133 }
5134 ALOGD("setInputWindows displayId=%" PRId32 " %s", displayId, windowList.c_str());
5135 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005136
Prabir Pradhand65552b2021-10-07 11:23:50 -07005137 // Check preconditions for new input windows
chaviw98318de2021-05-19 16:45:23 -05005138 for (const sp<WindowInfoHandle>& window : windowInfoHandles) {
Prabir Pradhand65552b2021-10-07 11:23:50 -07005139 const WindowInfo& info = *window->getInfo();
5140
5141 // Ensure all tokens are null if the window has feature NO_INPUT_CHANNEL
Prabir Pradhan51e7db02022-02-07 06:02:57 -08005142 const bool noInputWindow = info.inputConfig.test(WindowInfo::InputConfig::NO_INPUT_CHANNEL);
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05005143 if (noInputWindow && window->getToken() != nullptr) {
5144 ALOGE("%s has feature NO_INPUT_WINDOW, but a non-null token. Clearing",
5145 window->getName().c_str());
5146 window->releaseChannel();
5147 }
Prabir Pradhand65552b2021-10-07 11:23:50 -07005148
Prabir Pradhan5c85e052021-12-22 02:27:12 -08005149 // Ensure all spy windows are trusted overlays
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08005150 LOG_ALWAYS_FATAL_IF(info.isSpy() &&
5151 !info.inputConfig.test(
5152 WindowInfo::InputConfig::TRUSTED_OVERLAY),
Prabir Pradhan5c85e052021-12-22 02:27:12 -08005153 "%s has feature SPY, but is not a trusted overlay.",
5154 window->getName().c_str());
5155
Prabir Pradhand65552b2021-10-07 11:23:50 -07005156 // Ensure all stylus interceptors are trusted overlays
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08005157 LOG_ALWAYS_FATAL_IF(info.interceptsStylus() &&
5158 !info.inputConfig.test(
5159 WindowInfo::InputConfig::TRUSTED_OVERLAY),
Prabir Pradhand65552b2021-10-07 11:23:50 -07005160 "%s has feature INTERCEPTS_STYLUS, but is not a trusted overlay.",
5161 window->getName().c_str());
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05005162 }
5163
Arthur Hung72d8dc32020-03-28 00:48:39 +00005164 // Copy old handles for release if they are no longer present.
chaviw98318de2021-05-19 16:45:23 -05005165 const std::vector<sp<WindowInfoHandle>> oldWindowHandles = getWindowHandlesLocked(displayId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005166
chaviw98318de2021-05-19 16:45:23 -05005167 updateWindowHandlesForDisplayLocked(windowInfoHandles, displayId);
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07005168
chaviw98318de2021-05-19 16:45:23 -05005169 const std::vector<sp<WindowInfoHandle>>& windowHandles = getWindowHandlesLocked(displayId);
Arthur Hung72d8dc32020-03-28 00:48:39 +00005170
Vishnu Nairc519ff72021-01-21 08:23:08 -08005171 std::optional<FocusResolver::FocusChanges> changes =
5172 mFocusResolver.setInputWindows(displayId, windowHandles);
5173 if (changes) {
5174 onFocusChangedLocked(*changes);
Arthur Hung72d8dc32020-03-28 00:48:39 +00005175 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005176
Siarhei Vishniakou4700f822020-03-24 19:05:54 -07005177 std::unordered_map<int32_t, TouchState>::iterator stateIt =
5178 mTouchStatesByDisplay.find(displayId);
5179 if (stateIt != mTouchStatesByDisplay.end()) {
5180 TouchState& state = stateIt->second;
Arthur Hung72d8dc32020-03-28 00:48:39 +00005181 for (size_t i = 0; i < state.windows.size();) {
5182 TouchedWindow& touchedWindow = state.windows[i];
Prabir Pradhan6a9a8312021-04-23 11:59:31 -07005183 if (getWindowHandleLocked(touchedWindow.windowHandle) == nullptr) {
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07005184 LOG(INFO) << "Touched window was removed: " << touchedWindow.windowHandle->getName()
5185 << " in display %" << displayId;
Siarhei Vishniakouce5ab082020-07-09 17:03:21 -05005186 std::shared_ptr<InputChannel> touchedInputChannel =
Arthur Hung72d8dc32020-03-28 00:48:39 +00005187 getInputChannelLocked(touchedWindow.windowHandle->getToken());
5188 if (touchedInputChannel != nullptr) {
Michael Wrightfb04fd52022-11-24 22:31:11 +00005189 CancelationOptions options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS,
Arthur Hung72d8dc32020-03-28 00:48:39 +00005190 "touched window was removed");
5191 synthesizeCancelationEventsForInputChannelLocked(touchedInputChannel, options);
Siarhei Vishniakouca205502021-07-16 21:31:58 +00005192 // Since we are about to drop the touch, cancel the events for the wallpaper as
5193 // well.
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08005194 if (touchedWindow.targetFlags.test(InputTarget::Flags::FOREGROUND) &&
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08005195 touchedWindow.windowHandle->getInfo()->inputConfig.test(
5196 gui::WindowInfo::InputConfig::DUPLICATE_TOUCH_TO_WALLPAPER)) {
Siarhei Vishniakouca205502021-07-16 21:31:58 +00005197 sp<WindowInfoHandle> wallpaper = state.getWallpaperWindow();
Arthur Hungc539dbb2022-12-08 07:45:36 +00005198 synthesizeCancelationEventsForWindowLocked(wallpaper, options);
Siarhei Vishniakouca205502021-07-16 21:31:58 +00005199 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005200 }
Arthur Hung72d8dc32020-03-28 00:48:39 +00005201 state.windows.erase(state.windows.begin() + i);
5202 } else {
5203 ++i;
Michael Wrightd02c5b62014-02-10 15:10:22 -08005204 }
5205 }
arthurhungb89ccb02020-12-30 16:19:01 +08005206
arthurhung6d4bed92021-03-17 11:59:33 +08005207 // If drag window is gone, it would receive a cancel event and broadcast the DRAG_END. We
arthurhungb89ccb02020-12-30 16:19:01 +08005208 // could just clear the state here.
Arthur Hung3915c1f2022-05-31 07:17:17 +00005209 if (mDragState && mDragState->dragWindow->getInfo()->displayId == displayId &&
arthurhung6d4bed92021-03-17 11:59:33 +08005210 std::find(windowHandles.begin(), windowHandles.end(), mDragState->dragWindow) ==
arthurhungb89ccb02020-12-30 16:19:01 +08005211 windowHandles.end()) {
Arthur Hung3915c1f2022-05-31 07:17:17 +00005212 ALOGI("Drag window went away: %s", mDragState->dragWindow->getName().c_str());
5213 sendDropWindowCommandLocked(nullptr, 0, 0);
arthurhung6d4bed92021-03-17 11:59:33 +08005214 mDragState.reset();
arthurhungb89ccb02020-12-30 16:19:01 +08005215 }
Arthur Hung72d8dc32020-03-28 00:48:39 +00005216 }
Arthur Hung25e2af12020-03-26 12:58:37 +00005217
Arthur Hung72d8dc32020-03-28 00:48:39 +00005218 // Release information for windows that are no longer present.
5219 // This ensures that unused input channels are released promptly.
5220 // Otherwise, they might stick around until the window handle is destroyed
5221 // which might not happen until the next GC.
chaviw98318de2021-05-19 16:45:23 -05005222 for (const sp<WindowInfoHandle>& oldWindowHandle : oldWindowHandles) {
Prabir Pradhan6a9a8312021-04-23 11:59:31 -07005223 if (getWindowHandleLocked(oldWindowHandle) == nullptr) {
Arthur Hung72d8dc32020-03-28 00:48:39 +00005224 if (DEBUG_FOCUS) {
5225 ALOGD("Window went away: %s", oldWindowHandle->getName().c_str());
Arthur Hung25e2af12020-03-26 12:58:37 +00005226 }
Arthur Hung72d8dc32020-03-28 00:48:39 +00005227 oldWindowHandle->releaseChannel();
Arthur Hung25e2af12020-03-26 12:58:37 +00005228 }
chaviw291d88a2019-02-14 10:33:58 -08005229 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005230}
5231
5232void InputDispatcher::setFocusedApplication(
Chris Yea209fde2020-07-22 13:54:51 -07005233 int32_t displayId, const std::shared_ptr<InputApplicationHandle>& inputApplicationHandle) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005234 if (DEBUG_FOCUS) {
5235 ALOGD("setFocusedApplication displayId=%" PRId32 " %s", displayId,
5236 inputApplicationHandle ? inputApplicationHandle->getName().c_str() : "<nullptr>");
5237 }
Siarhei Vishniakoue41c4512020-09-08 19:35:58 -05005238 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08005239 std::scoped_lock _l(mLock);
Vishnu Nair599f1412021-06-21 10:39:58 -07005240 setFocusedApplicationLocked(displayId, inputApplicationHandle);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005241 } // release lock
5242
5243 // Wake up poll loop since it may need to make new input dispatching choices.
5244 mLooper->wake();
5245}
5246
Vishnu Nair599f1412021-06-21 10:39:58 -07005247void InputDispatcher::setFocusedApplicationLocked(
5248 int32_t displayId, const std::shared_ptr<InputApplicationHandle>& inputApplicationHandle) {
5249 std::shared_ptr<InputApplicationHandle> oldFocusedApplicationHandle =
5250 getValueByKey(mFocusedApplicationHandlesByDisplay, displayId);
5251
5252 if (sharedPointersEqual(oldFocusedApplicationHandle, inputApplicationHandle)) {
5253 return; // This application is already focused. No need to wake up or change anything.
5254 }
5255
5256 // Set the new application handle.
5257 if (inputApplicationHandle != nullptr) {
5258 mFocusedApplicationHandlesByDisplay[displayId] = inputApplicationHandle;
5259 } else {
5260 mFocusedApplicationHandlesByDisplay.erase(displayId);
5261 }
5262
5263 // No matter what the old focused application was, stop waiting on it because it is
5264 // no longer focused.
5265 resetNoFocusedWindowTimeoutLocked();
5266}
5267
Tiger Huang721e26f2018-07-24 22:26:19 +08005268/**
5269 * Sets the focused display, which is responsible for receiving focus-dispatched input events where
5270 * the display not specified.
5271 *
5272 * We track any unreleased events for each window. If a window loses the ability to receive the
5273 * released event, we will send a cancel event to it. So when the focused display is changed, we
5274 * cancel all the unreleased display-unspecified events for the focused window on the old focused
5275 * display. The display-specified events won't be affected.
5276 */
5277void InputDispatcher::setFocusedDisplay(int32_t displayId) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005278 if (DEBUG_FOCUS) {
5279 ALOGD("setFocusedDisplay displayId=%" PRId32, displayId);
5280 }
Tiger Huang721e26f2018-07-24 22:26:19 +08005281 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08005282 std::scoped_lock _l(mLock);
Tiger Huang721e26f2018-07-24 22:26:19 +08005283
5284 if (mFocusedDisplayId != displayId) {
Vishnu Nairad321cd2020-08-20 16:40:21 -07005285 sp<IBinder> oldFocusedWindowToken =
Vishnu Nairc519ff72021-01-21 08:23:08 -08005286 mFocusResolver.getFocusedWindowToken(mFocusedDisplayId);
Vishnu Nairad321cd2020-08-20 16:40:21 -07005287 if (oldFocusedWindowToken != nullptr) {
Siarhei Vishniakouce5ab082020-07-09 17:03:21 -05005288 std::shared_ptr<InputChannel> inputChannel =
Vishnu Nairad321cd2020-08-20 16:40:21 -07005289 getInputChannelLocked(oldFocusedWindowToken);
Tiger Huang721e26f2018-07-24 22:26:19 +08005290 if (inputChannel != nullptr) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07005291 CancelationOptions
Michael Wrightfb04fd52022-11-24 22:31:11 +00005292 options(CancelationOptions::Mode::CANCEL_NON_POINTER_EVENTS,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07005293 "The display which contains this window no longer has focus.");
Michael Wright3dd60e22019-03-27 22:06:44 +00005294 options.displayId = ADISPLAY_ID_NONE;
Tiger Huang721e26f2018-07-24 22:26:19 +08005295 synthesizeCancelationEventsForInputChannelLocked(inputChannel, options);
5296 }
5297 }
5298 mFocusedDisplayId = displayId;
5299
Chris Ye3c2d6f52020-08-09 10:39:48 -07005300 // Find new focused window and validate
Vishnu Nairc519ff72021-01-21 08:23:08 -08005301 sp<IBinder> newFocusedWindowToken = mFocusResolver.getFocusedWindowToken(displayId);
Prabir Pradhancef936d2021-07-21 16:17:52 +00005302 sendFocusChangedCommandLocked(oldFocusedWindowToken, newFocusedWindowToken);
Robert Carrf759f162018-11-13 12:57:11 -08005303
Vishnu Nairad321cd2020-08-20 16:40:21 -07005304 if (newFocusedWindowToken == nullptr) {
Tiger Huang721e26f2018-07-24 22:26:19 +08005305 ALOGW("Focused display #%" PRId32 " does not have a focused window.", displayId);
Vishnu Nairc519ff72021-01-21 08:23:08 -08005306 if (mFocusResolver.hasFocusedWindowTokens()) {
Vishnu Nairad321cd2020-08-20 16:40:21 -07005307 ALOGE("But another display has a focused window\n%s",
Vishnu Nairc519ff72021-01-21 08:23:08 -08005308 mFocusResolver.dumpFocusedWindows().c_str());
Tiger Huang721e26f2018-07-24 22:26:19 +08005309 }
5310 }
5311 }
Tiger Huang721e26f2018-07-24 22:26:19 +08005312 } // release lock
5313
5314 // Wake up poll loop since it may need to make new input dispatching choices.
5315 mLooper->wake();
5316}
5317
Michael Wrightd02c5b62014-02-10 15:10:22 -08005318void InputDispatcher::setInputDispatchMode(bool enabled, bool frozen) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005319 if (DEBUG_FOCUS) {
5320 ALOGD("setInputDispatchMode: enabled=%d, frozen=%d", enabled, frozen);
5321 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005322
5323 bool changed;
5324 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08005325 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005326
5327 if (mDispatchEnabled != enabled || mDispatchFrozen != frozen) {
5328 if (mDispatchFrozen && !frozen) {
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005329 resetNoFocusedWindowTimeoutLocked();
Michael Wrightd02c5b62014-02-10 15:10:22 -08005330 }
5331
5332 if (mDispatchEnabled && !enabled) {
5333 resetAndDropEverythingLocked("dispatcher is being disabled");
5334 }
5335
5336 mDispatchEnabled = enabled;
5337 mDispatchFrozen = frozen;
5338 changed = true;
5339 } else {
5340 changed = false;
5341 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005342 } // release lock
5343
5344 if (changed) {
5345 // Wake up poll loop since it may need to make new input dispatching choices.
5346 mLooper->wake();
5347 }
5348}
5349
5350void InputDispatcher::setInputFilterEnabled(bool enabled) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005351 if (DEBUG_FOCUS) {
5352 ALOGD("setInputFilterEnabled: enabled=%d", enabled);
5353 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005354
5355 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08005356 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005357
5358 if (mInputFilterEnabled == enabled) {
5359 return;
5360 }
5361
5362 mInputFilterEnabled = enabled;
5363 resetAndDropEverythingLocked("input filter is being enabled or disabled");
5364 } // release lock
5365
5366 // Wake up poll loop since there might be work to do to drop everything.
5367 mLooper->wake();
5368}
5369
Prabir Pradhanaeebeb42023-06-13 19:53:03 +00005370bool InputDispatcher::setInTouchMode(bool inTouchMode, gui::Pid pid, gui::Uid uid,
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00005371 bool hasPermission, int32_t displayId) {
Antonio Kantekf16f2832021-09-28 04:39:20 +00005372 bool needWake = false;
5373 {
5374 std::scoped_lock lock(mLock);
Antonio Kantek15beb512022-06-13 22:35:41 +00005375 ALOGD_IF(DEBUG_TOUCH_MODE,
Prabir Pradhanaeebeb42023-06-13 19:53:03 +00005376 "Request to change touch mode to %s (calling pid=%s, uid=%s, "
Antonio Kantek15beb512022-06-13 22:35:41 +00005377 "hasPermission=%s, target displayId=%d, mTouchModePerDisplay[displayId]=%s)",
Prabir Pradhanaeebeb42023-06-13 19:53:03 +00005378 toString(inTouchMode), pid.toString().c_str(), uid.toString().c_str(),
5379 toString(hasPermission), displayId,
Antonio Kantek15beb512022-06-13 22:35:41 +00005380 mTouchModePerDisplay.count(displayId) == 0
5381 ? "not set"
5382 : std::to_string(mTouchModePerDisplay[displayId]).c_str());
5383
Antonio Kantek15beb512022-06-13 22:35:41 +00005384 auto touchModeIt = mTouchModePerDisplay.find(displayId);
5385 if (touchModeIt != mTouchModePerDisplay.end() && touchModeIt->second == inTouchMode) {
Antonio Kantekea47acb2021-12-23 12:41:25 -08005386 return false;
Antonio Kantekf16f2832021-09-28 04:39:20 +00005387 }
Antonio Kantekea47acb2021-12-23 12:41:25 -08005388 if (!hasPermission) {
Antonio Kantek48710e42022-03-24 14:19:30 -07005389 if (!focusedWindowIsOwnedByLocked(pid, uid) &&
5390 !recentWindowsAreOwnedByLocked(pid, uid)) {
Prabir Pradhanaeebeb42023-06-13 19:53:03 +00005391 ALOGD("Touch mode switch rejected, caller (pid=%s, uid=%s) doesn't own the focused "
Antonio Kantek48710e42022-03-24 14:19:30 -07005392 "window nor none of the previously interacted window",
Prabir Pradhanaeebeb42023-06-13 19:53:03 +00005393 pid.toString().c_str(), uid.toString().c_str());
Antonio Kantekea47acb2021-12-23 12:41:25 -08005394 return false;
5395 }
Antonio Kantekf16f2832021-09-28 04:39:20 +00005396 }
Antonio Kantek15beb512022-06-13 22:35:41 +00005397 mTouchModePerDisplay[displayId] = inTouchMode;
5398 auto entry = std::make_unique<TouchModeEntry>(mIdGenerator.nextId(), now(), inTouchMode,
5399 displayId);
Antonio Kantekf16f2832021-09-28 04:39:20 +00005400 needWake = enqueueInboundEventLocked(std::move(entry));
5401 } // release lock
5402
5403 if (needWake) {
5404 mLooper->wake();
5405 }
Antonio Kantekea47acb2021-12-23 12:41:25 -08005406 return true;
Siarhei Vishniakouf3bc1aa2019-11-25 13:48:53 -08005407}
5408
Prabir Pradhanaeebeb42023-06-13 19:53:03 +00005409bool InputDispatcher::focusedWindowIsOwnedByLocked(gui::Pid pid, gui::Uid uid) {
Antonio Kantek48710e42022-03-24 14:19:30 -07005410 const sp<IBinder> focusedToken = mFocusResolver.getFocusedWindowToken(mFocusedDisplayId);
5411 if (focusedToken == nullptr) {
5412 return false;
5413 }
5414 sp<WindowInfoHandle> windowHandle = getWindowHandleLocked(focusedToken);
5415 return isWindowOwnedBy(windowHandle, pid, uid);
5416}
5417
Prabir Pradhanaeebeb42023-06-13 19:53:03 +00005418bool InputDispatcher::recentWindowsAreOwnedByLocked(gui::Pid pid, gui::Uid uid) {
Antonio Kantek48710e42022-03-24 14:19:30 -07005419 return std::find_if(mInteractionConnectionTokens.begin(), mInteractionConnectionTokens.end(),
5420 [&](const sp<IBinder>& connectionToken) REQUIRES(mLock) {
5421 const sp<WindowInfoHandle> windowHandle =
5422 getWindowHandleLocked(connectionToken);
5423 return isWindowOwnedBy(windowHandle, pid, uid);
5424 }) != mInteractionConnectionTokens.end();
5425}
5426
Bernardo Rufinoea97d182020-08-19 14:43:14 +01005427void InputDispatcher::setMaximumObscuringOpacityForTouch(float opacity) {
5428 if (opacity < 0 || opacity > 1) {
5429 LOG_ALWAYS_FATAL("Maximum obscuring opacity for touch should be >= 0 and <= 1");
5430 return;
5431 }
5432
5433 std::scoped_lock lock(mLock);
5434 mMaximumObscuringOpacityForTouch = opacity;
5435}
5436
Siarhei Vishniakou40b8fbd2022-11-04 10:50:26 -07005437std::tuple<TouchState*, TouchedWindow*, int32_t /*displayId*/>
5438InputDispatcher::findTouchStateWindowAndDisplayLocked(const sp<IBinder>& token) {
Arthur Hungabbb9d82021-09-01 14:52:30 +00005439 for (auto& [displayId, state] : mTouchStatesByDisplay) {
5440 for (TouchedWindow& w : state.windows) {
5441 if (w.windowHandle->getToken() == token) {
Siarhei Vishniakou40b8fbd2022-11-04 10:50:26 -07005442 return std::make_tuple(&state, &w, displayId);
Arthur Hungabbb9d82021-09-01 14:52:30 +00005443 }
5444 }
5445 }
Siarhei Vishniakou40b8fbd2022-11-04 10:50:26 -07005446 return std::make_tuple(nullptr, nullptr, ADISPLAY_ID_DEFAULT);
Arthur Hungabbb9d82021-09-01 14:52:30 +00005447}
5448
arthurhungb89ccb02020-12-30 16:19:01 +08005449bool InputDispatcher::transferTouchFocus(const sp<IBinder>& fromToken, const sp<IBinder>& toToken,
5450 bool isDragDrop) {
chaviwfbe5d9c2018-12-26 12:23:37 -08005451 if (fromToken == toToken) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005452 if (DEBUG_FOCUS) {
5453 ALOGD("Trivial transfer to same window.");
5454 }
chaviwfbe5d9c2018-12-26 12:23:37 -08005455 return true;
5456 }
5457
Michael Wrightd02c5b62014-02-10 15:10:22 -08005458 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08005459 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005460
Arthur Hungabbb9d82021-09-01 14:52:30 +00005461 // Find the target touch state and touched window by fromToken.
Siarhei Vishniakou40b8fbd2022-11-04 10:50:26 -07005462 auto [state, touchedWindow, displayId] = findTouchStateWindowAndDisplayLocked(fromToken);
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07005463
Arthur Hungabbb9d82021-09-01 14:52:30 +00005464 if (state == nullptr || touchedWindow == nullptr) {
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07005465 ALOGD("Touch transfer failed because from window is not being touched.");
Michael Wrightd02c5b62014-02-10 15:10:22 -08005466 return false;
5467 }
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07005468 std::set<int32_t> deviceIds = touchedWindow->getTouchingDeviceIds();
5469 if (deviceIds.size() != 1) {
Siarhei Vishniakou827d1ac2023-07-21 16:37:51 -07005470 LOG(INFO) << "Can't transfer touch. Currently touching devices: " << dumpSet(deviceIds)
5471 << " for window: " << touchedWindow->dump();
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07005472 return false;
5473 }
5474 const int32_t deviceId = *deviceIds.begin();
Arthur Hungabbb9d82021-09-01 14:52:30 +00005475
Arthur Hungabbb9d82021-09-01 14:52:30 +00005476 sp<WindowInfoHandle> toWindowHandle = getWindowHandleLocked(toToken, displayId);
5477 if (toWindowHandle == nullptr) {
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07005478 ALOGW("Cannot transfer touch because to window not found.");
Arthur Hungabbb9d82021-09-01 14:52:30 +00005479 return false;
5480 }
5481
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005482 if (DEBUG_FOCUS) {
5483 ALOGD("transferTouchFocus: fromWindowHandle=%s, toWindowHandle=%s",
Arthur Hungabbb9d82021-09-01 14:52:30 +00005484 touchedWindow->windowHandle->getName().c_str(),
5485 toWindowHandle->getName().c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08005486 }
5487
Arthur Hungabbb9d82021-09-01 14:52:30 +00005488 // Erase old window.
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08005489 ftl::Flags<InputTarget::Flags> oldTargetFlags = touchedWindow->targetFlags;
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07005490 std::bitset<MAX_POINTER_ID + 1> pointerIds = touchedWindow->getTouchingPointers(deviceId);
Arthur Hungc539dbb2022-12-08 07:45:36 +00005491 sp<WindowInfoHandle> fromWindowHandle = touchedWindow->windowHandle;
Arthur Hungabbb9d82021-09-01 14:52:30 +00005492 state->removeWindowByToken(fromToken);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005493
Arthur Hungabbb9d82021-09-01 14:52:30 +00005494 // Add new window.
Vaibhav Devmurari882bd9b2022-06-23 14:54:54 +00005495 nsecs_t downTimeInTarget = now();
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08005496 ftl::Flags<InputTarget::Flags> newTargetFlags =
5497 oldTargetFlags & (InputTarget::Flags::SPLIT | InputTarget::Flags::DISPATCH_AS_IS);
Prabir Pradhan6dfbf262022-03-14 15:24:30 +00005498 if (canReceiveForegroundTouches(*toWindowHandle->getInfo())) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08005499 newTargetFlags |= InputTarget::Flags::FOREGROUND;
Prabir Pradhan6dfbf262022-03-14 15:24:30 +00005500 }
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07005501 state->addOrUpdateWindow(toWindowHandle, newTargetFlags, deviceId, pointerIds,
5502 downTimeInTarget);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005503
Arthur Hungabbb9d82021-09-01 14:52:30 +00005504 // Store the dragging window.
5505 if (isDragDrop) {
Arthur Hungb75c2aa2022-07-15 09:35:36 +00005506 if (pointerIds.count() != 1) {
5507 ALOGW("The drag and drop cannot be started when there is no pointer or more than 1"
5508 " pointer on the window.");
Arthur Hung54745652022-04-20 07:17:41 +00005509 return false;
5510 }
Arthur Hungb75c2aa2022-07-15 09:35:36 +00005511 // Track the pointer id for drag window and generate the drag state.
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08005512 const size_t id = firstMarkedBit(pointerIds);
Arthur Hung54745652022-04-20 07:17:41 +00005513 mDragState = std::make_unique<DragState>(toWindowHandle, id);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005514 }
5515
Arthur Hungabbb9d82021-09-01 14:52:30 +00005516 // Synthesize cancel for old window and down for new window.
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07005517 std::shared_ptr<Connection> fromConnection = getConnectionLocked(fromToken);
5518 std::shared_ptr<Connection> toConnection = getConnectionLocked(toToken);
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07005519 if (fromConnection != nullptr && toConnection != nullptr) {
Svet Ganov5d3bc372020-01-26 23:11:07 -08005520 fromConnection->inputState.mergePointerStateTo(toConnection->inputState);
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07005521 CancelationOptions options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS,
5522 "transferring touch from this window to another window");
Michael Wrightd02c5b62014-02-10 15:10:22 -08005523 synthesizeCancelationEventsForConnectionLocked(fromConnection, options);
Arthur Hungc539dbb2022-12-08 07:45:36 +00005524 synthesizePointerDownEventsForConnectionLocked(downTimeInTarget, toConnection,
5525 newTargetFlags);
5526
5527 // Check if the wallpaper window should deliver the corresponding event.
5528 transferWallpaperTouch(oldTargetFlags, newTargetFlags, fromWindowHandle, toWindowHandle,
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07005529 *state, deviceId, pointerIds);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005530 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005531 } // release lock
5532
5533 // Wake up poll loop since it may need to make new input dispatching choices.
5534 mLooper->wake();
5535 return true;
5536}
5537
Siarhei Vishniakou7ae7afd2022-03-31 15:26:13 -07005538/**
5539 * Get the touched foreground window on the given display.
5540 * Return null if there are no windows touched on that display, or if more than one foreground
5541 * window is being touched.
5542 */
5543sp<WindowInfoHandle> InputDispatcher::findTouchedForegroundWindowLocked(int32_t displayId) const {
5544 auto stateIt = mTouchStatesByDisplay.find(displayId);
5545 if (stateIt == mTouchStatesByDisplay.end()) {
5546 ALOGI("No touch state on display %" PRId32, displayId);
5547 return nullptr;
5548 }
5549
5550 const TouchState& state = stateIt->second;
5551 sp<WindowInfoHandle> touchedForegroundWindow;
5552 // If multiple foreground windows are touched, return nullptr
5553 for (const TouchedWindow& window : state.windows) {
Siarhei Vishniakou253f4642022-11-09 13:42:06 -08005554 if (window.targetFlags.test(InputTarget::Flags::FOREGROUND)) {
Siarhei Vishniakou7ae7afd2022-03-31 15:26:13 -07005555 if (touchedForegroundWindow != nullptr) {
5556 ALOGI("Two or more foreground windows: %s and %s",
5557 touchedForegroundWindow->getName().c_str(),
5558 window.windowHandle->getName().c_str());
5559 return nullptr;
5560 }
5561 touchedForegroundWindow = window.windowHandle;
5562 }
5563 }
5564 return touchedForegroundWindow;
5565}
5566
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +00005567// Binder call
Siarhei Vishniakou7ae7afd2022-03-31 15:26:13 -07005568bool InputDispatcher::transferTouch(const sp<IBinder>& destChannelToken, int32_t displayId) {
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +00005569 sp<IBinder> fromToken;
5570 { // acquire lock
5571 std::scoped_lock _l(mLock);
Arthur Hungabbb9d82021-09-01 14:52:30 +00005572 sp<WindowInfoHandle> toWindowHandle = getWindowHandleLocked(destChannelToken, displayId);
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +00005573 if (toWindowHandle == nullptr) {
Siarhei Vishniakou7ae7afd2022-03-31 15:26:13 -07005574 ALOGW("Could not find window associated with token=%p on display %" PRId32,
5575 destChannelToken.get(), displayId);
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +00005576 return false;
5577 }
5578
Siarhei Vishniakou7ae7afd2022-03-31 15:26:13 -07005579 sp<WindowInfoHandle> from = findTouchedForegroundWindowLocked(displayId);
5580 if (from == nullptr) {
5581 ALOGE("Could not find a source window in %s for %p", __func__, destChannelToken.get());
5582 return false;
5583 }
5584
5585 fromToken = from->getToken();
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +00005586 } // release lock
5587
5588 return transferTouchFocus(fromToken, destChannelToken);
5589}
5590
Michael Wrightd02c5b62014-02-10 15:10:22 -08005591void InputDispatcher::resetAndDropEverythingLocked(const char* reason) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005592 if (DEBUG_FOCUS) {
5593 ALOGD("Resetting and dropping all events (%s).", reason);
5594 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005595
Michael Wrightfb04fd52022-11-24 22:31:11 +00005596 CancelationOptions options(CancelationOptions::Mode::CANCEL_ALL_EVENTS, reason);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005597 synthesizeCancelationEventsForAllConnectionsLocked(options);
5598
5599 resetKeyRepeatLocked();
5600 releasePendingEventLocked();
5601 drainInboundQueueLocked();
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005602 resetNoFocusedWindowTimeoutLocked();
Michael Wrightd02c5b62014-02-10 15:10:22 -08005603
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005604 mAnrTracker.clear();
Jeff Brownf086ddb2014-02-11 14:28:48 -08005605 mTouchStatesByDisplay.clear();
Michael Wrightd02c5b62014-02-10 15:10:22 -08005606}
5607
Siarhei Vishniakou4c9d6ff2023-04-18 11:23:20 -07005608void InputDispatcher::logDispatchStateLocked() const {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005609 std::string dump;
Michael Wrightd02c5b62014-02-10 15:10:22 -08005610 dumpDispatchStateLocked(dump);
5611
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005612 std::istringstream stream(dump);
5613 std::string line;
5614
5615 while (std::getline(stream, line, '\n')) {
Siarhei Vishniakoua235c042023-05-02 09:59:09 -07005616 ALOGI("%s", line.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08005617 }
5618}
5619
Siarhei Vishniakou4c9d6ff2023-04-18 11:23:20 -07005620std::string InputDispatcher::dumpPointerCaptureStateLocked() const {
Prabir Pradhan99987712020-11-10 18:43:05 -08005621 std::string dump;
5622
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00005623 dump += StringPrintf(INDENT "Pointer Capture Requested: %s\n",
5624 toString(mCurrentPointerCaptureRequest.enable));
Prabir Pradhan99987712020-11-10 18:43:05 -08005625
5626 std::string windowName = "None";
5627 if (mWindowTokenWithPointerCapture) {
chaviw98318de2021-05-19 16:45:23 -05005628 const sp<WindowInfoHandle> captureWindowHandle =
Prabir Pradhan99987712020-11-10 18:43:05 -08005629 getWindowHandleLocked(mWindowTokenWithPointerCapture);
5630 windowName = captureWindowHandle ? captureWindowHandle->getName().c_str()
5631 : "token has capture without window";
5632 }
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00005633 dump += StringPrintf(INDENT "Current Window with Pointer Capture: %s\n", windowName.c_str());
Prabir Pradhan99987712020-11-10 18:43:05 -08005634
5635 return dump;
5636}
5637
Siarhei Vishniakou4c9d6ff2023-04-18 11:23:20 -07005638void InputDispatcher::dumpDispatchStateLocked(std::string& dump) const {
Siarhei Vishniakou043a3ec2019-05-01 11:30:46 -07005639 dump += StringPrintf(INDENT "DispatchEnabled: %s\n", toString(mDispatchEnabled));
5640 dump += StringPrintf(INDENT "DispatchFrozen: %s\n", toString(mDispatchFrozen));
5641 dump += StringPrintf(INDENT "InputFilterEnabled: %s\n", toString(mInputFilterEnabled));
Tiger Huang721e26f2018-07-24 22:26:19 +08005642 dump += StringPrintf(INDENT "FocusedDisplayId: %" PRId32 "\n", mFocusedDisplayId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005643
Tiger Huang721e26f2018-07-24 22:26:19 +08005644 if (!mFocusedApplicationHandlesByDisplay.empty()) {
5645 dump += StringPrintf(INDENT "FocusedApplications:\n");
5646 for (auto& it : mFocusedApplicationHandlesByDisplay) {
5647 const int32_t displayId = it.first;
Chris Yea209fde2020-07-22 13:54:51 -07005648 const std::shared_ptr<InputApplicationHandle>& applicationHandle = it.second;
Siarhei Vishniakou70622952020-07-30 11:17:23 -05005649 const std::chrono::duration timeout =
5650 applicationHandle->getDispatchingTimeout(DEFAULT_INPUT_DISPATCHING_TIMEOUT);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07005651 dump += StringPrintf(INDENT2 "displayId=%" PRId32
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07005652 ", name='%s', dispatchingTimeout=%" PRId64 "ms\n",
Siarhei Vishniakou70622952020-07-30 11:17:23 -05005653 displayId, applicationHandle->getName().c_str(), millis(timeout));
Tiger Huang721e26f2018-07-24 22:26:19 +08005654 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005655 } else {
Tiger Huang721e26f2018-07-24 22:26:19 +08005656 dump += StringPrintf(INDENT "FocusedApplications: <none>\n");
Michael Wrightd02c5b62014-02-10 15:10:22 -08005657 }
Tiger Huang721e26f2018-07-24 22:26:19 +08005658
Vishnu Nairc519ff72021-01-21 08:23:08 -08005659 dump += mFocusResolver.dump();
Prabir Pradhan99987712020-11-10 18:43:05 -08005660 dump += dumpPointerCaptureStateLocked();
Michael Wrightd02c5b62014-02-10 15:10:22 -08005661
Siarhei Vishniakou4700f822020-03-24 19:05:54 -07005662 if (!mTouchStatesByDisplay.empty()) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005663 dump += StringPrintf(INDENT "TouchStatesByDisplay:\n");
Siarhei Vishniakou40b8fbd2022-11-04 10:50:26 -07005664 for (const auto& [displayId, state] : mTouchStatesByDisplay) {
Siarhei Vishniakou6e1e9872022-11-08 17:51:35 -08005665 std::string touchStateDump = addLinePrefix(state.dump(), INDENT2);
5666 dump += INDENT2 + std::to_string(displayId) + " : " + touchStateDump;
Michael Wrightd02c5b62014-02-10 15:10:22 -08005667 }
5668 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005669 dump += INDENT "TouchStates: <no displays touched>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005670 }
5671
arthurhung6d4bed92021-03-17 11:59:33 +08005672 if (mDragState) {
5673 dump += StringPrintf(INDENT "DragState:\n");
5674 mDragState->dump(dump, INDENT2);
5675 }
5676
Arthur Hungb92218b2018-08-14 12:00:21 +08005677 if (!mWindowHandlesByDisplay.empty()) {
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07005678 for (const auto& [displayId, windowHandles] : mWindowHandlesByDisplay) {
5679 dump += StringPrintf(INDENT "Display: %" PRId32 "\n", displayId);
5680 if (const auto& it = mDisplayInfos.find(displayId); it != mDisplayInfos.end()) {
5681 const auto& displayInfo = it->second;
5682 dump += StringPrintf(INDENT2 "logicalSize=%dx%d\n", displayInfo.logicalWidth,
5683 displayInfo.logicalHeight);
5684 displayInfo.transform.dump(dump, "transform", INDENT4);
5685 } else {
5686 dump += INDENT2 "No DisplayInfo found!\n";
5687 }
5688
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08005689 if (!windowHandles.empty()) {
Arthur Hungb92218b2018-08-14 12:00:21 +08005690 dump += INDENT2 "Windows:\n";
5691 for (size_t i = 0; i < windowHandles.size(); i++) {
chaviw98318de2021-05-19 16:45:23 -05005692 const sp<WindowInfoHandle>& windowHandle = windowHandles[i];
5693 const WindowInfo* windowInfo = windowHandle->getInfo();
Michael Wrightd02c5b62014-02-10 15:10:22 -08005694
Bernardo Rufino0f6a36e2020-11-11 10:10:59 +00005695 dump += StringPrintf(INDENT3 "%zu: name='%s', id=%" PRId32 ", displayId=%d, "
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08005696 "inputConfig=%s, alpha=%.2f, "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07005697 "frame=[%d,%d][%d,%d], globalScale=%f, "
Bernardo Rufino49d99e42021-01-18 15:16:59 +00005698 "applicationInfo.name=%s, "
5699 "applicationInfo.token=%s, "
chaviw1ff3d1e2020-07-01 15:53:47 -07005700 "touchableRegion=",
Bernardo Rufino0f6a36e2020-11-11 10:10:59 +00005701 i, windowInfo->name.c_str(), windowInfo->id,
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08005702 windowInfo->displayId,
5703 windowInfo->inputConfig.string().c_str(),
Chavi Weingarten7f019192023-08-08 20:39:01 +00005704 windowInfo->alpha, windowInfo->frame.left,
5705 windowInfo->frame.top, windowInfo->frame.right,
5706 windowInfo->frame.bottom, windowInfo->globalScaleFactor,
Bernardo Rufino49d99e42021-01-18 15:16:59 +00005707 windowInfo->applicationInfo.name.c_str(),
Siarhei Vishniakou63b63612023-04-12 11:00:23 -07005708 binderToString(windowInfo->applicationInfo.token).c_str());
Bernardo Rufino53fc31e2020-11-03 11:01:07 +00005709 dump += dumpRegion(windowInfo->touchableRegion);
Prabir Pradhanaeebeb42023-06-13 19:53:03 +00005710 dump += StringPrintf(", ownerPid=%s, ownerUid=%s, dispatchingTimeout=%" PRId64
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08005711 "ms, hasToken=%s, "
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07005712 "touchOcclusionMode=%s\n",
Prabir Pradhanaeebeb42023-06-13 19:53:03 +00005713 windowInfo->ownerPid.toString().c_str(),
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +00005714 windowInfo->ownerUid.toString().c_str(),
Bernardo Rufinoc2f1fad2020-11-04 17:30:57 +00005715 millis(windowInfo->dispatchingTimeout),
Siarhei Vishniakou63b63612023-04-12 11:00:23 -07005716 binderToString(windowInfo->token).c_str(),
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07005717 toString(windowInfo->touchOcclusionMode).c_str());
chaviw85b44202020-07-24 11:46:21 -07005718 windowInfo->transform.dump(dump, "transform", INDENT4);
Arthur Hungb92218b2018-08-14 12:00:21 +08005719 }
5720 } else {
5721 dump += INDENT2 "Windows: <none>\n";
5722 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005723 }
5724 } else {
Arthur Hungb92218b2018-08-14 12:00:21 +08005725 dump += INDENT "Displays: <none>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005726 }
5727
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08005728 if (!mGlobalMonitorsByDisplay.empty()) {
5729 for (const auto& [displayId, monitors] : mGlobalMonitorsByDisplay) {
5730 dump += StringPrintf(INDENT "Global monitors on display %d:\n", displayId);
Michael Wright3dd60e22019-03-27 22:06:44 +00005731 dumpMonitors(dump, monitors);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07005732 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005733 } else {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08005734 dump += INDENT "Global Monitors: <none>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005735 }
5736
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08005737 const nsecs_t currentTime = now();
Michael Wrightd02c5b62014-02-10 15:10:22 -08005738
5739 // Dump recently dispatched or dropped events from oldest to newest.
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07005740 if (!mRecentQueue.empty()) {
5741 dump += StringPrintf(INDENT "RecentQueue: length=%zu\n", mRecentQueue.size());
Siarhei Vishniakou4c9d6ff2023-04-18 11:23:20 -07005742 for (const std::shared_ptr<EventEntry>& entry : mRecentQueue) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005743 dump += INDENT2;
Siarhei Vishniakou14411c92020-09-18 21:15:05 -05005744 dump += entry->getDescription();
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07005745 dump += StringPrintf(", age=%" PRId64 "ms\n", ns2ms(currentTime - entry->eventTime));
Michael Wrightd02c5b62014-02-10 15:10:22 -08005746 }
5747 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005748 dump += INDENT "RecentQueue: <empty>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005749 }
5750
5751 // Dump event currently being dispatched.
5752 if (mPendingEvent) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005753 dump += INDENT "PendingEvent:\n";
5754 dump += INDENT2;
Siarhei Vishniakou14411c92020-09-18 21:15:05 -05005755 dump += mPendingEvent->getDescription();
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07005756 dump += StringPrintf(", age=%" PRId64 "ms\n",
5757 ns2ms(currentTime - mPendingEvent->eventTime));
Michael Wrightd02c5b62014-02-10 15:10:22 -08005758 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005759 dump += INDENT "PendingEvent: <none>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005760 }
5761
5762 // Dump inbound events from oldest to newest.
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07005763 if (!mInboundQueue.empty()) {
5764 dump += StringPrintf(INDENT "InboundQueue: length=%zu\n", mInboundQueue.size());
Siarhei Vishniakou4c9d6ff2023-04-18 11:23:20 -07005765 for (const std::shared_ptr<EventEntry>& entry : mInboundQueue) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005766 dump += INDENT2;
Siarhei Vishniakou14411c92020-09-18 21:15:05 -05005767 dump += entry->getDescription();
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07005768 dump += StringPrintf(", age=%" PRId64 "ms\n", ns2ms(currentTime - entry->eventTime));
Michael Wrightd02c5b62014-02-10 15:10:22 -08005769 }
5770 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005771 dump += INDENT "InboundQueue: <empty>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005772 }
5773
Prabir Pradhancef936d2021-07-21 16:17:52 +00005774 if (!mCommandQueue.empty()) {
5775 dump += StringPrintf(INDENT "CommandQueue: size=%zu\n", mCommandQueue.size());
5776 } else {
5777 dump += INDENT "CommandQueue: <empty>\n";
5778 }
5779
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005780 if (!mConnectionsByToken.empty()) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005781 dump += INDENT "Connections:\n";
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005782 for (const auto& [token, connection] : mConnectionsByToken) {
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07005783 dump += StringPrintf(INDENT2 "%i: channelName='%s', windowName='%s', "
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005784 "status=%s, monitor=%s, responsive=%s\n",
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005785 connection->inputChannel->getFd().get(),
5786 connection->getInputChannelName().c_str(),
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08005787 connection->getWindowName().c_str(),
5788 ftl::enum_string(connection->status).c_str(),
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005789 toString(connection->monitor), toString(connection->responsive));
Michael Wrightd02c5b62014-02-10 15:10:22 -08005790
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07005791 if (!connection->outboundQueue.empty()) {
5792 dump += StringPrintf(INDENT3 "OutboundQueue: length=%zu\n",
5793 connection->outboundQueue.size());
Siarhei Vishniakou14411c92020-09-18 21:15:05 -05005794 dump += dumpQueue(connection->outboundQueue, currentTime);
5795
Michael Wrightd02c5b62014-02-10 15:10:22 -08005796 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005797 dump += INDENT3 "OutboundQueue: <empty>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005798 }
5799
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07005800 if (!connection->waitQueue.empty()) {
5801 dump += StringPrintf(INDENT3 "WaitQueue: length=%zu\n",
5802 connection->waitQueue.size());
Siarhei Vishniakou14411c92020-09-18 21:15:05 -05005803 dump += dumpQueue(connection->waitQueue, currentTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005804 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005805 dump += INDENT3 "WaitQueue: <empty>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005806 }
Siarhei Vishniakoud38a1e02023-07-18 11:55:17 -07005807 std::stringstream inputStateDump;
5808 inputStateDump << connection->inputState;
5809 if (!isEmpty(inputStateDump)) {
5810 dump += INDENT3 "InputState: ";
5811 dump += inputStateDump.str() + "\n";
5812 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005813 }
5814 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005815 dump += INDENT "Connections: <none>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005816 }
5817
Siarhei Vishniakou6520a582023-10-27 21:53:45 -07005818 dump += "input_flags::remove_app_switch_drops() = ";
5819 dump += toString(input_flags::remove_app_switch_drops());
5820 dump += "\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005821 if (isAppSwitchPendingLocked()) {
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07005822 dump += StringPrintf(INDENT "AppSwitch: pending, due in %" PRId64 "ms\n",
5823 ns2ms(mAppSwitchDueTime - now()));
Michael Wrightd02c5b62014-02-10 15:10:22 -08005824 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005825 dump += INDENT "AppSwitch: not pending\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005826 }
5827
Antonio Kantek15beb512022-06-13 22:35:41 +00005828 if (!mTouchModePerDisplay.empty()) {
5829 dump += INDENT "TouchModePerDisplay:\n";
5830 for (const auto& [displayId, touchMode] : mTouchModePerDisplay) {
5831 dump += StringPrintf(INDENT2 "Display: %" PRId32 " TouchMode: %s\n", displayId,
5832 std::to_string(touchMode).c_str());
5833 }
5834 } else {
5835 dump += INDENT "TouchModePerDisplay: <none>\n";
5836 }
5837
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005838 dump += INDENT "Configuration:\n";
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07005839 dump += StringPrintf(INDENT2 "KeyRepeatDelay: %" PRId64 "ms\n", ns2ms(mConfig.keyRepeatDelay));
5840 dump += StringPrintf(INDENT2 "KeyRepeatTimeout: %" PRId64 "ms\n",
5841 ns2ms(mConfig.keyRepeatTimeout));
Siarhei Vishniakouf2652122021-03-05 21:39:46 +00005842 dump += mLatencyTracker.dump(INDENT2);
Siarhei Vishniakoua04181f2021-03-26 05:56:49 +00005843 dump += mLatencyAggregator.dump(INDENT2);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005844}
5845
Siarhei Vishniakou4c9d6ff2023-04-18 11:23:20 -07005846void InputDispatcher::dumpMonitors(std::string& dump, const std::vector<Monitor>& monitors) const {
Michael Wright3dd60e22019-03-27 22:06:44 +00005847 const size_t numMonitors = monitors.size();
5848 for (size_t i = 0; i < numMonitors; i++) {
5849 const Monitor& monitor = monitors[i];
Siarhei Vishniakouce5ab082020-07-09 17:03:21 -05005850 const std::shared_ptr<InputChannel>& channel = monitor.inputChannel;
Michael Wright3dd60e22019-03-27 22:06:44 +00005851 dump += StringPrintf(INDENT2 "%zu: '%s', ", i, channel->getName().c_str());
5852 dump += "\n";
5853 }
5854}
5855
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005856class LooperEventCallback : public LooperCallback {
5857public:
5858 LooperEventCallback(std::function<int(int events)> callback) : mCallback(callback) {}
5859 int handleEvent(int /*fd*/, int events, void* /*data*/) override { return mCallback(events); }
5860
5861private:
5862 std::function<int(int events)> mCallback;
5863};
5864
Siarhei Vishniakoueedd0fc2021-03-12 09:50:36 +00005865Result<std::unique_ptr<InputChannel>> InputDispatcher::createInputChannel(const std::string& name) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00005866 if (DEBUG_CHANNEL_CREATION) {
5867 ALOGD("channel '%s' ~ createInputChannel", name.c_str());
5868 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005869
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005870 std::unique_ptr<InputChannel> serverChannel;
Garfield Tan15601662020-09-22 15:32:38 -07005871 std::unique_ptr<InputChannel> clientChannel;
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005872 status_t result = InputChannel::openInputChannelPair(name, serverChannel, clientChannel);
Garfield Tan15601662020-09-22 15:32:38 -07005873
5874 if (result) {
5875 return base::Error(result) << "Failed to open input channel pair with name " << name;
5876 }
5877
Michael Wrightd02c5b62014-02-10 15:10:22 -08005878 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08005879 std::scoped_lock _l(mLock);
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005880 const sp<IBinder>& token = serverChannel->getConnectionToken();
Garfield Tan15601662020-09-22 15:32:38 -07005881 int fd = serverChannel->getFd();
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07005882 std::shared_ptr<Connection> connection =
5883 std::make_shared<Connection>(std::move(serverChannel), /*monitor=*/false,
5884 mIdGenerator);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005885
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005886 if (mConnectionsByToken.find(token) != mConnectionsByToken.end()) {
5887 ALOGE("Created a new connection, but the token %p is already known", token.get());
5888 }
5889 mConnectionsByToken.emplace(token, connection);
5890
5891 std::function<int(int events)> callback = std::bind(&InputDispatcher::handleReceiveCallback,
5892 this, std::placeholders::_1, token);
5893
Siarhei Vishniakouaed7ad02022-08-03 15:04:33 -07005894 mLooper->addFd(fd, 0, ALOOPER_EVENT_INPUT, sp<LooperEventCallback>::make(callback),
5895 nullptr);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005896 } // release lock
5897
5898 // Wake the looper because some connections have changed.
5899 mLooper->wake();
Garfield Tan15601662020-09-22 15:32:38 -07005900 return clientChannel;
Michael Wrightd02c5b62014-02-10 15:10:22 -08005901}
5902
Siarhei Vishniakoueedd0fc2021-03-12 09:50:36 +00005903Result<std::unique_ptr<InputChannel>> InputDispatcher::createInputMonitor(int32_t displayId,
Siarhei Vishniakoueedd0fc2021-03-12 09:50:36 +00005904 const std::string& name,
Prabir Pradhanaeebeb42023-06-13 19:53:03 +00005905 gui::Pid pid) {
Garfield Tan15601662020-09-22 15:32:38 -07005906 std::shared_ptr<InputChannel> serverChannel;
5907 std::unique_ptr<InputChannel> clientChannel;
5908 status_t result = openInputChannelPair(name, serverChannel, clientChannel);
5909 if (result) {
5910 return base::Error(result) << "Failed to open input channel pair with name " << name;
5911 }
5912
Michael Wright3dd60e22019-03-27 22:06:44 +00005913 { // acquire lock
5914 std::scoped_lock _l(mLock);
5915
5916 if (displayId < 0) {
Garfield Tan15601662020-09-22 15:32:38 -07005917 return base::Error(BAD_VALUE) << "Attempted to create input monitor with name " << name
5918 << " without a specified display.";
Michael Wright3dd60e22019-03-27 22:06:44 +00005919 }
5920
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07005921 std::shared_ptr<Connection> connection =
5922 std::make_shared<Connection>(serverChannel, /*monitor=*/true, mIdGenerator);
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005923 const sp<IBinder>& token = serverChannel->getConnectionToken();
Garfield Tan15601662020-09-22 15:32:38 -07005924 const int fd = serverChannel->getFd();
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005925
5926 if (mConnectionsByToken.find(token) != mConnectionsByToken.end()) {
5927 ALOGE("Created a new connection, but the token %p is already known", token.get());
5928 }
5929 mConnectionsByToken.emplace(token, connection);
5930 std::function<int(int events)> callback = std::bind(&InputDispatcher::handleReceiveCallback,
5931 this, std::placeholders::_1, token);
Michael Wright3dd60e22019-03-27 22:06:44 +00005932
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08005933 mGlobalMonitorsByDisplay[displayId].emplace_back(serverChannel, pid);
Michael Wright3dd60e22019-03-27 22:06:44 +00005934
Siarhei Vishniakouaed7ad02022-08-03 15:04:33 -07005935 mLooper->addFd(fd, 0, ALOOPER_EVENT_INPUT, sp<LooperEventCallback>::make(callback),
5936 nullptr);
Michael Wright3dd60e22019-03-27 22:06:44 +00005937 }
Garfield Tan15601662020-09-22 15:32:38 -07005938
Michael Wright3dd60e22019-03-27 22:06:44 +00005939 // Wake the looper because some connections have changed.
5940 mLooper->wake();
Garfield Tan15601662020-09-22 15:32:38 -07005941 return clientChannel;
Michael Wright3dd60e22019-03-27 22:06:44 +00005942}
5943
Garfield Tan15601662020-09-22 15:32:38 -07005944status_t InputDispatcher::removeInputChannel(const sp<IBinder>& connectionToken) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08005945 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08005946 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005947
Harry Cutts33476232023-01-30 19:57:29 +00005948 status_t status = removeInputChannelLocked(connectionToken, /*notify=*/false);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005949 if (status) {
5950 return status;
5951 }
5952 } // release lock
5953
5954 // Wake the poll loop because removing the connection may have changed the current
5955 // synchronization state.
5956 mLooper->wake();
5957 return OK;
5958}
5959
Garfield Tan15601662020-09-22 15:32:38 -07005960status_t InputDispatcher::removeInputChannelLocked(const sp<IBinder>& connectionToken,
5961 bool notify) {
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07005962 std::shared_ptr<Connection> connection = getConnectionLocked(connectionToken);
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07005963 if (connection == nullptr) {
Siarhei Vishniakoud706a282021-02-13 00:08:48 +00005964 // Connection can be removed via socket hang up or an explicit call to 'removeInputChannel'
Michael Wrightd02c5b62014-02-10 15:10:22 -08005965 return BAD_VALUE;
5966 }
5967
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07005968 removeConnectionLocked(connection);
Robert Carr5c8a0262018-10-03 16:30:44 -07005969
Michael Wrightd02c5b62014-02-10 15:10:22 -08005970 if (connection->monitor) {
Siarhei Vishniakouadefc3e2020-09-02 22:28:29 -05005971 removeMonitorChannelLocked(connectionToken);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005972 }
5973
Siarhei Vishniakouadefc3e2020-09-02 22:28:29 -05005974 mLooper->removeFd(connection->inputChannel->getFd());
Michael Wrightd02c5b62014-02-10 15:10:22 -08005975
5976 nsecs_t currentTime = now();
5977 abortBrokenDispatchCycleLocked(currentTime, connection, notify);
5978
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08005979 connection->status = Connection::Status::ZOMBIE;
Michael Wrightd02c5b62014-02-10 15:10:22 -08005980 return OK;
5981}
5982
Siarhei Vishniakouadefc3e2020-09-02 22:28:29 -05005983void InputDispatcher::removeMonitorChannelLocked(const sp<IBinder>& connectionToken) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08005984 for (auto it = mGlobalMonitorsByDisplay.begin(); it != mGlobalMonitorsByDisplay.end();) {
5985 auto& [displayId, monitors] = *it;
5986 std::erase_if(monitors, [connectionToken](const Monitor& monitor) {
5987 return monitor.inputChannel->getConnectionToken() == connectionToken;
5988 });
Michael Wright3dd60e22019-03-27 22:06:44 +00005989
Michael Wright3dd60e22019-03-27 22:06:44 +00005990 if (monitors.empty()) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08005991 it = mGlobalMonitorsByDisplay.erase(it);
Arthur Hung2fbf37f2018-09-13 18:16:41 +08005992 } else {
5993 ++it;
5994 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005995 }
5996}
5997
Michael Wright3dd60e22019-03-27 22:06:44 +00005998status_t InputDispatcher::pilferPointers(const sp<IBinder>& token) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08005999 std::scoped_lock _l(mLock);
Vaibhav Devmurari6abcf8f2022-06-06 10:08:05 +00006000 return pilferPointersLocked(token);
6001}
Michael Wright3dd60e22019-03-27 22:06:44 +00006002
Vaibhav Devmurari6abcf8f2022-06-06 10:08:05 +00006003status_t InputDispatcher::pilferPointersLocked(const sp<IBinder>& token) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006004 const std::shared_ptr<InputChannel> requestingChannel = getInputChannelLocked(token);
6005 if (!requestingChannel) {
Siarhei Vishniakou8384e0d2023-09-18 18:48:27 -07006006 LOG(WARNING)
6007 << "Attempted to pilfer pointers from an un-registered channel or invalid token";
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006008 return BAD_VALUE;
Michael Wright3dd60e22019-03-27 22:06:44 +00006009 }
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006010
Siarhei Vishniakou40b8fbd2022-11-04 10:50:26 -07006011 auto [statePtr, windowPtr, displayId] = findTouchStateWindowAndDisplayLocked(token);
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07006012 if (statePtr == nullptr || windowPtr == nullptr) {
Siarhei Vishniakou8384e0d2023-09-18 18:48:27 -07006013 LOG(WARNING)
6014 << "Attempted to pilfer points from a channel without any on-going pointer streams."
6015 " Ignoring.";
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006016 return BAD_VALUE;
6017 }
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07006018 std::set<int32_t> deviceIds = windowPtr->getTouchingDeviceIds();
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07006019 if (deviceIds.empty()) {
6020 LOG(WARNING) << "Can't pilfer: no touching devices in window: " << windowPtr->dump();
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07006021 return BAD_VALUE;
6022 }
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006023
Siarhei Vishniakou8384e0d2023-09-18 18:48:27 -07006024 for (const DeviceId deviceId : deviceIds) {
6025 TouchState& state = *statePtr;
6026 TouchedWindow& window = *windowPtr;
6027 // Send cancel events to all the input channels we're stealing from.
6028 CancelationOptions options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS,
6029 "input channel stole pointer stream");
6030 options.deviceId = deviceId;
6031 options.displayId = displayId;
6032 std::bitset<MAX_POINTER_ID + 1> pointerIds = window.getTouchingPointers(deviceId);
6033 options.pointerIds = pointerIds;
6034 std::string canceledWindows;
6035 for (const TouchedWindow& w : state.windows) {
6036 const std::shared_ptr<InputChannel> channel =
6037 getInputChannelLocked(w.windowHandle->getToken());
6038 if (channel != nullptr && channel->getConnectionToken() != token) {
6039 synthesizeCancelationEventsForInputChannelLocked(channel, options);
6040 canceledWindows += canceledWindows.empty() ? "[" : ", ";
6041 canceledWindows += channel->getName();
6042 }
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006043 }
Siarhei Vishniakou8384e0d2023-09-18 18:48:27 -07006044 canceledWindows += canceledWindows.empty() ? "[]" : "]";
6045 LOG(INFO) << "Channel " << requestingChannel->getName()
6046 << " is stealing input gesture for device " << deviceId << " from "
6047 << canceledWindows;
6048
6049 // Prevent the gesture from being sent to any other windows.
6050 // This only blocks relevant pointers to be sent to other windows
6051 window.addPilferingPointers(deviceId, pointerIds);
6052
6053 state.cancelPointersForWindowsExcept(deviceId, pointerIds, token);
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006054 }
Michael Wright3dd60e22019-03-27 22:06:44 +00006055 return OK;
6056}
6057
Prabir Pradhan99987712020-11-10 18:43:05 -08006058void InputDispatcher::requestPointerCapture(const sp<IBinder>& windowToken, bool enabled) {
6059 { // acquire lock
6060 std::scoped_lock _l(mLock);
6061 if (DEBUG_FOCUS) {
chaviw98318de2021-05-19 16:45:23 -05006062 const sp<WindowInfoHandle> windowHandle = getWindowHandleLocked(windowToken);
Prabir Pradhan99987712020-11-10 18:43:05 -08006063 ALOGI("Request to %s Pointer Capture from: %s.", enabled ? "enable" : "disable",
6064 windowHandle != nullptr ? windowHandle->getName().c_str()
6065 : "token without window");
6066 }
6067
Vishnu Nairc519ff72021-01-21 08:23:08 -08006068 const sp<IBinder> focusedToken = mFocusResolver.getFocusedWindowToken(mFocusedDisplayId);
Prabir Pradhan99987712020-11-10 18:43:05 -08006069 if (focusedToken != windowToken) {
6070 ALOGW("Ignoring request to %s Pointer Capture: window does not have focus.",
6071 enabled ? "enable" : "disable");
6072 return;
6073 }
6074
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00006075 if (enabled == mCurrentPointerCaptureRequest.enable) {
Prabir Pradhan99987712020-11-10 18:43:05 -08006076 ALOGW("Ignoring request to %s Pointer Capture: "
6077 "window has %s requested pointer capture.",
6078 enabled ? "enable" : "disable", enabled ? "already" : "not");
6079 return;
6080 }
6081
Christine Franksb768bb42021-11-29 12:11:31 -08006082 if (enabled) {
6083 if (std::find(mIneligibleDisplaysForPointerCapture.begin(),
6084 mIneligibleDisplaysForPointerCapture.end(),
6085 mFocusedDisplayId) != mIneligibleDisplaysForPointerCapture.end()) {
6086 ALOGW("Ignoring request to enable Pointer Capture: display is not eligible");
6087 return;
6088 }
6089 }
6090
Prabir Pradhan99987712020-11-10 18:43:05 -08006091 setPointerCaptureLocked(enabled);
6092 } // release lock
6093
6094 // Wake the thread to process command entries.
6095 mLooper->wake();
6096}
6097
Christine Franksb768bb42021-11-29 12:11:31 -08006098void InputDispatcher::setDisplayEligibilityForPointerCapture(int32_t displayId, bool isEligible) {
6099 { // acquire lock
6100 std::scoped_lock _l(mLock);
6101 std::erase(mIneligibleDisplaysForPointerCapture, displayId);
6102 if (!isEligible) {
6103 mIneligibleDisplaysForPointerCapture.push_back(displayId);
6104 }
6105 } // release lock
6106}
6107
Prabir Pradhanaeebeb42023-06-13 19:53:03 +00006108std::optional<gui::Pid> InputDispatcher::findMonitorPidByTokenLocked(const sp<IBinder>& token) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006109 for (const auto& [_, monitors] : mGlobalMonitorsByDisplay) {
Michael Wright3dd60e22019-03-27 22:06:44 +00006110 for (const Monitor& monitor : monitors) {
Siarhei Vishniakou26d3cfb2019-10-15 17:02:32 -07006111 if (monitor.inputChannel->getConnectionToken() == token) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08006112 return monitor.pid;
Michael Wright3dd60e22019-03-27 22:06:44 +00006113 }
6114 }
6115 }
6116 return std::nullopt;
6117}
6118
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07006119std::shared_ptr<Connection> InputDispatcher::getConnectionLocked(
6120 const sp<IBinder>& inputConnectionToken) const {
Siarhei Vishniakoud0d71b62019-10-14 14:50:45 -07006121 if (inputConnectionToken == nullptr) {
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07006122 return nullptr;
Arthur Hung3b413f22018-10-26 18:05:34 +08006123 }
6124
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00006125 for (const auto& [token, connection] : mConnectionsByToken) {
6126 if (token == inputConnectionToken) {
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07006127 return connection;
Michael Wrightd02c5b62014-02-10 15:10:22 -08006128 }
6129 }
Robert Carr4e670e52018-08-15 13:26:12 -07006130
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07006131 return nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08006132}
6133
Siarhei Vishniakouad991402020-10-28 11:40:09 -05006134std::string InputDispatcher::getConnectionNameLocked(const sp<IBinder>& connectionToken) const {
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07006135 std::shared_ptr<Connection> connection = getConnectionLocked(connectionToken);
Siarhei Vishniakouad991402020-10-28 11:40:09 -05006136 if (connection == nullptr) {
6137 return "<nullptr>";
6138 }
6139 return connection->getInputChannelName();
6140}
6141
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07006142void InputDispatcher::removeConnectionLocked(const std::shared_ptr<Connection>& connection) {
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006143 mAnrTracker.eraseToken(connection->inputChannel->getConnectionToken());
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00006144 mConnectionsByToken.erase(connection->inputChannel->getConnectionToken());
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07006145}
6146
Prabir Pradhancef936d2021-07-21 16:17:52 +00006147void InputDispatcher::doDispatchCycleFinishedCommand(nsecs_t finishTime,
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07006148 const std::shared_ptr<Connection>& connection,
6149 uint32_t seq, bool handled,
6150 nsecs_t consumeTime) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00006151 // Handle post-event policy actions.
Prabir Pradhancef936d2021-07-21 16:17:52 +00006152 bool restartEvent;
Prabir Pradhan8c90d782023-09-15 21:16:44 +00006153
6154 { // Start critical section
6155 auto dispatchEntryIt =
6156 std::find_if(connection->waitQueue.begin(), connection->waitQueue.end(),
6157 [seq](auto& e) { return e->seq == seq; });
6158 if (dispatchEntryIt == connection->waitQueue.end()) {
6159 return;
6160 }
6161
6162 DispatchEntry& dispatchEntry = **dispatchEntryIt;
6163
6164 const nsecs_t eventDuration = finishTime - dispatchEntry.deliveryTime;
6165 if (eventDuration > SLOW_EVENT_PROCESSING_WARNING_TIMEOUT) {
6166 ALOGI("%s spent %" PRId64 "ms processing %s", connection->getWindowName().c_str(),
6167 ns2ms(eventDuration), dispatchEntry.eventEntry->getDescription().c_str());
6168 }
6169 if (shouldReportFinishedEvent(dispatchEntry, *connection)) {
6170 mLatencyTracker.trackFinishedEvent(dispatchEntry.eventEntry->id,
6171 connection->inputChannel->getConnectionToken(),
6172 dispatchEntry.deliveryTime, consumeTime, finishTime);
6173 }
6174
6175 if (dispatchEntry.eventEntry->type == EventEntry::Type::KEY) {
6176 KeyEntry& keyEntry = static_cast<KeyEntry&>(*(dispatchEntry.eventEntry));
6177 restartEvent =
6178 afterKeyEventLockedInterruptable(connection, dispatchEntry, keyEntry, handled);
6179 } else if (dispatchEntry.eventEntry->type == EventEntry::Type::MOTION) {
6180 MotionEntry& motionEntry = static_cast<MotionEntry&>(*(dispatchEntry.eventEntry));
6181 restartEvent = afterMotionEventLockedInterruptable(connection, dispatchEntry,
6182 motionEntry, handled);
6183 } else {
6184 restartEvent = false;
6185 }
6186 } // End critical section: The -LockedInterruptable methods may have released the lock.
Prabir Pradhancef936d2021-07-21 16:17:52 +00006187
6188 // Dequeue the event and start the next cycle.
6189 // Because the lock might have been released, it is possible that the
6190 // contents of the wait queue to have been drained, so we need to double-check
6191 // a few things.
Prabir Pradhan8c90d782023-09-15 21:16:44 +00006192 auto entryIt = std::find_if(connection->waitQueue.begin(), connection->waitQueue.end(),
6193 [seq](auto& e) { return e->seq == seq; });
6194 if (entryIt != connection->waitQueue.end()) {
6195 std::unique_ptr<DispatchEntry> dispatchEntry = std::move(*entryIt);
6196 connection->waitQueue.erase(entryIt);
6197
Prabir Pradhancef936d2021-07-21 16:17:52 +00006198 const sp<IBinder>& connectionToken = connection->inputChannel->getConnectionToken();
6199 mAnrTracker.erase(dispatchEntry->timeoutTime, connectionToken);
6200 if (!connection->responsive) {
6201 connection->responsive = isConnectionResponsive(*connection);
6202 if (connection->responsive) {
6203 // The connection was unresponsive, and now it's responsive.
6204 processConnectionResponsiveLocked(*connection);
6205 }
6206 }
6207 traceWaitQueueLength(*connection);
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08006208 if (restartEvent && connection->status == Connection::Status::NORMAL) {
Prabir Pradhan8c90d782023-09-15 21:16:44 +00006209 connection->outboundQueue.emplace_front(std::move(dispatchEntry));
Prabir Pradhancef936d2021-07-21 16:17:52 +00006210 traceOutboundQueueLength(*connection);
6211 } else {
Prabir Pradhan8c90d782023-09-15 21:16:44 +00006212 releaseDispatchEntry(std::move(dispatchEntry));
Prabir Pradhancef936d2021-07-21 16:17:52 +00006213 }
6214 }
6215
6216 // Start the next dispatch cycle for this connection.
6217 startDispatchCycleLocked(now(), connection);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006218}
6219
Prabir Pradhancef936d2021-07-21 16:17:52 +00006220void InputDispatcher::sendFocusChangedCommandLocked(const sp<IBinder>& oldToken,
6221 const sp<IBinder>& newToken) {
6222 auto command = [this, oldToken, newToken]() REQUIRES(mLock) {
6223 scoped_unlock unlock(mLock);
Prabir Pradhana41d2442023-04-20 21:30:40 +00006224 mPolicy.notifyFocusChanged(oldToken, newToken);
Prabir Pradhancef936d2021-07-21 16:17:52 +00006225 };
6226 postCommandLocked(std::move(command));
Michael Wrightd02c5b62014-02-10 15:10:22 -08006227}
6228
Prabir Pradhancef936d2021-07-21 16:17:52 +00006229void InputDispatcher::sendDropWindowCommandLocked(const sp<IBinder>& token, float x, float y) {
6230 auto command = [this, token, x, y]() REQUIRES(mLock) {
6231 scoped_unlock unlock(mLock);
Prabir Pradhana41d2442023-04-20 21:30:40 +00006232 mPolicy.notifyDropWindow(token, x, y);
Prabir Pradhancef936d2021-07-21 16:17:52 +00006233 };
6234 postCommandLocked(std::move(command));
Robert Carrf759f162018-11-13 12:57:11 -08006235}
6236
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07006237void InputDispatcher::onAnrLocked(const std::shared_ptr<Connection>& connection) {
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006238 if (connection == nullptr) {
6239 LOG_ALWAYS_FATAL("Caller must check for nullness");
6240 }
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006241 // Since we are allowing the policy to extend the timeout, maybe the waitQueue
6242 // is already healthy again. Don't raise ANR in this situation
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006243 if (connection->waitQueue.empty()) {
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006244 ALOGI("Not raising ANR because the connection %s has recovered",
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006245 connection->inputChannel->getName().c_str());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006246 return;
6247 }
6248 /**
6249 * The "oldestEntry" is the entry that was first sent to the application. That entry, however,
6250 * may not be the one that caused the timeout to occur. One possibility is that window timeout
6251 * has changed. This could cause newer entries to time out before the already dispatched
6252 * entries. In that situation, the newest entries caused ANR. But in all likelihood, the app
6253 * processes the events linearly. So providing information about the oldest entry seems to be
6254 * most useful.
6255 */
Prabir Pradhan8c90d782023-09-15 21:16:44 +00006256 DispatchEntry& oldestEntry = *connection->waitQueue.front();
6257 const nsecs_t currentWait = now() - oldestEntry.deliveryTime;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006258 std::string reason =
6259 android::base::StringPrintf("%s is not responding. Waited %" PRId64 "ms for %s",
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006260 connection->inputChannel->getName().c_str(),
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006261 ns2ms(currentWait),
Prabir Pradhan8c90d782023-09-15 21:16:44 +00006262 oldestEntry.eventEntry->getDescription().c_str());
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006263 sp<IBinder> connectionToken = connection->inputChannel->getConnectionToken();
Siarhei Vishniakou2b4782c2020-11-07 01:51:18 -06006264 updateLastAnrStateLocked(getWindowHandleLocked(connectionToken), reason);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006265
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006266 processConnectionUnresponsiveLocked(*connection, std::move(reason));
6267
6268 // Stop waking up for events on this connection, it is already unresponsive
6269 cancelEventsForAnrLocked(connection);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006270}
6271
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05006272void InputDispatcher::onAnrLocked(std::shared_ptr<InputApplicationHandle> application) {
6273 std::string reason =
6274 StringPrintf("%s does not have a focused window", application->getName().c_str());
6275 updateLastAnrStateLocked(*application, reason);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006276
Yabin Cui8eb9c552023-06-08 18:05:07 +00006277 auto command = [this, app = std::move(application)]() REQUIRES(mLock) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00006278 scoped_unlock unlock(mLock);
Yabin Cuiced952f2023-06-09 21:12:51 +00006279 mPolicy.notifyNoFocusedWindowAnr(app);
Prabir Pradhancef936d2021-07-21 16:17:52 +00006280 };
6281 postCommandLocked(std::move(command));
Bernardo Rufino2e1f6512020-10-08 13:42:07 +00006282}
6283
chaviw98318de2021-05-19 16:45:23 -05006284void InputDispatcher::updateLastAnrStateLocked(const sp<WindowInfoHandle>& window,
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006285 const std::string& reason) {
6286 const std::string windowLabel = getApplicationWindowLabel(nullptr, window);
6287 updateLastAnrStateLocked(windowLabel, reason);
6288}
6289
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05006290void InputDispatcher::updateLastAnrStateLocked(const InputApplicationHandle& application,
6291 const std::string& reason) {
6292 const std::string windowLabel = getApplicationWindowLabel(&application, nullptr);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006293 updateLastAnrStateLocked(windowLabel, reason);
6294}
6295
6296void InputDispatcher::updateLastAnrStateLocked(const std::string& windowLabel,
6297 const std::string& reason) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08006298 // Capture a record of the InputDispatcher state at the time of the ANR.
Yi Kong9b14ac62018-07-17 13:48:38 -07006299 time_t t = time(nullptr);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006300 struct tm tm;
6301 localtime_r(&t, &tm);
6302 char timestr[64];
6303 strftime(timestr, sizeof(timestr), "%F %T", &tm);
Siarhei Vishniakoub1a16272020-05-06 16:09:19 -07006304 mLastAnrState.clear();
6305 mLastAnrState += INDENT "ANR:\n";
6306 mLastAnrState += StringPrintf(INDENT2 "Time: %s\n", timestr);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07006307 mLastAnrState += StringPrintf(INDENT2 "Reason: %s\n", reason.c_str());
6308 mLastAnrState += StringPrintf(INDENT2 "Window: %s\n", windowLabel.c_str());
Siarhei Vishniakoub1a16272020-05-06 16:09:19 -07006309 dumpDispatchStateLocked(mLastAnrState);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006310}
6311
Prabir Pradhancef936d2021-07-21 16:17:52 +00006312void InputDispatcher::doInterceptKeyBeforeDispatchingCommand(const sp<IBinder>& focusedWindowToken,
6313 KeyEntry& entry) {
6314 const KeyEvent event = createKeyEvent(entry);
6315 nsecs_t delay = 0;
6316 { // release lock
6317 scoped_unlock unlock(mLock);
6318 android::base::Timer t;
Prabir Pradhana41d2442023-04-20 21:30:40 +00006319 delay = mPolicy.interceptKeyBeforeDispatching(focusedWindowToken, event, entry.policyFlags);
Prabir Pradhancef936d2021-07-21 16:17:52 +00006320 if (t.duration() > SLOW_INTERCEPTION_THRESHOLD) {
6321 ALOGW("Excessive delay in interceptKeyBeforeDispatching; took %s ms",
6322 std::to_string(t.duration().count()).c_str());
6323 }
6324 } // acquire lock
Michael Wrightd02c5b62014-02-10 15:10:22 -08006325
6326 if (delay < 0) {
Michael Wright5caf55a2022-11-24 22:31:42 +00006327 entry.interceptKeyResult = KeyEntry::InterceptKeyResult::SKIP;
Prabir Pradhancef936d2021-07-21 16:17:52 +00006328 } else if (delay == 0) {
Michael Wright5caf55a2022-11-24 22:31:42 +00006329 entry.interceptKeyResult = KeyEntry::InterceptKeyResult::CONTINUE;
Michael Wrightd02c5b62014-02-10 15:10:22 -08006330 } else {
Michael Wright5caf55a2022-11-24 22:31:42 +00006331 entry.interceptKeyResult = KeyEntry::InterceptKeyResult::TRY_AGAIN_LATER;
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006332 entry.interceptKeyWakeupTime = now() + delay;
Michael Wrightd02c5b62014-02-10 15:10:22 -08006333 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08006334}
6335
Prabir Pradhancef936d2021-07-21 16:17:52 +00006336void InputDispatcher::sendWindowUnresponsiveCommandLocked(const sp<IBinder>& token,
Prabir Pradhanaeebeb42023-06-13 19:53:03 +00006337 std::optional<gui::Pid> pid,
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006338 std::string reason) {
Yabin Cui8eb9c552023-06-08 18:05:07 +00006339 auto command = [this, token, pid, r = std::move(reason)]() REQUIRES(mLock) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00006340 scoped_unlock unlock(mLock);
Yabin Cuiced952f2023-06-09 21:12:51 +00006341 mPolicy.notifyWindowUnresponsive(token, pid, r);
Prabir Pradhancef936d2021-07-21 16:17:52 +00006342 };
6343 postCommandLocked(std::move(command));
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006344}
6345
Prabir Pradhanedd96402022-02-15 01:46:16 -08006346void InputDispatcher::sendWindowResponsiveCommandLocked(const sp<IBinder>& token,
Prabir Pradhanaeebeb42023-06-13 19:53:03 +00006347 std::optional<gui::Pid> pid) {
Prabir Pradhanedd96402022-02-15 01:46:16 -08006348 auto command = [this, token, pid]() REQUIRES(mLock) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00006349 scoped_unlock unlock(mLock);
Prabir Pradhana41d2442023-04-20 21:30:40 +00006350 mPolicy.notifyWindowResponsive(token, pid);
Prabir Pradhancef936d2021-07-21 16:17:52 +00006351 };
6352 postCommandLocked(std::move(command));
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006353}
6354
6355/**
6356 * Tell the policy that a connection has become unresponsive so that it can start ANR.
6357 * Check whether the connection of interest is a monitor or a window, and add the corresponding
6358 * command entry to the command queue.
6359 */
6360void InputDispatcher::processConnectionUnresponsiveLocked(const Connection& connection,
6361 std::string reason) {
6362 const sp<IBinder>& connectionToken = connection.inputChannel->getConnectionToken();
Prabir Pradhanaeebeb42023-06-13 19:53:03 +00006363 std::optional<gui::Pid> pid;
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006364 if (connection.monitor) {
6365 ALOGW("Monitor %s is unresponsive: %s", connection.inputChannel->getName().c_str(),
6366 reason.c_str());
Prabir Pradhanedd96402022-02-15 01:46:16 -08006367 pid = findMonitorPidByTokenLocked(connectionToken);
6368 } else {
6369 // The connection is a window
6370 ALOGW("Window %s is unresponsive: %s", connection.inputChannel->getName().c_str(),
6371 reason.c_str());
6372 const sp<WindowInfoHandle> handle = getWindowHandleLocked(connectionToken);
6373 if (handle != nullptr) {
6374 pid = handle->getInfo()->ownerPid;
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006375 }
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006376 }
Prabir Pradhanedd96402022-02-15 01:46:16 -08006377 sendWindowUnresponsiveCommandLocked(connectionToken, pid, std::move(reason));
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006378}
6379
6380/**
6381 * Tell the policy that a connection has become responsive so that it can stop ANR.
6382 */
6383void InputDispatcher::processConnectionResponsiveLocked(const Connection& connection) {
6384 const sp<IBinder>& connectionToken = connection.inputChannel->getConnectionToken();
Prabir Pradhanaeebeb42023-06-13 19:53:03 +00006385 std::optional<gui::Pid> pid;
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006386 if (connection.monitor) {
Prabir Pradhanedd96402022-02-15 01:46:16 -08006387 pid = findMonitorPidByTokenLocked(connectionToken);
6388 } else {
6389 // The connection is a window
6390 const sp<WindowInfoHandle> handle = getWindowHandleLocked(connectionToken);
6391 if (handle != nullptr) {
6392 pid = handle->getInfo()->ownerPid;
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006393 }
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006394 }
Prabir Pradhanedd96402022-02-15 01:46:16 -08006395 sendWindowResponsiveCommandLocked(connectionToken, pid);
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00006396}
6397
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07006398bool InputDispatcher::afterKeyEventLockedInterruptable(
Prabir Pradhan8c90d782023-09-15 21:16:44 +00006399 const std::shared_ptr<Connection>& connection, DispatchEntry& dispatchEntry,
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07006400 KeyEntry& keyEntry, bool handled) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006401 if (keyEntry.flags & AKEY_EVENT_FLAG_FALLBACK) {
Prabir Pradhanf93562f2018-11-29 12:13:37 -08006402 if (!handled) {
6403 // Report the key as unhandled, since the fallback was not handled.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006404 mReporter->reportUnhandledKey(keyEntry.id);
Prabir Pradhanf93562f2018-11-29 12:13:37 -08006405 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006406 return false;
6407 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08006408
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006409 // Get the fallback key state.
6410 // Clear it out after dispatching the UP.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006411 int32_t originalKeyCode = keyEntry.keyCode;
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006412 std::optional<int32_t> fallbackKeyCode = connection->inputState.getFallbackKey(originalKeyCode);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006413 if (keyEntry.action == AKEY_EVENT_ACTION_UP) {
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006414 connection->inputState.removeFallbackKey(originalKeyCode);
6415 }
6416
Prabir Pradhan8c90d782023-09-15 21:16:44 +00006417 if (handled || !dispatchEntry.hasForegroundTarget()) {
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006418 // If the application handles the original key for which we previously
6419 // generated a fallback or if the window is not a foreground window,
6420 // then cancel the associated fallback key, if any.
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006421 if (fallbackKeyCode) {
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006422 // Dispatch the unhandled key to the policy with the cancel flag.
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006423 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
6424 ALOGD("Unhandled key event: Asking policy to cancel fallback action. "
6425 "keyCode=%d, action=%d, repeatCount=%d, policyFlags=0x%08x",
6426 keyEntry.keyCode, keyEntry.action, keyEntry.repeatCount,
6427 keyEntry.policyFlags);
6428 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006429 KeyEvent event = createKeyEvent(keyEntry);
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006430 event.setFlags(event.getFlags() | AKEY_EVENT_FLAG_CANCELED);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006431
6432 mLock.unlock();
6433
Prabir Pradhana41d2442023-04-20 21:30:40 +00006434 if (const auto unhandledKeyFallback =
6435 mPolicy.dispatchUnhandledKey(connection->inputChannel->getConnectionToken(),
6436 event, keyEntry.policyFlags);
6437 unhandledKeyFallback) {
6438 event = *unhandledKeyFallback;
6439 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08006440
6441 mLock.lock();
6442
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006443 // Cancel the fallback key.
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006444 if (*fallbackKeyCode != AKEYCODE_UNKNOWN) {
Michael Wrightfb04fd52022-11-24 22:31:11 +00006445 CancelationOptions options(CancelationOptions::Mode::CANCEL_FALLBACK_EVENTS,
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006446 "application handled the original non-fallback key "
6447 "or is no longer a foreground target, "
6448 "canceling previously dispatched fallback key");
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006449 options.keyCode = *fallbackKeyCode;
Michael Wrightd02c5b62014-02-10 15:10:22 -08006450 synthesizeCancelationEventsForConnectionLocked(connection, options);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006451 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006452 connection->inputState.removeFallbackKey(originalKeyCode);
6453 }
6454 } else {
6455 // If the application did not handle a non-fallback key, first check
6456 // that we are in a good state to perform unhandled key event processing
6457 // Then ask the policy what to do with it.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006458 bool initialDown = keyEntry.action == AKEY_EVENT_ACTION_DOWN && keyEntry.repeatCount == 0;
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006459 if (!fallbackKeyCode && !initialDown) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006460 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
6461 ALOGD("Unhandled key event: Skipping unhandled key event processing "
6462 "since this is not an initial down. "
6463 "keyCode=%d, action=%d, repeatCount=%d, policyFlags=0x%08x",
6464 originalKeyCode, keyEntry.action, keyEntry.repeatCount, keyEntry.policyFlags);
6465 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006466 return false;
6467 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08006468
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006469 // Dispatch the unhandled key to the policy.
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006470 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
6471 ALOGD("Unhandled key event: Asking policy to perform fallback action. "
6472 "keyCode=%d, action=%d, repeatCount=%d, policyFlags=0x%08x",
6473 keyEntry.keyCode, keyEntry.action, keyEntry.repeatCount, keyEntry.policyFlags);
6474 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006475 KeyEvent event = createKeyEvent(keyEntry);
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006476
6477 mLock.unlock();
6478
Prabir Pradhana41d2442023-04-20 21:30:40 +00006479 bool fallback = false;
6480 if (auto fb = mPolicy.dispatchUnhandledKey(connection->inputChannel->getConnectionToken(),
6481 event, keyEntry.policyFlags);
6482 fb) {
6483 fallback = true;
6484 event = *fb;
6485 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006486
6487 mLock.lock();
6488
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08006489 if (connection->status != Connection::Status::NORMAL) {
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006490 connection->inputState.removeFallbackKey(originalKeyCode);
6491 return false;
6492 }
6493
6494 // Latch the fallback keycode for this key on an initial down.
6495 // The fallback keycode cannot change at any other point in the lifecycle.
6496 if (initialDown) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08006497 if (fallback) {
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006498 *fallbackKeyCode = event.getKeyCode();
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006499 } else {
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006500 *fallbackKeyCode = AKEYCODE_UNKNOWN;
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006501 }
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006502 connection->inputState.setFallbackKey(originalKeyCode, *fallbackKeyCode);
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006503 }
6504
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006505 ALOG_ASSERT(fallbackKeyCode);
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006506
6507 // Cancel the fallback key if the policy decides not to send it anymore.
6508 // We will continue to dispatch the key to the policy but we will no
6509 // longer dispatch a fallback key to the application.
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006510 if (*fallbackKeyCode != AKEYCODE_UNKNOWN &&
6511 (!fallback || *fallbackKeyCode != event.getKeyCode())) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006512 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
6513 if (fallback) {
6514 ALOGD("Unhandled key event: Policy requested to send key %d"
6515 "as a fallback for %d, but on the DOWN it had requested "
6516 "to send %d instead. Fallback canceled.",
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006517 event.getKeyCode(), originalKeyCode, *fallbackKeyCode);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006518 } else {
6519 ALOGD("Unhandled key event: Policy did not request fallback for %d, "
6520 "but on the DOWN it had requested to send %d. "
6521 "Fallback canceled.",
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006522 originalKeyCode, *fallbackKeyCode);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006523 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006524 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006525
Michael Wrightfb04fd52022-11-24 22:31:11 +00006526 CancelationOptions options(CancelationOptions::Mode::CANCEL_FALLBACK_EVENTS,
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006527 "canceling fallback, policy no longer desires it");
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006528 options.keyCode = *fallbackKeyCode;
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006529 synthesizeCancelationEventsForConnectionLocked(connection, options);
6530
6531 fallback = false;
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006532 *fallbackKeyCode = AKEYCODE_UNKNOWN;
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006533 if (keyEntry.action != AKEY_EVENT_ACTION_UP) {
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006534 connection->inputState.setFallbackKey(originalKeyCode, *fallbackKeyCode);
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006535 }
6536 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08006537
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006538 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
6539 {
6540 std::string msg;
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006541 const std::map<int32_t, int32_t>& fallbackKeys =
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006542 connection->inputState.getFallbackKeys();
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006543 for (const auto& [key, value] : fallbackKeys) {
6544 msg += StringPrintf(", %d->%d", key, value);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006545 }
6546 ALOGD("Unhandled key event: %zu currently tracked fallback keys%s.",
6547 fallbackKeys.size(), msg.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08006548 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006549 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006550
6551 if (fallback) {
6552 // Restart the dispatch cycle using the fallback key.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006553 keyEntry.eventTime = event.getEventTime();
6554 keyEntry.deviceId = event.getDeviceId();
6555 keyEntry.source = event.getSource();
6556 keyEntry.displayId = event.getDisplayId();
6557 keyEntry.flags = event.getFlags() | AKEY_EVENT_FLAG_FALLBACK;
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006558 keyEntry.keyCode = *fallbackKeyCode;
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006559 keyEntry.scanCode = event.getScanCode();
6560 keyEntry.metaState = event.getMetaState();
6561 keyEntry.repeatCount = event.getRepeatCount();
6562 keyEntry.downTime = event.getDownTime();
6563 keyEntry.syntheticRepeat = false;
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006564
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006565 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
6566 ALOGD("Unhandled key event: Dispatching fallback key. "
6567 "originalKeyCode=%d, fallbackKeyCode=%d, fallbackMetaState=%08x",
Siarhei Vishniakou0fe01262023-04-17 08:11:37 -07006568 originalKeyCode, *fallbackKeyCode, keyEntry.metaState);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006569 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006570 return true; // restart the event
6571 } else {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006572 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
6573 ALOGD("Unhandled key event: No fallback key.");
6574 }
Prabir Pradhanf93562f2018-11-29 12:13:37 -08006575
6576 // Report the key as unhandled, since there is no fallback key.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006577 mReporter->reportUnhandledKey(keyEntry.id);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006578 }
6579 }
6580 return false;
6581}
6582
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07006583bool InputDispatcher::afterMotionEventLockedInterruptable(
Prabir Pradhan8c90d782023-09-15 21:16:44 +00006584 const std::shared_ptr<Connection>& connection, DispatchEntry& dispatchEntry,
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07006585 MotionEntry& motionEntry, bool handled) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08006586 return false;
6587}
6588
Michael Wrightd02c5b62014-02-10 15:10:22 -08006589void InputDispatcher::traceInboundQueueLengthLocked() {
6590 if (ATRACE_ENABLED()) {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07006591 ATRACE_INT("iq", mInboundQueue.size());
Michael Wrightd02c5b62014-02-10 15:10:22 -08006592 }
6593}
6594
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00006595void InputDispatcher::traceOutboundQueueLength(const Connection& connection) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08006596 if (ATRACE_ENABLED()) {
6597 char counterName[40];
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00006598 snprintf(counterName, sizeof(counterName), "oq:%s", connection.getWindowName().c_str());
6599 ATRACE_INT(counterName, connection.outboundQueue.size());
Michael Wrightd02c5b62014-02-10 15:10:22 -08006600 }
6601}
6602
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00006603void InputDispatcher::traceWaitQueueLength(const Connection& connection) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08006604 if (ATRACE_ENABLED()) {
6605 char counterName[40];
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00006606 snprintf(counterName, sizeof(counterName), "wq:%s", connection.getWindowName().c_str());
6607 ATRACE_INT(counterName, connection.waitQueue.size());
Michael Wrightd02c5b62014-02-10 15:10:22 -08006608 }
6609}
6610
Siarhei Vishniakou5e20f272023-06-08 17:24:44 -07006611void InputDispatcher::dump(std::string& dump) const {
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08006612 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006613
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08006614 dump += "Input Dispatcher State:\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08006615 dumpDispatchStateLocked(dump);
6616
Siarhei Vishniakoub1a16272020-05-06 16:09:19 -07006617 if (!mLastAnrState.empty()) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08006618 dump += "\nInput Dispatcher State at time of last ANR:\n";
Siarhei Vishniakoub1a16272020-05-06 16:09:19 -07006619 dump += mLastAnrState;
Michael Wrightd02c5b62014-02-10 15:10:22 -08006620 }
6621}
6622
6623void InputDispatcher::monitor() {
6624 // Acquire and release the lock to ensure that the dispatcher has not deadlocked.
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08006625 std::unique_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006626 mLooper->wake();
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08006627 mDispatcherIsAlive.wait(_l);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006628}
6629
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -08006630/**
6631 * Wake up the dispatcher and wait until it processes all events and commands.
6632 * The notification of mDispatcherEnteredIdle is guaranteed to happen after wake(), so
6633 * this method can be safely called from any thread, as long as you've ensured that
6634 * the work you are interested in completing has already been queued.
6635 */
Siarhei Vishniakoua66d65e2023-06-16 10:32:51 -07006636bool InputDispatcher::waitForIdle() const {
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -08006637 /**
6638 * Timeout should represent the longest possible time that a device might spend processing
6639 * events and commands.
6640 */
6641 constexpr std::chrono::duration TIMEOUT = 100ms;
6642 std::unique_lock lock(mLock);
6643 mLooper->wake();
6644 std::cv_status result = mDispatcherEnteredIdle.wait_for(lock, TIMEOUT);
6645 return result == std::cv_status::no_timeout;
6646}
6647
Vishnu Naire798b472020-07-23 13:52:21 -07006648/**
6649 * Sets focus to the window identified by the token. This must be called
6650 * after updating any input window handles.
6651 *
6652 * Params:
6653 * request.token - input channel token used to identify the window that should gain focus.
6654 * request.focusedToken - the token that the caller expects currently to be focused. If the
6655 * specified token does not match the currently focused window, this request will be dropped.
6656 * If the specified focused token matches the currently focused window, the call will succeed.
6657 * Set this to "null" if this call should succeed no matter what the currently focused token is.
6658 * request.timestamp - SYSTEM_TIME_MONOTONIC timestamp in nanos set by the client (wm)
6659 * when requesting the focus change. This determines which request gets
6660 * precedence if there is a focus change request from another source such as pointer down.
6661 */
Vishnu Nair958da932020-08-21 17:12:37 -07006662void InputDispatcher::setFocusedWindow(const FocusRequest& request) {
6663 { // acquire lock
6664 std::scoped_lock _l(mLock);
Vishnu Nairc519ff72021-01-21 08:23:08 -08006665 std::optional<FocusResolver::FocusChanges> changes =
6666 mFocusResolver.setFocusedWindow(request, getWindowHandlesLocked(request.displayId));
6667 if (changes) {
6668 onFocusChangedLocked(*changes);
Vishnu Nair958da932020-08-21 17:12:37 -07006669 }
6670 } // release lock
6671 // Wake up poll loop since it may need to make new input dispatching choices.
6672 mLooper->wake();
6673}
6674
Vishnu Nairc519ff72021-01-21 08:23:08 -08006675void InputDispatcher::onFocusChangedLocked(const FocusResolver::FocusChanges& changes) {
6676 if (changes.oldFocus) {
6677 std::shared_ptr<InputChannel> focusedInputChannel = getInputChannelLocked(changes.oldFocus);
Vishnu Nair7d3d00d2020-08-03 11:20:42 -07006678 if (focusedInputChannel) {
Michael Wrightfb04fd52022-11-24 22:31:11 +00006679 CancelationOptions options(CancelationOptions::Mode::CANCEL_NON_POINTER_EVENTS,
Vishnu Nair7d3d00d2020-08-03 11:20:42 -07006680 "focus left window");
6681 synthesizeCancelationEventsForInputChannelLocked(focusedInputChannel, options);
Harry Cutts33476232023-01-30 19:57:29 +00006682 enqueueFocusEventLocked(changes.oldFocus, /*hasFocus=*/false, changes.reason);
Vishnu Nair7d3d00d2020-08-03 11:20:42 -07006683 }
Vishnu Nair7d3d00d2020-08-03 11:20:42 -07006684 }
Vishnu Nairc519ff72021-01-21 08:23:08 -08006685 if (changes.newFocus) {
Siarhei Vishniakouc033dfb2023-10-03 10:45:16 -07006686 resetNoFocusedWindowTimeoutLocked();
Harry Cutts33476232023-01-30 19:57:29 +00006687 enqueueFocusEventLocked(changes.newFocus, /*hasFocus=*/true, changes.reason);
Vishnu Nair7d3d00d2020-08-03 11:20:42 -07006688 }
6689
Prabir Pradhan99987712020-11-10 18:43:05 -08006690 // If a window has pointer capture, then it must have focus. We need to ensure that this
6691 // contract is upheld when pointer capture is being disabled due to a loss of window focus.
6692 // If the window loses focus before it loses pointer capture, then the window can be in a state
6693 // where it has pointer capture but not focus, violating the contract. Therefore we must
6694 // dispatch the pointer capture event before the focus event. Since focus events are added to
6695 // the front of the queue (above), we add the pointer capture event to the front of the queue
6696 // after the focus events are added. This ensures the pointer capture event ends up at the
6697 // front.
6698 disablePointerCaptureForcedLocked();
6699
Vishnu Nairc519ff72021-01-21 08:23:08 -08006700 if (mFocusedDisplayId == changes.displayId) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00006701 sendFocusChangedCommandLocked(changes.oldFocus, changes.newFocus);
Vishnu Nair7d3d00d2020-08-03 11:20:42 -07006702 }
6703}
Vishnu Nair958da932020-08-21 17:12:37 -07006704
Prabir Pradhan99987712020-11-10 18:43:05 -08006705void InputDispatcher::disablePointerCaptureForcedLocked() {
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00006706 if (!mCurrentPointerCaptureRequest.enable && !mWindowTokenWithPointerCapture) {
Prabir Pradhan99987712020-11-10 18:43:05 -08006707 return;
6708 }
6709
6710 ALOGD_IF(DEBUG_FOCUS, "Disabling Pointer Capture because the window lost focus.");
6711
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00006712 if (mCurrentPointerCaptureRequest.enable) {
Prabir Pradhan99987712020-11-10 18:43:05 -08006713 setPointerCaptureLocked(false);
6714 }
6715
6716 if (!mWindowTokenWithPointerCapture) {
6717 // No need to send capture changes because no window has capture.
6718 return;
6719 }
6720
6721 if (mPendingEvent != nullptr) {
6722 // Move the pending event to the front of the queue. This will give the chance
6723 // for the pending event to be dropped if it is a captured event.
6724 mInboundQueue.push_front(mPendingEvent);
6725 mPendingEvent = nullptr;
6726 }
6727
6728 auto entry = std::make_unique<PointerCaptureChangedEntry>(mIdGenerator.nextId(), now(),
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00006729 mCurrentPointerCaptureRequest);
Prabir Pradhan99987712020-11-10 18:43:05 -08006730 mInboundQueue.push_front(std::move(entry));
6731}
6732
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00006733void InputDispatcher::setPointerCaptureLocked(bool enable) {
6734 mCurrentPointerCaptureRequest.enable = enable;
6735 mCurrentPointerCaptureRequest.seq++;
6736 auto command = [this, request = mCurrentPointerCaptureRequest]() REQUIRES(mLock) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00006737 scoped_unlock unlock(mLock);
Prabir Pradhana41d2442023-04-20 21:30:40 +00006738 mPolicy.setPointerCapture(request);
Prabir Pradhancef936d2021-07-21 16:17:52 +00006739 };
6740 postCommandLocked(std::move(command));
Prabir Pradhan99987712020-11-10 18:43:05 -08006741}
6742
Vishnu Nair599f1412021-06-21 10:39:58 -07006743void InputDispatcher::displayRemoved(int32_t displayId) {
6744 { // acquire lock
6745 std::scoped_lock _l(mLock);
6746 // Set an empty list to remove all handles from the specific display.
Harry Cutts101ee9b2023-07-06 18:04:14 +00006747 setInputWindowsLocked(/*windowInfoHandles=*/{}, displayId);
Vishnu Nair599f1412021-06-21 10:39:58 -07006748 setFocusedApplicationLocked(displayId, nullptr);
6749 // Call focus resolver to clean up stale requests. This must be called after input windows
6750 // have been removed for the removed display.
6751 mFocusResolver.displayRemoved(displayId);
Christine Franksb768bb42021-11-29 12:11:31 -08006752 // Reset pointer capture eligibility, regardless of previous state.
6753 std::erase(mIneligibleDisplaysForPointerCapture, displayId);
Antonio Kantek15beb512022-06-13 22:35:41 +00006754 // Remove the associated touch mode state.
6755 mTouchModePerDisplay.erase(displayId);
Siarhei Vishniakou5c02a712023-05-15 15:45:02 -07006756 mVerifiersByDisplay.erase(displayId);
Vishnu Nair599f1412021-06-21 10:39:58 -07006757 } // release lock
6758
6759 // Wake up poll loop since it may need to make new input dispatching choices.
6760 mLooper->wake();
6761}
6762
Patrick Williamsd828f302023-04-28 17:52:08 -05006763void InputDispatcher::onWindowInfosChanged(const gui::WindowInfosUpdate& update) {
chaviw15fab6f2021-06-07 14:15:52 -05006764 // The listener sends the windows as a flattened array. Separate the windows by display for
6765 // more convenient parsing.
6766 std::unordered_map<int32_t, std::vector<sp<WindowInfoHandle>>> handlesPerDisplay;
Patrick Williamsd828f302023-04-28 17:52:08 -05006767 for (const auto& info : update.windowInfos) {
chaviw15fab6f2021-06-07 14:15:52 -05006768 handlesPerDisplay.emplace(info.displayId, std::vector<sp<WindowInfoHandle>>());
Siarhei Vishniakouaed7ad02022-08-03 15:04:33 -07006769 handlesPerDisplay[info.displayId].push_back(sp<WindowInfoHandle>::make(info));
chaviw15fab6f2021-06-07 14:15:52 -05006770 }
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07006771
6772 { // acquire lock
6773 std::scoped_lock _l(mLock);
Prabir Pradhan814fe082022-07-22 20:22:18 +00006774
6775 // Ensure that we have an entry created for all existing displays so that if a displayId has
6776 // no windows, we can tell that the windows were removed from the display.
6777 for (const auto& [displayId, _] : mWindowHandlesByDisplay) {
6778 handlesPerDisplay[displayId];
6779 }
6780
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07006781 mDisplayInfos.clear();
Patrick Williamsd828f302023-04-28 17:52:08 -05006782 for (const auto& displayInfo : update.displayInfos) {
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07006783 mDisplayInfos.emplace(displayInfo.displayId, displayInfo);
6784 }
6785
6786 for (const auto& [displayId, handles] : handlesPerDisplay) {
6787 setInputWindowsLocked(handles, displayId);
6788 }
Patrick Williams9464b2c2023-05-23 11:22:04 -05006789
6790 if (update.vsyncId < mWindowInfosVsyncId) {
6791 ALOGE("Received out of order window infos update. Last update vsync id: %" PRId64
6792 ", current update vsync id: %" PRId64,
6793 mWindowInfosVsyncId, update.vsyncId);
6794 }
6795 mWindowInfosVsyncId = update.vsyncId;
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07006796 }
6797 // Wake up poll loop since it may need to make new input dispatching choices.
6798 mLooper->wake();
chaviw15fab6f2021-06-07 14:15:52 -05006799}
6800
Vishnu Nair062a8672021-09-03 16:07:44 -07006801bool InputDispatcher::shouldDropInput(
6802 const EventEntry& entry, const sp<android::gui::WindowInfoHandle>& windowHandle) const {
Prabir Pradhan51e7db02022-02-07 06:02:57 -08006803 if (windowHandle->getInfo()->inputConfig.test(WindowInfo::InputConfig::DROP_INPUT) ||
6804 (windowHandle->getInfo()->inputConfig.test(
6805 WindowInfo::InputConfig::DROP_INPUT_IF_OBSCURED) &&
Vishnu Nair062a8672021-09-03 16:07:44 -07006806 isWindowObscuredLocked(windowHandle))) {
Prabir Pradhan51e7db02022-02-07 06:02:57 -08006807 ALOGW("Dropping %s event targeting %s as requested by the input configuration {%s} on "
6808 "display %" PRId32 ".",
Vishnu Nair062a8672021-09-03 16:07:44 -07006809 ftl::enum_string(entry.type).c_str(), windowHandle->getName().c_str(),
Prabir Pradhan51e7db02022-02-07 06:02:57 -08006810 windowHandle->getInfo()->inputConfig.string().c_str(),
Vishnu Nair062a8672021-09-03 16:07:44 -07006811 windowHandle->getInfo()->displayId);
6812 return true;
6813 }
6814 return false;
6815}
6816
Siarhei Vishniakou18050092021-09-01 13:32:49 -07006817void InputDispatcher::DispatcherWindowListener::onWindowInfosChanged(
Patrick Williamsd828f302023-04-28 17:52:08 -05006818 const gui::WindowInfosUpdate& update) {
6819 mDispatcher.onWindowInfosChanged(update);
Siarhei Vishniakou18050092021-09-01 13:32:49 -07006820}
6821
Arthur Hungdfd528e2021-12-08 13:23:04 +00006822void InputDispatcher::cancelCurrentTouch() {
6823 {
6824 std::scoped_lock _l(mLock);
6825 ALOGD("Canceling all ongoing pointer gestures on all displays.");
Michael Wrightfb04fd52022-11-24 22:31:11 +00006826 CancelationOptions options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS,
Arthur Hungdfd528e2021-12-08 13:23:04 +00006827 "cancel current touch");
6828 synthesizeCancelationEventsForAllConnectionsLocked(options);
6829
6830 mTouchStatesByDisplay.clear();
Arthur Hungdfd528e2021-12-08 13:23:04 +00006831 }
6832 // Wake up poll loop since there might be work to do.
6833 mLooper->wake();
6834}
6835
Prabir Pradhan1376fcd2022-01-21 09:56:35 -08006836void InputDispatcher::setMonitorDispatchingTimeoutForTest(std::chrono::nanoseconds timeout) {
6837 std::scoped_lock _l(mLock);
6838 mMonitorDispatchingTimeout = timeout;
6839}
6840
Arthur Hungc539dbb2022-12-08 07:45:36 +00006841void InputDispatcher::slipWallpaperTouch(ftl::Flags<InputTarget::Flags> targetFlags,
6842 const sp<WindowInfoHandle>& oldWindowHandle,
6843 const sp<WindowInfoHandle>& newWindowHandle,
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07006844 TouchState& state, int32_t deviceId, int32_t pointerId,
Siarhei Vishniakoubf880522023-05-01 11:03:22 -07006845 std::vector<InputTarget>& targets) const {
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08006846 std::bitset<MAX_POINTER_ID + 1> pointerIds;
6847 pointerIds.set(pointerId);
Arthur Hungc539dbb2022-12-08 07:45:36 +00006848 const bool oldHasWallpaper = oldWindowHandle->getInfo()->inputConfig.test(
6849 gui::WindowInfo::InputConfig::DUPLICATE_TOUCH_TO_WALLPAPER);
6850 const bool newHasWallpaper = targetFlags.test(InputTarget::Flags::FOREGROUND) &&
6851 newWindowHandle->getInfo()->inputConfig.test(
6852 gui::WindowInfo::InputConfig::DUPLICATE_TOUCH_TO_WALLPAPER);
6853 const sp<WindowInfoHandle> oldWallpaper =
6854 oldHasWallpaper ? state.getWallpaperWindow() : nullptr;
6855 const sp<WindowInfoHandle> newWallpaper =
6856 newHasWallpaper ? findWallpaperWindowBelow(newWindowHandle) : nullptr;
6857 if (oldWallpaper == newWallpaper) {
6858 return;
6859 }
6860
6861 if (oldWallpaper != nullptr) {
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -08006862 const TouchedWindow& oldTouchedWindow = state.getTouchedWindow(oldWallpaper);
Siarhei Vishniakou2899c552023-07-10 18:20:46 -07006863 addPointerWindowTargetLocked(oldWallpaper,
6864 oldTouchedWindow.targetFlags |
6865 InputTarget::Flags::DISPATCH_AS_SLIPPERY_EXIT,
6866 pointerIds, oldTouchedWindow.getDownTimeInTarget(deviceId),
6867 targets);
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07006868 state.removeTouchingPointerFromWindow(deviceId, pointerId, oldWallpaper);
Arthur Hungc539dbb2022-12-08 07:45:36 +00006869 }
6870
6871 if (newWallpaper != nullptr) {
6872 state.addOrUpdateWindow(newWallpaper,
6873 InputTarget::Flags::DISPATCH_AS_SLIPPERY_ENTER |
6874 InputTarget::Flags::WINDOW_IS_OBSCURED |
6875 InputTarget::Flags::WINDOW_IS_PARTIALLY_OBSCURED,
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07006876 deviceId, pointerIds);
Arthur Hungc539dbb2022-12-08 07:45:36 +00006877 }
6878}
6879
6880void InputDispatcher::transferWallpaperTouch(ftl::Flags<InputTarget::Flags> oldTargetFlags,
6881 ftl::Flags<InputTarget::Flags> newTargetFlags,
6882 const sp<WindowInfoHandle> fromWindowHandle,
6883 const sp<WindowInfoHandle> toWindowHandle,
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07006884 TouchState& state, int32_t deviceId,
Siarhei Vishniakou8a878352023-01-30 14:05:01 -08006885 std::bitset<MAX_POINTER_ID + 1> pointerIds) {
Arthur Hungc539dbb2022-12-08 07:45:36 +00006886 const bool oldHasWallpaper = oldTargetFlags.test(InputTarget::Flags::FOREGROUND) &&
6887 fromWindowHandle->getInfo()->inputConfig.test(
6888 gui::WindowInfo::InputConfig::DUPLICATE_TOUCH_TO_WALLPAPER);
6889 const bool newHasWallpaper = newTargetFlags.test(InputTarget::Flags::FOREGROUND) &&
6890 toWindowHandle->getInfo()->inputConfig.test(
6891 gui::WindowInfo::InputConfig::DUPLICATE_TOUCH_TO_WALLPAPER);
6892
6893 const sp<WindowInfoHandle> oldWallpaper =
6894 oldHasWallpaper ? state.getWallpaperWindow() : nullptr;
6895 const sp<WindowInfoHandle> newWallpaper =
6896 newHasWallpaper ? findWallpaperWindowBelow(toWindowHandle) : nullptr;
6897 if (oldWallpaper == newWallpaper) {
6898 return;
6899 }
6900
6901 if (oldWallpaper != nullptr) {
6902 CancelationOptions options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS,
6903 "transferring touch focus to another window");
6904 state.removeWindowByToken(oldWallpaper->getToken());
6905 synthesizeCancelationEventsForWindowLocked(oldWallpaper, options);
6906 }
6907
6908 if (newWallpaper != nullptr) {
6909 nsecs_t downTimeInTarget = now();
6910 ftl::Flags<InputTarget::Flags> wallpaperFlags =
6911 oldTargetFlags & (InputTarget::Flags::SPLIT | InputTarget::Flags::DISPATCH_AS_IS);
6912 wallpaperFlags |= InputTarget::Flags::WINDOW_IS_OBSCURED |
6913 InputTarget::Flags::WINDOW_IS_PARTIALLY_OBSCURED;
Siarhei Vishniakou0836a302023-05-03 13:54:30 -07006914 state.addOrUpdateWindow(newWallpaper, wallpaperFlags, deviceId, pointerIds,
6915 downTimeInTarget);
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07006916 std::shared_ptr<Connection> wallpaperConnection =
6917 getConnectionLocked(newWallpaper->getToken());
Arthur Hungc539dbb2022-12-08 07:45:36 +00006918 if (wallpaperConnection != nullptr) {
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -07006919 std::shared_ptr<Connection> toConnection =
6920 getConnectionLocked(toWindowHandle->getToken());
Arthur Hungc539dbb2022-12-08 07:45:36 +00006921 toConnection->inputState.mergePointerStateTo(wallpaperConnection->inputState);
6922 synthesizePointerDownEventsForConnectionLocked(downTimeInTarget, wallpaperConnection,
6923 wallpaperFlags);
6924 }
6925 }
6926}
6927
6928sp<WindowInfoHandle> InputDispatcher::findWallpaperWindowBelow(
6929 const sp<WindowInfoHandle>& windowHandle) const {
6930 const std::vector<sp<WindowInfoHandle>>& windowHandles =
6931 getWindowHandlesLocked(windowHandle->getInfo()->displayId);
6932 bool foundWindow = false;
6933 for (const sp<WindowInfoHandle>& otherHandle : windowHandles) {
6934 if (!foundWindow && otherHandle != windowHandle) {
6935 continue;
6936 }
6937 if (windowHandle == otherHandle) {
6938 foundWindow = true;
6939 continue;
6940 }
6941
6942 if (otherHandle->getInfo()->inputConfig.test(WindowInfo::InputConfig::IS_WALLPAPER)) {
6943 return otherHandle;
6944 }
6945 }
6946 return nullptr;
6947}
6948
Nergi Rahardi730cf3c2023-04-13 12:41:17 +09006949void InputDispatcher::setKeyRepeatConfiguration(nsecs_t timeout, nsecs_t delay) {
6950 std::scoped_lock _l(mLock);
6951
6952 mConfig.keyRepeatTimeout = timeout;
6953 mConfig.keyRepeatDelay = delay;
6954}
6955
Garfield Tane84e6f92019-08-29 17:28:41 -07006956} // namespace android::inputdispatcher