blob: 5c47be9be037fddd8d2649d1ea8d305ddc17bc5b [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>
Peter Collingbourneb04b9b82021-02-08 12:09:47 -080023#include <android-base/properties.h>
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -080024#include <android-base/stringprintf.h>
Siarhei Vishniakou70622952020-07-30 11:17:23 -050025#include <android/os/IInputConstants.h>
Robert Carr4e670e52018-08-15 13:26:12 -070026#include <binder/Binder.h>
Dominik Laskowski75788452021-02-09 18:51:25 -080027#include <ftl/enum.h>
chaviw15fab6f2021-06-07 14:15:52 -050028#include <gui/SurfaceComposerClient.h>
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -080029#include <input/InputDevice.h>
Garfield Tan0fc2fa72019-08-29 17:22:15 -070030#include <powermanager/PowerManager.h>
Michael Wright44753b12020-07-08 13:48:11 +010031#include <unistd.h>
Garfield Tan0fc2fa72019-08-29 17:22:15 -070032#include <utils/Trace.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080033
Michael Wright44753b12020-07-08 13:48:11 +010034#include <cerrno>
35#include <cinttypes>
36#include <climits>
37#include <cstddef>
38#include <ctime>
39#include <queue>
40#include <sstream>
41
42#include "Connection.h"
Arthur Hung1a1007b2022-05-11 07:15:01 +000043#include "DebugConfig.h"
Chris Yef59a2f42020-10-16 12:55:26 -070044#include "InputDispatcher.h"
Michael Wright44753b12020-07-08 13:48:11 +010045
Michael Wrightd02c5b62014-02-10 15:10:22 -080046#define INDENT " "
47#define INDENT2 " "
48#define INDENT3 " "
49#define INDENT4 " "
50
Peter Collingbourneb04b9b82021-02-08 12:09:47 -080051using android::base::HwTimeoutMultiplier;
Siarhei Vishniakoueedd0fc2021-03-12 09:50:36 +000052using android::base::Result;
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -080053using android::base::StringPrintf;
Prabir Pradhan48f8cb92021-08-26 14:05:36 -070054using android::gui::DisplayInfo;
chaviw98318de2021-05-19 16:45:23 -050055using android::gui::FocusRequest;
56using android::gui::TouchOcclusionMode;
57using android::gui::WindowInfo;
58using android::gui::WindowInfoHandle;
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -080059using android::os::BlockUntrustedTouchesMode;
Siarhei Vishniakou2508b872020-12-03 16:33:53 -100060using android::os::IInputConstants;
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -080061using android::os::InputEventInjectionResult;
62using android::os::InputEventInjectionSync;
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -080063
Garfield Tane84e6f92019-08-29 17:28:41 -070064namespace android::inputdispatcher {
Michael Wrightd02c5b62014-02-10 15:10:22 -080065
Prabir Pradhancef936d2021-07-21 16:17:52 +000066namespace {
Prabir Pradhancef936d2021-07-21 16:17:52 +000067// Temporarily releases a held mutex for the lifetime of the instance.
68// Named to match std::scoped_lock
69class scoped_unlock {
70public:
71 explicit scoped_unlock(std::mutex& mutex) : mMutex(mutex) { mMutex.unlock(); }
72 ~scoped_unlock() { mMutex.lock(); }
73
74private:
75 std::mutex& mMutex;
76};
77
Michael Wrightd02c5b62014-02-10 15:10:22 -080078// Default input dispatching timeout if there is no focused application or paused window
79// from which to determine an appropriate dispatching timeout.
Peter Collingbourneb04b9b82021-02-08 12:09:47 -080080const std::chrono::duration DEFAULT_INPUT_DISPATCHING_TIMEOUT = std::chrono::milliseconds(
81 android::os::IInputConstants::UNMULTIPLIED_DEFAULT_DISPATCHING_TIMEOUT_MILLIS *
82 HwTimeoutMultiplier());
Michael Wrightd02c5b62014-02-10 15:10:22 -080083
84// Amount of time to allow for all pending events to be processed when an app switch
85// key is on the way. This is used to preempt input dispatch and drop input events
86// when an application takes too long to respond and the user has pressed an app switch key.
Michael Wright2b3c3302018-03-02 17:19:13 +000087constexpr nsecs_t APP_SWITCH_TIMEOUT = 500 * 1000000LL; // 0.5sec
Michael Wrightd02c5b62014-02-10 15:10:22 -080088
Siarhei Vishniakou289e9242022-02-15 14:50:16 -080089const std::chrono::duration STALE_EVENT_TIMEOUT = std::chrono::seconds(10) * HwTimeoutMultiplier();
Michael Wrightd02c5b62014-02-10 15:10:22 -080090
Michael Wrightd02c5b62014-02-10 15:10:22 -080091// 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 +000092constexpr nsecs_t SLOW_EVENT_PROCESSING_WARNING_TIMEOUT = 2000 * 1000000LL; // 2sec
93
94// Log a warning when an interception call takes longer than this to process.
95constexpr std::chrono::milliseconds SLOW_INTERCEPTION_THRESHOLD = 50ms;
Michael Wrightd02c5b62014-02-10 15:10:22 -080096
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -070097// Additional key latency in case a connection is still processing some motion events.
98// This will help with the case when a user touched a button that opens a new window,
99// and gives us the chance to dispatch the key to this new window.
100constexpr std::chrono::nanoseconds KEY_WAITING_FOR_EVENTS_TIMEOUT = 500ms;
101
Michael Wrightd02c5b62014-02-10 15:10:22 -0800102// Number of recent events to keep for debugging purposes.
Michael Wright2b3c3302018-03-02 17:19:13 +0000103constexpr size_t RECENT_QUEUE_MAX_SIZE = 10;
104
Antonio Kantekea47acb2021-12-23 12:41:25 -0800105// Event log tags. See EventLogTags.logtags for reference.
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +0000106constexpr int LOGTAG_INPUT_INTERACTION = 62000;
107constexpr int LOGTAG_INPUT_FOCUS = 62001;
Arthur Hungb3307ee2021-10-14 10:57:37 +0000108constexpr int LOGTAG_INPUT_CANCEL = 62003;
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +0000109
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000110inline nsecs_t now() {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800111 return systemTime(SYSTEM_TIME_MONOTONIC);
112}
113
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000114inline const char* toString(bool value) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800115 return value ? "true" : "false";
116}
117
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000118inline const std::string toString(const sp<IBinder>& binder) {
Bernardo Rufino49d99e42021-01-18 15:16:59 +0000119 if (binder == nullptr) {
120 return "<null>";
121 }
122 return StringPrintf("%p", binder.get());
123}
124
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000125inline int32_t getMotionEventActionPointerIndex(int32_t action) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700126 return (action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >>
127 AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800128}
129
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000130bool isValidKeyAction(int32_t action) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800131 switch (action) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700132 case AKEY_EVENT_ACTION_DOWN:
133 case AKEY_EVENT_ACTION_UP:
134 return true;
135 default:
136 return false;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800137 }
138}
139
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000140bool validateKeyEvent(int32_t action) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700141 if (!isValidKeyAction(action)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800142 ALOGE("Key event has invalid action code 0x%x", action);
143 return false;
144 }
145 return true;
146}
147
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000148bool isValidMotionAction(int32_t action, int32_t actionButton, int32_t pointerCount) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800149 switch (action & AMOTION_EVENT_ACTION_MASK) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700150 case AMOTION_EVENT_ACTION_DOWN:
151 case AMOTION_EVENT_ACTION_UP:
152 case AMOTION_EVENT_ACTION_CANCEL:
153 case AMOTION_EVENT_ACTION_MOVE:
154 case AMOTION_EVENT_ACTION_OUTSIDE:
155 case AMOTION_EVENT_ACTION_HOVER_ENTER:
156 case AMOTION_EVENT_ACTION_HOVER_MOVE:
157 case AMOTION_EVENT_ACTION_HOVER_EXIT:
158 case AMOTION_EVENT_ACTION_SCROLL:
159 return true;
160 case AMOTION_EVENT_ACTION_POINTER_DOWN:
161 case AMOTION_EVENT_ACTION_POINTER_UP: {
162 int32_t index = getMotionEventActionPointerIndex(action);
163 return index >= 0 && index < pointerCount;
164 }
165 case AMOTION_EVENT_ACTION_BUTTON_PRESS:
166 case AMOTION_EVENT_ACTION_BUTTON_RELEASE:
167 return actionButton != 0;
168 default:
169 return false;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800170 }
171}
172
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000173int64_t millis(std::chrono::nanoseconds t) {
Siarhei Vishniakouc1ae5562020-06-30 14:22:57 -0500174 return std::chrono::duration_cast<std::chrono::milliseconds>(t).count();
175}
176
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000177bool validateMotionEvent(int32_t action, int32_t actionButton, size_t pointerCount,
178 const PointerProperties* pointerProperties) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700179 if (!isValidMotionAction(action, actionButton, pointerCount)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800180 ALOGE("Motion event has invalid action code 0x%x", action);
181 return false;
182 }
183 if (pointerCount < 1 || pointerCount > MAX_POINTERS) {
Siarhei Vishniakou01747382022-01-20 13:23:27 -0800184 ALOGE("Motion event has invalid pointer count %zu; value must be between 1 and %zu.",
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700185 pointerCount, MAX_POINTERS);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800186 return false;
187 }
188 BitSet32 pointerIdBits;
189 for (size_t i = 0; i < pointerCount; i++) {
190 int32_t id = pointerProperties[i].id;
191 if (id < 0 || id > MAX_POINTER_ID) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700192 ALOGE("Motion event has invalid pointer id %d; value must be between 0 and %d", id,
193 MAX_POINTER_ID);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800194 return false;
195 }
196 if (pointerIdBits.hasBit(id)) {
197 ALOGE("Motion event has duplicate pointer id %d", id);
198 return false;
199 }
200 pointerIdBits.markBit(id);
201 }
202 return true;
203}
204
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000205std::string dumpRegion(const Region& region) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800206 if (region.isEmpty()) {
Bernardo Rufino53fc31e2020-11-03 11:01:07 +0000207 return "<empty>";
Michael Wrightd02c5b62014-02-10 15:10:22 -0800208 }
209
Bernardo Rufino53fc31e2020-11-03 11:01:07 +0000210 std::string dump;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800211 bool first = true;
212 Region::const_iterator cur = region.begin();
213 Region::const_iterator const tail = region.end();
214 while (cur != tail) {
215 if (first) {
216 first = false;
217 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -0800218 dump += "|";
Michael Wrightd02c5b62014-02-10 15:10:22 -0800219 }
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -0800220 dump += StringPrintf("[%d,%d][%d,%d]", cur->left, cur->top, cur->right, cur->bottom);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800221 cur++;
222 }
Bernardo Rufino53fc31e2020-11-03 11:01:07 +0000223 return dump;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800224}
225
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000226std::string dumpQueue(const std::deque<DispatchEntry*>& queue, nsecs_t currentTime) {
Siarhei Vishniakou14411c92020-09-18 21:15:05 -0500227 constexpr size_t maxEntries = 50; // max events to print
228 constexpr size_t skipBegin = maxEntries / 2;
229 const size_t skipEnd = queue.size() - maxEntries / 2;
230 // skip from maxEntries / 2 ... size() - maxEntries/2
231 // only print from 0 .. skipBegin and then from skipEnd .. size()
232
233 std::string dump;
234 for (size_t i = 0; i < queue.size(); i++) {
235 const DispatchEntry& entry = *queue[i];
236 if (i >= skipBegin && i < skipEnd) {
237 dump += StringPrintf(INDENT4 "<skipped %zu entries>\n", skipEnd - skipBegin);
238 i = skipEnd - 1; // it will be incremented to "skipEnd" by 'continue'
239 continue;
240 }
241 dump.append(INDENT4);
242 dump += entry.eventEntry->getDescription();
243 dump += StringPrintf(", seq=%" PRIu32
244 ", targetFlags=0x%08x, resolvedAction=%d, age=%" PRId64 "ms",
245 entry.seq, entry.targetFlags, entry.resolvedAction,
246 ns2ms(currentTime - entry.eventEntry->eventTime));
247 if (entry.deliveryTime != 0) {
248 // This entry was delivered, so add information on how long we've been waiting
249 dump += StringPrintf(", wait=%" PRId64 "ms", ns2ms(currentTime - entry.deliveryTime));
250 }
251 dump.append("\n");
252 }
253 return dump;
254}
255
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -0700256/**
257 * Find the entry in std::unordered_map by key, and return it.
258 * If the entry is not found, return a default constructed entry.
259 *
260 * Useful when the entries are vectors, since an empty vector will be returned
261 * if the entry is not found.
262 * Also useful when the entries are sp<>. If an entry is not found, nullptr is returned.
263 */
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -0700264template <typename K, typename V>
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000265V getValueByKey(const std::unordered_map<K, V>& map, K key) {
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -0700266 auto it = map.find(key);
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -0700267 return it != map.end() ? it->second : V{};
Tiger Huang721e26f2018-07-24 22:26:19 +0800268}
269
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000270bool haveSameToken(const sp<WindowInfoHandle>& first, const sp<WindowInfoHandle>& second) {
chaviwaf87b3e2019-10-01 16:59:28 -0700271 if (first == second) {
272 return true;
273 }
274
275 if (first == nullptr || second == nullptr) {
276 return false;
277 }
278
279 return first->getToken() == second->getToken();
280}
281
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000282bool haveSameApplicationToken(const WindowInfo* first, const WindowInfo* second) {
Bernardo Rufino1ff9d592021-01-18 16:58:57 +0000283 if (first == nullptr || second == nullptr) {
284 return false;
285 }
286 return first->applicationInfo.token != nullptr &&
287 first->applicationInfo.token == second->applicationInfo.token;
288}
289
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000290std::unique_ptr<DispatchEntry> createDispatchEntry(const InputTarget& inputTarget,
291 std::shared_ptr<EventEntry> eventEntry,
292 int32_t inputTargetFlags) {
chaviw1ff3d1e2020-07-01 15:53:47 -0700293 if (inputTarget.useDefaultPointerTransform()) {
294 const ui::Transform& transform = inputTarget.getDefaultPointerTransform();
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700295 return std::make_unique<DispatchEntry>(eventEntry, inputTargetFlags, transform,
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700296 inputTarget.displayTransform,
297 inputTarget.globalScaleFactor);
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000298 }
299
300 ALOG_ASSERT(eventEntry->type == EventEntry::Type::MOTION);
301 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(*eventEntry);
302
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700303 std::vector<PointerCoords> pointerCoords;
304 pointerCoords.resize(motionEntry.pointerCount);
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000305
306 // Use the first pointer information to normalize all other pointers. This could be any pointer
307 // as long as all other pointers are normalized to the same value and the final DispatchEntry
chaviw1ff3d1e2020-07-01 15:53:47 -0700308 // uses the transform for the normalized pointer.
309 const ui::Transform& firstPointerTransform =
310 inputTarget.pointerTransforms[inputTarget.pointerIds.firstMarkedBit()];
311 ui::Transform inverseFirstTransform = firstPointerTransform.inverse();
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000312
313 // Iterate through all pointers in the event to normalize against the first.
314 for (uint32_t pointerIndex = 0; pointerIndex < motionEntry.pointerCount; pointerIndex++) {
315 const PointerProperties& pointerProperties = motionEntry.pointerProperties[pointerIndex];
316 uint32_t pointerId = uint32_t(pointerProperties.id);
chaviw1ff3d1e2020-07-01 15:53:47 -0700317 const ui::Transform& currTransform = inputTarget.pointerTransforms[pointerId];
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000318
319 pointerCoords[pointerIndex].copyFrom(motionEntry.pointerCoords[pointerIndex]);
chaviw1ff3d1e2020-07-01 15:53:47 -0700320 // First, apply the current pointer's transform to update the coordinates into
321 // window space.
322 pointerCoords[pointerIndex].transform(currTransform);
323 // Next, apply the inverse transform of the normalized coordinates so the
324 // current coordinates are transformed into the normalized coordinate space.
325 pointerCoords[pointerIndex].transform(inverseFirstTransform);
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000326 }
327
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700328 std::unique_ptr<MotionEntry> combinedMotionEntry =
329 std::make_unique<MotionEntry>(motionEntry.id, motionEntry.eventTime,
330 motionEntry.deviceId, motionEntry.source,
331 motionEntry.displayId, motionEntry.policyFlags,
332 motionEntry.action, motionEntry.actionButton,
333 motionEntry.flags, motionEntry.metaState,
334 motionEntry.buttonState, motionEntry.classification,
335 motionEntry.edgeFlags, motionEntry.xPrecision,
336 motionEntry.yPrecision, motionEntry.xCursorPosition,
337 motionEntry.yCursorPosition, motionEntry.downTime,
338 motionEntry.pointerCount, motionEntry.pointerProperties,
Prabir Pradhan5beda762021-12-10 09:30:08 +0000339 pointerCoords.data());
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000340
341 if (motionEntry.injectionState) {
342 combinedMotionEntry->injectionState = motionEntry.injectionState;
343 combinedMotionEntry->injectionState->refCount += 1;
344 }
345
346 std::unique_ptr<DispatchEntry> dispatchEntry =
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700347 std::make_unique<DispatchEntry>(std::move(combinedMotionEntry), inputTargetFlags,
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700348 firstPointerTransform, inputTarget.displayTransform,
349 inputTarget.globalScaleFactor);
Chavi Weingarten65f98b82020-01-16 18:56:50 +0000350 return dispatchEntry;
351}
352
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000353status_t openInputChannelPair(const std::string& name, std::shared_ptr<InputChannel>& serverChannel,
354 std::unique_ptr<InputChannel>& clientChannel) {
Garfield Tan15601662020-09-22 15:32:38 -0700355 std::unique_ptr<InputChannel> uniqueServerChannel;
356 status_t result = InputChannel::openInputChannelPair(name, uniqueServerChannel, clientChannel);
357
358 serverChannel = std::move(uniqueServerChannel);
359 return result;
360}
361
Siarhei Vishniakoue41c4512020-09-08 19:35:58 -0500362template <typename T>
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000363bool sharedPointersEqual(const std::shared_ptr<T>& lhs, const std::shared_ptr<T>& rhs) {
Siarhei Vishniakoue41c4512020-09-08 19:35:58 -0500364 if (lhs == nullptr && rhs == nullptr) {
365 return true;
366 }
367 if (lhs == nullptr || rhs == nullptr) {
368 return false;
369 }
370 return *lhs == *rhs;
371}
372
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000373KeyEvent createKeyEvent(const KeyEntry& entry) {
Siarhei Vishniakou2e2ea992020-12-15 02:57:19 +0000374 KeyEvent event;
375 event.initialize(entry.id, entry.deviceId, entry.source, entry.displayId, INVALID_HMAC,
376 entry.action, entry.flags, entry.keyCode, entry.scanCode, entry.metaState,
377 entry.repeatCount, entry.downTime, entry.eventTime);
378 return event;
379}
380
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000381bool shouldReportMetricsForConnection(const Connection& connection) {
Siarhei Vishniakouf2652122021-03-05 21:39:46 +0000382 // Do not keep track of gesture monitors. They receive every event and would disproportionately
383 // affect the statistics.
384 if (connection.monitor) {
385 return false;
386 }
387 // If the connection is experiencing ANR, let's skip it. We have separate ANR metrics
388 if (!connection.responsive) {
389 return false;
390 }
391 return true;
392}
393
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000394bool shouldReportFinishedEvent(const DispatchEntry& dispatchEntry, const Connection& connection) {
Siarhei Vishniakouf2652122021-03-05 21:39:46 +0000395 const EventEntry& eventEntry = *dispatchEntry.eventEntry;
396 const int32_t& inputEventId = eventEntry.id;
397 if (inputEventId != dispatchEntry.resolvedEventId) {
398 // Event was transmuted
399 return false;
400 }
401 if (inputEventId == android::os::IInputConstants::INVALID_INPUT_EVENT_ID) {
402 return false;
403 }
404 // Only track latency for events that originated from hardware
405 if (eventEntry.isSynthesized()) {
406 return false;
407 }
408 const EventEntry::Type& inputEventEntryType = eventEntry.type;
409 if (inputEventEntryType == EventEntry::Type::KEY) {
410 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(eventEntry);
411 if (keyEntry.flags & AKEY_EVENT_FLAG_CANCELED) {
412 return false;
413 }
414 } else if (inputEventEntryType == EventEntry::Type::MOTION) {
415 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(eventEntry);
416 if (motionEntry.action == AMOTION_EVENT_ACTION_CANCEL ||
417 motionEntry.action == AMOTION_EVENT_ACTION_HOVER_EXIT) {
418 return false;
419 }
420 } else {
421 // Not a key or a motion
422 return false;
423 }
424 if (!shouldReportMetricsForConnection(connection)) {
425 return false;
426 }
427 return true;
428}
429
Prabir Pradhancef936d2021-07-21 16:17:52 +0000430/**
431 * Connection is responsive if it has no events in the waitQueue that are older than the
432 * current time.
433 */
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000434bool isConnectionResponsive(const Connection& connection) {
Prabir Pradhancef936d2021-07-21 16:17:52 +0000435 const nsecs_t currentTime = now();
436 for (const DispatchEntry* entry : connection.waitQueue) {
437 if (entry->timeoutTime < currentTime) {
438 return false;
439 }
440 }
441 return true;
442}
443
Antonio Kantekf16f2832021-09-28 04:39:20 +0000444// Returns true if the event type passed as argument represents a user activity.
445bool isUserActivityEvent(const EventEntry& eventEntry) {
446 switch (eventEntry.type) {
447 case EventEntry::Type::FOCUS:
448 case EventEntry::Type::POINTER_CAPTURE_CHANGED:
449 case EventEntry::Type::DRAG:
450 case EventEntry::Type::TOUCH_MODE_CHANGED:
451 case EventEntry::Type::SENSOR:
452 case EventEntry::Type::CONFIGURATION_CHANGED:
453 return false;
454 case EventEntry::Type::DEVICE_RESET:
455 case EventEntry::Type::KEY:
456 case EventEntry::Type::MOTION:
457 return true;
458 }
459}
460
Prabir Pradhan3f90d312021-11-19 03:57:24 -0800461// Returns true if the given window can accept pointer events at the given display location.
Prabir Pradhand65552b2021-10-07 11:23:50 -0700462bool windowAcceptsTouchAt(const WindowInfo& windowInfo, int32_t displayId, int32_t x, int32_t y,
463 bool isStylus) {
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -0800464 const auto inputConfig = windowInfo.inputConfig;
465 if (windowInfo.displayId != displayId ||
466 inputConfig.test(WindowInfo::InputConfig::NOT_VISIBLE)) {
Prabir Pradhan3f90d312021-11-19 03:57:24 -0800467 return false;
468 }
Prabir Pradhand65552b2021-10-07 11:23:50 -0700469 const bool windowCanInterceptTouch = isStylus && windowInfo.interceptsStylus();
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -0800470 if (inputConfig.test(WindowInfo::InputConfig::NOT_TOUCHABLE) && !windowCanInterceptTouch) {
Prabir Pradhan3f90d312021-11-19 03:57:24 -0800471 return false;
472 }
Prabir Pradhan06349042022-02-04 09:19:17 -0800473 if (!windowInfo.touchableRegionContainsPoint(x, y)) {
Prabir Pradhan3f90d312021-11-19 03:57:24 -0800474 return false;
475 }
476 return true;
477}
478
Prabir Pradhand65552b2021-10-07 11:23:50 -0700479bool isPointerFromStylus(const MotionEntry& entry, int32_t pointerIndex) {
480 return isFromSource(entry.source, AINPUT_SOURCE_STYLUS) &&
481 (entry.pointerProperties[pointerIndex].toolType == AMOTION_EVENT_TOOL_TYPE_STYLUS ||
482 entry.pointerProperties[pointerIndex].toolType == AMOTION_EVENT_TOOL_TYPE_ERASER);
483}
484
Prabir Pradhan6dfbf262022-03-14 15:24:30 +0000485// Determines if the given window can be targeted as InputTarget::FLAG_FOREGROUND.
486// Foreground events are only sent to "foreground targetable" windows, but not all gestures sent to
487// such window are necessarily targeted with the flag. For example, an event with ACTION_OUTSIDE can
488// be sent to such a window, but it is not a foreground event and doesn't use
489// InputTarget::FLAG_FOREGROUND.
490bool canReceiveForegroundTouches(const WindowInfo& info) {
491 // A non-touchable window can still receive touch events (e.g. in the case of
492 // STYLUS_INTERCEPTOR), so prevent such windows from receiving foreground events for touches.
493 return !info.inputConfig.test(gui::WindowInfo::InputConfig::NOT_TOUCHABLE) && !info.isSpy();
494}
495
Antonio Kantek48710e42022-03-24 14:19:30 -0700496bool isWindowOwnedBy(const sp<WindowInfoHandle>& windowHandle, int32_t pid, int32_t uid) {
497 if (windowHandle == nullptr) {
498 return false;
499 }
500 const WindowInfo* windowInfo = windowHandle->getInfo();
501 if (pid == windowInfo->ownerPid && uid == windowInfo->ownerUid) {
502 return true;
503 }
504 return false;
505}
506
Prabir Pradhan8a2b1a42022-04-11 17:23:34 +0000507// Checks targeted injection using the window's owner's uid.
508// Returns an empty string if an entry can be sent to the given window, or an error message if the
509// entry is a targeted injection whose uid target doesn't match the window owner.
510std::optional<std::string> verifyTargetedInjection(const sp<WindowInfoHandle>& window,
511 const EventEntry& entry) {
512 if (entry.injectionState == nullptr || !entry.injectionState->targetUid) {
513 // The event was not injected, or the injected event does not target a window.
514 return {};
515 }
516 const int32_t uid = *entry.injectionState->targetUid;
517 if (window == nullptr) {
518 return StringPrintf("No valid window target for injection into uid %d.", uid);
519 }
520 if (entry.injectionState->targetUid != window->getInfo()->ownerUid) {
521 return StringPrintf("Injected event targeted at uid %d would be dispatched to window '%s' "
522 "owned by uid %d.",
523 uid, window->getName().c_str(), window->getInfo()->ownerUid);
524 }
525 return {};
526}
527
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000528} // namespace
529
Michael Wrightd02c5b62014-02-10 15:10:22 -0800530// --- InputDispatcher ---
531
Garfield Tan00f511d2019-06-12 16:55:40 -0700532InputDispatcher::InputDispatcher(const sp<InputDispatcherPolicyInterface>& policy)
Siarhei Vishniakou289e9242022-02-15 14:50:16 -0800533 : InputDispatcher(policy, STALE_EVENT_TIMEOUT) {}
534
535InputDispatcher::InputDispatcher(const sp<InputDispatcherPolicyInterface>& policy,
536 std::chrono::nanoseconds staleEventTimeout)
Garfield Tan00f511d2019-06-12 16:55:40 -0700537 : mPolicy(policy),
538 mPendingEvent(nullptr),
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700539 mLastDropReason(DropReason::NOT_DROPPED),
Garfield Tanff1f1bb2020-01-28 13:24:04 -0800540 mIdGenerator(IdGenerator::Source::INPUT_DISPATCHER),
Garfield Tan00f511d2019-06-12 16:55:40 -0700541 mAppSwitchSawKeyDown(false),
542 mAppSwitchDueTime(LONG_LONG_MAX),
543 mNextUnblockedEvent(nullptr),
Prabir Pradhan1376fcd2022-01-21 09:56:35 -0800544 mMonitorDispatchingTimeout(DEFAULT_INPUT_DISPATCHING_TIMEOUT),
Garfield Tan00f511d2019-06-12 16:55:40 -0700545 mDispatchEnabled(false),
546 mDispatchFrozen(false),
547 mInputFilterEnabled(false),
Siarhei Vishniakouf3bc1aa2019-11-25 13:48:53 -0800548 // mInTouchMode will be initialized by the WindowManager to the default device config.
549 // To avoid leaking stack in case that call never comes, and for tests,
550 // initialize it here anyways.
Antonio Kantekf16f2832021-09-28 04:39:20 +0000551 mInTouchMode(kDefaultInTouchMode),
Bernardo Rufinoea97d182020-08-19 14:43:14 +0100552 mMaximumObscuringOpacityForTouch(1.0f),
Siarhei Vishniakou2508b872020-12-03 16:33:53 -1000553 mFocusedDisplayId(ADISPLAY_ID_DEFAULT),
Prabir Pradhan99987712020-11-10 18:43:05 -0800554 mWindowTokenWithPointerCapture(nullptr),
Siarhei Vishniakou289e9242022-02-15 14:50:16 -0800555 mStaleEventTimeout(staleEventTimeout),
Siarhei Vishniakoua04181f2021-03-26 05:56:49 +0000556 mLatencyAggregator(),
Siarhei Vishniakoubd252722022-01-06 03:49:35 -0800557 mLatencyTracker(&mLatencyAggregator) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800558 mLooper = new Looper(false);
Prabir Pradhanf93562f2018-11-29 12:13:37 -0800559 mReporter = createInputReporter();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800560
Siarhei Vishniakou18050092021-09-01 13:32:49 -0700561 mWindowInfoListener = new DispatcherWindowListener(*this);
562 SurfaceComposerClient::getDefault()->addWindowInfosListener(mWindowInfoListener);
563
Yi Kong9b14ac62018-07-17 13:48:38 -0700564 mKeyRepeatState.lastKeyEntry = nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800565
566 policy->getDispatcherConfiguration(&mConfig);
567}
568
569InputDispatcher::~InputDispatcher() {
Prabir Pradhancef936d2021-07-21 16:17:52 +0000570 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800571
Prabir Pradhancef936d2021-07-21 16:17:52 +0000572 resetKeyRepeatLocked();
573 releasePendingEventLocked();
574 drainInboundQueueLocked();
575 mCommandQueue.clear();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800576
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +0000577 while (!mConnectionsByToken.empty()) {
578 sp<Connection> connection = mConnectionsByToken.begin()->second;
Prabir Pradhancef936d2021-07-21 16:17:52 +0000579 removeInputChannelLocked(connection->inputChannel->getConnectionToken(),
580 false /* notify */);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800581 }
582}
583
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700584status_t InputDispatcher::start() {
Prabir Pradhan5a57cff2019-10-31 18:40:33 -0700585 if (mThread) {
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700586 return ALREADY_EXISTS;
587 }
Prabir Pradhan5a57cff2019-10-31 18:40:33 -0700588 mThread = std::make_unique<InputThread>(
589 "InputDispatcher", [this]() { dispatchOnce(); }, [this]() { mLooper->wake(); });
590 return OK;
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700591}
592
593status_t InputDispatcher::stop() {
Prabir Pradhan5a57cff2019-10-31 18:40:33 -0700594 if (mThread && mThread->isCallingThread()) {
595 ALOGE("InputDispatcher cannot be stopped from its own thread!");
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700596 return INVALID_OPERATION;
597 }
Prabir Pradhan5a57cff2019-10-31 18:40:33 -0700598 mThread.reset();
599 return OK;
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700600}
601
Michael Wrightd02c5b62014-02-10 15:10:22 -0800602void InputDispatcher::dispatchOnce() {
603 nsecs_t nextWakeupTime = LONG_LONG_MAX;
604 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -0800605 std::scoped_lock _l(mLock);
606 mDispatcherIsAlive.notify_all();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800607
608 // Run a dispatch loop if there are no pending commands.
609 // The dispatch loop might enqueue commands to run afterwards.
610 if (!haveCommandsLocked()) {
611 dispatchOnceInnerLocked(&nextWakeupTime);
612 }
613
614 // Run all pending commands if there are any.
615 // If any commands were run then force the next poll to wake up immediately.
Prabir Pradhancef936d2021-07-21 16:17:52 +0000616 if (runCommandsLockedInterruptable()) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800617 nextWakeupTime = LONG_LONG_MIN;
618 }
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -0800619
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700620 // If we are still waiting for ack on some events,
621 // we might have to wake up earlier to check if an app is anr'ing.
622 const nsecs_t nextAnrCheck = processAnrsLocked();
623 nextWakeupTime = std::min(nextWakeupTime, nextAnrCheck);
624
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -0800625 // We are about to enter an infinitely long sleep, because we have no commands or
626 // pending or queued events
627 if (nextWakeupTime == LONG_LONG_MAX) {
628 mDispatcherEnteredIdle.notify_all();
629 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800630 } // release lock
631
632 // Wait for callback or timeout or wake. (make sure we round up, not down)
633 nsecs_t currentTime = now();
634 int timeoutMillis = toMillisecondTimeoutDelay(currentTime, nextWakeupTime);
635 mLooper->pollOnce(timeoutMillis);
636}
637
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700638/**
Siarhei Vishniakouf56b2692020-09-08 19:43:33 -0500639 * Raise ANR if there is no focused window.
640 * Before the ANR is raised, do a final state check:
641 * 1. The currently focused application must be the same one we are waiting for.
642 * 2. Ensure we still don't have a focused window.
643 */
644void InputDispatcher::processNoFocusedWindowAnrLocked() {
645 // Check if the application that we are waiting for is still focused.
646 std::shared_ptr<InputApplicationHandle> focusedApplication =
647 getValueByKey(mFocusedApplicationHandlesByDisplay, mAwaitedApplicationDisplayId);
648 if (focusedApplication == nullptr ||
649 focusedApplication->getApplicationToken() !=
650 mAwaitedFocusedApplication->getApplicationToken()) {
651 // Unexpected because we should have reset the ANR timer when focused application changed
652 ALOGE("Waited for a focused window, but focused application has already changed to %s",
653 focusedApplication->getName().c_str());
654 return; // The focused application has changed.
655 }
656
chaviw98318de2021-05-19 16:45:23 -0500657 const sp<WindowInfoHandle>& focusedWindowHandle =
Siarhei Vishniakouf56b2692020-09-08 19:43:33 -0500658 getFocusedWindowHandleLocked(mAwaitedApplicationDisplayId);
659 if (focusedWindowHandle != nullptr) {
660 return; // We now have a focused window. No need for ANR.
661 }
662 onAnrLocked(mAwaitedFocusedApplication);
663}
664
665/**
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700666 * Check if any of the connections' wait queues have events that are too old.
667 * If we waited for events to be ack'ed for more than the window timeout, raise an ANR.
668 * Return the time at which we should wake up next.
669 */
670nsecs_t InputDispatcher::processAnrsLocked() {
671 const nsecs_t currentTime = now();
672 nsecs_t nextAnrCheck = LONG_LONG_MAX;
673 // Check if we are waiting for a focused window to appear. Raise ANR if waited too long
674 if (mNoFocusedWindowTimeoutTime.has_value() && mAwaitedFocusedApplication != nullptr) {
675 if (currentTime >= *mNoFocusedWindowTimeoutTime) {
Siarhei Vishniakouf56b2692020-09-08 19:43:33 -0500676 processNoFocusedWindowAnrLocked();
Chris Yea209fde2020-07-22 13:54:51 -0700677 mAwaitedFocusedApplication.reset();
Siarhei Vishniakouf56b2692020-09-08 19:43:33 -0500678 mNoFocusedWindowTimeoutTime = std::nullopt;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700679 return LONG_LONG_MIN;
680 } else {
Siarhei Vishniakou38a6d272020-10-20 20:29:33 -0500681 // Keep waiting. We will drop the event when mNoFocusedWindowTimeoutTime comes.
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700682 nextAnrCheck = *mNoFocusedWindowTimeoutTime;
683 }
684 }
685
686 // Check if any connection ANRs are due
687 nextAnrCheck = std::min(nextAnrCheck, mAnrTracker.firstTimeout());
688 if (currentTime < nextAnrCheck) { // most likely scenario
689 return nextAnrCheck; // everything is normal. Let's check again at nextAnrCheck
690 }
691
692 // If we reached here, we have an unresponsive connection.
693 sp<Connection> connection = getConnectionLocked(mAnrTracker.firstToken());
694 if (connection == nullptr) {
695 ALOGE("Could not find connection for entry %" PRId64, mAnrTracker.firstTimeout());
696 return nextAnrCheck;
697 }
698 connection->responsive = false;
699 // Stop waking up for this unresponsive connection
700 mAnrTracker.eraseToken(connection->inputChannel->getConnectionToken());
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +0000701 onAnrLocked(connection);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700702 return LONG_LONG_MIN;
703}
704
Prabir Pradhan1376fcd2022-01-21 09:56:35 -0800705std::chrono::nanoseconds InputDispatcher::getDispatchingTimeoutLocked(
706 const sp<Connection>& connection) {
707 if (connection->monitor) {
708 return mMonitorDispatchingTimeout;
709 }
710 const sp<WindowInfoHandle> window =
711 getWindowHandleLocked(connection->inputChannel->getConnectionToken());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700712 if (window != nullptr) {
Siarhei Vishniakou70622952020-07-30 11:17:23 -0500713 return window->getDispatchingTimeout(DEFAULT_INPUT_DISPATCHING_TIMEOUT);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700714 }
Siarhei Vishniakou70622952020-07-30 11:17:23 -0500715 return DEFAULT_INPUT_DISPATCHING_TIMEOUT;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700716}
717
Michael Wrightd02c5b62014-02-10 15:10:22 -0800718void InputDispatcher::dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) {
719 nsecs_t currentTime = now();
720
Jeff Browndc5992e2014-04-11 01:27:26 -0700721 // Reset the key repeat timer whenever normal dispatch is suspended while the
722 // device is in a non-interactive state. This is to ensure that we abort a key
723 // repeat if the device is just coming out of sleep.
724 if (!mDispatchEnabled) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800725 resetKeyRepeatLocked();
726 }
727
728 // If dispatching is frozen, do not process timeouts or try to deliver any new events.
729 if (mDispatchFrozen) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +0100730 if (DEBUG_FOCUS) {
731 ALOGD("Dispatch frozen. Waiting some more.");
732 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800733 return;
734 }
735
736 // Optimize latency of app switches.
737 // Essentially we start a short timeout when an app switch key (HOME / ENDCALL) has
738 // been pressed. When it expires, we preempt dispatch and drop all other pending events.
739 bool isAppSwitchDue = mAppSwitchDueTime <= currentTime;
740 if (mAppSwitchDueTime < *nextWakeupTime) {
741 *nextWakeupTime = mAppSwitchDueTime;
742 }
743
744 // Ready to start a new event.
745 // If we don't already have a pending event, go grab one.
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700746 if (!mPendingEvent) {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -0700747 if (mInboundQueue.empty()) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800748 if (isAppSwitchDue) {
749 // The inbound queue is empty so the app switch key we were waiting
750 // for will never arrive. Stop waiting for it.
751 resetPendingAppSwitchLocked(false);
752 isAppSwitchDue = false;
753 }
754
755 // Synthesize a key repeat if appropriate.
756 if (mKeyRepeatState.lastKeyEntry) {
757 if (currentTime >= mKeyRepeatState.nextRepeatTime) {
758 mPendingEvent = synthesizeKeyRepeatLocked(currentTime);
759 } else {
760 if (mKeyRepeatState.nextRepeatTime < *nextWakeupTime) {
761 *nextWakeupTime = mKeyRepeatState.nextRepeatTime;
762 }
763 }
764 }
765
766 // Nothing to do if there is no pending event.
767 if (!mPendingEvent) {
768 return;
769 }
770 } else {
771 // Inbound queue has at least one entry.
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -0700772 mPendingEvent = mInboundQueue.front();
773 mInboundQueue.pop_front();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800774 traceInboundQueueLengthLocked();
775 }
776
777 // Poke user activity for this event.
778 if (mPendingEvent->policyFlags & POLICY_FLAG_PASS_TO_USER) {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700779 pokeUserActivityLocked(*mPendingEvent);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800780 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800781 }
782
783 // Now we have an event to dispatch.
784 // All events are eventually dequeued and processed this way, even if we intend to drop them.
Yi Kong9b14ac62018-07-17 13:48:38 -0700785 ALOG_ASSERT(mPendingEvent != nullptr);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800786 bool done = false;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700787 DropReason dropReason = DropReason::NOT_DROPPED;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800788 if (!(mPendingEvent->policyFlags & POLICY_FLAG_PASS_TO_USER)) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700789 dropReason = DropReason::POLICY;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800790 } else if (!mDispatchEnabled) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700791 dropReason = DropReason::DISABLED;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800792 }
793
794 if (mNextUnblockedEvent == mPendingEvent) {
Yi Kong9b14ac62018-07-17 13:48:38 -0700795 mNextUnblockedEvent = nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800796 }
797
798 switch (mPendingEvent->type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -0700799 case EventEntry::Type::CONFIGURATION_CHANGED: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700800 const ConfigurationChangedEntry& typedEntry =
801 static_cast<const ConfigurationChangedEntry&>(*mPendingEvent);
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700802 done = dispatchConfigurationChangedLocked(currentTime, typedEntry);
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700803 dropReason = DropReason::NOT_DROPPED; // configuration changes are never dropped
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700804 break;
805 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800806
Siarhei Vishniakou49483272019-10-22 13:13:47 -0700807 case EventEntry::Type::DEVICE_RESET: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700808 const DeviceResetEntry& typedEntry =
809 static_cast<const DeviceResetEntry&>(*mPendingEvent);
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700810 done = dispatchDeviceResetLocked(currentTime, typedEntry);
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700811 dropReason = DropReason::NOT_DROPPED; // device resets are never dropped
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700812 break;
813 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800814
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +0100815 case EventEntry::Type::FOCUS: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700816 std::shared_ptr<FocusEntry> typedEntry =
817 std::static_pointer_cast<FocusEntry>(mPendingEvent);
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +0100818 dispatchFocusLocked(currentTime, typedEntry);
819 done = true;
820 dropReason = DropReason::NOT_DROPPED; // focus events are never dropped
821 break;
822 }
823
Antonio Kantek7242d8b2021-08-05 16:07:20 -0700824 case EventEntry::Type::TOUCH_MODE_CHANGED: {
825 const auto typedEntry = std::static_pointer_cast<TouchModeEntry>(mPendingEvent);
826 dispatchTouchModeChangeLocked(currentTime, typedEntry);
827 done = true;
828 dropReason = DropReason::NOT_DROPPED; // touch mode events are never dropped
829 break;
830 }
831
Prabir Pradhan99987712020-11-10 18:43:05 -0800832 case EventEntry::Type::POINTER_CAPTURE_CHANGED: {
833 const auto typedEntry =
834 std::static_pointer_cast<PointerCaptureChangedEntry>(mPendingEvent);
835 dispatchPointerCaptureChangedLocked(currentTime, typedEntry, dropReason);
836 done = true;
837 break;
838 }
839
arthurhungb89ccb02020-12-30 16:19:01 +0800840 case EventEntry::Type::DRAG: {
841 std::shared_ptr<DragEntry> typedEntry =
842 std::static_pointer_cast<DragEntry>(mPendingEvent);
843 dispatchDragLocked(currentTime, typedEntry);
844 done = true;
845 break;
846 }
847
Siarhei Vishniakou49483272019-10-22 13:13:47 -0700848 case EventEntry::Type::KEY: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700849 std::shared_ptr<KeyEntry> keyEntry = std::static_pointer_cast<KeyEntry>(mPendingEvent);
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700850 if (isAppSwitchDue) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700851 if (isAppSwitchKeyEvent(*keyEntry)) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700852 resetPendingAppSwitchLocked(true);
853 isAppSwitchDue = false;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700854 } else if (dropReason == DropReason::NOT_DROPPED) {
855 dropReason = DropReason::APP_SWITCH;
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700856 }
857 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700858 if (dropReason == DropReason::NOT_DROPPED && isStaleEvent(currentTime, *keyEntry)) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700859 dropReason = DropReason::STALE;
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700860 }
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700861 if (dropReason == DropReason::NOT_DROPPED && mNextUnblockedEvent) {
862 dropReason = DropReason::BLOCKED;
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700863 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700864 done = dispatchKeyLocked(currentTime, keyEntry, &dropReason, nextWakeupTime);
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700865 break;
866 }
867
Siarhei Vishniakou49483272019-10-22 13:13:47 -0700868 case EventEntry::Type::MOTION: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700869 std::shared_ptr<MotionEntry> motionEntry =
870 std::static_pointer_cast<MotionEntry>(mPendingEvent);
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700871 if (dropReason == DropReason::NOT_DROPPED && isAppSwitchDue) {
872 dropReason = DropReason::APP_SWITCH;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800873 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700874 if (dropReason == DropReason::NOT_DROPPED && isStaleEvent(currentTime, *motionEntry)) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700875 dropReason = DropReason::STALE;
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700876 }
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700877 if (dropReason == DropReason::NOT_DROPPED && mNextUnblockedEvent) {
878 dropReason = DropReason::BLOCKED;
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700879 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700880 done = dispatchMotionLocked(currentTime, motionEntry, &dropReason, nextWakeupTime);
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700881 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800882 }
Chris Yef59a2f42020-10-16 12:55:26 -0700883
884 case EventEntry::Type::SENSOR: {
885 std::shared_ptr<SensorEntry> sensorEntry =
886 std::static_pointer_cast<SensorEntry>(mPendingEvent);
887 if (dropReason == DropReason::NOT_DROPPED && isAppSwitchDue) {
888 dropReason = DropReason::APP_SWITCH;
889 }
890 // Sensor timestamps use SYSTEM_TIME_BOOTTIME time base, so we can't use
891 // 'currentTime' here, get SYSTEM_TIME_BOOTTIME instead.
892 nsecs_t bootTime = systemTime(SYSTEM_TIME_BOOTTIME);
893 if (dropReason == DropReason::NOT_DROPPED && isStaleEvent(bootTime, *sensorEntry)) {
894 dropReason = DropReason::STALE;
895 }
896 dispatchSensorLocked(currentTime, sensorEntry, &dropReason, nextWakeupTime);
897 done = true;
898 break;
899 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800900 }
901
902 if (done) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700903 if (dropReason != DropReason::NOT_DROPPED) {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700904 dropInboundEventLocked(*mPendingEvent, dropReason);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800905 }
Michael Wright3a981722015-06-10 15:26:13 +0100906 mLastDropReason = dropReason;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800907
908 releasePendingEventLocked();
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700909 *nextWakeupTime = LONG_LONG_MIN; // force next poll to wake up immediately
Michael Wrightd02c5b62014-02-10 15:10:22 -0800910 }
911}
912
Siarhei Vishniakou289e9242022-02-15 14:50:16 -0800913bool InputDispatcher::isStaleEvent(nsecs_t currentTime, const EventEntry& entry) {
914 return std::chrono::nanoseconds(currentTime - entry.eventTime) >= mStaleEventTimeout;
915}
916
Siarhei Vishniakou850ce122020-05-26 22:39:43 -0700917/**
918 * Return true if the events preceding this incoming motion event should be dropped
919 * Return false otherwise (the default behaviour)
920 */
921bool InputDispatcher::shouldPruneInboundQueueLocked(const MotionEntry& motionEntry) {
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700922 const bool isPointerDownEvent = motionEntry.action == AMOTION_EVENT_ACTION_DOWN &&
Prabir Pradhanaa561d12021-09-24 06:57:33 -0700923 isFromSource(motionEntry.source, AINPUT_SOURCE_CLASS_POINTER);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700924
925 // Optimize case where the current application is unresponsive and the user
926 // decides to touch a window in a different application.
927 // If the application takes too long to catch up then we drop all events preceding
928 // the touch into the other window.
929 if (isPointerDownEvent && mAwaitedFocusedApplication != nullptr) {
Siarhei Vishniakou850ce122020-05-26 22:39:43 -0700930 int32_t displayId = motionEntry.displayId;
931 int32_t x = static_cast<int32_t>(
932 motionEntry.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X));
933 int32_t y = static_cast<int32_t>(
934 motionEntry.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y));
Prabir Pradhand65552b2021-10-07 11:23:50 -0700935
936 const bool isStylus = isPointerFromStylus(motionEntry, 0 /*pointerIndex*/);
chaviw98318de2021-05-19 16:45:23 -0500937 sp<WindowInfoHandle> touchedWindowHandle =
Prabir Pradhand65552b2021-10-07 11:23:50 -0700938 findTouchedWindowAtLocked(displayId, x, y, nullptr, isStylus);
Siarhei Vishniakou850ce122020-05-26 22:39:43 -0700939 if (touchedWindowHandle != nullptr &&
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700940 touchedWindowHandle->getApplicationToken() !=
941 mAwaitedFocusedApplication->getApplicationToken()) {
Siarhei Vishniakou850ce122020-05-26 22:39:43 -0700942 // User touched a different application than the one we are waiting on.
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700943 ALOGI("Pruning input queue because user touched a different application while waiting "
944 "for %s",
945 mAwaitedFocusedApplication->getName().c_str());
Siarhei Vishniakou850ce122020-05-26 22:39:43 -0700946 return true;
947 }
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700948
Prabir Pradhandfabf8a2022-01-21 08:19:30 -0800949 // Alternatively, maybe there's a spy window that could handle this event.
950 const std::vector<sp<WindowInfoHandle>> touchedSpies =
951 findTouchedSpyWindowsAtLocked(displayId, x, y, isStylus);
952 for (const auto& windowHandle : touchedSpies) {
953 const sp<Connection> connection = getConnectionLocked(windowHandle->getToken());
Siarhei Vishniakou34ed4d42020-06-18 00:43:02 +0000954 if (connection != nullptr && connection->responsive) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -0800955 // This spy window could take more input. Drop all events preceding this
956 // event, so that the spy window can get a chance to receive the stream.
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700957 ALOGW("Pruning the input queue because %s is unresponsive, but we have a "
Prabir Pradhandfabf8a2022-01-21 08:19:30 -0800958 "responsive spy window that may handle the event.",
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700959 mAwaitedFocusedApplication->getName().c_str());
960 return true;
961 }
962 }
963 }
964
965 // Prevent getting stuck: if we have a pending key event, and some motion events that have not
966 // yet been processed by some connections, the dispatcher will wait for these motion
967 // events to be processed before dispatching the key event. This is because these motion events
968 // may cause a new window to be launched, which the user might expect to receive focus.
969 // To prevent waiting forever for such events, just send the key to the currently focused window
970 if (isPointerDownEvent && mKeyIsWaitingForEventsTimeout) {
971 ALOGD("Received a new pointer down event, stop waiting for events to process and "
972 "just send the pending key event to the focused window.");
973 mKeyIsWaitingForEventsTimeout = now();
Siarhei Vishniakou850ce122020-05-26 22:39:43 -0700974 }
975 return false;
976}
977
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700978bool InputDispatcher::enqueueInboundEventLocked(std::unique_ptr<EventEntry> newEntry) {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -0700979 bool needWake = mInboundQueue.empty();
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700980 mInboundQueue.push_back(std::move(newEntry));
981 EventEntry& entry = *(mInboundQueue.back());
Michael Wrightd02c5b62014-02-10 15:10:22 -0800982 traceInboundQueueLengthLocked();
983
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700984 switch (entry.type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -0700985 case EventEntry::Type::KEY: {
Prabir Pradhan8a2b1a42022-04-11 17:23:34 +0000986 LOG_ALWAYS_FATAL_IF((entry.policyFlags & POLICY_FLAG_TRUSTED) == 0,
987 "Unexpected untrusted event.");
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700988 // Optimize app switch latency.
989 // If the application takes too long to catch up then we drop all events preceding
990 // the app switch key.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700991 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(entry);
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700992 if (isAppSwitchKeyEvent(keyEntry)) {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700993 if (keyEntry.action == AKEY_EVENT_ACTION_DOWN) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700994 mAppSwitchSawKeyDown = true;
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700995 } else if (keyEntry.action == AKEY_EVENT_ACTION_UP) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700996 if (mAppSwitchSawKeyDown) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +0000997 if (DEBUG_APP_SWITCH) {
998 ALOGD("App switch is pending!");
999 }
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001000 mAppSwitchDueTime = keyEntry.eventTime + APP_SWITCH_TIMEOUT;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001001 mAppSwitchSawKeyDown = false;
1002 needWake = true;
1003 }
1004 }
1005 }
Arthur Hung2ee6d0b2022-03-03 20:19:38 +08001006
1007 // If a new up event comes in, and the pending event with same key code has been asked
1008 // to try again later because of the policy. We have to reset the intercept key wake up
1009 // time for it may have been handled in the policy and could be dropped.
1010 if (keyEntry.action == AKEY_EVENT_ACTION_UP && mPendingEvent &&
1011 mPendingEvent->type == EventEntry::Type::KEY) {
1012 KeyEntry& pendingKey = static_cast<KeyEntry&>(*mPendingEvent);
1013 if (pendingKey.keyCode == keyEntry.keyCode &&
1014 pendingKey.interceptKeyResult ==
1015 KeyEntry::INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER) {
1016 pendingKey.interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_UNKNOWN;
1017 pendingKey.interceptKeyWakeupTime = 0;
1018 needWake = true;
1019 }
1020 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001021 break;
1022 }
1023
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001024 case EventEntry::Type::MOTION: {
Prabir Pradhan8a2b1a42022-04-11 17:23:34 +00001025 LOG_ALWAYS_FATAL_IF((entry.policyFlags & POLICY_FLAG_TRUSTED) == 0,
1026 "Unexpected untrusted event.");
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001027 if (shouldPruneInboundQueueLocked(static_cast<MotionEntry&>(entry))) {
1028 mNextUnblockedEvent = mInboundQueue.back();
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001029 needWake = true;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001030 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001031 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001032 }
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001033 case EventEntry::Type::FOCUS: {
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001034 LOG_ALWAYS_FATAL("Focus events should be inserted using enqueueFocusEventLocked");
1035 break;
1036 }
Antonio Kantek7242d8b2021-08-05 16:07:20 -07001037 case EventEntry::Type::TOUCH_MODE_CHANGED:
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001038 case EventEntry::Type::CONFIGURATION_CHANGED:
Prabir Pradhan99987712020-11-10 18:43:05 -08001039 case EventEntry::Type::DEVICE_RESET:
Chris Yef59a2f42020-10-16 12:55:26 -07001040 case EventEntry::Type::SENSOR:
arthurhungb89ccb02020-12-30 16:19:01 +08001041 case EventEntry::Type::POINTER_CAPTURE_CHANGED:
1042 case EventEntry::Type::DRAG: {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001043 // nothing to do
1044 break;
1045 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001046 }
1047
1048 return needWake;
1049}
1050
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001051void InputDispatcher::addRecentEventLocked(std::shared_ptr<EventEntry> entry) {
Chris Yef59a2f42020-10-16 12:55:26 -07001052 // Do not store sensor event in recent queue to avoid flooding the queue.
1053 if (entry->type != EventEntry::Type::SENSOR) {
1054 mRecentQueue.push_back(entry);
1055 }
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001056 if (mRecentQueue.size() > RECENT_QUEUE_MAX_SIZE) {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001057 mRecentQueue.pop_front();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001058 }
1059}
1060
chaviw98318de2021-05-19 16:45:23 -05001061sp<WindowInfoHandle> InputDispatcher::findTouchedWindowAtLocked(int32_t displayId, int32_t x,
1062 int32_t y, TouchState* touchState,
Prabir Pradhand65552b2021-10-07 11:23:50 -07001063 bool isStylus,
chaviw98318de2021-05-19 16:45:23 -05001064 bool addOutsideTargets,
1065 bool ignoreDragWindow) {
Siarhei Vishniakou64452932020-11-06 17:51:32 -06001066 if (addOutsideTargets && touchState == nullptr) {
1067 LOG_ALWAYS_FATAL("Must provide a valid touch state if adding outside targets");
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07001068 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001069 // Traverse windows from front to back to find touched window.
Prabir Pradhan07e05b62021-11-19 03:57:24 -08001070 const auto& windowHandles = getWindowHandlesLocked(displayId);
chaviw98318de2021-05-19 16:45:23 -05001071 for (const sp<WindowInfoHandle>& windowHandle : windowHandles) {
arthurhung6d4bed92021-03-17 11:59:33 +08001072 if (ignoreDragWindow && haveSameToken(windowHandle, mDragState->dragWindow)) {
arthurhungb89ccb02020-12-30 16:19:01 +08001073 continue;
1074 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001075
Prabir Pradhan3f90d312021-11-19 03:57:24 -08001076 const WindowInfo& info = *windowHandle->getInfo();
Prabir Pradhand65552b2021-10-07 11:23:50 -07001077 if (!info.isSpy() && windowAcceptsTouchAt(info, displayId, x, y, isStylus)) {
Prabir Pradhan3f90d312021-11-19 03:57:24 -08001078 return windowHandle;
1079 }
Tiger Huang85b8c5e2019-01-17 18:34:54 +08001080
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08001081 if (addOutsideTargets &&
1082 info.inputConfig.test(WindowInfo::InputConfig::WATCH_OUTSIDE_TOUCH)) {
Prabir Pradhan3f90d312021-11-19 03:57:24 -08001083 touchState->addOrUpdateWindow(windowHandle, InputTarget::FLAG_DISPATCH_AS_OUTSIDE,
1084 BitSet32(0));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001085 }
1086 }
Yi Kong9b14ac62018-07-17 13:48:38 -07001087 return nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001088}
1089
Prabir Pradhand65552b2021-10-07 11:23:50 -07001090std::vector<sp<WindowInfoHandle>> InputDispatcher::findTouchedSpyWindowsAtLocked(
1091 int32_t displayId, int32_t x, int32_t y, bool isStylus) const {
Prabir Pradhan07e05b62021-11-19 03:57:24 -08001092 // Traverse windows from front to back and gather the touched spy windows.
1093 std::vector<sp<WindowInfoHandle>> spyWindows;
1094 const auto& windowHandles = getWindowHandlesLocked(displayId);
1095 for (const sp<WindowInfoHandle>& windowHandle : windowHandles) {
1096 const WindowInfo& info = *windowHandle->getInfo();
1097
Prabir Pradhand65552b2021-10-07 11:23:50 -07001098 if (!windowAcceptsTouchAt(info, displayId, x, y, isStylus)) {
Prabir Pradhan07e05b62021-11-19 03:57:24 -08001099 continue;
1100 }
1101 if (!info.isSpy()) {
1102 // The first touched non-spy window was found, so return the spy windows touched so far.
1103 return spyWindows;
1104 }
1105 spyWindows.push_back(windowHandle);
1106 }
1107 return spyWindows;
1108}
1109
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001110void InputDispatcher::dropInboundEventLocked(const EventEntry& entry, DropReason dropReason) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001111 const char* reason;
1112 switch (dropReason) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001113 case DropReason::POLICY:
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001114 if (DEBUG_INBOUND_EVENT_DETAILS) {
1115 ALOGD("Dropped event because policy consumed it.");
1116 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001117 reason = "inbound event was dropped because the policy consumed it";
1118 break;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001119 case DropReason::DISABLED:
1120 if (mLastDropReason != DropReason::DISABLED) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001121 ALOGI("Dropped event because input dispatch is disabled.");
1122 }
1123 reason = "inbound event was dropped because input dispatch is disabled";
1124 break;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001125 case DropReason::APP_SWITCH:
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001126 ALOGI("Dropped event because of pending overdue app switch.");
1127 reason = "inbound event was dropped because of pending overdue app switch";
1128 break;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001129 case DropReason::BLOCKED:
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001130 ALOGI("Dropped event because the current application is not responding and the user "
1131 "has started interacting with a different application.");
1132 reason = "inbound event was dropped because the current application is not responding "
1133 "and the user has started interacting with a different application";
1134 break;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001135 case DropReason::STALE:
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001136 ALOGI("Dropped event because it is stale.");
1137 reason = "inbound event was dropped because it is stale";
1138 break;
Prabir Pradhan99987712020-11-10 18:43:05 -08001139 case DropReason::NO_POINTER_CAPTURE:
1140 ALOGI("Dropped event because there is no window with Pointer Capture.");
1141 reason = "inbound event was dropped because there is no window with Pointer Capture";
1142 break;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001143 case DropReason::NOT_DROPPED: {
1144 LOG_ALWAYS_FATAL("Should not be dropping a NOT_DROPPED event");
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001145 return;
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001146 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001147 }
1148
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001149 switch (entry.type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001150 case EventEntry::Type::KEY: {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001151 CancelationOptions options(CancelationOptions::CANCEL_NON_POINTER_EVENTS, reason);
1152 synthesizeCancelationEventsForAllConnectionsLocked(options);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001153 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001154 }
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001155 case EventEntry::Type::MOTION: {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001156 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(entry);
1157 if (motionEntry.source & AINPUT_SOURCE_CLASS_POINTER) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001158 CancelationOptions options(CancelationOptions::CANCEL_POINTER_EVENTS, reason);
1159 synthesizeCancelationEventsForAllConnectionsLocked(options);
1160 } else {
1161 CancelationOptions options(CancelationOptions::CANCEL_NON_POINTER_EVENTS, reason);
1162 synthesizeCancelationEventsForAllConnectionsLocked(options);
1163 }
1164 break;
1165 }
Chris Yef59a2f42020-10-16 12:55:26 -07001166 case EventEntry::Type::SENSOR: {
1167 break;
1168 }
arthurhungb89ccb02020-12-30 16:19:01 +08001169 case EventEntry::Type::POINTER_CAPTURE_CHANGED:
1170 case EventEntry::Type::DRAG: {
Prabir Pradhan99987712020-11-10 18:43:05 -08001171 break;
1172 }
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001173 case EventEntry::Type::FOCUS:
Antonio Kantek7242d8b2021-08-05 16:07:20 -07001174 case EventEntry::Type::TOUCH_MODE_CHANGED:
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001175 case EventEntry::Type::CONFIGURATION_CHANGED:
1176 case EventEntry::Type::DEVICE_RESET: {
Dominik Laskowski75788452021-02-09 18:51:25 -08001177 LOG_ALWAYS_FATAL("Should not drop %s events", ftl::enum_string(entry.type).c_str());
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001178 break;
1179 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001180 }
1181}
1182
Siarhei Vishniakou61291d42019-02-11 18:13:20 -08001183static bool isAppSwitchKeyCode(int32_t keyCode) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001184 return keyCode == AKEYCODE_HOME || keyCode == AKEYCODE_ENDCALL ||
1185 keyCode == AKEYCODE_APP_SWITCH;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001186}
1187
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001188bool InputDispatcher::isAppSwitchKeyEvent(const KeyEntry& keyEntry) {
1189 return !(keyEntry.flags & AKEY_EVENT_FLAG_CANCELED) && isAppSwitchKeyCode(keyEntry.keyCode) &&
1190 (keyEntry.policyFlags & POLICY_FLAG_TRUSTED) &&
1191 (keyEntry.policyFlags & POLICY_FLAG_PASS_TO_USER);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001192}
1193
1194bool InputDispatcher::isAppSwitchPendingLocked() {
1195 return mAppSwitchDueTime != LONG_LONG_MAX;
1196}
1197
1198void InputDispatcher::resetPendingAppSwitchLocked(bool handled) {
1199 mAppSwitchDueTime = LONG_LONG_MAX;
1200
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001201 if (DEBUG_APP_SWITCH) {
1202 if (handled) {
1203 ALOGD("App switch has arrived.");
1204 } else {
1205 ALOGD("App switch was abandoned.");
1206 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001207 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001208}
1209
Michael Wrightd02c5b62014-02-10 15:10:22 -08001210bool InputDispatcher::haveCommandsLocked() const {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001211 return !mCommandQueue.empty();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001212}
1213
Prabir Pradhancef936d2021-07-21 16:17:52 +00001214bool InputDispatcher::runCommandsLockedInterruptable() {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001215 if (mCommandQueue.empty()) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001216 return false;
1217 }
1218
1219 do {
Prabir Pradhancef936d2021-07-21 16:17:52 +00001220 auto command = std::move(mCommandQueue.front());
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001221 mCommandQueue.pop_front();
Prabir Pradhancef936d2021-07-21 16:17:52 +00001222 // Commands are run with the lock held, but may release and re-acquire the lock from within.
1223 command();
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001224 } while (!mCommandQueue.empty());
Michael Wrightd02c5b62014-02-10 15:10:22 -08001225 return true;
1226}
1227
Prabir Pradhancef936d2021-07-21 16:17:52 +00001228void InputDispatcher::postCommandLocked(Command&& command) {
1229 mCommandQueue.push_back(command);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001230}
1231
1232void InputDispatcher::drainInboundQueueLocked() {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001233 while (!mInboundQueue.empty()) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001234 std::shared_ptr<EventEntry> entry = mInboundQueue.front();
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07001235 mInboundQueue.pop_front();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001236 releaseInboundEventLocked(entry);
1237 }
1238 traceInboundQueueLengthLocked();
1239}
1240
1241void InputDispatcher::releasePendingEventLocked() {
1242 if (mPendingEvent) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001243 releaseInboundEventLocked(mPendingEvent);
Yi Kong9b14ac62018-07-17 13:48:38 -07001244 mPendingEvent = nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001245 }
1246}
1247
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001248void InputDispatcher::releaseInboundEventLocked(std::shared_ptr<EventEntry> entry) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001249 InjectionState* injectionState = entry->injectionState;
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001250 if (injectionState && injectionState->injectionResult == InputEventInjectionResult::PENDING) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001251 if (DEBUG_DISPATCH_CYCLE) {
1252 ALOGD("Injected inbound event was dropped.");
1253 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001254 setInjectionResult(*entry, InputEventInjectionResult::FAILED);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001255 }
1256 if (entry == mNextUnblockedEvent) {
Yi Kong9b14ac62018-07-17 13:48:38 -07001257 mNextUnblockedEvent = nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001258 }
1259 addRecentEventLocked(entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001260}
1261
1262void InputDispatcher::resetKeyRepeatLocked() {
1263 if (mKeyRepeatState.lastKeyEntry) {
Yi Kong9b14ac62018-07-17 13:48:38 -07001264 mKeyRepeatState.lastKeyEntry = nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001265 }
1266}
1267
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001268std::shared_ptr<KeyEntry> InputDispatcher::synthesizeKeyRepeatLocked(nsecs_t currentTime) {
1269 std::shared_ptr<KeyEntry> entry = mKeyRepeatState.lastKeyEntry;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001270
Michael Wright2e732952014-09-24 13:26:59 -07001271 uint32_t policyFlags = entry->policyFlags &
1272 (POLICY_FLAG_RAW_MASK | POLICY_FLAG_PASS_TO_USER | POLICY_FLAG_TRUSTED);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001273
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001274 std::shared_ptr<KeyEntry> newEntry =
1275 std::make_unique<KeyEntry>(mIdGenerator.nextId(), currentTime, entry->deviceId,
1276 entry->source, entry->displayId, policyFlags, entry->action,
1277 entry->flags, entry->keyCode, entry->scanCode,
1278 entry->metaState, entry->repeatCount + 1, entry->downTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001279
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001280 newEntry->syntheticRepeat = true;
1281 mKeyRepeatState.lastKeyEntry = newEntry;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001282 mKeyRepeatState.nextRepeatTime = currentTime + mConfig.keyRepeatDelay;
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001283 return newEntry;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001284}
1285
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001286bool InputDispatcher::dispatchConfigurationChangedLocked(nsecs_t currentTime,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001287 const ConfigurationChangedEntry& entry) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001288 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
1289 ALOGD("dispatchConfigurationChanged - eventTime=%" PRId64, entry.eventTime);
1290 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001291
1292 // Reset key repeating in case a keyboard device was added or removed or something.
1293 resetKeyRepeatLocked();
1294
1295 // Enqueue a command to run outside the lock to tell the policy that the configuration changed.
Prabir Pradhancef936d2021-07-21 16:17:52 +00001296 auto command = [this, eventTime = entry.eventTime]() REQUIRES(mLock) {
1297 scoped_unlock unlock(mLock);
1298 mPolicy->notifyConfigurationChanged(eventTime);
1299 };
1300 postCommandLocked(std::move(command));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001301 return true;
1302}
1303
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001304bool InputDispatcher::dispatchDeviceResetLocked(nsecs_t currentTime,
1305 const DeviceResetEntry& entry) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001306 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
1307 ALOGD("dispatchDeviceReset - eventTime=%" PRId64 ", deviceId=%d", entry.eventTime,
1308 entry.deviceId);
1309 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001310
liushenxiang42232912021-05-21 20:24:09 +08001311 // Reset key repeating in case a keyboard device was disabled or enabled.
1312 if (mKeyRepeatState.lastKeyEntry && mKeyRepeatState.lastKeyEntry->deviceId == entry.deviceId) {
1313 resetKeyRepeatLocked();
1314 }
1315
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001316 CancelationOptions options(CancelationOptions::CANCEL_ALL_EVENTS, "device was reset");
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001317 options.deviceId = entry.deviceId;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001318 synthesizeCancelationEventsForAllConnectionsLocked(options);
1319 return true;
1320}
1321
Vishnu Nairad321cd2020-08-20 16:40:21 -07001322void InputDispatcher::enqueueFocusEventLocked(const sp<IBinder>& windowToken, bool hasFocus,
Vishnu Nairc519ff72021-01-21 08:23:08 -08001323 const std::string& reason) {
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001324 if (mPendingEvent != nullptr) {
1325 // Move the pending event to the front of the queue. This will give the chance
1326 // for the pending event to get dispatched to the newly focused window
1327 mInboundQueue.push_front(mPendingEvent);
1328 mPendingEvent = nullptr;
1329 }
1330
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001331 std::unique_ptr<FocusEntry> focusEntry =
1332 std::make_unique<FocusEntry>(mIdGenerator.nextId(), now(), windowToken, hasFocus,
1333 reason);
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001334
1335 // This event should go to the front of the queue, but behind all other focus events
1336 // Find the last focus event, and insert right after it
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001337 std::deque<std::shared_ptr<EventEntry>>::reverse_iterator it =
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001338 std::find_if(mInboundQueue.rbegin(), mInboundQueue.rend(),
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001339 [](const std::shared_ptr<EventEntry>& event) {
1340 return event->type == EventEntry::Type::FOCUS;
1341 });
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07001342
1343 // Maintain the order of focus events. Insert the entry after all other focus events.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001344 mInboundQueue.insert(it.base(), std::move(focusEntry));
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001345}
1346
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001347void InputDispatcher::dispatchFocusLocked(nsecs_t currentTime, std::shared_ptr<FocusEntry> entry) {
Siarhei Vishniakouce5ab082020-07-09 17:03:21 -05001348 std::shared_ptr<InputChannel> channel = getInputChannelLocked(entry->connectionToken);
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001349 if (channel == nullptr) {
1350 return; // Window has gone away
1351 }
1352 InputTarget target;
1353 target.inputChannel = channel;
1354 target.flags = InputTarget::FLAG_DISPATCH_AS_IS;
1355 entry->dispatchInProgress = true;
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00001356 std::string message = std::string("Focus ") + (entry->hasFocus ? "entering " : "leaving ") +
1357 channel->getName();
Vishnu Nair7d3d00d2020-08-03 11:20:42 -07001358 std::string reason = std::string("reason=").append(entry->reason);
1359 android_log_event_list(LOGTAG_INPUT_FOCUS) << message << reason << LOG_ID_EVENTS;
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001360 dispatchEventLocked(currentTime, entry, {target});
1361}
1362
Prabir Pradhan99987712020-11-10 18:43:05 -08001363void InputDispatcher::dispatchPointerCaptureChangedLocked(
1364 nsecs_t currentTime, const std::shared_ptr<PointerCaptureChangedEntry>& entry,
1365 DropReason& dropReason) {
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001366 dropReason = DropReason::NOT_DROPPED;
1367
Prabir Pradhan99987712020-11-10 18:43:05 -08001368 const bool haveWindowWithPointerCapture = mWindowTokenWithPointerCapture != nullptr;
Prabir Pradhan99987712020-11-10 18:43:05 -08001369 sp<IBinder> token;
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001370
1371 if (entry->pointerCaptureRequest.enable) {
1372 // Enable Pointer Capture.
1373 if (haveWindowWithPointerCapture &&
1374 (entry->pointerCaptureRequest == mCurrentPointerCaptureRequest)) {
Prabir Pradhan7092e262022-05-03 16:51:09 +00001375 // This can happen if pointer capture is disabled and re-enabled before we notify the
1376 // app of the state change, so there is no need to notify the app.
1377 ALOGI("Skipping dispatch of Pointer Capture being enabled: no state change.");
1378 return;
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001379 }
1380 if (!mCurrentPointerCaptureRequest.enable) {
Prabir Pradhan99987712020-11-10 18:43:05 -08001381 // This can happen if a window requests capture and immediately releases capture.
1382 ALOGW("No window requested Pointer Capture.");
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001383 dropReason = DropReason::NO_POINTER_CAPTURE;
Prabir Pradhan99987712020-11-10 18:43:05 -08001384 return;
1385 }
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001386 if (entry->pointerCaptureRequest.seq != mCurrentPointerCaptureRequest.seq) {
1387 ALOGI("Skipping dispatch of Pointer Capture being enabled: sequence number mismatch.");
1388 return;
1389 }
1390
Vishnu Nairc519ff72021-01-21 08:23:08 -08001391 token = mFocusResolver.getFocusedWindowToken(mFocusedDisplayId);
Prabir Pradhan99987712020-11-10 18:43:05 -08001392 LOG_ALWAYS_FATAL_IF(!token, "Cannot find focused window for Pointer Capture.");
1393 mWindowTokenWithPointerCapture = token;
1394 } else {
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001395 // Disable Pointer Capture.
1396 // We do not check if the sequence number matches for requests to disable Pointer Capture
1397 // for two reasons:
1398 // 1. Pointer Capture can be disabled by a focus change, which means we can get two entries
1399 // to disable capture with the same sequence number: one generated by
1400 // disablePointerCaptureForcedLocked() and another as an acknowledgement of Pointer
1401 // Capture being disabled in InputReader.
1402 // 2. We respect any request to disable Pointer Capture generated by InputReader, since the
1403 // actual Pointer Capture state that affects events being generated by input devices is
1404 // in InputReader.
1405 if (!haveWindowWithPointerCapture) {
1406 // Pointer capture was already forcefully disabled because of focus change.
1407 dropReason = DropReason::NOT_DROPPED;
1408 return;
1409 }
Prabir Pradhan99987712020-11-10 18:43:05 -08001410 token = mWindowTokenWithPointerCapture;
1411 mWindowTokenWithPointerCapture = nullptr;
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001412 if (mCurrentPointerCaptureRequest.enable) {
Prabir Pradhan7d030382020-12-21 07:58:35 -08001413 setPointerCaptureLocked(false);
1414 }
Prabir Pradhan99987712020-11-10 18:43:05 -08001415 }
1416
1417 auto channel = getInputChannelLocked(token);
1418 if (channel == nullptr) {
1419 // Window has gone away, clean up Pointer Capture state.
1420 mWindowTokenWithPointerCapture = nullptr;
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00001421 if (mCurrentPointerCaptureRequest.enable) {
Prabir Pradhan7d030382020-12-21 07:58:35 -08001422 setPointerCaptureLocked(false);
1423 }
Prabir Pradhan99987712020-11-10 18:43:05 -08001424 return;
1425 }
1426 InputTarget target;
1427 target.inputChannel = channel;
1428 target.flags = InputTarget::FLAG_DISPATCH_AS_IS;
1429 entry->dispatchInProgress = true;
1430 dispatchEventLocked(currentTime, entry, {target});
1431
1432 dropReason = DropReason::NOT_DROPPED;
1433}
1434
Antonio Kantek7242d8b2021-08-05 16:07:20 -07001435void InputDispatcher::dispatchTouchModeChangeLocked(nsecs_t currentTime,
1436 const std::shared_ptr<TouchModeEntry>& entry) {
1437 const std::vector<sp<WindowInfoHandle>>& windowHandles =
1438 getWindowHandlesLocked(mFocusedDisplayId);
1439 if (windowHandles.empty()) {
1440 return;
1441 }
1442 const std::vector<InputTarget> inputTargets =
1443 getInputTargetsFromWindowHandlesLocked(windowHandles);
1444 if (inputTargets.empty()) {
1445 return;
1446 }
1447 entry->dispatchInProgress = true;
1448 dispatchEventLocked(currentTime, entry, inputTargets);
1449}
1450
1451std::vector<InputTarget> InputDispatcher::getInputTargetsFromWindowHandlesLocked(
1452 const std::vector<sp<WindowInfoHandle>>& windowHandles) const {
1453 std::vector<InputTarget> inputTargets;
1454 for (const sp<WindowInfoHandle>& handle : windowHandles) {
1455 // TODO(b/193718270): Due to performance concerns, consider notifying visible windows only.
1456 const sp<IBinder>& token = handle->getToken();
1457 if (token == nullptr) {
1458 continue;
1459 }
1460 std::shared_ptr<InputChannel> channel = getInputChannelLocked(token);
1461 if (channel == nullptr) {
1462 continue; // Window has gone away
1463 }
1464 InputTarget target;
1465 target.inputChannel = channel;
1466 target.flags = InputTarget::FLAG_DISPATCH_AS_IS;
1467 inputTargets.push_back(target);
1468 }
1469 return inputTargets;
1470}
1471
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001472bool InputDispatcher::dispatchKeyLocked(nsecs_t currentTime, std::shared_ptr<KeyEntry> entry,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001473 DropReason* dropReason, nsecs_t* nextWakeupTime) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001474 // Preprocessing.
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001475 if (!entry->dispatchInProgress) {
1476 if (entry->repeatCount == 0 && entry->action == AKEY_EVENT_ACTION_DOWN &&
1477 (entry->policyFlags & POLICY_FLAG_TRUSTED) &&
1478 (!(entry->policyFlags & POLICY_FLAG_DISABLE_KEY_REPEAT))) {
1479 if (mKeyRepeatState.lastKeyEntry &&
Chris Ye2ad95392020-09-01 13:44:44 -07001480 mKeyRepeatState.lastKeyEntry->keyCode == entry->keyCode &&
Michael Wrightd02c5b62014-02-10 15:10:22 -08001481 // We have seen two identical key downs in a row which indicates that the device
1482 // driver is automatically generating key repeats itself. We take note of the
1483 // repeat here, but we disable our own next key repeat timer since it is clear that
1484 // we will not need to synthesize key repeats ourselves.
Chris Ye2ad95392020-09-01 13:44:44 -07001485 mKeyRepeatState.lastKeyEntry->deviceId == entry->deviceId) {
1486 // Make sure we don't get key down from a different device. If a different
1487 // device Id has same key pressed down, the new device Id will replace the
1488 // current one to hold the key repeat with repeat count reset.
1489 // In the future when got a KEY_UP on the device id, drop it and do not
1490 // stop the key repeat on current device.
Michael Wrightd02c5b62014-02-10 15:10:22 -08001491 entry->repeatCount = mKeyRepeatState.lastKeyEntry->repeatCount + 1;
1492 resetKeyRepeatLocked();
1493 mKeyRepeatState.nextRepeatTime = LONG_LONG_MAX; // don't generate repeats ourselves
1494 } else {
1495 // Not a repeat. Save key down state in case we do see a repeat later.
1496 resetKeyRepeatLocked();
1497 mKeyRepeatState.nextRepeatTime = entry->eventTime + mConfig.keyRepeatTimeout;
1498 }
1499 mKeyRepeatState.lastKeyEntry = entry;
Chris Ye2ad95392020-09-01 13:44:44 -07001500 } else if (entry->action == AKEY_EVENT_ACTION_UP && mKeyRepeatState.lastKeyEntry &&
1501 mKeyRepeatState.lastKeyEntry->deviceId != entry->deviceId) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001502 // The key on device 'deviceId' is still down, do not stop key repeat
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001503 if (DEBUG_INBOUND_EVENT_DETAILS) {
1504 ALOGD("deviceId=%d got KEY_UP as stale", entry->deviceId);
1505 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001506 } else if (!entry->syntheticRepeat) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001507 resetKeyRepeatLocked();
1508 }
1509
1510 if (entry->repeatCount == 1) {
1511 entry->flags |= AKEY_EVENT_FLAG_LONG_PRESS;
1512 } else {
1513 entry->flags &= ~AKEY_EVENT_FLAG_LONG_PRESS;
1514 }
1515
1516 entry->dispatchInProgress = true;
1517
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001518 logOutboundKeyDetails("dispatchKey - ", *entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001519 }
1520
1521 // Handle case where the policy asked us to try again later last time.
1522 if (entry->interceptKeyResult == KeyEntry::INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER) {
1523 if (currentTime < entry->interceptKeyWakeupTime) {
1524 if (entry->interceptKeyWakeupTime < *nextWakeupTime) {
1525 *nextWakeupTime = entry->interceptKeyWakeupTime;
1526 }
1527 return false; // wait until next wakeup
1528 }
1529 entry->interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_UNKNOWN;
1530 entry->interceptKeyWakeupTime = 0;
1531 }
1532
1533 // Give the policy a chance to intercept the key.
1534 if (entry->interceptKeyResult == KeyEntry::INTERCEPT_KEY_RESULT_UNKNOWN) {
1535 if (entry->policyFlags & POLICY_FLAG_PASS_TO_USER) {
Vishnu Nairad321cd2020-08-20 16:40:21 -07001536 sp<IBinder> focusedWindowToken =
Vishnu Nairc519ff72021-01-21 08:23:08 -08001537 mFocusResolver.getFocusedWindowToken(getTargetDisplayId(*entry));
Prabir Pradhancef936d2021-07-21 16:17:52 +00001538
1539 auto command = [this, focusedWindowToken, entry]() REQUIRES(mLock) {
1540 doInterceptKeyBeforeDispatchingCommand(focusedWindowToken, *entry);
1541 };
1542 postCommandLocked(std::move(command));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001543 return false; // wait for the command to run
1544 } else {
1545 entry->interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_CONTINUE;
1546 }
1547 } else if (entry->interceptKeyResult == KeyEntry::INTERCEPT_KEY_RESULT_SKIP) {
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001548 if (*dropReason == DropReason::NOT_DROPPED) {
1549 *dropReason = DropReason::POLICY;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001550 }
1551 }
1552
1553 // Clean up if dropping the event.
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001554 if (*dropReason != DropReason::NOT_DROPPED) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001555 setInjectionResult(*entry,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001556 *dropReason == DropReason::POLICY ? InputEventInjectionResult::SUCCEEDED
1557 : InputEventInjectionResult::FAILED);
Garfield Tan6a5a14e2020-01-28 13:24:04 -08001558 mReporter->reportDroppedKey(entry->id);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001559 return true;
1560 }
1561
1562 // Identify targets.
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08001563 std::vector<InputTarget> inputTargets;
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001564 InputEventInjectionResult injectionResult =
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001565 findFocusedWindowTargetsLocked(currentTime, *entry, inputTargets, nextWakeupTime);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001566 if (injectionResult == InputEventInjectionResult::PENDING) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001567 return false;
1568 }
1569
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001570 setInjectionResult(*entry, injectionResult);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001571 if (injectionResult != InputEventInjectionResult::SUCCEEDED) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001572 return true;
1573 }
1574
Arthur Hung2fbf37f2018-09-13 18:16:41 +08001575 // Add monitor channels from event's or focused display.
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001576 addGlobalMonitoringTargetsLocked(inputTargets, getTargetDisplayId(*entry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001577
1578 // Dispatch the key.
1579 dispatchEventLocked(currentTime, entry, inputTargets);
1580 return true;
1581}
1582
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001583void InputDispatcher::logOutboundKeyDetails(const char* prefix, const KeyEntry& entry) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001584 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
1585 ALOGD("%seventTime=%" PRId64 ", deviceId=%d, source=0x%x, displayId=%" PRId32 ", "
1586 "policyFlags=0x%x, action=0x%x, flags=0x%x, keyCode=0x%x, scanCode=0x%x, "
1587 "metaState=0x%x, repeatCount=%d, downTime=%" PRId64,
1588 prefix, entry.eventTime, entry.deviceId, entry.source, entry.displayId,
1589 entry.policyFlags, entry.action, entry.flags, entry.keyCode, entry.scanCode,
1590 entry.metaState, entry.repeatCount, entry.downTime);
1591 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001592}
1593
Prabir Pradhancef936d2021-07-21 16:17:52 +00001594void InputDispatcher::dispatchSensorLocked(nsecs_t currentTime,
1595 const std::shared_ptr<SensorEntry>& entry,
Chris Yef59a2f42020-10-16 12:55:26 -07001596 DropReason* dropReason, nsecs_t* nextWakeupTime) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001597 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
1598 ALOGD("notifySensorEvent eventTime=%" PRId64 ", hwTimestamp=%" PRId64 ", deviceId=%d, "
1599 "source=0x%x, sensorType=%s",
1600 entry->eventTime, entry->hwTimestamp, entry->deviceId, entry->source,
Dominik Laskowski75788452021-02-09 18:51:25 -08001601 ftl::enum_string(entry->sensorType).c_str());
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001602 }
Prabir Pradhancef936d2021-07-21 16:17:52 +00001603 auto command = [this, entry]() REQUIRES(mLock) {
1604 scoped_unlock unlock(mLock);
1605
1606 if (entry->accuracyChanged) {
1607 mPolicy->notifySensorAccuracy(entry->deviceId, entry->sensorType, entry->accuracy);
1608 }
1609 mPolicy->notifySensorEvent(entry->deviceId, entry->sensorType, entry->accuracy,
1610 entry->hwTimestamp, entry->values);
1611 };
1612 postCommandLocked(std::move(command));
Chris Yef59a2f42020-10-16 12:55:26 -07001613}
1614
1615bool InputDispatcher::flushSensor(int deviceId, InputDeviceSensorType sensorType) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001616 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
1617 ALOGD("flushSensor deviceId=%d, sensorType=%s", deviceId,
Dominik Laskowski75788452021-02-09 18:51:25 -08001618 ftl::enum_string(sensorType).c_str());
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001619 }
Chris Yef59a2f42020-10-16 12:55:26 -07001620 { // acquire lock
1621 std::scoped_lock _l(mLock);
1622
1623 for (auto it = mInboundQueue.begin(); it != mInboundQueue.end(); it++) {
1624 std::shared_ptr<EventEntry> entry = *it;
1625 if (entry->type == EventEntry::Type::SENSOR) {
1626 it = mInboundQueue.erase(it);
1627 releaseInboundEventLocked(entry);
1628 }
1629 }
1630 }
1631 return true;
1632}
1633
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001634bool InputDispatcher::dispatchMotionLocked(nsecs_t currentTime, std::shared_ptr<MotionEntry> entry,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001635 DropReason* dropReason, nsecs_t* nextWakeupTime) {
Michael Wright3dd60e22019-03-27 22:06:44 +00001636 ATRACE_CALL();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001637 // Preprocessing.
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001638 if (!entry->dispatchInProgress) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001639 entry->dispatchInProgress = true;
1640
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001641 logOutboundMotionDetails("dispatchMotion - ", *entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001642 }
1643
1644 // Clean up if dropping the event.
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -07001645 if (*dropReason != DropReason::NOT_DROPPED) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001646 setInjectionResult(*entry,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001647 *dropReason == DropReason::POLICY ? InputEventInjectionResult::SUCCEEDED
1648 : InputEventInjectionResult::FAILED);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001649 return true;
1650 }
1651
Prabir Pradhanaa561d12021-09-24 06:57:33 -07001652 const bool isPointerEvent = isFromSource(entry->source, AINPUT_SOURCE_CLASS_POINTER);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001653
1654 // Identify targets.
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08001655 std::vector<InputTarget> inputTargets;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001656
1657 bool conflictingPointerActions = false;
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001658 InputEventInjectionResult injectionResult;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001659 if (isPointerEvent) {
1660 // Pointer event. (eg. touchscreen)
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001661 injectionResult =
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001662 findTouchedWindowTargetsLocked(currentTime, *entry, inputTargets, nextWakeupTime,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001663 &conflictingPointerActions);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001664 } else {
1665 // Non touch event. (eg. trackball)
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001666 injectionResult =
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001667 findFocusedWindowTargetsLocked(currentTime, *entry, inputTargets, nextWakeupTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001668 }
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001669 if (injectionResult == InputEventInjectionResult::PENDING) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001670 return false;
1671 }
1672
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001673 setInjectionResult(*entry, injectionResult);
Prabir Pradhan8a2b1a42022-04-11 17:23:34 +00001674 if (injectionResult == InputEventInjectionResult::TARGET_MISMATCH) {
Siarhei Vishniakou767917f2020-03-24 20:49:09 -07001675 return true;
1676 }
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001677 if (injectionResult != InputEventInjectionResult::SUCCEEDED) {
Siarhei Vishniakou767917f2020-03-24 20:49:09 -07001678 CancelationOptions::Mode mode(isPointerEvent
1679 ? CancelationOptions::CANCEL_POINTER_EVENTS
1680 : CancelationOptions::CANCEL_NON_POINTER_EVENTS);
1681 CancelationOptions options(mode, "input event injection failed");
1682 synthesizeCancelationEventsForMonitorsLocked(options);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001683 return true;
1684 }
1685
Arthur Hung2fbf37f2018-09-13 18:16:41 +08001686 // Add monitor channels from event's or focused display.
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001687 addGlobalMonitoringTargetsLocked(inputTargets, getTargetDisplayId(*entry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001688
1689 // Dispatch the motion.
1690 if (conflictingPointerActions) {
1691 CancelationOptions options(CancelationOptions::CANCEL_POINTER_EVENTS,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001692 "conflicting pointer actions");
Michael Wrightd02c5b62014-02-10 15:10:22 -08001693 synthesizeCancelationEventsForAllConnectionsLocked(options);
1694 }
1695 dispatchEventLocked(currentTime, entry, inputTargets);
1696 return true;
1697}
1698
chaviw98318de2021-05-19 16:45:23 -05001699void InputDispatcher::enqueueDragEventLocked(const sp<WindowInfoHandle>& windowHandle,
Arthur Hung54745652022-04-20 07:17:41 +00001700 bool isExiting, const int32_t rawX,
1701 const int32_t rawY) {
1702 const vec2 xy = windowHandle->getInfo()->transform.transform(vec2(rawX, rawY));
arthurhungb89ccb02020-12-30 16:19:01 +08001703 std::unique_ptr<DragEntry> dragEntry =
Arthur Hung54745652022-04-20 07:17:41 +00001704 std::make_unique<DragEntry>(mIdGenerator.nextId(), now(), windowHandle->getToken(),
1705 isExiting, xy.x, xy.y);
arthurhungb89ccb02020-12-30 16:19:01 +08001706
1707 enqueueInboundEventLocked(std::move(dragEntry));
1708}
1709
1710void InputDispatcher::dispatchDragLocked(nsecs_t currentTime, std::shared_ptr<DragEntry> entry) {
1711 std::shared_ptr<InputChannel> channel = getInputChannelLocked(entry->connectionToken);
1712 if (channel == nullptr) {
1713 return; // Window has gone away
1714 }
1715 InputTarget target;
1716 target.inputChannel = channel;
1717 target.flags = InputTarget::FLAG_DISPATCH_AS_IS;
1718 entry->dispatchInProgress = true;
1719 dispatchEventLocked(currentTime, entry, {target});
1720}
1721
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001722void InputDispatcher::logOutboundMotionDetails(const char* prefix, const MotionEntry& entry) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001723 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
1724 ALOGD("%seventTime=%" PRId64 ", deviceId=%d, source=0x%x, displayId=%" PRId32
1725 ", policyFlags=0x%x, "
Siarhei Vishniakouca205502021-07-16 21:31:58 +00001726 "action=%s, actionButton=0x%x, flags=0x%x, "
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001727 "metaState=0x%x, buttonState=0x%x,"
1728 "edgeFlags=0x%x, xPrecision=%f, yPrecision=%f, downTime=%" PRId64,
1729 prefix, entry.eventTime, entry.deviceId, entry.source, entry.displayId,
Siarhei Vishniakouca205502021-07-16 21:31:58 +00001730 entry.policyFlags, MotionEvent::actionToString(entry.action).c_str(),
1731 entry.actionButton, entry.flags, entry.metaState, entry.buttonState, entry.edgeFlags,
1732 entry.xPrecision, entry.yPrecision, entry.downTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001733
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001734 for (uint32_t i = 0; i < entry.pointerCount; i++) {
1735 ALOGD(" Pointer %d: id=%d, toolType=%d, "
1736 "x=%f, y=%f, pressure=%f, size=%f, "
1737 "touchMajor=%f, touchMinor=%f, toolMajor=%f, toolMinor=%f, "
1738 "orientation=%f",
1739 i, entry.pointerProperties[i].id, entry.pointerProperties[i].toolType,
1740 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_X),
1741 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_Y),
1742 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_PRESSURE),
1743 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_SIZE),
1744 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR),
1745 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR),
1746 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR),
1747 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR),
1748 entry.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION));
1749 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001750 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001751}
1752
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07001753void InputDispatcher::dispatchEventLocked(nsecs_t currentTime,
1754 std::shared_ptr<EventEntry> eventEntry,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001755 const std::vector<InputTarget>& inputTargets) {
Michael Wright3dd60e22019-03-27 22:06:44 +00001756 ATRACE_CALL();
Prabir Pradhan61a5d242021-07-26 16:41:09 +00001757 if (DEBUG_DISPATCH_CYCLE) {
1758 ALOGD("dispatchEventToCurrentInputTargets");
1759 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001760
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00001761 updateInteractionTokensLocked(*eventEntry, inputTargets);
1762
Michael Wrightd02c5b62014-02-10 15:10:22 -08001763 ALOG_ASSERT(eventEntry->dispatchInProgress); // should already have been set to true
1764
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001765 pokeUserActivityLocked(*eventEntry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001766
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08001767 for (const InputTarget& inputTarget : inputTargets) {
Siarhei Vishniakou26d3cfb2019-10-15 17:02:32 -07001768 sp<Connection> connection =
1769 getConnectionLocked(inputTarget.inputChannel->getConnectionToken());
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07001770 if (connection != nullptr) {
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08001771 prepareDispatchCycleLocked(currentTime, connection, eventEntry, inputTarget);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001772 } else {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01001773 if (DEBUG_FOCUS) {
1774 ALOGD("Dropping event delivery to target with channel '%s' because it "
1775 "is no longer registered with the input dispatcher.",
1776 inputTarget.inputChannel->getName().c_str());
1777 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001778 }
1779 }
1780}
1781
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001782void InputDispatcher::cancelEventsForAnrLocked(const sp<Connection>& connection) {
1783 // We will not be breaking any connections here, even if the policy wants us to abort dispatch.
1784 // If the policy decides to close the app, we will get a channel removal event via
1785 // unregisterInputChannel, and will clean up the connection that way. We are already not
1786 // sending new pointers to the connection when it blocked, but focused events will continue to
1787 // pile up.
1788 ALOGW("Canceling events for %s because it is unresponsive",
1789 connection->inputChannel->getName().c_str());
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08001790 if (connection->status == Connection::Status::NORMAL) {
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001791 CancelationOptions options(CancelationOptions::CANCEL_ALL_EVENTS,
1792 "application not responding");
1793 synthesizeCancelationEventsForConnectionLocked(connection, options);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001794 }
1795}
1796
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001797void InputDispatcher::resetNoFocusedWindowTimeoutLocked() {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01001798 if (DEBUG_FOCUS) {
1799 ALOGD("Resetting ANR timeouts.");
1800 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001801
1802 // Reset input target wait timeout.
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001803 mNoFocusedWindowTimeoutTime = std::nullopt;
Chris Yea209fde2020-07-22 13:54:51 -07001804 mAwaitedFocusedApplication.reset();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001805}
1806
Tiger Huang721e26f2018-07-24 22:26:19 +08001807/**
1808 * Get the display id that the given event should go to. If this event specifies a valid display id,
1809 * then it should be dispatched to that display. Otherwise, the event goes to the focused display.
1810 * Focused display is the display that the user most recently interacted with.
1811 */
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001812int32_t InputDispatcher::getTargetDisplayId(const EventEntry& entry) {
Tiger Huang721e26f2018-07-24 22:26:19 +08001813 int32_t displayId;
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001814 switch (entry.type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001815 case EventEntry::Type::KEY: {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001816 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(entry);
1817 displayId = keyEntry.displayId;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001818 break;
1819 }
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001820 case EventEntry::Type::MOTION: {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07001821 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(entry);
1822 displayId = motionEntry.displayId;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001823 break;
1824 }
Antonio Kantekf16f2832021-09-28 04:39:20 +00001825 case EventEntry::Type::TOUCH_MODE_CHANGED:
Prabir Pradhan99987712020-11-10 18:43:05 -08001826 case EventEntry::Type::POINTER_CAPTURE_CHANGED:
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001827 case EventEntry::Type::FOCUS:
Siarhei Vishniakou49483272019-10-22 13:13:47 -07001828 case EventEntry::Type::CONFIGURATION_CHANGED:
Chris Yef59a2f42020-10-16 12:55:26 -07001829 case EventEntry::Type::DEVICE_RESET:
arthurhungb89ccb02020-12-30 16:19:01 +08001830 case EventEntry::Type::SENSOR:
1831 case EventEntry::Type::DRAG: {
Dominik Laskowski75788452021-02-09 18:51:25 -08001832 ALOGE("%s events do not have a target display", ftl::enum_string(entry.type).c_str());
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001833 return ADISPLAY_ID_NONE;
1834 }
Tiger Huang721e26f2018-07-24 22:26:19 +08001835 }
1836 return displayId == ADISPLAY_ID_NONE ? mFocusedDisplayId : displayId;
1837}
1838
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001839bool InputDispatcher::shouldWaitToSendKeyLocked(nsecs_t currentTime,
1840 const char* focusedWindowName) {
1841 if (mAnrTracker.empty()) {
1842 // already processed all events that we waited for
1843 mKeyIsWaitingForEventsTimeout = std::nullopt;
1844 return false;
1845 }
1846
1847 if (!mKeyIsWaitingForEventsTimeout.has_value()) {
1848 // Start the timer
Siarhei Vishniakoud706a282021-02-13 00:08:48 +00001849 // Wait to send key because there are unprocessed events that may cause focus to change
Siarhei Vishniakou70622952020-07-30 11:17:23 -05001850 mKeyIsWaitingForEventsTimeout = currentTime +
1851 std::chrono::duration_cast<std::chrono::nanoseconds>(KEY_WAITING_FOR_EVENTS_TIMEOUT)
1852 .count();
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001853 return true;
1854 }
1855
1856 // We still have pending events, and already started the timer
1857 if (currentTime < *mKeyIsWaitingForEventsTimeout) {
1858 return true; // Still waiting
1859 }
1860
1861 // Waited too long, and some connection still hasn't processed all motions
1862 // Just send the key to the focused window
1863 ALOGW("Dispatching key to %s even though there are other unprocessed events",
1864 focusedWindowName);
1865 mKeyIsWaitingForEventsTimeout = std::nullopt;
1866 return false;
1867}
1868
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001869InputEventInjectionResult InputDispatcher::findFocusedWindowTargetsLocked(
1870 nsecs_t currentTime, const EventEntry& entry, std::vector<InputTarget>& inputTargets,
1871 nsecs_t* nextWakeupTime) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08001872 std::string reason;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001873
Tiger Huang721e26f2018-07-24 22:26:19 +08001874 int32_t displayId = getTargetDisplayId(entry);
chaviw98318de2021-05-19 16:45:23 -05001875 sp<WindowInfoHandle> focusedWindowHandle = getFocusedWindowHandleLocked(displayId);
Chris Yea209fde2020-07-22 13:54:51 -07001876 std::shared_ptr<InputApplicationHandle> focusedApplicationHandle =
Tiger Huang721e26f2018-07-24 22:26:19 +08001877 getValueByKey(mFocusedApplicationHandlesByDisplay, displayId);
1878
Michael Wrightd02c5b62014-02-10 15:10:22 -08001879 // If there is no currently focused window and no focused application
1880 // then drop the event.
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001881 if (focusedWindowHandle == nullptr && focusedApplicationHandle == nullptr) {
1882 ALOGI("Dropping %s event because there is no focused window or focused application in "
1883 "display %" PRId32 ".",
Dominik Laskowski75788452021-02-09 18:51:25 -08001884 ftl::enum_string(entry.type).c_str(), displayId);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001885 return InputEventInjectionResult::FAILED;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001886 }
1887
Vishnu Nair062a8672021-09-03 16:07:44 -07001888 // Drop key events if requested by input feature
1889 if (focusedWindowHandle != nullptr && shouldDropInput(entry, focusedWindowHandle)) {
1890 return InputEventInjectionResult::FAILED;
1891 }
1892
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001893 // Compatibility behavior: raise ANR if there is a focused application, but no focused window.
1894 // Only start counting when we have a focused event to dispatch. The ANR is canceled if we
1895 // start interacting with another application via touch (app switch). This code can be removed
1896 // if the "no focused window ANR" is moved to the policy. Input doesn't know whether
1897 // an app is expected to have a focused window.
1898 if (focusedWindowHandle == nullptr && focusedApplicationHandle != nullptr) {
1899 if (!mNoFocusedWindowTimeoutTime.has_value()) {
1900 // We just discovered that there's no focused window. Start the ANR timer
Siarhei Vishniakouc1ae5562020-06-30 14:22:57 -05001901 std::chrono::nanoseconds timeout = focusedApplicationHandle->getDispatchingTimeout(
1902 DEFAULT_INPUT_DISPATCHING_TIMEOUT);
1903 mNoFocusedWindowTimeoutTime = currentTime + timeout.count();
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001904 mAwaitedFocusedApplication = focusedApplicationHandle;
Siarhei Vishniakouf56b2692020-09-08 19:43:33 -05001905 mAwaitedApplicationDisplayId = displayId;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001906 ALOGW("Waiting because no window has focus but %s may eventually add a "
1907 "window when it finishes starting up. Will wait for %" PRId64 "ms",
Siarhei Vishniakouc1ae5562020-06-30 14:22:57 -05001908 mAwaitedFocusedApplication->getName().c_str(), millis(timeout));
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001909 *nextWakeupTime = *mNoFocusedWindowTimeoutTime;
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001910 return InputEventInjectionResult::PENDING;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001911 } else if (currentTime > *mNoFocusedWindowTimeoutTime) {
1912 // Already raised ANR. Drop the event
1913 ALOGE("Dropping %s event because there is no focused window",
Dominik Laskowski75788452021-02-09 18:51:25 -08001914 ftl::enum_string(entry.type).c_str());
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001915 return InputEventInjectionResult::FAILED;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001916 } else {
1917 // Still waiting for the focused window
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001918 return InputEventInjectionResult::PENDING;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001919 }
1920 }
1921
1922 // we have a valid, non-null focused window
1923 resetNoFocusedWindowTimeoutLocked();
1924
Prabir Pradhan8a2b1a42022-04-11 17:23:34 +00001925 // Verify targeted injection.
1926 if (const auto err = verifyTargetedInjection(focusedWindowHandle, entry); err) {
1927 ALOGW("Dropping injected event: %s", (*err).c_str());
1928 return InputEventInjectionResult::TARGET_MISMATCH;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001929 }
1930
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08001931 if (focusedWindowHandle->getInfo()->inputConfig.test(
1932 WindowInfo::InputConfig::PAUSE_DISPATCHING)) {
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001933 ALOGI("Waiting because %s is paused", focusedWindowHandle->getName().c_str());
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001934 return InputEventInjectionResult::PENDING;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001935 }
1936
1937 // If the event is a key event, then we must wait for all previous events to
1938 // complete before delivering it because previous events may have the
1939 // side-effect of transferring focus to a different window and we want to
1940 // ensure that the following keys are sent to the new window.
1941 //
1942 // Suppose the user touches a button in a window then immediately presses "A".
1943 // If the button causes a pop-up window to appear then we want to ensure that
1944 // the "A" key is delivered to the new pop-up window. This is because users
1945 // often anticipate pending UI changes when typing on a keyboard.
1946 // To obtain this behavior, we must serialize key events with respect to all
1947 // prior input events.
1948 if (entry.type == EventEntry::Type::KEY) {
1949 if (shouldWaitToSendKeyLocked(currentTime, focusedWindowHandle->getName().c_str())) {
1950 *nextWakeupTime = *mKeyIsWaitingForEventsTimeout;
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001951 return InputEventInjectionResult::PENDING;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001952 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001953 }
1954
1955 // Success! Output targets.
Tiger Huang721e26f2018-07-24 22:26:19 +08001956 addWindowTargetLocked(focusedWindowHandle,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07001957 InputTarget::FLAG_FOREGROUND | InputTarget::FLAG_DISPATCH_AS_IS,
1958 BitSet32(0), inputTargets);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001959
1960 // Done.
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001961 return InputEventInjectionResult::SUCCEEDED;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001962}
1963
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001964/**
1965 * Given a list of monitors, remove the ones we cannot find a connection for, and the ones
1966 * that are currently unresponsive.
1967 */
Prabir Pradhan0a99c922021-09-03 08:27:53 -07001968std::vector<Monitor> InputDispatcher::selectResponsiveMonitorsLocked(
1969 const std::vector<Monitor>& monitors) const {
1970 std::vector<Monitor> responsiveMonitors;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001971 std::copy_if(monitors.begin(), monitors.end(), std::back_inserter(responsiveMonitors),
Prabir Pradhan0a99c922021-09-03 08:27:53 -07001972 [this](const Monitor& monitor) REQUIRES(mLock) {
1973 sp<Connection> connection =
1974 getConnectionLocked(monitor.inputChannel->getConnectionToken());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001975 if (connection == nullptr) {
1976 ALOGE("Could not find connection for monitor %s",
Prabir Pradhan0a99c922021-09-03 08:27:53 -07001977 monitor.inputChannel->getName().c_str());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001978 return false;
1979 }
1980 if (!connection->responsive) {
1981 ALOGW("Unresponsive monitor %s will not get the new gesture",
1982 connection->inputChannel->getName().c_str());
1983 return false;
1984 }
1985 return true;
1986 });
1987 return responsiveMonitors;
1988}
1989
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001990InputEventInjectionResult InputDispatcher::findTouchedWindowTargetsLocked(
1991 nsecs_t currentTime, const MotionEntry& entry, std::vector<InputTarget>& inputTargets,
1992 nsecs_t* nextWakeupTime, bool* outConflictingPointerActions) {
Michael Wright3dd60e22019-03-27 22:06:44 +00001993 ATRACE_CALL();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001994
Michael Wrightd02c5b62014-02-10 15:10:22 -08001995 // For security reasons, we defer updating the touch state until we are sure that
1996 // event injection will be allowed.
Prabir Pradhan3f90d312021-11-19 03:57:24 -08001997 const int32_t displayId = entry.displayId;
1998 const int32_t action = entry.action;
1999 const int32_t maskedAction = action & AMOTION_EVENT_ACTION_MASK;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002000
2001 // Update the touch state as needed based on the properties of the touch event.
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002002 InputEventInjectionResult injectionResult = InputEventInjectionResult::PENDING;
chaviw98318de2021-05-19 16:45:23 -05002003 sp<WindowInfoHandle> newHoverWindowHandle(mLastHoverWindowHandle);
2004 sp<WindowInfoHandle> newTouchedWindowHandle;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002005
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002006 // Copy current touch state into tempTouchState.
2007 // This state will be used to update mTouchStatesByDisplay at the end of this function.
2008 // If no state for the specified display exists, then our initial state will be empty.
Yi Kong9b14ac62018-07-17 13:48:38 -07002009 const TouchState* oldState = nullptr;
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002010 TouchState tempTouchState;
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002011 if (const auto it = mTouchStatesByDisplay.find(displayId); it != mTouchStatesByDisplay.end()) {
2012 oldState = &(it->second);
Prabir Pradhane680f9b2022-02-04 04:24:00 -08002013 tempTouchState = *oldState;
Jeff Brownf086ddb2014-02-11 14:28:48 -08002014 }
2015
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002016 bool isSplit = tempTouchState.split;
2017 bool switchedDevice = tempTouchState.deviceId >= 0 && tempTouchState.displayId >= 0 &&
2018 (tempTouchState.deviceId != entry.deviceId || tempTouchState.source != entry.source ||
2019 tempTouchState.displayId != displayId);
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002020
2021 const bool isHoverAction = (maskedAction == AMOTION_EVENT_ACTION_HOVER_MOVE ||
2022 maskedAction == AMOTION_EVENT_ACTION_HOVER_ENTER ||
2023 maskedAction == AMOTION_EVENT_ACTION_HOVER_EXIT);
2024 const bool newGesture = (maskedAction == AMOTION_EVENT_ACTION_DOWN ||
2025 maskedAction == AMOTION_EVENT_ACTION_SCROLL || isHoverAction);
Prabir Pradhanaa561d12021-09-24 06:57:33 -07002026 const bool isFromMouse = isFromSource(entry.source, AINPUT_SOURCE_MOUSE);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002027 bool wrongDevice = false;
2028 if (newGesture) {
2029 bool down = maskedAction == AMOTION_EVENT_ACTION_DOWN;
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002030 if (switchedDevice && tempTouchState.down && !down && !isHoverAction) {
Siarhei Vishniakouf0007dd2020-04-13 11:40:37 -07002031 ALOGI("Dropping event because a pointer for a different device is already down "
2032 "in display %" PRId32,
2033 displayId);
Kevin Schoedel1eb587b2017-05-03 13:58:56 -04002034 // TODO: test multiple simultaneous input streams.
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002035 injectionResult = InputEventInjectionResult::FAILED;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002036 switchedDevice = false;
2037 wrongDevice = true;
2038 goto Failed;
2039 }
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002040 tempTouchState.reset();
2041 tempTouchState.down = down;
2042 tempTouchState.deviceId = entry.deviceId;
2043 tempTouchState.source = entry.source;
2044 tempTouchState.displayId = displayId;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002045 isSplit = false;
Kevin Schoedel1eb587b2017-05-03 13:58:56 -04002046 } else if (switchedDevice && maskedAction == AMOTION_EVENT_ACTION_MOVE) {
Siarhei Vishniakouf0007dd2020-04-13 11:40:37 -07002047 ALOGI("Dropping move event because a pointer for a different device is already active "
2048 "in display %" PRId32,
2049 displayId);
Kevin Schoedel1eb587b2017-05-03 13:58:56 -04002050 // TODO: test multiple simultaneous input streams.
Prabir Pradhan8a2b1a42022-04-11 17:23:34 +00002051 injectionResult = InputEventInjectionResult::FAILED;
Kevin Schoedel1eb587b2017-05-03 13:58:56 -04002052 switchedDevice = false;
2053 wrongDevice = true;
2054 goto Failed;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002055 }
2056
2057 if (newGesture || (isSplit && maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN)) {
2058 /* Case 1: New splittable pointer going down, or need target for hover or scroll. */
2059
Garfield Tan00f511d2019-06-12 16:55:40 -07002060 int32_t x;
2061 int32_t y;
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002062 const int32_t pointerIndex = getMotionEventActionPointerIndex(action);
Garfield Tan00f511d2019-06-12 16:55:40 -07002063 // Always dispatch mouse events to cursor position.
2064 if (isFromMouse) {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002065 x = int32_t(entry.xCursorPosition);
2066 y = int32_t(entry.yCursorPosition);
Garfield Tan00f511d2019-06-12 16:55:40 -07002067 } else {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002068 x = int32_t(entry.pointerCoords[pointerIndex].getAxisValue(AMOTION_EVENT_AXIS_X));
2069 y = int32_t(entry.pointerCoords[pointerIndex].getAxisValue(AMOTION_EVENT_AXIS_Y));
Garfield Tan00f511d2019-06-12 16:55:40 -07002070 }
Prabir Pradhan0a99c922021-09-03 08:27:53 -07002071 const bool isDown = maskedAction == AMOTION_EVENT_ACTION_DOWN;
Prabir Pradhand65552b2021-10-07 11:23:50 -07002072 const bool isStylus = isPointerFromStylus(entry, pointerIndex);
Siarhei Vishniakou64452932020-11-06 17:51:32 -06002073 newTouchedWindowHandle = findTouchedWindowAtLocked(displayId, x, y, &tempTouchState,
Prabir Pradhand65552b2021-10-07 11:23:50 -07002074 isStylus, isDown /*addOutsideTargets*/);
Michael Wright3dd60e22019-03-27 22:06:44 +00002075
Michael Wrightd02c5b62014-02-10 15:10:22 -08002076 // Handle the case where we did not find a window.
Yi Kong9b14ac62018-07-17 13:48:38 -07002077 if (newTouchedWindowHandle == nullptr) {
Arthur Hungb3307ee2021-10-14 10:57:37 +00002078 ALOGD("No new touched window at (%" PRId32 ", %" PRId32 ") in display %" PRId32, x, y,
2079 displayId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002080 // Try to assign the pointer to the first foreground window we find, if there is one.
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002081 newTouchedWindowHandle = tempTouchState.getFirstForegroundWindowHandle();
Michael Wright3dd60e22019-03-27 22:06:44 +00002082 }
2083
Prabir Pradhan8a2b1a42022-04-11 17:23:34 +00002084 // Verify targeted injection.
2085 if (const auto err = verifyTargetedInjection(newTouchedWindowHandle, entry); err) {
2086 ALOGW("Dropping injected touch event: %s", (*err).c_str());
2087 injectionResult = os::InputEventInjectionResult::TARGET_MISMATCH;
2088 newTouchedWindowHandle = nullptr;
2089 goto Failed;
2090 }
2091
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002092 // Figure out whether splitting will be allowed for this window.
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002093 if (newTouchedWindowHandle != nullptr) {
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002094 if (newTouchedWindowHandle->getInfo()->supportsSplitTouch()) {
2095 // New window supports splitting, but we should never split mouse events.
2096 isSplit = !isFromMouse;
2097 } else if (isSplit) {
2098 // New window does not support splitting but we have already split events.
2099 // Ignore the new window.
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002100 newTouchedWindowHandle = nullptr;
2101 }
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002102 } else {
2103 // No window is touched, so set split to true. This will allow the next pointer down to
Prabir Pradhan713bb3e2021-12-20 02:07:40 -08002104 // be delivered to a new window which supports split touch. Pointers from a mouse device
2105 // should never be split.
2106 tempTouchState.split = isSplit = !isFromMouse;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002107 }
2108
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002109 // Update hover state.
Michael Wright3dd60e22019-03-27 22:06:44 +00002110 if (newTouchedWindowHandle != nullptr) {
Garfield Tandf26e862020-07-01 20:18:19 -07002111 if (maskedAction == AMOTION_EVENT_ACTION_HOVER_EXIT) {
2112 newHoverWindowHandle = nullptr;
2113 } else if (isHoverAction) {
Michael Wright3dd60e22019-03-27 22:06:44 +00002114 newHoverWindowHandle = newTouchedWindowHandle;
Michael Wright3dd60e22019-03-27 22:06:44 +00002115 }
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002116 }
2117
Prabir Pradhan07e05b62021-11-19 03:57:24 -08002118 std::vector<sp<WindowInfoHandle>> newTouchedWindows =
Prabir Pradhand65552b2021-10-07 11:23:50 -07002119 findTouchedSpyWindowsAtLocked(displayId, x, y, isStylus);
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002120 if (newTouchedWindowHandle != nullptr) {
Prabir Pradhan07e05b62021-11-19 03:57:24 -08002121 // Process the foreground window first so that it is the first to receive the event.
2122 newTouchedWindows.insert(newTouchedWindows.begin(), newTouchedWindowHandle);
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002123 }
2124
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002125 if (newTouchedWindows.empty()) {
2126 ALOGI("Dropping event because there is no touchable window at (%d, %d) on display %d.",
2127 x, y, displayId);
2128 injectionResult = InputEventInjectionResult::FAILED;
2129 goto Failed;
2130 }
2131
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002132 for (const sp<WindowInfoHandle>& windowHandle : newTouchedWindows) {
2133 const WindowInfo& info = *windowHandle->getInfo();
2134
Prabir Pradhan8a2b1a42022-04-11 17:23:34 +00002135 // Skip spy window targets that are not valid for targeted injection.
2136 if (const auto err = verifyTargetedInjection(windowHandle, entry); err) {
2137 continue;
2138 }
2139
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08002140 if (info.inputConfig.test(WindowInfo::InputConfig::PAUSE_DISPATCHING)) {
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002141 ALOGI("Not sending touch event to %s because it is paused",
2142 windowHandle->getName().c_str());
2143 continue;
2144 }
2145
2146 // Ensure the window has a connection and the connection is responsive
2147 const bool isResponsive = hasResponsiveConnectionLocked(*windowHandle);
2148 if (!isResponsive) {
2149 ALOGW("Not sending touch gesture to %s because it is not responsive",
2150 windowHandle->getName().c_str());
2151 continue;
2152 }
2153
2154 // Drop events that can't be trusted due to occlusion
2155 if (mBlockUntrustedTouchesMode != BlockUntrustedTouchesMode::DISABLED) {
2156 TouchOcclusionInfo occlusionInfo =
2157 computeTouchOcclusionInfoLocked(windowHandle, x, y);
2158 if (!isTouchTrustedLocked(occlusionInfo)) {
2159 if (DEBUG_TOUCH_OCCLUSION) {
2160 ALOGD("Stack of obscuring windows during untrusted touch (%d, %d):", x, y);
2161 for (const auto& log : occlusionInfo.debugInfo) {
2162 ALOGD("%s", log.c_str());
2163 }
2164 }
2165 sendUntrustedTouchCommandLocked(occlusionInfo.obscuringPackage);
2166 if (mBlockUntrustedTouchesMode == BlockUntrustedTouchesMode::BLOCK) {
2167 ALOGW("Dropping untrusted touch event due to %s/%d",
2168 occlusionInfo.obscuringPackage.c_str(), occlusionInfo.obscuringUid);
2169 continue;
2170 }
2171 }
2172 }
2173
2174 // Drop touch events if requested by input feature
2175 if (shouldDropInput(entry, windowHandle)) {
2176 continue;
2177 }
2178
2179 // Set target flags.
2180 int32_t targetFlags = InputTarget::FLAG_DISPATCH_AS_IS;
2181
Prabir Pradhan6dfbf262022-03-14 15:24:30 +00002182 if (canReceiveForegroundTouches(*windowHandle->getInfo())) {
2183 // There should only be one touched window that can be "foreground" for the pointer.
Prabir Pradhan07e05b62021-11-19 03:57:24 -08002184 targetFlags |= InputTarget::FLAG_FOREGROUND;
2185 }
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002186
2187 if (isSplit) {
2188 targetFlags |= InputTarget::FLAG_SPLIT;
2189 }
2190 if (isWindowObscuredAtPointLocked(windowHandle, x, y)) {
2191 targetFlags |= InputTarget::FLAG_WINDOW_IS_OBSCURED;
2192 } else if (isWindowObscuredLocked(windowHandle)) {
2193 targetFlags |= InputTarget::FLAG_WINDOW_IS_PARTIALLY_OBSCURED;
2194 }
Michael Wright3dd60e22019-03-27 22:06:44 +00002195
2196 // Update the temporary touch state.
2197 BitSet32 pointerIds;
Arthur Hung02701602022-07-15 09:35:36 +00002198 pointerIds.markBit(entry.pointerProperties[pointerIndex].id);
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002199
2200 tempTouchState.addOrUpdateWindow(windowHandle, targetFlags, pointerIds);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002201 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002202 } else {
2203 /* Case 2: Pointer move, up, cancel or non-splittable pointer down. */
2204
2205 // If the pointer is not currently down, then ignore the event.
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002206 if (!tempTouchState.down) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01002207 if (DEBUG_FOCUS) {
2208 ALOGD("Dropping event because the pointer is not down or we previously "
2209 "dropped the pointer down event in display %" PRId32,
2210 displayId);
2211 }
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002212 injectionResult = InputEventInjectionResult::FAILED;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002213 goto Failed;
2214 }
2215
arthurhung6d4bed92021-03-17 11:59:33 +08002216 addDragEventLocked(entry);
arthurhungb89ccb02020-12-30 16:19:01 +08002217
Michael Wrightd02c5b62014-02-10 15:10:22 -08002218 // Check whether touches should slip outside of the current foreground window.
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002219 if (maskedAction == AMOTION_EVENT_ACTION_MOVE && entry.pointerCount == 1 &&
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002220 tempTouchState.isSlippery()) {
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002221 const int32_t x = int32_t(entry.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X));
2222 const int32_t y = int32_t(entry.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y));
Michael Wrightd02c5b62014-02-10 15:10:22 -08002223
Prabir Pradhand65552b2021-10-07 11:23:50 -07002224 const bool isStylus = isPointerFromStylus(entry, 0 /*pointerIndex*/);
chaviw98318de2021-05-19 16:45:23 -05002225 sp<WindowInfoHandle> oldTouchedWindowHandle =
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002226 tempTouchState.getFirstForegroundWindowHandle();
Prabir Pradhand65552b2021-10-07 11:23:50 -07002227 newTouchedWindowHandle =
2228 findTouchedWindowAtLocked(displayId, x, y, &tempTouchState, isStylus);
Vishnu Nair062a8672021-09-03 16:07:44 -07002229
Prabir Pradhan8a2b1a42022-04-11 17:23:34 +00002230 // Verify targeted injection.
2231 if (const auto err = verifyTargetedInjection(newTouchedWindowHandle, entry); err) {
2232 ALOGW("Dropping injected event: %s", (*err).c_str());
2233 injectionResult = os::InputEventInjectionResult::TARGET_MISMATCH;
2234 newTouchedWindowHandle = nullptr;
2235 goto Failed;
2236 }
2237
Vishnu Nair062a8672021-09-03 16:07:44 -07002238 // Drop touch events if requested by input feature
2239 if (newTouchedWindowHandle != nullptr &&
2240 shouldDropInput(entry, newTouchedWindowHandle)) {
2241 newTouchedWindowHandle = nullptr;
2242 }
2243
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002244 if (oldTouchedWindowHandle != newTouchedWindowHandle &&
2245 oldTouchedWindowHandle != nullptr && newTouchedWindowHandle != nullptr) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01002246 if (DEBUG_FOCUS) {
2247 ALOGD("Touch is slipping out of window %s into window %s in display %" PRId32,
2248 oldTouchedWindowHandle->getName().c_str(),
2249 newTouchedWindowHandle->getName().c_str(), displayId);
2250 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002251 // Make a slippery exit from the old window.
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002252 tempTouchState.addOrUpdateWindow(oldTouchedWindowHandle,
2253 InputTarget::FLAG_DISPATCH_AS_SLIPPERY_EXIT,
2254 BitSet32(0));
Michael Wrightd02c5b62014-02-10 15:10:22 -08002255
2256 // Make a slippery entrance into the new window.
2257 if (newTouchedWindowHandle->getInfo()->supportsSplitTouch()) {
Prabir Pradhan713bb3e2021-12-20 02:07:40 -08002258 isSplit = !isFromMouse;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002259 }
2260
Prabir Pradhan6dfbf262022-03-14 15:24:30 +00002261 int32_t targetFlags = InputTarget::FLAG_DISPATCH_AS_SLIPPERY_ENTER;
2262 if (canReceiveForegroundTouches(*newTouchedWindowHandle->getInfo())) {
2263 targetFlags |= InputTarget::FLAG_FOREGROUND;
2264 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002265 if (isSplit) {
2266 targetFlags |= InputTarget::FLAG_SPLIT;
2267 }
2268 if (isWindowObscuredAtPointLocked(newTouchedWindowHandle, x, y)) {
2269 targetFlags |= InputTarget::FLAG_WINDOW_IS_OBSCURED;
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10002270 } else if (isWindowObscuredLocked(newTouchedWindowHandle)) {
2271 targetFlags |= InputTarget::FLAG_WINDOW_IS_PARTIALLY_OBSCURED;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002272 }
2273
2274 BitSet32 pointerIds;
Arthur Hung02701602022-07-15 09:35:36 +00002275 pointerIds.markBit(entry.pointerProperties[0].id);
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002276 tempTouchState.addOrUpdateWindow(newTouchedWindowHandle, targetFlags, pointerIds);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002277 }
2278 }
Arthur Hung45f24342022-11-15 03:30:48 +00002279
2280 // Update the pointerIds for non-splittable when it received pointer down.
2281 if (!isSplit && maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN) {
2282 // If no split, we suppose all touched windows should receive pointer down.
2283 const int32_t pointerIndex = getMotionEventActionPointerIndex(action);
2284 for (size_t i = 0; i < tempTouchState.windows.size(); i++) {
2285 TouchedWindow& touchedWindow = tempTouchState.windows[i];
2286 // Ignore drag window for it should just track one pointer.
2287 if (mDragState && mDragState->dragWindow == touchedWindow.windowHandle) {
2288 continue;
2289 }
2290 touchedWindow.pointerIds.markBit(entry.pointerProperties[pointerIndex].id);
2291 }
2292 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002293 }
2294
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002295 // Update dispatching for hover enter and exit.
Michael Wrightd02c5b62014-02-10 15:10:22 -08002296 if (newHoverWindowHandle != mLastHoverWindowHandle) {
Prabir Pradhan3f90d312021-11-19 03:57:24 -08002297 // Let the previous window know that the hover sequence is over, unless we already did
2298 // it when dispatching it as is to newTouchedWindowHandle.
Garfield Tandf26e862020-07-01 20:18:19 -07002299 if (mLastHoverWindowHandle != nullptr &&
2300 (maskedAction != AMOTION_EVENT_ACTION_HOVER_EXIT ||
2301 mLastHoverWindowHandle != newTouchedWindowHandle)) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00002302 if (DEBUG_HOVER) {
2303 ALOGD("Sending hover exit event to window %s.",
2304 mLastHoverWindowHandle->getName().c_str());
2305 }
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002306 tempTouchState.addOrUpdateWindow(mLastHoverWindowHandle,
2307 InputTarget::FLAG_DISPATCH_AS_HOVER_EXIT, BitSet32(0));
Michael Wrightd02c5b62014-02-10 15:10:22 -08002308 }
2309
Garfield Tandf26e862020-07-01 20:18:19 -07002310 // Let the new window know that the hover sequence is starting, unless we already did it
2311 // when dispatching it as is to newTouchedWindowHandle.
2312 if (newHoverWindowHandle != nullptr &&
2313 (maskedAction != AMOTION_EVENT_ACTION_HOVER_ENTER ||
2314 newHoverWindowHandle != newTouchedWindowHandle)) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00002315 if (DEBUG_HOVER) {
2316 ALOGD("Sending hover enter event to window %s.",
2317 newHoverWindowHandle->getName().c_str());
2318 }
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002319 tempTouchState.addOrUpdateWindow(newHoverWindowHandle,
2320 InputTarget::FLAG_DISPATCH_AS_HOVER_ENTER,
2321 BitSet32(0));
Michael Wrightd02c5b62014-02-10 15:10:22 -08002322 }
2323 }
2324
Prabir Pradhan6dfbf262022-03-14 15:24:30 +00002325 // Ensure that we have at least one foreground window or at least one window that cannot be a
2326 // foreground target. If we only have windows that are not receiving foreground touches (e.g. we
2327 // only have windows getting ACTION_OUTSIDE), then drop the event, because there is no window
2328 // that is actually receiving the entire gesture.
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002329 if (std::none_of(tempTouchState.windows.begin(), tempTouchState.windows.end(),
2330 [](const TouchedWindow& touchedWindow) {
Prabir Pradhan6dfbf262022-03-14 15:24:30 +00002331 return !canReceiveForegroundTouches(
2332 *touchedWindow.windowHandle->getInfo()) ||
2333 (touchedWindow.targetFlags & InputTarget::FLAG_FOREGROUND) != 0;
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002334 })) {
Siarhei Vishniakou1fb18912022-03-08 10:31:39 -08002335 ALOGI("Dropping event because there is no touched window on display %d to receive it: %s",
2336 displayId, entry.getDescription().c_str());
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002337 injectionResult = InputEventInjectionResult::FAILED;
2338 goto Failed;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002339 }
2340
Prabir Pradhan8a2b1a42022-04-11 17:23:34 +00002341 // Ensure that all touched windows are valid for injection.
2342 if (entry.injectionState != nullptr) {
2343 std::string errs;
2344 for (const TouchedWindow& touchedWindow : tempTouchState.windows) {
2345 if (touchedWindow.targetFlags & InputTarget::FLAG_DISPATCH_AS_OUTSIDE) {
2346 // Allow ACTION_OUTSIDE events generated by targeted injection to be
2347 // dispatched to any uid, since the coords will be zeroed out later.
2348 continue;
2349 }
2350 const auto err = verifyTargetedInjection(touchedWindow.windowHandle, entry);
2351 if (err) errs += "\n - " + *err;
2352 }
2353 if (!errs.empty()) {
2354 ALOGW("Dropping targeted injection: At least one touched window is not owned by uid "
2355 "%d:%s",
2356 *entry.injectionState->targetUid, errs.c_str());
2357 injectionResult = InputEventInjectionResult::TARGET_MISMATCH;
2358 goto Failed;
2359 }
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002360 }
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002361
Michael Wrightd02c5b62014-02-10 15:10:22 -08002362 // Check whether windows listening for outside touches are owned by the same UID. If it is
2363 // set the policy flag that we will not reveal coordinate information to this window.
2364 if (maskedAction == AMOTION_EVENT_ACTION_DOWN) {
chaviw98318de2021-05-19 16:45:23 -05002365 sp<WindowInfoHandle> foregroundWindowHandle =
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002366 tempTouchState.getFirstForegroundWindowHandle();
Michael Wright3dd60e22019-03-27 22:06:44 +00002367 if (foregroundWindowHandle) {
2368 const int32_t foregroundWindowUid = foregroundWindowHandle->getInfo()->ownerUid;
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002369 for (const TouchedWindow& touchedWindow : tempTouchState.windows) {
Michael Wright3dd60e22019-03-27 22:06:44 +00002370 if (touchedWindow.targetFlags & InputTarget::FLAG_DISPATCH_AS_OUTSIDE) {
chaviw98318de2021-05-19 16:45:23 -05002371 sp<WindowInfoHandle> windowInfoHandle = touchedWindow.windowHandle;
2372 if (windowInfoHandle->getInfo()->ownerUid != foregroundWindowUid) {
2373 tempTouchState.addOrUpdateWindow(windowInfoHandle,
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002374 InputTarget::FLAG_ZERO_COORDS,
2375 BitSet32(0));
Michael Wright3dd60e22019-03-27 22:06:44 +00002376 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002377 }
2378 }
2379 }
2380 }
2381
Michael Wrightd02c5b62014-02-10 15:10:22 -08002382 // If this is the first pointer going down and the touched window has a wallpaper
2383 // then also add the touched wallpaper windows so they are locked in for the duration
2384 // of the touch gesture.
2385 // We do not collect wallpapers during HOVER_MOVE or SCROLL because the wallpaper
2386 // engine only supports touch events. We would need to add a mechanism similar
2387 // to View.onGenericMotionEvent to enable wallpapers to handle these events.
2388 if (maskedAction == AMOTION_EVENT_ACTION_DOWN) {
chaviw98318de2021-05-19 16:45:23 -05002389 sp<WindowInfoHandle> foregroundWindowHandle =
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002390 tempTouchState.getFirstForegroundWindowHandle();
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08002391 if (foregroundWindowHandle &&
2392 foregroundWindowHandle->getInfo()->inputConfig.test(
2393 WindowInfo::InputConfig::DUPLICATE_TOUCH_TO_WALLPAPER)) {
chaviw98318de2021-05-19 16:45:23 -05002394 const std::vector<sp<WindowInfoHandle>>& windowHandles =
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08002395 getWindowHandlesLocked(displayId);
chaviw98318de2021-05-19 16:45:23 -05002396 for (const sp<WindowInfoHandle>& windowHandle : windowHandles) {
2397 const WindowInfo* info = windowHandle->getInfo();
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002398 if (info->displayId == displayId &&
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08002399 windowHandle->getInfo()->inputConfig.test(
2400 WindowInfo::InputConfig::IS_WALLPAPER)) {
Arthur Hung45f24342022-11-15 03:30:48 +00002401 BitSet32 pointerIds;
2402 pointerIds.markBit(entry.pointerProperties[0].id);
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002403 tempTouchState
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002404 .addOrUpdateWindow(windowHandle,
2405 InputTarget::FLAG_WINDOW_IS_OBSCURED |
2406 InputTarget::
2407 FLAG_WINDOW_IS_PARTIALLY_OBSCURED |
2408 InputTarget::FLAG_DISPATCH_AS_IS,
Arthur Hung45f24342022-11-15 03:30:48 +00002409 pointerIds);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002410 }
2411 }
2412 }
2413 }
2414
2415 // Success! Output targets.
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002416 injectionResult = InputEventInjectionResult::SUCCEEDED;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002417
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002418 for (const TouchedWindow& touchedWindow : tempTouchState.windows) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002419 addWindowTargetLocked(touchedWindow.windowHandle, touchedWindow.targetFlags,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002420 touchedWindow.pointerIds, inputTargets);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002421 }
2422
2423 // Drop the outside or hover touch windows since we will not care about them
2424 // in the next iteration.
Siarhei Vishniakou33eceeb2020-03-24 19:50:03 -07002425 tempTouchState.filterNonAsIsTouchWindows();
Michael Wrightd02c5b62014-02-10 15:10:22 -08002426
2427Failed:
Michael Wrightd02c5b62014-02-10 15:10:22 -08002428 // Update final pieces of touch state if the injector had permission.
Siarhei Vishniakou767917f2020-03-24 20:49:09 -07002429 if (!wrongDevice) {
2430 if (switchedDevice) {
2431 if (DEBUG_FOCUS) {
2432 ALOGD("Conflicting pointer actions: Switched to a different device.");
2433 }
2434 *outConflictingPointerActions = true;
2435 }
2436
2437 if (isHoverAction) {
2438 // Started hovering, therefore no longer down.
2439 if (oldState && oldState->down) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01002440 if (DEBUG_FOCUS) {
Siarhei Vishniakou767917f2020-03-24 20:49:09 -07002441 ALOGD("Conflicting pointer actions: Hover received while pointer was "
2442 "down.");
Siarhei Vishniakou86587282019-09-09 18:20:15 +01002443 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002444 *outConflictingPointerActions = true;
2445 }
Siarhei Vishniakou767917f2020-03-24 20:49:09 -07002446 tempTouchState.reset();
2447 if (maskedAction == AMOTION_EVENT_ACTION_HOVER_ENTER ||
2448 maskedAction == AMOTION_EVENT_ACTION_HOVER_MOVE) {
2449 tempTouchState.deviceId = entry.deviceId;
2450 tempTouchState.source = entry.source;
2451 tempTouchState.displayId = displayId;
2452 }
2453 } else if (maskedAction == AMOTION_EVENT_ACTION_UP ||
2454 maskedAction == AMOTION_EVENT_ACTION_CANCEL) {
2455 // All pointers up or canceled.
2456 tempTouchState.reset();
2457 } else if (maskedAction == AMOTION_EVENT_ACTION_DOWN) {
2458 // First pointer went down.
2459 if (oldState && oldState->down) {
2460 if (DEBUG_FOCUS) {
2461 ALOGD("Conflicting pointer actions: Down received while already down.");
2462 }
2463 *outConflictingPointerActions = true;
2464 }
2465 } else if (maskedAction == AMOTION_EVENT_ACTION_POINTER_UP) {
2466 // One pointer went up.
Arthur Hung02701602022-07-15 09:35:36 +00002467 int32_t pointerIndex = getMotionEventActionPointerIndex(action);
2468 uint32_t pointerId = entry.pointerProperties[pointerIndex].id;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002469
Arthur Hung02701602022-07-15 09:35:36 +00002470 for (size_t i = 0; i < tempTouchState.windows.size();) {
2471 TouchedWindow& touchedWindow = tempTouchState.windows[i];
2472 touchedWindow.pointerIds.clearBit(pointerId);
2473 if (touchedWindow.pointerIds.isEmpty()) {
2474 tempTouchState.windows.erase(tempTouchState.windows.begin() + i);
2475 continue;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002476 }
Arthur Hung02701602022-07-15 09:35:36 +00002477 i += 1;
2478 }
Siarhei Vishniakou767917f2020-03-24 20:49:09 -07002479 }
Jeff Brownf086ddb2014-02-11 14:28:48 -08002480
Siarhei Vishniakou767917f2020-03-24 20:49:09 -07002481 // Save changes unless the action was scroll in which case the temporary touch
2482 // state was only valid for this one action.
2483 if (maskedAction != AMOTION_EVENT_ACTION_SCROLL) {
2484 if (tempTouchState.displayId >= 0) {
2485 mTouchStatesByDisplay[displayId] = tempTouchState;
2486 } else {
2487 mTouchStatesByDisplay.erase(displayId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002488 }
Siarhei Vishniakou767917f2020-03-24 20:49:09 -07002489 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002490
Siarhei Vishniakou767917f2020-03-24 20:49:09 -07002491 // Update hover state.
2492 mLastHoverWindowHandle = newHoverWindowHandle;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002493 }
2494
Michael Wrightd02c5b62014-02-10 15:10:22 -08002495 return injectionResult;
2496}
2497
arthurhung6d4bed92021-03-17 11:59:33 +08002498void InputDispatcher::finishDragAndDrop(int32_t displayId, float x, float y) {
Prabir Pradhand65552b2021-10-07 11:23:50 -07002499 // Prevent stylus interceptor windows from affecting drag and drop behavior for now, until we
2500 // have an explicit reason to support it.
2501 constexpr bool isStylus = false;
2502
chaviw98318de2021-05-19 16:45:23 -05002503 const sp<WindowInfoHandle> dropWindow =
Prabir Pradhand65552b2021-10-07 11:23:50 -07002504 findTouchedWindowAtLocked(displayId, x, y, nullptr /*touchState*/, isStylus,
Siarhei Vishniakou64452932020-11-06 17:51:32 -06002505 false /*addOutsideTargets*/, true /*ignoreDragWindow*/);
arthurhung6d4bed92021-03-17 11:59:33 +08002506 if (dropWindow) {
2507 vec2 local = dropWindow->getInfo()->transform.transform(x, y);
Prabir Pradhancef936d2021-07-21 16:17:52 +00002508 sendDropWindowCommandLocked(dropWindow->getToken(), local.x, local.y);
Arthur Hung6d0571e2021-04-09 20:18:16 +08002509 } else {
Arthur Hung54745652022-04-20 07:17:41 +00002510 ALOGW("No window found when drop.");
Prabir Pradhancef936d2021-07-21 16:17:52 +00002511 sendDropWindowCommandLocked(nullptr, 0, 0);
arthurhung6d4bed92021-03-17 11:59:33 +08002512 }
2513 mDragState.reset();
2514}
2515
2516void InputDispatcher::addDragEventLocked(const MotionEntry& entry) {
Arthur Hung3915c1f2022-05-31 07:17:17 +00002517 if (!mDragState || mDragState->dragWindow->getInfo()->displayId != entry.displayId) {
arthurhungb89ccb02020-12-30 16:19:01 +08002518 return;
2519 }
2520
arthurhung6d4bed92021-03-17 11:59:33 +08002521 if (!mDragState->isStartDrag) {
2522 mDragState->isStartDrag = true;
2523 mDragState->isStylusButtonDownAtStart =
2524 (entry.buttonState & AMOTION_EVENT_BUTTON_STYLUS_PRIMARY) != 0;
2525 }
2526
Arthur Hung54745652022-04-20 07:17:41 +00002527 // Find the pointer index by id.
2528 int32_t pointerIndex = 0;
2529 for (; static_cast<uint32_t>(pointerIndex) < entry.pointerCount; pointerIndex++) {
2530 const PointerProperties& pointerProperties = entry.pointerProperties[pointerIndex];
2531 if (pointerProperties.id == mDragState->pointerId) {
2532 break;
arthurhung6d4bed92021-03-17 11:59:33 +08002533 }
Arthur Hung54745652022-04-20 07:17:41 +00002534 }
arthurhung6d4bed92021-03-17 11:59:33 +08002535
Arthur Hung54745652022-04-20 07:17:41 +00002536 if (uint32_t(pointerIndex) == entry.pointerCount) {
2537 LOG_ALWAYS_FATAL("Should find a valid pointer index by id %d", mDragState->pointerId);
Prabir Pradhancef936d2021-07-21 16:17:52 +00002538 sendDropWindowCommandLocked(nullptr, 0, 0);
arthurhung6d4bed92021-03-17 11:59:33 +08002539 mDragState.reset();
Arthur Hung54745652022-04-20 07:17:41 +00002540 return;
2541 }
2542
2543 const int32_t maskedAction = entry.action & AMOTION_EVENT_ACTION_MASK;
2544 const int32_t x = entry.pointerCoords[pointerIndex].getX();
2545 const int32_t y = entry.pointerCoords[pointerIndex].getY();
2546
2547 switch (maskedAction) {
2548 case AMOTION_EVENT_ACTION_MOVE: {
2549 // Handle the special case : stylus button no longer pressed.
2550 bool isStylusButtonDown =
2551 (entry.buttonState & AMOTION_EVENT_BUTTON_STYLUS_PRIMARY) != 0;
2552 if (mDragState->isStylusButtonDownAtStart && !isStylusButtonDown) {
2553 finishDragAndDrop(entry.displayId, x, y);
2554 return;
2555 }
2556
2557 // Prevent stylus interceptor windows from affecting drag and drop behavior for now,
2558 // until we have an explicit reason to support it.
2559 constexpr bool isStylus = false;
2560
2561 const sp<WindowInfoHandle> hoverWindowHandle =
2562 findTouchedWindowAtLocked(entry.displayId, x, y, nullptr /*touchState*/,
2563 isStylus, false /*addOutsideTargets*/,
2564 true /*ignoreDragWindow*/);
2565 // enqueue drag exit if needed.
2566 if (hoverWindowHandle != mDragState->dragHoverWindowHandle &&
2567 !haveSameToken(hoverWindowHandle, mDragState->dragHoverWindowHandle)) {
2568 if (mDragState->dragHoverWindowHandle != nullptr) {
2569 enqueueDragEventLocked(mDragState->dragHoverWindowHandle, true /*isExiting*/, x,
2570 y);
2571 }
2572 mDragState->dragHoverWindowHandle = hoverWindowHandle;
2573 }
2574 // enqueue drag location if needed.
2575 if (hoverWindowHandle != nullptr) {
2576 enqueueDragEventLocked(hoverWindowHandle, false /*isExiting*/, x, y);
2577 }
2578 break;
2579 }
2580
2581 case AMOTION_EVENT_ACTION_POINTER_UP:
2582 if (getMotionEventActionPointerIndex(entry.action) != pointerIndex) {
2583 break;
2584 }
2585 // The drag pointer is up.
2586 [[fallthrough]];
2587 case AMOTION_EVENT_ACTION_UP:
2588 finishDragAndDrop(entry.displayId, x, y);
2589 break;
2590 case AMOTION_EVENT_ACTION_CANCEL: {
2591 ALOGD("Receiving cancel when drag and drop.");
2592 sendDropWindowCommandLocked(nullptr, 0, 0);
2593 mDragState.reset();
2594 break;
2595 }
arthurhungb89ccb02020-12-30 16:19:01 +08002596 }
2597}
2598
chaviw98318de2021-05-19 16:45:23 -05002599void InputDispatcher::addWindowTargetLocked(const sp<WindowInfoHandle>& windowHandle,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002600 int32_t targetFlags, BitSet32 pointerIds,
2601 std::vector<InputTarget>& inputTargets) {
Chavi Weingarten65f98b82020-01-16 18:56:50 +00002602 std::vector<InputTarget>::iterator it =
2603 std::find_if(inputTargets.begin(), inputTargets.end(),
2604 [&windowHandle](const InputTarget& inputTarget) {
2605 return inputTarget.inputChannel->getConnectionToken() ==
2606 windowHandle->getToken();
2607 });
Chavi Weingarten97b8eec2020-01-09 18:09:08 +00002608
chaviw98318de2021-05-19 16:45:23 -05002609 const WindowInfo* windowInfo = windowHandle->getInfo();
Chavi Weingarten65f98b82020-01-16 18:56:50 +00002610
2611 if (it == inputTargets.end()) {
2612 InputTarget inputTarget;
Siarhei Vishniakouce5ab082020-07-09 17:03:21 -05002613 std::shared_ptr<InputChannel> inputChannel =
2614 getInputChannelLocked(windowHandle->getToken());
Chavi Weingarten65f98b82020-01-16 18:56:50 +00002615 if (inputChannel == nullptr) {
2616 ALOGW("Window %s already unregistered input channel", windowHandle->getName().c_str());
2617 return;
2618 }
2619 inputTarget.inputChannel = inputChannel;
2620 inputTarget.flags = targetFlags;
2621 inputTarget.globalScaleFactor = windowInfo->globalScaleFactor;
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07002622 const auto& displayInfoIt = mDisplayInfos.find(windowInfo->displayId);
2623 if (displayInfoIt != mDisplayInfos.end()) {
Prabir Pradhanb9b18502021-08-26 12:30:32 -07002624 inputTarget.displayTransform = displayInfoIt->second.transform;
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07002625 } else {
Prabir Pradhan8b89c2f2021-07-29 16:30:14 +00002626 ALOGE("DisplayInfo not found for window on display: %d", windowInfo->displayId);
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07002627 }
Chavi Weingarten65f98b82020-01-16 18:56:50 +00002628 inputTargets.push_back(inputTarget);
2629 it = inputTargets.end() - 1;
2630 }
2631
2632 ALOG_ASSERT(it->flags == targetFlags);
2633 ALOG_ASSERT(it->globalScaleFactor == windowInfo->globalScaleFactor);
2634
chaviw1ff3d1e2020-07-01 15:53:47 -07002635 it->addPointers(pointerIds, windowInfo->transform);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002636}
2637
Michael Wright3dd60e22019-03-27 22:06:44 +00002638void InputDispatcher::addGlobalMonitoringTargetsLocked(std::vector<InputTarget>& inputTargets,
Prabir Pradhan0a99c922021-09-03 08:27:53 -07002639 int32_t displayId) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002640 auto monitorsIt = mGlobalMonitorsByDisplay.find(displayId);
2641 if (monitorsIt == mGlobalMonitorsByDisplay.end()) return;
Michael Wright3dd60e22019-03-27 22:06:44 +00002642
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002643 for (const Monitor& monitor : selectResponsiveMonitorsLocked(monitorsIt->second)) {
2644 InputTarget target;
2645 target.inputChannel = monitor.inputChannel;
2646 target.flags = InputTarget::FLAG_DISPATCH_AS_IS;
2647 if (const auto& it = mDisplayInfos.find(displayId); it != mDisplayInfos.end()) {
2648 target.displayTransform = it->second.transform;
Arthur Hung2fbf37f2018-09-13 18:16:41 +08002649 }
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08002650 target.setDefaultPointerTransform(target.displayTransform);
2651 inputTargets.push_back(target);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002652 }
2653}
2654
Robert Carrc9bf1d32020-04-13 17:21:08 -07002655/**
2656 * Indicate whether one window handle should be considered as obscuring
2657 * another window handle. We only check a few preconditions. Actually
2658 * checking the bounds is left to the caller.
2659 */
chaviw98318de2021-05-19 16:45:23 -05002660static bool canBeObscuredBy(const sp<WindowInfoHandle>& windowHandle,
2661 const sp<WindowInfoHandle>& otherHandle) {
Robert Carrc9bf1d32020-04-13 17:21:08 -07002662 // Compare by token so cloned layers aren't counted
2663 if (haveSameToken(windowHandle, otherHandle)) {
2664 return false;
2665 }
2666 auto info = windowHandle->getInfo();
2667 auto otherInfo = otherHandle->getInfo();
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08002668 if (otherInfo->inputConfig.test(WindowInfo::InputConfig::NOT_VISIBLE)) {
Robert Carrc9bf1d32020-04-13 17:21:08 -07002669 return false;
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08002670 } else if (otherInfo->alpha == 0 &&
2671 otherInfo->inputConfig.test(WindowInfo::InputConfig::NOT_TOUCHABLE)) {
Bernardo Rufino653d2e02020-10-20 17:32:40 +00002672 // Those act as if they were invisible, so we don't need to flag them.
2673 // We do want to potentially flag touchable windows even if they have 0
2674 // opacity, since they can consume touches and alter the effects of the
2675 // user interaction (eg. apps that rely on
2676 // FLAG_WINDOW_IS_PARTIALLY_OBSCURED should still be told about those
2677 // windows), hence we also check for FLAG_NOT_TOUCHABLE.
2678 return false;
Bernardo Rufino8007daf2020-09-22 09:40:01 +00002679 } else if (info->ownerUid == otherInfo->ownerUid) {
2680 // If ownerUid is the same we don't generate occlusion events as there
2681 // is no security boundary within an uid.
Robert Carrc9bf1d32020-04-13 17:21:08 -07002682 return false;
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08002683 } else if (otherInfo->inputConfig.test(gui::WindowInfo::InputConfig::TRUSTED_OVERLAY)) {
Robert Carrc9bf1d32020-04-13 17:21:08 -07002684 return false;
2685 } else if (otherInfo->displayId != info->displayId) {
2686 return false;
2687 }
2688 return true;
2689}
2690
Bernardo Rufinoea97d182020-08-19 14:43:14 +01002691/**
2692 * Returns touch occlusion information in the form of TouchOcclusionInfo. To check if the touch is
2693 * untrusted, one should check:
2694 *
2695 * 1. If result.hasBlockingOcclusion is true.
2696 * If it's, it means the touch should be blocked due to a window with occlusion mode of
2697 * BLOCK_UNTRUSTED.
2698 *
2699 * 2. If result.obscuringOpacity > mMaximumObscuringOpacityForTouch.
2700 * If it is (and 1 is false), then the touch should be blocked because a stack of windows
2701 * (possibly only one) with occlusion mode of USE_OPACITY from one UID resulted in a composed
2702 * obscuring opacity above the threshold. Note that if there was no window of occlusion mode
2703 * USE_OPACITY, result.obscuringOpacity would've been 0 and since
2704 * mMaximumObscuringOpacityForTouch >= 0, the condition above would never be true.
2705 *
2706 * If neither of those is true, then it means the touch can be allowed.
2707 */
2708InputDispatcher::TouchOcclusionInfo InputDispatcher::computeTouchOcclusionInfoLocked(
chaviw98318de2021-05-19 16:45:23 -05002709 const sp<WindowInfoHandle>& windowHandle, int32_t x, int32_t y) const {
2710 const WindowInfo* windowInfo = windowHandle->getInfo();
Bernardo Rufino4bae0ac2020-10-14 18:33:46 +00002711 int32_t displayId = windowInfo->displayId;
chaviw98318de2021-05-19 16:45:23 -05002712 const std::vector<sp<WindowInfoHandle>>& windowHandles = getWindowHandlesLocked(displayId);
Bernardo Rufinoea97d182020-08-19 14:43:14 +01002713 TouchOcclusionInfo info;
2714 info.hasBlockingOcclusion = false;
2715 info.obscuringOpacity = 0;
2716 info.obscuringUid = -1;
2717 std::map<int32_t, float> opacityByUid;
chaviw98318de2021-05-19 16:45:23 -05002718 for (const sp<WindowInfoHandle>& otherHandle : windowHandles) {
Bernardo Rufinoea97d182020-08-19 14:43:14 +01002719 if (windowHandle == otherHandle) {
2720 break; // All future windows are below us. Exit early.
2721 }
chaviw98318de2021-05-19 16:45:23 -05002722 const WindowInfo* otherInfo = otherHandle->getInfo();
Bernardo Rufino1ff9d592021-01-18 16:58:57 +00002723 if (canBeObscuredBy(windowHandle, otherHandle) && otherInfo->frameContainsPoint(x, y) &&
2724 !haveSameApplicationToken(windowInfo, otherInfo)) {
Bernardo Rufino4bae0ac2020-10-14 18:33:46 +00002725 if (DEBUG_TOUCH_OCCLUSION) {
2726 info.debugInfo.push_back(
2727 dumpWindowForTouchOcclusion(otherInfo, /* isTouchedWindow */ false));
2728 }
Bernardo Rufinoea97d182020-08-19 14:43:14 +01002729 // canBeObscuredBy() has returned true above, which means this window is untrusted, so
2730 // we perform the checks below to see if the touch can be propagated or not based on the
2731 // window's touch occlusion mode
2732 if (otherInfo->touchOcclusionMode == TouchOcclusionMode::BLOCK_UNTRUSTED) {
2733 info.hasBlockingOcclusion = true;
2734 info.obscuringUid = otherInfo->ownerUid;
2735 info.obscuringPackage = otherInfo->packageName;
2736 break;
2737 }
2738 if (otherInfo->touchOcclusionMode == TouchOcclusionMode::USE_OPACITY) {
2739 uint32_t uid = otherInfo->ownerUid;
2740 float opacity =
2741 (opacityByUid.find(uid) == opacityByUid.end()) ? 0 : opacityByUid[uid];
2742 // Given windows A and B:
2743 // opacity(A, B) = 1 - [1 - opacity(A)] * [1 - opacity(B)]
2744 opacity = 1 - (1 - opacity) * (1 - otherInfo->alpha);
2745 opacityByUid[uid] = opacity;
2746 if (opacity > info.obscuringOpacity) {
2747 info.obscuringOpacity = opacity;
2748 info.obscuringUid = uid;
2749 info.obscuringPackage = otherInfo->packageName;
2750 }
2751 }
2752 }
2753 }
Bernardo Rufino4bae0ac2020-10-14 18:33:46 +00002754 if (DEBUG_TOUCH_OCCLUSION) {
2755 info.debugInfo.push_back(
2756 dumpWindowForTouchOcclusion(windowInfo, /* isTouchedWindow */ true));
2757 }
Bernardo Rufinoea97d182020-08-19 14:43:14 +01002758 return info;
2759}
2760
chaviw98318de2021-05-19 16:45:23 -05002761std::string InputDispatcher::dumpWindowForTouchOcclusion(const WindowInfo* info,
Bernardo Rufino4bae0ac2020-10-14 18:33:46 +00002762 bool isTouchedWindow) const {
Prabir Pradhan51e7db02022-02-07 06:02:57 -08002763 return StringPrintf(INDENT2 "* %spackage=%s/%" PRId32 ", id=%" PRId32 ", mode=%s, alpha=%.2f, "
2764 "frame=[%" PRId32 ",%" PRId32 "][%" PRId32 ",%" PRId32
2765 "], touchableRegion=%s, window={%s}, inputConfig={%s}, "
2766 "hasToken=%s, applicationInfo.name=%s, applicationInfo.token=%s\n",
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08002767 isTouchedWindow ? "[TOUCHED] " : "", info->packageName.c_str(),
2768 info->ownerUid, info->id, toString(info->touchOcclusionMode).c_str(),
2769 info->alpha, info->frameLeft, info->frameTop, info->frameRight,
2770 info->frameBottom, dumpRegion(info->touchableRegion).c_str(),
2771 info->name.c_str(), info->inputConfig.string().c_str(),
Prabir Pradhan51e7db02022-02-07 06:02:57 -08002772 toString(info->token != nullptr), info->applicationInfo.name.c_str(),
Bernardo Rufino49d99e42021-01-18 15:16:59 +00002773 toString(info->applicationInfo.token).c_str());
Bernardo Rufino4bae0ac2020-10-14 18:33:46 +00002774}
2775
Bernardo Rufinoea97d182020-08-19 14:43:14 +01002776bool InputDispatcher::isTouchTrustedLocked(const TouchOcclusionInfo& occlusionInfo) const {
2777 if (occlusionInfo.hasBlockingOcclusion) {
2778 ALOGW("Untrusted touch due to occlusion by %s/%d", occlusionInfo.obscuringPackage.c_str(),
2779 occlusionInfo.obscuringUid);
2780 return false;
2781 }
2782 if (occlusionInfo.obscuringOpacity > mMaximumObscuringOpacityForTouch) {
2783 ALOGW("Untrusted touch due to occlusion by %s/%d (obscuring opacity = "
2784 "%.2f, maximum allowed = %.2f)",
2785 occlusionInfo.obscuringPackage.c_str(), occlusionInfo.obscuringUid,
2786 occlusionInfo.obscuringOpacity, mMaximumObscuringOpacityForTouch);
2787 return false;
2788 }
2789 return true;
2790}
2791
chaviw98318de2021-05-19 16:45:23 -05002792bool InputDispatcher::isWindowObscuredAtPointLocked(const sp<WindowInfoHandle>& windowHandle,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002793 int32_t x, int32_t y) const {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002794 int32_t displayId = windowHandle->getInfo()->displayId;
chaviw98318de2021-05-19 16:45:23 -05002795 const std::vector<sp<WindowInfoHandle>>& windowHandles = getWindowHandlesLocked(displayId);
2796 for (const sp<WindowInfoHandle>& otherHandle : windowHandles) {
Robert Carrc9bf1d32020-04-13 17:21:08 -07002797 if (windowHandle == otherHandle) {
2798 break; // All future windows are below us. Exit early.
Michael Wrightd02c5b62014-02-10 15:10:22 -08002799 }
chaviw98318de2021-05-19 16:45:23 -05002800 const WindowInfo* otherInfo = otherHandle->getInfo();
Robert Carrc9bf1d32020-04-13 17:21:08 -07002801 if (canBeObscuredBy(windowHandle, otherHandle) &&
minchelif28cc4e2020-03-19 11:18:11 +08002802 otherInfo->frameContainsPoint(x, y)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002803 return true;
2804 }
2805 }
2806 return false;
2807}
2808
chaviw98318de2021-05-19 16:45:23 -05002809bool InputDispatcher::isWindowObscuredLocked(const sp<WindowInfoHandle>& windowHandle) const {
Michael Wrightcdcd8f22016-03-22 16:52:13 -07002810 int32_t displayId = windowHandle->getInfo()->displayId;
chaviw98318de2021-05-19 16:45:23 -05002811 const std::vector<sp<WindowInfoHandle>>& windowHandles = getWindowHandlesLocked(displayId);
2812 const WindowInfo* windowInfo = windowHandle->getInfo();
2813 for (const sp<WindowInfoHandle>& otherHandle : windowHandles) {
Robert Carrc9bf1d32020-04-13 17:21:08 -07002814 if (windowHandle == otherHandle) {
2815 break; // All future windows are below us. Exit early.
Michael Wrightcdcd8f22016-03-22 16:52:13 -07002816 }
chaviw98318de2021-05-19 16:45:23 -05002817 const WindowInfo* otherInfo = otherHandle->getInfo();
Robert Carrc9bf1d32020-04-13 17:21:08 -07002818 if (canBeObscuredBy(windowHandle, otherHandle) &&
minchelif28cc4e2020-03-19 11:18:11 +08002819 otherInfo->overlaps(windowInfo)) {
Michael Wrightcdcd8f22016-03-22 16:52:13 -07002820 return true;
2821 }
2822 }
2823 return false;
2824}
2825
Siarhei Vishniakou61291d42019-02-11 18:13:20 -08002826std::string InputDispatcher::getApplicationWindowLabel(
chaviw98318de2021-05-19 16:45:23 -05002827 const InputApplicationHandle* applicationHandle, const sp<WindowInfoHandle>& windowHandle) {
Yi Kong9b14ac62018-07-17 13:48:38 -07002828 if (applicationHandle != nullptr) {
2829 if (windowHandle != nullptr) {
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07002830 return applicationHandle->getName() + " - " + windowHandle->getName();
Michael Wrightd02c5b62014-02-10 15:10:22 -08002831 } else {
2832 return applicationHandle->getName();
2833 }
Yi Kong9b14ac62018-07-17 13:48:38 -07002834 } else if (windowHandle != nullptr) {
Siarhei Vishniakou850ce122020-05-26 22:39:43 -07002835 return windowHandle->getInfo()->applicationInfo.name + " - " + windowHandle->getName();
Michael Wrightd02c5b62014-02-10 15:10:22 -08002836 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002837 return "<unknown application or window>";
Michael Wrightd02c5b62014-02-10 15:10:22 -08002838 }
2839}
2840
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002841void InputDispatcher::pokeUserActivityLocked(const EventEntry& eventEntry) {
Antonio Kantekf16f2832021-09-28 04:39:20 +00002842 if (!isUserActivityEvent(eventEntry)) {
2843 // Not poking user activity if the event type does not represent a user activity
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01002844 return;
2845 }
Tiger Huang721e26f2018-07-24 22:26:19 +08002846 int32_t displayId = getTargetDisplayId(eventEntry);
chaviw98318de2021-05-19 16:45:23 -05002847 sp<WindowInfoHandle> focusedWindowHandle = getFocusedWindowHandleLocked(displayId);
Tiger Huang721e26f2018-07-24 22:26:19 +08002848 if (focusedWindowHandle != nullptr) {
chaviw98318de2021-05-19 16:45:23 -05002849 const WindowInfo* info = focusedWindowHandle->getInfo();
Prabir Pradhan51e7db02022-02-07 06:02:57 -08002850 if (info->inputConfig.test(WindowInfo::InputConfig::DISABLE_USER_ACTIVITY)) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00002851 if (DEBUG_DISPATCH_CYCLE) {
2852 ALOGD("Not poking user activity: disabled by window '%s'.", info->name.c_str());
2853 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002854 return;
2855 }
2856 }
2857
2858 int32_t eventType = USER_ACTIVITY_EVENT_OTHER;
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002859 switch (eventEntry.type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07002860 case EventEntry::Type::MOTION: {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002861 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(eventEntry);
2862 if (motionEntry.action == AMOTION_EVENT_ACTION_CANCEL) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002863 return;
2864 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002865
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002866 if (MotionEvent::isTouchEvent(motionEntry.source, motionEntry.action)) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002867 eventType = USER_ACTIVITY_EVENT_TOUCH;
2868 }
2869 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002870 }
Siarhei Vishniakou49483272019-10-22 13:13:47 -07002871 case EventEntry::Type::KEY: {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002872 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(eventEntry);
2873 if (keyEntry.flags & AKEY_EVENT_FLAG_CANCELED) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002874 return;
2875 }
2876 eventType = USER_ACTIVITY_EVENT_BUTTON;
2877 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002878 }
Antonio Kantekf16f2832021-09-28 04:39:20 +00002879 default: {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07002880 LOG_ALWAYS_FATAL("%s events are not user activity",
Dominik Laskowski75788452021-02-09 18:51:25 -08002881 ftl::enum_string(eventEntry.type).c_str());
Siarhei Vishniakou49483272019-10-22 13:13:47 -07002882 break;
2883 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002884 }
2885
Prabir Pradhancef936d2021-07-21 16:17:52 +00002886 auto command = [this, eventTime = eventEntry.eventTime, eventType, displayId]()
2887 REQUIRES(mLock) {
2888 scoped_unlock unlock(mLock);
2889 mPolicy->pokeUserActivity(eventTime, eventType, displayId);
2890 };
2891 postCommandLocked(std::move(command));
Michael Wrightd02c5b62014-02-10 15:10:22 -08002892}
2893
2894void InputDispatcher::prepareDispatchCycleLocked(nsecs_t currentTime,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002895 const sp<Connection>& connection,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07002896 std::shared_ptr<EventEntry> eventEntry,
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08002897 const InputTarget& inputTarget) {
Michael Wright3dd60e22019-03-27 22:06:44 +00002898 if (ATRACE_ENABLED()) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002899 std::string message =
Garfield Tanff1f1bb2020-01-28 13:24:04 -08002900 StringPrintf("prepareDispatchCycleLocked(inputChannel=%s, id=0x%" PRIx32 ")",
Garfield Tan6a5a14e2020-01-28 13:24:04 -08002901 connection->getInputChannelName().c_str(), eventEntry->id);
Michael Wright3dd60e22019-03-27 22:06:44 +00002902 ATRACE_NAME(message.c_str());
2903 }
Prabir Pradhan61a5d242021-07-26 16:41:09 +00002904 if (DEBUG_DISPATCH_CYCLE) {
2905 ALOGD("channel '%s' ~ prepareDispatchCycle - flags=0x%08x, "
2906 "globalScaleFactor=%f, pointerIds=0x%x %s",
2907 connection->getInputChannelName().c_str(), inputTarget.flags,
2908 inputTarget.globalScaleFactor, inputTarget.pointerIds.value,
2909 inputTarget.getPointerInfoString().c_str());
2910 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002911
2912 // Skip this event if the connection status is not normal.
2913 // We don't want to enqueue additional outbound events if the connection is broken.
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08002914 if (connection->status != Connection::Status::NORMAL) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00002915 if (DEBUG_DISPATCH_CYCLE) {
2916 ALOGD("channel '%s' ~ Dropping event because the channel status is %s",
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08002917 connection->getInputChannelName().c_str(),
2918 ftl::enum_string(connection->status).c_str());
Prabir Pradhan61a5d242021-07-26 16:41:09 +00002919 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002920 return;
2921 }
2922
2923 // Split a motion event if needed.
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08002924 if (inputTarget.flags & InputTarget::FLAG_SPLIT) {
2925 LOG_ALWAYS_FATAL_IF(eventEntry->type != EventEntry::Type::MOTION,
2926 "Entry type %s should not have FLAG_SPLIT",
Dominik Laskowski75788452021-02-09 18:51:25 -08002927 ftl::enum_string(eventEntry->type).c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08002928
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002929 const MotionEntry& originalMotionEntry = static_cast<const MotionEntry&>(*eventEntry);
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08002930 if (inputTarget.pointerIds.count() != originalMotionEntry.pointerCount) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07002931 std::unique_ptr<MotionEntry> splitMotionEntry =
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08002932 splitMotionEvent(originalMotionEntry, inputTarget.pointerIds);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002933 if (!splitMotionEntry) {
2934 return; // split event was dropped
2935 }
Arthur Hungb3307ee2021-10-14 10:57:37 +00002936 if (splitMotionEntry->action == AMOTION_EVENT_ACTION_CANCEL) {
2937 std::string reason = std::string("reason=pointer cancel on split window");
2938 android_log_event_list(LOGTAG_INPUT_CANCEL)
2939 << connection->getInputChannelName().c_str() << reason << LOG_ID_EVENTS;
2940 }
Siarhei Vishniakou86587282019-09-09 18:20:15 +01002941 if (DEBUG_FOCUS) {
2942 ALOGD("channel '%s' ~ Split motion event.",
2943 connection->getInputChannelName().c_str());
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07002944 logOutboundMotionDetails(" ", *splitMotionEntry);
Siarhei Vishniakou86587282019-09-09 18:20:15 +01002945 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07002946 enqueueDispatchEntriesLocked(currentTime, connection, std::move(splitMotionEntry),
2947 inputTarget);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002948 return;
2949 }
2950 }
2951
2952 // Not splitting. Enqueue dispatch entries for the event as is.
2953 enqueueDispatchEntriesLocked(currentTime, connection, eventEntry, inputTarget);
2954}
2955
2956void InputDispatcher::enqueueDispatchEntriesLocked(nsecs_t currentTime,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002957 const sp<Connection>& connection,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07002958 std::shared_ptr<EventEntry> eventEntry,
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08002959 const InputTarget& inputTarget) {
Michael Wright3dd60e22019-03-27 22:06:44 +00002960 if (ATRACE_ENABLED()) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002961 std::string message =
Garfield Tanff1f1bb2020-01-28 13:24:04 -08002962 StringPrintf("enqueueDispatchEntriesLocked(inputChannel=%s, id=0x%" PRIx32 ")",
Garfield Tan6a5a14e2020-01-28 13:24:04 -08002963 connection->getInputChannelName().c_str(), eventEntry->id);
Michael Wright3dd60e22019-03-27 22:06:44 +00002964 ATRACE_NAME(message.c_str());
2965 }
2966
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07002967 bool wasEmpty = connection->outboundQueue.empty();
Michael Wrightd02c5b62014-02-10 15:10:22 -08002968
2969 // Enqueue dispatch entries for the requested modes.
chaviw8c9cf542019-03-25 13:02:48 -07002970 enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002971 InputTarget::FLAG_DISPATCH_AS_HOVER_EXIT);
chaviw8c9cf542019-03-25 13:02:48 -07002972 enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002973 InputTarget::FLAG_DISPATCH_AS_OUTSIDE);
chaviw8c9cf542019-03-25 13:02:48 -07002974 enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002975 InputTarget::FLAG_DISPATCH_AS_HOVER_ENTER);
chaviw8c9cf542019-03-25 13:02:48 -07002976 enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002977 InputTarget::FLAG_DISPATCH_AS_IS);
chaviw8c9cf542019-03-25 13:02:48 -07002978 enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002979 InputTarget::FLAG_DISPATCH_AS_SLIPPERY_EXIT);
chaviw8c9cf542019-03-25 13:02:48 -07002980 enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002981 InputTarget::FLAG_DISPATCH_AS_SLIPPERY_ENTER);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002982
2983 // If the outbound queue was previously empty, start the dispatch cycle going.
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07002984 if (wasEmpty && !connection->outboundQueue.empty()) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002985 startDispatchCycleLocked(currentTime, connection);
2986 }
2987}
2988
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002989void InputDispatcher::enqueueDispatchEntryLocked(const sp<Connection>& connection,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07002990 std::shared_ptr<EventEntry> eventEntry,
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08002991 const InputTarget& inputTarget,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002992 int32_t dispatchMode) {
Michael Wright3dd60e22019-03-27 22:06:44 +00002993 if (ATRACE_ENABLED()) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07002994 std::string message = StringPrintf("enqueueDispatchEntry(inputChannel=%s, dispatchMode=%s)",
2995 connection->getInputChannelName().c_str(),
2996 dispatchModeToString(dispatchMode).c_str());
Michael Wright3dd60e22019-03-27 22:06:44 +00002997 ATRACE_NAME(message.c_str());
2998 }
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08002999 int32_t inputTargetFlags = inputTarget.flags;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003000 if (!(inputTargetFlags & dispatchMode)) {
3001 return;
3002 }
3003 inputTargetFlags = (inputTargetFlags & ~InputTarget::FLAG_DISPATCH_MASK) | dispatchMode;
3004
3005 // This is a new event.
3006 // Enqueue a new dispatch entry onto the outbound queue for this connection.
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08003007 std::unique_ptr<DispatchEntry> dispatchEntry =
Chavi Weingarten65f98b82020-01-16 18:56:50 +00003008 createDispatchEntry(inputTarget, eventEntry, inputTargetFlags);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003009
Chavi Weingarten65f98b82020-01-16 18:56:50 +00003010 // Use the eventEntry from dispatchEntry since the entry may have changed and can now be a
3011 // different EventEntry than what was passed in.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003012 EventEntry& newEntry = *(dispatchEntry->eventEntry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003013 // Apply target flags and update the connection's input state.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003014 switch (newEntry.type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003015 case EventEntry::Type::KEY: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003016 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(newEntry);
Garfield Tanff1f1bb2020-01-28 13:24:04 -08003017 dispatchEntry->resolvedEventId = keyEntry.id;
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003018 dispatchEntry->resolvedAction = keyEntry.action;
3019 dispatchEntry->resolvedFlags = keyEntry.flags;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003020
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003021 if (!connection->inputState.trackKey(keyEntry, dispatchEntry->resolvedAction,
3022 dispatchEntry->resolvedFlags)) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003023 if (DEBUG_DISPATCH_CYCLE) {
3024 ALOGD("channel '%s' ~ enqueueDispatchEntryLocked: skipping inconsistent key "
3025 "event",
3026 connection->getInputChannelName().c_str());
3027 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003028 return; // skip the inconsistent event
3029 }
3030 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003031 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003032
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003033 case EventEntry::Type::MOTION: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003034 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(newEntry);
Garfield Tanff1f1bb2020-01-28 13:24:04 -08003035 // Assign a default value to dispatchEntry that will never be generated by InputReader,
3036 // and assign a InputDispatcher value if it doesn't change in the if-else chain below.
3037 constexpr int32_t DEFAULT_RESOLVED_EVENT_ID =
3038 static_cast<int32_t>(IdGenerator::Source::OTHER);
3039 dispatchEntry->resolvedEventId = DEFAULT_RESOLVED_EVENT_ID;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003040 if (dispatchMode & InputTarget::FLAG_DISPATCH_AS_OUTSIDE) {
3041 dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_OUTSIDE;
3042 } else if (dispatchMode & InputTarget::FLAG_DISPATCH_AS_HOVER_EXIT) {
3043 dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_HOVER_EXIT;
3044 } else if (dispatchMode & InputTarget::FLAG_DISPATCH_AS_HOVER_ENTER) {
3045 dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_HOVER_ENTER;
3046 } else if (dispatchMode & InputTarget::FLAG_DISPATCH_AS_SLIPPERY_EXIT) {
3047 dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_CANCEL;
3048 } else if (dispatchMode & InputTarget::FLAG_DISPATCH_AS_SLIPPERY_ENTER) {
3049 dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_DOWN;
3050 } else {
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003051 dispatchEntry->resolvedAction = motionEntry.action;
Garfield Tanff1f1bb2020-01-28 13:24:04 -08003052 dispatchEntry->resolvedEventId = motionEntry.id;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003053 }
3054 if (dispatchEntry->resolvedAction == AMOTION_EVENT_ACTION_HOVER_MOVE &&
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003055 !connection->inputState.isHovering(motionEntry.deviceId, motionEntry.source,
3056 motionEntry.displayId)) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003057 if (DEBUG_DISPATCH_CYCLE) {
3058 ALOGD("channel '%s' ~ enqueueDispatchEntryLocked: filling in missing hover "
3059 "enter event",
3060 connection->getInputChannelName().c_str());
3061 }
Siarhei Vishniakouf2652122021-03-05 21:39:46 +00003062 // We keep the 'resolvedEventId' here equal to the original 'motionEntry.id' because
3063 // this is a one-to-one event conversion.
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003064 dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_HOVER_ENTER;
3065 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003066
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003067 dispatchEntry->resolvedFlags = motionEntry.flags;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003068 if (dispatchEntry->targetFlags & InputTarget::FLAG_WINDOW_IS_OBSCURED) {
3069 dispatchEntry->resolvedFlags |= AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED;
3070 }
3071 if (dispatchEntry->targetFlags & InputTarget::FLAG_WINDOW_IS_PARTIALLY_OBSCURED) {
3072 dispatchEntry->resolvedFlags |= AMOTION_EVENT_FLAG_WINDOW_IS_PARTIALLY_OBSCURED;
3073 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003074
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003075 if (!connection->inputState.trackMotion(motionEntry, dispatchEntry->resolvedAction,
3076 dispatchEntry->resolvedFlags)) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003077 if (DEBUG_DISPATCH_CYCLE) {
3078 ALOGD("channel '%s' ~ enqueueDispatchEntryLocked: skipping inconsistent motion "
3079 "event",
3080 connection->getInputChannelName().c_str());
3081 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003082 return; // skip the inconsistent event
3083 }
3084
Garfield Tanff1f1bb2020-01-28 13:24:04 -08003085 dispatchEntry->resolvedEventId =
3086 dispatchEntry->resolvedEventId == DEFAULT_RESOLVED_EVENT_ID
3087 ? mIdGenerator.nextId()
3088 : motionEntry.id;
3089 if (ATRACE_ENABLED() && dispatchEntry->resolvedEventId != motionEntry.id) {
3090 std::string message = StringPrintf("Transmute MotionEvent(id=0x%" PRIx32
3091 ") to MotionEvent(id=0x%" PRIx32 ").",
3092 motionEntry.id, dispatchEntry->resolvedEventId);
3093 ATRACE_NAME(message.c_str());
3094 }
3095
Prabir Pradhan47cf0a02021-03-11 20:30:57 -08003096 if ((motionEntry.flags & AMOTION_EVENT_FLAG_NO_FOCUS_CHANGE) &&
3097 (motionEntry.policyFlags & POLICY_FLAG_TRUSTED)) {
3098 // Skip reporting pointer down outside focus to the policy.
3099 break;
3100 }
3101
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003102 dispatchPointerDownOutsideFocus(motionEntry.source, dispatchEntry->resolvedAction,
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08003103 inputTarget.inputChannel->getConnectionToken());
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003104
3105 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003106 }
Prabir Pradhan99987712020-11-10 18:43:05 -08003107 case EventEntry::Type::FOCUS:
Antonio Kantek7242d8b2021-08-05 16:07:20 -07003108 case EventEntry::Type::TOUCH_MODE_CHANGED:
arthurhungb89ccb02020-12-30 16:19:01 +08003109 case EventEntry::Type::POINTER_CAPTURE_CHANGED:
3110 case EventEntry::Type::DRAG: {
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01003111 break;
3112 }
Chris Yef59a2f42020-10-16 12:55:26 -07003113 case EventEntry::Type::SENSOR: {
3114 LOG_ALWAYS_FATAL("SENSOR events should not go to apps via input channel");
3115 break;
3116 }
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003117 case EventEntry::Type::CONFIGURATION_CHANGED:
3118 case EventEntry::Type::DEVICE_RESET: {
3119 LOG_ALWAYS_FATAL("%s events should not go to apps",
Dominik Laskowski75788452021-02-09 18:51:25 -08003120 ftl::enum_string(newEntry.type).c_str());
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003121 break;
3122 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003123 }
3124
3125 // Remember that we are waiting for this dispatch to complete.
3126 if (dispatchEntry->hasForegroundTarget()) {
Chavi Weingarten65f98b82020-01-16 18:56:50 +00003127 incrementPendingForegroundDispatches(newEntry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003128 }
3129
3130 // Enqueue the dispatch entry.
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -08003131 connection->outboundQueue.push_back(dispatchEntry.release());
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00003132 traceOutboundQueueLength(*connection);
chaviw8c9cf542019-03-25 13:02:48 -07003133}
3134
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003135/**
3136 * This function is purely for debugging. It helps us understand where the user interaction
3137 * was taking place. For example, if user is touching launcher, we will see a log that user
3138 * started interacting with launcher. In that example, the event would go to the wallpaper as well.
3139 * We will see both launcher and wallpaper in that list.
3140 * Once the interaction with a particular set of connections starts, no new logs will be printed
3141 * until the set of interacted connections changes.
3142 *
3143 * The following items are skipped, to reduce the logspam:
3144 * ACTION_OUTSIDE: any windows that are receiving ACTION_OUTSIDE are not logged
3145 * ACTION_UP: any windows that receive ACTION_UP are not logged (for both keys and motions).
3146 * This includes situations like the soft BACK button key. When the user releases (lifts up the
3147 * finger) the back button, then navigation bar will inject KEYCODE_BACK with ACTION_UP.
3148 * Both of those ACTION_UP events would not be logged
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003149 */
3150void InputDispatcher::updateInteractionTokensLocked(const EventEntry& entry,
3151 const std::vector<InputTarget>& targets) {
3152 // Skip ACTION_UP events, and all events other than keys and motions
3153 if (entry.type == EventEntry::Type::KEY) {
3154 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(entry);
3155 if (keyEntry.action == AKEY_EVENT_ACTION_UP) {
3156 return;
3157 }
3158 } else if (entry.type == EventEntry::Type::MOTION) {
3159 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(entry);
3160 if (motionEntry.action == AMOTION_EVENT_ACTION_UP ||
3161 motionEntry.action == AMOTION_EVENT_ACTION_CANCEL) {
3162 return;
3163 }
3164 } else {
3165 return; // Not a key or a motion
3166 }
3167
Prabir Pradhan6a9a8312021-04-23 11:59:31 -07003168 std::unordered_set<sp<IBinder>, StrongPointerHash<IBinder>> newConnectionTokens;
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003169 std::vector<sp<Connection>> newConnections;
3170 for (const InputTarget& target : targets) {
3171 if ((target.flags & InputTarget::FLAG_DISPATCH_AS_OUTSIDE) ==
3172 InputTarget::FLAG_DISPATCH_AS_OUTSIDE) {
3173 continue; // Skip windows that receive ACTION_OUTSIDE
3174 }
3175
3176 sp<IBinder> token = target.inputChannel->getConnectionToken();
3177 sp<Connection> connection = getConnectionLocked(token);
Siarhei Vishniakoud706a282021-02-13 00:08:48 +00003178 if (connection == nullptr) {
3179 continue;
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003180 }
3181 newConnectionTokens.insert(std::move(token));
3182 newConnections.emplace_back(connection);
3183 }
3184 if (newConnectionTokens == mInteractionConnectionTokens) {
3185 return; // no change
3186 }
3187 mInteractionConnectionTokens = newConnectionTokens;
3188
Siarhei Vishniakoud706a282021-02-13 00:08:48 +00003189 std::string targetList;
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003190 for (const sp<Connection>& connection : newConnections) {
Siarhei Vishniakoud706a282021-02-13 00:08:48 +00003191 targetList += connection->getWindowName() + ", ";
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003192 }
Siarhei Vishniakoud706a282021-02-13 00:08:48 +00003193 std::string message = "Interaction with: " + targetList;
3194 if (targetList.empty()) {
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +00003195 message += "<none>";
3196 }
3197 android_log_event_list(LOGTAG_INPUT_INTERACTION) << message << LOG_ID_EVENTS;
3198}
3199
chaviwfd6d3512019-03-25 13:23:49 -07003200void InputDispatcher::dispatchPointerDownOutsideFocus(uint32_t source, int32_t action,
Vishnu Nairad321cd2020-08-20 16:40:21 -07003201 const sp<IBinder>& token) {
chaviw8c9cf542019-03-25 13:02:48 -07003202 int32_t maskedAction = action & AMOTION_EVENT_ACTION_MASK;
chaviwfd6d3512019-03-25 13:23:49 -07003203 uint32_t maskedSource = source & AINPUT_SOURCE_CLASS_MASK;
3204 if (maskedSource != AINPUT_SOURCE_CLASS_POINTER || maskedAction != AMOTION_EVENT_ACTION_DOWN) {
chaviw8c9cf542019-03-25 13:02:48 -07003205 return;
3206 }
3207
Vishnu Nairc519ff72021-01-21 08:23:08 -08003208 sp<IBinder> focusedToken = mFocusResolver.getFocusedWindowToken(mFocusedDisplayId);
Vishnu Nairad321cd2020-08-20 16:40:21 -07003209 if (focusedToken == token) {
3210 // ignore since token is focused
chaviw8c9cf542019-03-25 13:02:48 -07003211 return;
3212 }
3213
Prabir Pradhancef936d2021-07-21 16:17:52 +00003214 auto command = [this, token]() REQUIRES(mLock) {
3215 scoped_unlock unlock(mLock);
3216 mPolicy->onPointerDownOutsideFocus(token);
3217 };
3218 postCommandLocked(std::move(command));
Michael Wrightd02c5b62014-02-10 15:10:22 -08003219}
3220
3221void InputDispatcher::startDispatchCycleLocked(nsecs_t currentTime,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003222 const sp<Connection>& connection) {
Michael Wright3dd60e22019-03-27 22:06:44 +00003223 if (ATRACE_ENABLED()) {
3224 std::string message = StringPrintf("startDispatchCycleLocked(inputChannel=%s)",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003225 connection->getInputChannelName().c_str());
Michael Wright3dd60e22019-03-27 22:06:44 +00003226 ATRACE_NAME(message.c_str());
3227 }
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003228 if (DEBUG_DISPATCH_CYCLE) {
3229 ALOGD("channel '%s' ~ startDispatchCycle", connection->getInputChannelName().c_str());
3230 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003231
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08003232 while (connection->status == Connection::Status::NORMAL && !connection->outboundQueue.empty()) {
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07003233 DispatchEntry* dispatchEntry = connection->outboundQueue.front();
Michael Wrightd02c5b62014-02-10 15:10:22 -08003234 dispatchEntry->deliveryTime = currentTime;
Prabir Pradhan1376fcd2022-01-21 09:56:35 -08003235 const std::chrono::nanoseconds timeout = getDispatchingTimeoutLocked(connection);
Siarhei Vishniakou70622952020-07-30 11:17:23 -05003236 dispatchEntry->timeoutTime = currentTime + timeout.count();
Michael Wrightd02c5b62014-02-10 15:10:22 -08003237
3238 // Publish the event.
3239 status_t status;
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003240 const EventEntry& eventEntry = *(dispatchEntry->eventEntry);
3241 switch (eventEntry.type) {
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003242 case EventEntry::Type::KEY: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003243 const KeyEntry& keyEntry = static_cast<const KeyEntry&>(eventEntry);
3244 std::array<uint8_t, 32> hmac = getSignature(keyEntry, *dispatchEntry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003245
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003246 // Publish the key event.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003247 status = connection->inputPublisher
3248 .publishKeyEvent(dispatchEntry->seq,
3249 dispatchEntry->resolvedEventId, keyEntry.deviceId,
3250 keyEntry.source, keyEntry.displayId,
3251 std::move(hmac), dispatchEntry->resolvedAction,
3252 dispatchEntry->resolvedFlags, keyEntry.keyCode,
3253 keyEntry.scanCode, keyEntry.metaState,
3254 keyEntry.repeatCount, keyEntry.downTime,
3255 keyEntry.eventTime);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003256 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003257 }
3258
Siarhei Vishniakou49483272019-10-22 13:13:47 -07003259 case EventEntry::Type::MOTION: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003260 const MotionEntry& motionEntry = static_cast<const MotionEntry&>(eventEntry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003261
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003262 PointerCoords scaledCoords[MAX_POINTERS];
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003263 const PointerCoords* usingCoords = motionEntry.pointerCoords;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003264
chaviw82357092020-01-28 13:13:06 -08003265 // Set the X and Y offset and X and Y scale depending on the input source.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003266 if ((motionEntry.source & AINPUT_SOURCE_CLASS_POINTER) &&
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003267 !(dispatchEntry->targetFlags & InputTarget::FLAG_ZERO_COORDS)) {
3268 float globalScaleFactor = dispatchEntry->globalScaleFactor;
chaviw82357092020-01-28 13:13:06 -08003269 if (globalScaleFactor != 1.0f) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003270 for (uint32_t i = 0; i < motionEntry.pointerCount; i++) {
3271 scaledCoords[i] = motionEntry.pointerCoords[i];
chaviw82357092020-01-28 13:13:06 -08003272 // Don't apply window scale here since we don't want scale to affect raw
3273 // coordinates. The scale will be sent back to the client and applied
3274 // later when requesting relative coordinates.
3275 scaledCoords[i].scale(globalScaleFactor, 1 /* windowXScale */,
3276 1 /* windowYScale */);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003277 }
3278 usingCoords = scaledCoords;
3279 }
3280 } else {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003281 // We don't want the dispatch target to know.
3282 if (dispatchEntry->targetFlags & InputTarget::FLAG_ZERO_COORDS) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003283 for (uint32_t i = 0; i < motionEntry.pointerCount; i++) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003284 scaledCoords[i].clear();
3285 }
3286 usingCoords = scaledCoords;
3287 }
3288 }
Edgar Arriagac6ae4bb2020-04-16 18:46:48 -07003289
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003290 std::array<uint8_t, 32> hmac = getSignature(motionEntry, *dispatchEntry);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003291
3292 // Publish the motion event.
3293 status = connection->inputPublisher
Garfield Tanff1f1bb2020-01-28 13:24:04 -08003294 .publishMotionEvent(dispatchEntry->seq,
3295 dispatchEntry->resolvedEventId,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003296 motionEntry.deviceId, motionEntry.source,
3297 motionEntry.displayId, std::move(hmac),
Garfield Tanff1f1bb2020-01-28 13:24:04 -08003298 dispatchEntry->resolvedAction,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003299 motionEntry.actionButton,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003300 dispatchEntry->resolvedFlags,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003301 motionEntry.edgeFlags, motionEntry.metaState,
3302 motionEntry.buttonState,
3303 motionEntry.classification,
chaviw9eaa22c2020-07-01 16:21:27 -07003304 dispatchEntry->transform,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003305 motionEntry.xPrecision, motionEntry.yPrecision,
3306 motionEntry.xCursorPosition,
3307 motionEntry.yCursorPosition,
Prabir Pradhanb9b18502021-08-26 12:30:32 -07003308 dispatchEntry->rawTransform,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003309 motionEntry.downTime, motionEntry.eventTime,
3310 motionEntry.pointerCount,
3311 motionEntry.pointerProperties, usingCoords);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003312 break;
3313 }
Prabir Pradhan99987712020-11-10 18:43:05 -08003314
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01003315 case EventEntry::Type::FOCUS: {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003316 const FocusEntry& focusEntry = static_cast<const FocusEntry&>(eventEntry);
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01003317 status = connection->inputPublisher.publishFocusEvent(dispatchEntry->seq,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003318 focusEntry.id,
Antonio Kantek3cfec7b2021-11-05 18:26:17 -07003319 focusEntry.hasFocus);
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01003320 break;
3321 }
3322
Antonio Kantek7242d8b2021-08-05 16:07:20 -07003323 case EventEntry::Type::TOUCH_MODE_CHANGED: {
3324 const TouchModeEntry& touchModeEntry =
3325 static_cast<const TouchModeEntry&>(eventEntry);
3326 status = connection->inputPublisher
3327 .publishTouchModeEvent(dispatchEntry->seq, touchModeEntry.id,
3328 touchModeEntry.inTouchMode);
3329
3330 break;
3331 }
3332
Prabir Pradhan99987712020-11-10 18:43:05 -08003333 case EventEntry::Type::POINTER_CAPTURE_CHANGED: {
3334 const auto& captureEntry =
3335 static_cast<const PointerCaptureChangedEntry&>(eventEntry);
3336 status = connection->inputPublisher
3337 .publishCaptureEvent(dispatchEntry->seq, captureEntry.id,
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00003338 captureEntry.pointerCaptureRequest.enable);
Prabir Pradhan99987712020-11-10 18:43:05 -08003339 break;
3340 }
3341
arthurhungb89ccb02020-12-30 16:19:01 +08003342 case EventEntry::Type::DRAG: {
3343 const DragEntry& dragEntry = static_cast<const DragEntry&>(eventEntry);
3344 status = connection->inputPublisher.publishDragEvent(dispatchEntry->seq,
3345 dragEntry.id, dragEntry.x,
3346 dragEntry.y,
3347 dragEntry.isExiting);
3348 break;
3349 }
3350
Siarhei Vishniakou3b37f9a2019-11-23 13:42:41 -08003351 case EventEntry::Type::CONFIGURATION_CHANGED:
Chris Yef59a2f42020-10-16 12:55:26 -07003352 case EventEntry::Type::DEVICE_RESET:
3353 case EventEntry::Type::SENSOR: {
Siarhei Vishniakou3b37f9a2019-11-23 13:42:41 -08003354 LOG_ALWAYS_FATAL("Should never start dispatch cycles for %s events",
Dominik Laskowski75788452021-02-09 18:51:25 -08003355 ftl::enum_string(eventEntry.type).c_str());
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003356 return;
Siarhei Vishniakou3b37f9a2019-11-23 13:42:41 -08003357 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003358 }
3359
3360 // Check the result.
3361 if (status) {
3362 if (status == WOULD_BLOCK) {
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07003363 if (connection->waitQueue.empty()) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003364 ALOGE("channel '%s' ~ Could not publish event because the pipe is full. "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003365 "This is unexpected because the wait queue is empty, so the pipe "
3366 "should be empty and we shouldn't have any problems writing an "
Siarhei Vishniakou09b02ac2021-04-14 22:24:04 +00003367 "event to it, status=%s(%d)",
3368 connection->getInputChannelName().c_str(), statusToString(status).c_str(),
3369 status);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003370 abortBrokenDispatchCycleLocked(currentTime, connection, true /*notify*/);
3371 } else {
3372 // Pipe is full and we are waiting for the app to finish process some events
3373 // before sending more events to it.
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003374 if (DEBUG_DISPATCH_CYCLE) {
3375 ALOGD("channel '%s' ~ Could not publish event because the pipe is full, "
3376 "waiting for the application to catch up",
3377 connection->getInputChannelName().c_str());
3378 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003379 }
3380 } else {
3381 ALOGE("channel '%s' ~ Could not publish event due to an unexpected error, "
Siarhei Vishniakou09b02ac2021-04-14 22:24:04 +00003382 "status=%s(%d)",
3383 connection->getInputChannelName().c_str(), statusToString(status).c_str(),
3384 status);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003385 abortBrokenDispatchCycleLocked(currentTime, connection, true /*notify*/);
3386 }
3387 return;
3388 }
3389
3390 // Re-enqueue the event on the wait queue.
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07003391 connection->outboundQueue.erase(std::remove(connection->outboundQueue.begin(),
3392 connection->outboundQueue.end(),
3393 dispatchEntry));
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00003394 traceOutboundQueueLength(*connection);
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07003395 connection->waitQueue.push_back(dispatchEntry);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003396 if (connection->responsive) {
3397 mAnrTracker.insert(dispatchEntry->timeoutTime,
3398 connection->inputChannel->getConnectionToken());
3399 }
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00003400 traceWaitQueueLength(*connection);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003401 }
3402}
3403
chaviw09c8d2d2020-08-24 15:48:26 -07003404std::array<uint8_t, 32> InputDispatcher::sign(const VerifiedInputEvent& event) const {
3405 size_t size;
3406 switch (event.type) {
3407 case VerifiedInputEvent::Type::KEY: {
3408 size = sizeof(VerifiedKeyEvent);
3409 break;
3410 }
3411 case VerifiedInputEvent::Type::MOTION: {
3412 size = sizeof(VerifiedMotionEvent);
3413 break;
3414 }
3415 }
3416 const uint8_t* start = reinterpret_cast<const uint8_t*>(&event);
3417 return mHmacKeyManager.sign(start, size);
3418}
3419
Edgar Arriagac6ae4bb2020-04-16 18:46:48 -07003420const std::array<uint8_t, 32> InputDispatcher::getSignature(
3421 const MotionEntry& motionEntry, const DispatchEntry& dispatchEntry) const {
Prabir Pradhanb5cb9572021-09-24 06:35:16 -07003422 const int32_t actionMasked = dispatchEntry.resolvedAction & AMOTION_EVENT_ACTION_MASK;
3423 if (actionMasked != AMOTION_EVENT_ACTION_UP && actionMasked != AMOTION_EVENT_ACTION_DOWN) {
Edgar Arriagac6ae4bb2020-04-16 18:46:48 -07003424 // Only sign events up and down events as the purely move events
3425 // are tied to their up/down counterparts so signing would be redundant.
Prabir Pradhanb5cb9572021-09-24 06:35:16 -07003426 return INVALID_HMAC;
Edgar Arriagac6ae4bb2020-04-16 18:46:48 -07003427 }
Prabir Pradhanb5cb9572021-09-24 06:35:16 -07003428
3429 VerifiedMotionEvent verifiedEvent =
3430 verifiedMotionEventFromMotionEntry(motionEntry, dispatchEntry.rawTransform);
3431 verifiedEvent.actionMasked = actionMasked;
3432 verifiedEvent.flags = dispatchEntry.resolvedFlags & VERIFIED_MOTION_EVENT_FLAGS;
3433 return sign(verifiedEvent);
Edgar Arriagac6ae4bb2020-04-16 18:46:48 -07003434}
3435
3436const std::array<uint8_t, 32> InputDispatcher::getSignature(
3437 const KeyEntry& keyEntry, const DispatchEntry& dispatchEntry) const {
3438 VerifiedKeyEvent verifiedEvent = verifiedKeyEventFromKeyEntry(keyEntry);
3439 verifiedEvent.flags = dispatchEntry.resolvedFlags & VERIFIED_KEY_EVENT_FLAGS;
3440 verifiedEvent.action = dispatchEntry.resolvedAction;
chaviw09c8d2d2020-08-24 15:48:26 -07003441 return sign(verifiedEvent);
Edgar Arriagac6ae4bb2020-04-16 18:46:48 -07003442}
3443
Michael Wrightd02c5b62014-02-10 15:10:22 -08003444void InputDispatcher::finishDispatchCycleLocked(nsecs_t currentTime,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003445 const sp<Connection>& connection, uint32_t seq,
Siarhei Vishniakou3531ae72021-02-02 12:12:27 -10003446 bool handled, nsecs_t consumeTime) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003447 if (DEBUG_DISPATCH_CYCLE) {
3448 ALOGD("channel '%s' ~ finishDispatchCycle - seq=%u, handled=%s",
3449 connection->getInputChannelName().c_str(), seq, toString(handled));
3450 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003451
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08003452 if (connection->status == Connection::Status::BROKEN ||
3453 connection->status == Connection::Status::ZOMBIE) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003454 return;
3455 }
3456
3457 // Notify other system components and prepare to start the next dispatch cycle.
Prabir Pradhancef936d2021-07-21 16:17:52 +00003458 auto command = [this, currentTime, connection, seq, handled, consumeTime]() REQUIRES(mLock) {
3459 doDispatchCycleFinishedCommand(currentTime, connection, seq, handled, consumeTime);
3460 };
3461 postCommandLocked(std::move(command));
Michael Wrightd02c5b62014-02-10 15:10:22 -08003462}
3463
3464void InputDispatcher::abortBrokenDispatchCycleLocked(nsecs_t currentTime,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003465 const sp<Connection>& connection,
3466 bool notify) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003467 if (DEBUG_DISPATCH_CYCLE) {
3468 ALOGD("channel '%s' ~ abortBrokenDispatchCycle - notify=%s",
3469 connection->getInputChannelName().c_str(), toString(notify));
3470 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003471
3472 // Clear the dispatch queues.
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07003473 drainDispatchQueue(connection->outboundQueue);
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00003474 traceOutboundQueueLength(*connection);
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07003475 drainDispatchQueue(connection->waitQueue);
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00003476 traceWaitQueueLength(*connection);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003477
3478 // The connection appears to be unrecoverably broken.
3479 // Ignore already broken or zombie connections.
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08003480 if (connection->status == Connection::Status::NORMAL) {
3481 connection->status = Connection::Status::BROKEN;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003482
3483 if (notify) {
3484 // Notify other system components.
Prabir Pradhancef936d2021-07-21 16:17:52 +00003485 ALOGE("channel '%s' ~ Channel is unrecoverably broken and will be disposed!",
3486 connection->getInputChannelName().c_str());
3487
3488 auto command = [this, connection]() REQUIRES(mLock) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00003489 scoped_unlock unlock(mLock);
3490 mPolicy->notifyInputChannelBroken(connection->inputChannel->getConnectionToken());
3491 };
3492 postCommandLocked(std::move(command));
Michael Wrightd02c5b62014-02-10 15:10:22 -08003493 }
3494 }
3495}
3496
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07003497void InputDispatcher::drainDispatchQueue(std::deque<DispatchEntry*>& queue) {
3498 while (!queue.empty()) {
3499 DispatchEntry* dispatchEntry = queue.front();
3500 queue.pop_front();
Siarhei Vishniakou62683e82019-03-06 17:59:56 -08003501 releaseDispatchEntry(dispatchEntry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003502 }
3503}
3504
Siarhei Vishniakou62683e82019-03-06 17:59:56 -08003505void InputDispatcher::releaseDispatchEntry(DispatchEntry* dispatchEntry) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003506 if (dispatchEntry->hasForegroundTarget()) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003507 decrementPendingForegroundDispatches(*(dispatchEntry->eventEntry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08003508 }
3509 delete dispatchEntry;
3510}
3511
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00003512int InputDispatcher::handleReceiveCallback(int events, sp<IBinder> connectionToken) {
3513 std::scoped_lock _l(mLock);
3514 sp<Connection> connection = getConnectionLocked(connectionToken);
3515 if (connection == nullptr) {
3516 ALOGW("Received looper callback for unknown input channel token %p. events=0x%x",
3517 connectionToken.get(), events);
3518 return 0; // remove the callback
3519 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003520
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00003521 bool notify;
3522 if (!(events & (ALOOPER_EVENT_ERROR | ALOOPER_EVENT_HANGUP))) {
3523 if (!(events & ALOOPER_EVENT_INPUT)) {
3524 ALOGW("channel '%s' ~ Received spurious callback for unhandled poll event. "
3525 "events=0x%x",
3526 connection->getInputChannelName().c_str(), events);
3527 return 1;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003528 }
3529
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00003530 nsecs_t currentTime = now();
3531 bool gotOne = false;
3532 status_t status = OK;
3533 for (;;) {
3534 Result<InputPublisher::ConsumerResponse> result =
3535 connection->inputPublisher.receiveConsumerResponse();
3536 if (!result.ok()) {
3537 status = result.error().code();
3538 break;
3539 }
3540
3541 if (std::holds_alternative<InputPublisher::Finished>(*result)) {
3542 const InputPublisher::Finished& finish =
3543 std::get<InputPublisher::Finished>(*result);
3544 finishDispatchCycleLocked(currentTime, connection, finish.seq, finish.handled,
3545 finish.consumeTime);
3546 } else if (std::holds_alternative<InputPublisher::Timeline>(*result)) {
Siarhei Vishniakouf2652122021-03-05 21:39:46 +00003547 if (shouldReportMetricsForConnection(*connection)) {
3548 const InputPublisher::Timeline& timeline =
3549 std::get<InputPublisher::Timeline>(*result);
3550 mLatencyTracker
3551 .trackGraphicsLatency(timeline.inputEventId,
3552 connection->inputChannel->getConnectionToken(),
3553 std::move(timeline.graphicsTimeline));
3554 }
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00003555 }
3556 gotOne = true;
3557 }
3558 if (gotOne) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00003559 runCommandsLockedInterruptable();
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00003560 if (status == WOULD_BLOCK) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003561 return 1;
3562 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003563 }
3564
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00003565 notify = status != DEAD_OBJECT || !connection->monitor;
3566 if (notify) {
3567 ALOGE("channel '%s' ~ Failed to receive finished signal. status=%s(%d)",
3568 connection->getInputChannelName().c_str(), statusToString(status).c_str(),
3569 status);
3570 }
3571 } else {
3572 // Monitor channels are never explicitly unregistered.
3573 // We do it automatically when the remote endpoint is closed so don't warn about them.
3574 const bool stillHaveWindowHandle =
3575 getWindowHandleLocked(connection->inputChannel->getConnectionToken()) != nullptr;
3576 notify = !connection->monitor && stillHaveWindowHandle;
3577 if (notify) {
3578 ALOGW("channel '%s' ~ Consumer closed input channel or an error occurred. events=0x%x",
3579 connection->getInputChannelName().c_str(), events);
3580 }
3581 }
3582
3583 // Remove the channel.
3584 removeInputChannelLocked(connection->inputChannel->getConnectionToken(), notify);
3585 return 0; // remove the callback
Michael Wrightd02c5b62014-02-10 15:10:22 -08003586}
3587
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003588void InputDispatcher::synthesizeCancelationEventsForAllConnectionsLocked(
Michael Wrightd02c5b62014-02-10 15:10:22 -08003589 const CancelationOptions& options) {
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00003590 for (const auto& [token, connection] : mConnectionsByToken) {
Siarhei Vishniakou2e2ea992020-12-15 02:57:19 +00003591 synthesizeCancelationEventsForConnectionLocked(connection, options);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003592 }
3593}
3594
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003595void InputDispatcher::synthesizeCancelationEventsForMonitorsLocked(
Michael Wrightfa13dcf2015-06-12 13:25:11 +01003596 const CancelationOptions& options) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08003597 for (const auto& [_, monitors] : mGlobalMonitorsByDisplay) {
Michael Wright3dd60e22019-03-27 22:06:44 +00003598 for (const Monitor& monitor : monitors) {
3599 synthesizeCancelationEventsForInputChannelLocked(monitor.inputChannel, options);
Arthur Hung2fbf37f2018-09-13 18:16:41 +08003600 }
Michael Wrightfa13dcf2015-06-12 13:25:11 +01003601 }
3602}
3603
Michael Wrightd02c5b62014-02-10 15:10:22 -08003604void InputDispatcher::synthesizeCancelationEventsForInputChannelLocked(
Siarhei Vishniakouce5ab082020-07-09 17:03:21 -05003605 const std::shared_ptr<InputChannel>& channel, const CancelationOptions& options) {
Siarhei Vishniakou26d3cfb2019-10-15 17:02:32 -07003606 sp<Connection> connection = getConnectionLocked(channel->getConnectionToken());
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07003607 if (connection == nullptr) {
3608 return;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003609 }
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07003610
3611 synthesizeCancelationEventsForConnectionLocked(connection, options);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003612}
3613
3614void InputDispatcher::synthesizeCancelationEventsForConnectionLocked(
3615 const sp<Connection>& connection, const CancelationOptions& options) {
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08003616 if (connection->status == Connection::Status::BROKEN) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003617 return;
3618 }
3619
3620 nsecs_t currentTime = now();
3621
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003622 std::vector<std::unique_ptr<EventEntry>> cancelationEvents =
Siarhei Vishniakou00fca7c2019-10-29 13:05:57 -07003623 connection->inputState.synthesizeCancelationEvents(currentTime, options);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003624
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08003625 if (cancelationEvents.empty()) {
3626 return;
3627 }
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003628 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
3629 ALOGD("channel '%s' ~ Synthesized %zu cancelation events to bring channel back in sync "
3630 "with reality: %s, mode=%d.",
3631 connection->getInputChannelName().c_str(), cancelationEvents.size(), options.reason,
3632 options.mode);
3633 }
Svet Ganov5d3bc372020-01-26 23:11:07 -08003634
Arthur Hungb3307ee2021-10-14 10:57:37 +00003635 std::string reason = std::string("reason=").append(options.reason);
3636 android_log_event_list(LOGTAG_INPUT_CANCEL)
3637 << connection->getInputChannelName().c_str() << reason << LOG_ID_EVENTS;
3638
Svet Ganov5d3bc372020-01-26 23:11:07 -08003639 InputTarget target;
chaviw98318de2021-05-19 16:45:23 -05003640 sp<WindowInfoHandle> windowHandle =
Svet Ganov5d3bc372020-01-26 23:11:07 -08003641 getWindowHandleLocked(connection->inputChannel->getConnectionToken());
3642 if (windowHandle != nullptr) {
chaviw98318de2021-05-19 16:45:23 -05003643 const WindowInfo* windowInfo = windowHandle->getInfo();
chaviw1ff3d1e2020-07-01 15:53:47 -07003644 target.setDefaultPointerTransform(windowInfo->transform);
Svet Ganov5d3bc372020-01-26 23:11:07 -08003645 target.globalScaleFactor = windowInfo->globalScaleFactor;
3646 }
3647 target.inputChannel = connection->inputChannel;
3648 target.flags = InputTarget::FLAG_DISPATCH_AS_IS;
3649
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08003650 for (size_t i = 0; i < cancelationEvents.size(); i++) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003651 std::unique_ptr<EventEntry> cancelationEventEntry = std::move(cancelationEvents[i]);
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08003652 switch (cancelationEventEntry->type) {
3653 case EventEntry::Type::KEY: {
3654 logOutboundKeyDetails("cancel - ",
3655 static_cast<const KeyEntry&>(*cancelationEventEntry));
3656 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003657 }
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08003658 case EventEntry::Type::MOTION: {
3659 logOutboundMotionDetails("cancel - ",
3660 static_cast<const MotionEntry&>(*cancelationEventEntry));
3661 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003662 }
Prabir Pradhan99987712020-11-10 18:43:05 -08003663 case EventEntry::Type::FOCUS:
Antonio Kantek7242d8b2021-08-05 16:07:20 -07003664 case EventEntry::Type::TOUCH_MODE_CHANGED:
arthurhungb89ccb02020-12-30 16:19:01 +08003665 case EventEntry::Type::POINTER_CAPTURE_CHANGED:
3666 case EventEntry::Type::DRAG: {
Prabir Pradhan99987712020-11-10 18:43:05 -08003667 LOG_ALWAYS_FATAL("Canceling %s events is not supported",
Dominik Laskowski75788452021-02-09 18:51:25 -08003668 ftl::enum_string(cancelationEventEntry->type).c_str());
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08003669 break;
3670 }
3671 case EventEntry::Type::CONFIGURATION_CHANGED:
Chris Yef59a2f42020-10-16 12:55:26 -07003672 case EventEntry::Type::DEVICE_RESET:
3673 case EventEntry::Type::SENSOR: {
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08003674 LOG_ALWAYS_FATAL("%s event should not be found inside Connections's queue",
Dominik Laskowski75788452021-02-09 18:51:25 -08003675 ftl::enum_string(cancelationEventEntry->type).c_str());
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08003676 break;
3677 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003678 }
3679
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003680 enqueueDispatchEntryLocked(connection, std::move(cancelationEventEntry), target,
3681 InputTarget::FLAG_DISPATCH_AS_IS);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003682 }
Siarhei Vishniakoubd118892020-01-10 14:08:28 -08003683
3684 startDispatchCycleLocked(currentTime, connection);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003685}
3686
Svet Ganov5d3bc372020-01-26 23:11:07 -08003687void InputDispatcher::synthesizePointerDownEventsForConnectionLocked(
3688 const sp<Connection>& connection) {
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08003689 if (connection->status == Connection::Status::BROKEN) {
Svet Ganov5d3bc372020-01-26 23:11:07 -08003690 return;
3691 }
3692
3693 nsecs_t currentTime = now();
3694
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003695 std::vector<std::unique_ptr<EventEntry>> downEvents =
Svet Ganov5d3bc372020-01-26 23:11:07 -08003696 connection->inputState.synthesizePointerDownEvents(currentTime);
3697
3698 if (downEvents.empty()) {
3699 return;
3700 }
3701
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003702 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
Svet Ganov5d3bc372020-01-26 23:11:07 -08003703 ALOGD("channel '%s' ~ Synthesized %zu down events to ensure consistent event stream.",
3704 connection->getInputChannelName().c_str(), downEvents.size());
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003705 }
Svet Ganov5d3bc372020-01-26 23:11:07 -08003706
3707 InputTarget target;
chaviw98318de2021-05-19 16:45:23 -05003708 sp<WindowInfoHandle> windowHandle =
Svet Ganov5d3bc372020-01-26 23:11:07 -08003709 getWindowHandleLocked(connection->inputChannel->getConnectionToken());
3710 if (windowHandle != nullptr) {
chaviw98318de2021-05-19 16:45:23 -05003711 const WindowInfo* windowInfo = windowHandle->getInfo();
chaviw1ff3d1e2020-07-01 15:53:47 -07003712 target.setDefaultPointerTransform(windowInfo->transform);
Svet Ganov5d3bc372020-01-26 23:11:07 -08003713 target.globalScaleFactor = windowInfo->globalScaleFactor;
3714 }
3715 target.inputChannel = connection->inputChannel;
3716 target.flags = InputTarget::FLAG_DISPATCH_AS_IS;
3717
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003718 for (std::unique_ptr<EventEntry>& downEventEntry : downEvents) {
Svet Ganov5d3bc372020-01-26 23:11:07 -08003719 switch (downEventEntry->type) {
3720 case EventEntry::Type::MOTION: {
3721 logOutboundMotionDetails("down - ",
3722 static_cast<const MotionEntry&>(*downEventEntry));
3723 break;
3724 }
3725
3726 case EventEntry::Type::KEY:
3727 case EventEntry::Type::FOCUS:
Antonio Kantek7242d8b2021-08-05 16:07:20 -07003728 case EventEntry::Type::TOUCH_MODE_CHANGED:
Svet Ganov5d3bc372020-01-26 23:11:07 -08003729 case EventEntry::Type::CONFIGURATION_CHANGED:
Prabir Pradhan99987712020-11-10 18:43:05 -08003730 case EventEntry::Type::DEVICE_RESET:
Chris Yef59a2f42020-10-16 12:55:26 -07003731 case EventEntry::Type::POINTER_CAPTURE_CHANGED:
arthurhungb89ccb02020-12-30 16:19:01 +08003732 case EventEntry::Type::SENSOR:
3733 case EventEntry::Type::DRAG: {
Svet Ganov5d3bc372020-01-26 23:11:07 -08003734 LOG_ALWAYS_FATAL("%s event should not be found inside Connections's queue",
Dominik Laskowski75788452021-02-09 18:51:25 -08003735 ftl::enum_string(downEventEntry->type).c_str());
Svet Ganov5d3bc372020-01-26 23:11:07 -08003736 break;
3737 }
3738 }
3739
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003740 enqueueDispatchEntryLocked(connection, std::move(downEventEntry), target,
3741 InputTarget::FLAG_DISPATCH_AS_IS);
Svet Ganov5d3bc372020-01-26 23:11:07 -08003742 }
3743
3744 startDispatchCycleLocked(currentTime, connection);
3745}
3746
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003747std::unique_ptr<MotionEntry> InputDispatcher::splitMotionEvent(
3748 const MotionEntry& originalMotionEntry, BitSet32 pointerIds) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003749 ALOG_ASSERT(pointerIds.value != 0);
3750
3751 uint32_t splitPointerIndexMap[MAX_POINTERS];
3752 PointerProperties splitPointerProperties[MAX_POINTERS];
3753 PointerCoords splitPointerCoords[MAX_POINTERS];
3754
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003755 uint32_t originalPointerCount = originalMotionEntry.pointerCount;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003756 uint32_t splitPointerCount = 0;
3757
3758 for (uint32_t originalPointerIndex = 0; originalPointerIndex < originalPointerCount;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003759 originalPointerIndex++) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003760 const PointerProperties& pointerProperties =
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003761 originalMotionEntry.pointerProperties[originalPointerIndex];
Michael Wrightd02c5b62014-02-10 15:10:22 -08003762 uint32_t pointerId = uint32_t(pointerProperties.id);
3763 if (pointerIds.hasBit(pointerId)) {
3764 splitPointerIndexMap[splitPointerCount] = originalPointerIndex;
3765 splitPointerProperties[splitPointerCount].copyFrom(pointerProperties);
3766 splitPointerCoords[splitPointerCount].copyFrom(
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003767 originalMotionEntry.pointerCoords[originalPointerIndex]);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003768 splitPointerCount += 1;
3769 }
3770 }
3771
3772 if (splitPointerCount != pointerIds.count()) {
3773 // This is bad. We are missing some of the pointers that we expected to deliver.
3774 // Most likely this indicates that we received an ACTION_MOVE events that has
3775 // different pointer ids than we expected based on the previous ACTION_DOWN
3776 // or ACTION_POINTER_DOWN events that caused us to decide to split the pointers
3777 // in this way.
3778 ALOGW("Dropping split motion event because the pointer count is %d but "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003779 "we expected there to be %d pointers. This probably means we received "
3780 "a broken sequence of pointer ids from the input device.",
3781 splitPointerCount, pointerIds.count());
Yi Kong9b14ac62018-07-17 13:48:38 -07003782 return nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003783 }
3784
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003785 int32_t action = originalMotionEntry.action;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003786 int32_t maskedAction = action & AMOTION_EVENT_ACTION_MASK;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003787 if (maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN ||
3788 maskedAction == AMOTION_EVENT_ACTION_POINTER_UP) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08003789 int32_t originalPointerIndex = getMotionEventActionPointerIndex(action);
3790 const PointerProperties& pointerProperties =
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003791 originalMotionEntry.pointerProperties[originalPointerIndex];
Michael Wrightd02c5b62014-02-10 15:10:22 -08003792 uint32_t pointerId = uint32_t(pointerProperties.id);
3793 if (pointerIds.hasBit(pointerId)) {
3794 if (pointerIds.count() == 1) {
3795 // The first/last pointer went down/up.
3796 action = maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003797 ? AMOTION_EVENT_ACTION_DOWN
arthurhungea3f4fc2020-12-21 23:18:53 +08003798 : (originalMotionEntry.flags & AMOTION_EVENT_FLAG_CANCELED) != 0
3799 ? AMOTION_EVENT_ACTION_CANCEL
3800 : AMOTION_EVENT_ACTION_UP;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003801 } else {
3802 // A secondary pointer went down/up.
3803 uint32_t splitPointerIndex = 0;
3804 while (pointerId != uint32_t(splitPointerProperties[splitPointerIndex].id)) {
3805 splitPointerIndex += 1;
3806 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003807 action = maskedAction |
3808 (splitPointerIndex << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003809 }
3810 } else {
3811 // An unrelated pointer changed.
3812 action = AMOTION_EVENT_ACTION_MOVE;
3813 }
3814 }
3815
Garfield Tanff1f1bb2020-01-28 13:24:04 -08003816 int32_t newId = mIdGenerator.nextId();
3817 if (ATRACE_ENABLED()) {
3818 std::string message = StringPrintf("Split MotionEvent(id=0x%" PRIx32
3819 ") to MotionEvent(id=0x%" PRIx32 ").",
3820 originalMotionEntry.id, newId);
3821 ATRACE_NAME(message.c_str());
3822 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003823 std::unique_ptr<MotionEntry> splitMotionEntry =
3824 std::make_unique<MotionEntry>(newId, originalMotionEntry.eventTime,
3825 originalMotionEntry.deviceId, originalMotionEntry.source,
3826 originalMotionEntry.displayId,
3827 originalMotionEntry.policyFlags, action,
3828 originalMotionEntry.actionButton,
3829 originalMotionEntry.flags, originalMotionEntry.metaState,
3830 originalMotionEntry.buttonState,
3831 originalMotionEntry.classification,
3832 originalMotionEntry.edgeFlags,
3833 originalMotionEntry.xPrecision,
3834 originalMotionEntry.yPrecision,
3835 originalMotionEntry.xCursorPosition,
3836 originalMotionEntry.yCursorPosition,
3837 originalMotionEntry.downTime, splitPointerCount,
Prabir Pradhan5beda762021-12-10 09:30:08 +00003838 splitPointerProperties, splitPointerCoords);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003839
Siarhei Vishniakoud2770042019-10-29 11:08:14 -07003840 if (originalMotionEntry.injectionState) {
3841 splitMotionEntry->injectionState = originalMotionEntry.injectionState;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003842 splitMotionEntry->injectionState->refCount += 1;
3843 }
3844
3845 return splitMotionEntry;
3846}
3847
3848void InputDispatcher::notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003849 if (DEBUG_INBOUND_EVENT_DETAILS) {
3850 ALOGD("notifyConfigurationChanged - eventTime=%" PRId64, args->eventTime);
3851 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003852
Antonio Kantekf16f2832021-09-28 04:39:20 +00003853 bool needWake = false;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003854 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08003855 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003856
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003857 std::unique_ptr<ConfigurationChangedEntry> newEntry =
3858 std::make_unique<ConfigurationChangedEntry>(args->id, args->eventTime);
3859 needWake = enqueueInboundEventLocked(std::move(newEntry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08003860 } // release lock
3861
3862 if (needWake) {
3863 mLooper->wake();
3864 }
3865}
3866
Siarhei Vishniakou61fafdd2018-04-13 11:00:58 -05003867/**
3868 * If one of the meta shortcuts is detected, process them here:
3869 * Meta + Backspace -> generate BACK
3870 * Meta + Enter -> generate HOME
3871 * This will potentially overwrite keyCode and metaState.
3872 */
3873void InputDispatcher::accelerateMetaShortcuts(const int32_t deviceId, const int32_t action,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003874 int32_t& keyCode, int32_t& metaState) {
Siarhei Vishniakou61fafdd2018-04-13 11:00:58 -05003875 if (metaState & AMETA_META_ON && action == AKEY_EVENT_ACTION_DOWN) {
3876 int32_t newKeyCode = AKEYCODE_UNKNOWN;
3877 if (keyCode == AKEYCODE_DEL) {
3878 newKeyCode = AKEYCODE_BACK;
3879 } else if (keyCode == AKEYCODE_ENTER) {
3880 newKeyCode = AKEYCODE_HOME;
3881 }
3882 if (newKeyCode != AKEYCODE_UNKNOWN) {
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08003883 std::scoped_lock _l(mLock);
Siarhei Vishniakou61fafdd2018-04-13 11:00:58 -05003884 struct KeyReplacement replacement = {keyCode, deviceId};
Siarhei Vishniakou4700f822020-03-24 19:05:54 -07003885 mReplacedKeys[replacement] = newKeyCode;
Siarhei Vishniakou61fafdd2018-04-13 11:00:58 -05003886 keyCode = newKeyCode;
3887 metaState &= ~(AMETA_META_ON | AMETA_META_LEFT_ON | AMETA_META_RIGHT_ON);
3888 }
3889 } else if (action == AKEY_EVENT_ACTION_UP) {
3890 // In order to maintain a consistent stream of up and down events, check to see if the key
3891 // going up is one we've replaced in a down event and haven't yet replaced in an up event,
3892 // even if the modifier was released between the down and the up events.
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08003893 std::scoped_lock _l(mLock);
Siarhei Vishniakou61fafdd2018-04-13 11:00:58 -05003894 struct KeyReplacement replacement = {keyCode, deviceId};
Siarhei Vishniakou4700f822020-03-24 19:05:54 -07003895 auto replacementIt = mReplacedKeys.find(replacement);
3896 if (replacementIt != mReplacedKeys.end()) {
3897 keyCode = replacementIt->second;
3898 mReplacedKeys.erase(replacementIt);
Siarhei Vishniakou61fafdd2018-04-13 11:00:58 -05003899 metaState &= ~(AMETA_META_ON | AMETA_META_LEFT_ON | AMETA_META_RIGHT_ON);
3900 }
3901 }
3902}
3903
Michael Wrightd02c5b62014-02-10 15:10:22 -08003904void InputDispatcher::notifyKey(const NotifyKeyArgs* args) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003905 if (DEBUG_INBOUND_EVENT_DETAILS) {
3906 ALOGD("notifyKey - eventTime=%" PRId64 ", deviceId=%d, source=0x%x, displayId=%" PRId32
3907 "policyFlags=0x%x, action=0x%x, "
3908 "flags=0x%x, keyCode=0x%x, scanCode=0x%x, metaState=0x%x, downTime=%" PRId64,
3909 args->eventTime, args->deviceId, args->source, args->displayId, args->policyFlags,
3910 args->action, args->flags, args->keyCode, args->scanCode, args->metaState,
3911 args->downTime);
3912 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003913 if (!validateKeyEvent(args->action)) {
3914 return;
3915 }
3916
3917 uint32_t policyFlags = args->policyFlags;
3918 int32_t flags = args->flags;
3919 int32_t metaState = args->metaState;
Siarhei Vishniakou622bd322018-10-29 18:02:27 -07003920 // InputDispatcher tracks and generates key repeats on behalf of
3921 // whatever notifies it, so repeatCount should always be set to 0
3922 constexpr int32_t repeatCount = 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003923 if ((policyFlags & POLICY_FLAG_VIRTUAL) || (flags & AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY)) {
3924 policyFlags |= POLICY_FLAG_VIRTUAL;
3925 flags |= AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY;
3926 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003927 if (policyFlags & POLICY_FLAG_FUNCTION) {
3928 metaState |= AMETA_FUNCTION_ON;
3929 }
3930
3931 policyFlags |= POLICY_FLAG_TRUSTED;
3932
Michael Wright78f24442014-08-06 15:55:28 -07003933 int32_t keyCode = args->keyCode;
Siarhei Vishniakou61fafdd2018-04-13 11:00:58 -05003934 accelerateMetaShortcuts(args->deviceId, args->action, keyCode, metaState);
Michael Wright78f24442014-08-06 15:55:28 -07003935
Michael Wrightd02c5b62014-02-10 15:10:22 -08003936 KeyEvent event;
Garfield Tan6a5a14e2020-01-28 13:24:04 -08003937 event.initialize(args->id, args->deviceId, args->source, args->displayId, INVALID_HMAC,
Garfield Tan4cc839f2020-01-24 11:26:14 -08003938 args->action, flags, keyCode, args->scanCode, metaState, repeatCount,
3939 args->downTime, args->eventTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003940
Michael Wright2b3c3302018-03-02 17:19:13 +00003941 android::base::Timer t;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003942 mPolicy->interceptKeyBeforeQueueing(&event, /*byref*/ policyFlags);
Michael Wright2b3c3302018-03-02 17:19:13 +00003943 if (t.duration() > SLOW_INTERCEPTION_THRESHOLD) {
3944 ALOGW("Excessive delay in interceptKeyBeforeQueueing; took %s ms",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07003945 std::to_string(t.duration().count()).c_str());
Michael Wright2b3c3302018-03-02 17:19:13 +00003946 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08003947
Antonio Kantekf16f2832021-09-28 04:39:20 +00003948 bool needWake = false;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003949 { // acquire lock
3950 mLock.lock();
3951
3952 if (shouldSendKeyToInputFilterLocked(args)) {
3953 mLock.unlock();
3954
Siarhei Vishniakouf00a4ec2021-06-16 03:55:32 +00003955 policyFlags |= POLICY_FLAG_FILTERED;
Michael Wrightd02c5b62014-02-10 15:10:22 -08003956 if (!mPolicy->filterInputEvent(&event, policyFlags)) {
3957 return; // event was consumed by the filter
3958 }
3959
3960 mLock.lock();
3961 }
3962
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003963 std::unique_ptr<KeyEntry> newEntry =
3964 std::make_unique<KeyEntry>(args->id, args->eventTime, args->deviceId, args->source,
3965 args->displayId, policyFlags, args->action, flags,
3966 keyCode, args->scanCode, metaState, repeatCount,
3967 args->downTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08003968
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07003969 needWake = enqueueInboundEventLocked(std::move(newEntry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08003970 mLock.unlock();
3971 } // release lock
3972
3973 if (needWake) {
3974 mLooper->wake();
3975 }
3976}
3977
3978bool InputDispatcher::shouldSendKeyToInputFilterLocked(const NotifyKeyArgs* args) {
3979 return mInputFilterEnabled;
3980}
3981
3982void InputDispatcher::notifyMotion(const NotifyMotionArgs* args) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00003983 if (DEBUG_INBOUND_EVENT_DETAILS) {
3984 ALOGD("notifyMotion - id=%" PRIx32 " eventTime=%" PRId64 ", deviceId=%d, source=0x%x, "
3985 "displayId=%" PRId32 ", policyFlags=0x%x, "
3986 "action=0x%x, actionButton=0x%x, flags=0x%x, metaState=0x%x, buttonState=0x%x, "
3987 "edgeFlags=0x%x, xPrecision=%f, yPrecision=%f, xCursorPosition=%f, "
3988 "yCursorPosition=%f, downTime=%" PRId64,
3989 args->id, args->eventTime, args->deviceId, args->source, args->displayId,
3990 args->policyFlags, args->action, args->actionButton, args->flags, args->metaState,
3991 args->buttonState, args->edgeFlags, args->xPrecision, args->yPrecision,
3992 args->xCursorPosition, args->yCursorPosition, args->downTime);
3993 for (uint32_t i = 0; i < args->pointerCount; i++) {
3994 ALOGD(" Pointer %d: id=%d, toolType=%d, "
3995 "x=%f, y=%f, pressure=%f, size=%f, "
3996 "touchMajor=%f, touchMinor=%f, toolMajor=%f, toolMinor=%f, "
3997 "orientation=%f",
3998 i, args->pointerProperties[i].id, args->pointerProperties[i].toolType,
3999 args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_X),
4000 args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_Y),
4001 args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_PRESSURE),
4002 args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_SIZE),
4003 args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR),
4004 args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR),
4005 args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR),
4006 args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR),
4007 args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION));
4008 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004009 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004010 if (!validateMotionEvent(args->action, args->actionButton, args->pointerCount,
4011 args->pointerProperties)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004012 return;
4013 }
4014
4015 uint32_t policyFlags = args->policyFlags;
4016 policyFlags |= POLICY_FLAG_TRUSTED;
Michael Wright2b3c3302018-03-02 17:19:13 +00004017
4018 android::base::Timer t;
Charles Chen3611f1f2019-01-29 17:26:18 +08004019 mPolicy->interceptMotionBeforeQueueing(args->displayId, args->eventTime, /*byref*/ policyFlags);
Michael Wright2b3c3302018-03-02 17:19:13 +00004020 if (t.duration() > SLOW_INTERCEPTION_THRESHOLD) {
4021 ALOGW("Excessive delay in interceptMotionBeforeQueueing; took %s ms",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004022 std::to_string(t.duration().count()).c_str());
Michael Wright2b3c3302018-03-02 17:19:13 +00004023 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004024
Antonio Kantekf16f2832021-09-28 04:39:20 +00004025 bool needWake = false;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004026 { // acquire lock
4027 mLock.lock();
4028
4029 if (shouldSendMotionToInputFilterLocked(args)) {
Prabir Pradhan81420cc2021-09-06 10:28:50 -07004030 ui::Transform displayTransform;
4031 if (const auto it = mDisplayInfos.find(args->displayId); it != mDisplayInfos.end()) {
4032 displayTransform = it->second.transform;
4033 }
4034
Michael Wrightd02c5b62014-02-10 15:10:22 -08004035 mLock.unlock();
4036
4037 MotionEvent event;
Garfield Tan6a5a14e2020-01-28 13:24:04 -08004038 event.initialize(args->id, args->deviceId, args->source, args->displayId, INVALID_HMAC,
4039 args->action, args->actionButton, args->flags, args->edgeFlags,
Prabir Pradhanb9b18502021-08-26 12:30:32 -07004040 args->metaState, args->buttonState, args->classification,
Prabir Pradhan81420cc2021-09-06 10:28:50 -07004041 displayTransform, args->xPrecision, args->yPrecision,
4042 args->xCursorPosition, args->yCursorPosition, displayTransform,
Prabir Pradhanb9b18502021-08-26 12:30:32 -07004043 args->downTime, args->eventTime, args->pointerCount,
4044 args->pointerProperties, args->pointerCoords);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004045
4046 policyFlags |= POLICY_FLAG_FILTERED;
4047 if (!mPolicy->filterInputEvent(&event, policyFlags)) {
4048 return; // event was consumed by the filter
4049 }
4050
4051 mLock.lock();
4052 }
4053
4054 // Just enqueue a new motion event.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004055 std::unique_ptr<MotionEntry> newEntry =
4056 std::make_unique<MotionEntry>(args->id, args->eventTime, args->deviceId,
4057 args->source, args->displayId, policyFlags,
4058 args->action, args->actionButton, args->flags,
4059 args->metaState, args->buttonState,
4060 args->classification, args->edgeFlags,
4061 args->xPrecision, args->yPrecision,
4062 args->xCursorPosition, args->yCursorPosition,
4063 args->downTime, args->pointerCount,
Prabir Pradhan5beda762021-12-10 09:30:08 +00004064 args->pointerProperties, args->pointerCoords);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004065
Siarhei Vishniakou363e7292021-07-09 03:22:42 +00004066 if (args->id != android::os::IInputConstants::INVALID_INPUT_EVENT_ID &&
4067 IdGenerator::getSource(args->id) == IdGenerator::Source::INPUT_READER &&
4068 !mInputFilterEnabled) {
4069 const bool isDown = args->action == AMOTION_EVENT_ACTION_DOWN;
4070 mLatencyTracker.trackListener(args->id, isDown, args->eventTime, args->readTime);
4071 }
4072
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004073 needWake = enqueueInboundEventLocked(std::move(newEntry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08004074 mLock.unlock();
4075 } // release lock
4076
4077 if (needWake) {
4078 mLooper->wake();
4079 }
4080}
4081
Chris Yef59a2f42020-10-16 12:55:26 -07004082void InputDispatcher::notifySensor(const NotifySensorArgs* args) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004083 if (DEBUG_INBOUND_EVENT_DETAILS) {
4084 ALOGD("notifySensor - id=%" PRIx32 " eventTime=%" PRId64 ", deviceId=%d, source=0x%x, "
4085 " sensorType=%s",
4086 args->id, args->eventTime, args->deviceId, args->source,
Dominik Laskowski75788452021-02-09 18:51:25 -08004087 ftl::enum_string(args->sensorType).c_str());
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004088 }
Chris Yef59a2f42020-10-16 12:55:26 -07004089
Antonio Kantekf16f2832021-09-28 04:39:20 +00004090 bool needWake = false;
Chris Yef59a2f42020-10-16 12:55:26 -07004091 { // acquire lock
4092 mLock.lock();
4093
4094 // Just enqueue a new sensor event.
4095 std::unique_ptr<SensorEntry> newEntry =
4096 std::make_unique<SensorEntry>(args->id, args->eventTime, args->deviceId,
4097 args->source, 0 /* policyFlags*/, args->hwTimestamp,
4098 args->sensorType, args->accuracy,
4099 args->accuracyChanged, args->values);
4100
4101 needWake = enqueueInboundEventLocked(std::move(newEntry));
4102 mLock.unlock();
4103 } // release lock
4104
4105 if (needWake) {
4106 mLooper->wake();
4107 }
4108}
4109
Chris Yefb552902021-02-03 17:18:37 -08004110void InputDispatcher::notifyVibratorState(const NotifyVibratorStateArgs* args) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004111 if (DEBUG_INBOUND_EVENT_DETAILS) {
4112 ALOGD("notifyVibratorState - eventTime=%" PRId64 ", device=%d, isOn=%d", args->eventTime,
4113 args->deviceId, args->isOn);
4114 }
Chris Yefb552902021-02-03 17:18:37 -08004115 mPolicy->notifyVibratorState(args->deviceId, args->isOn);
4116}
4117
Michael Wrightd02c5b62014-02-10 15:10:22 -08004118bool InputDispatcher::shouldSendMotionToInputFilterLocked(const NotifyMotionArgs* args) {
Jackal Guof9696682018-10-05 12:23:23 +08004119 return mInputFilterEnabled;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004120}
4121
4122void InputDispatcher::notifySwitch(const NotifySwitchArgs* args) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004123 if (DEBUG_INBOUND_EVENT_DETAILS) {
4124 ALOGD("notifySwitch - eventTime=%" PRId64 ", policyFlags=0x%x, switchValues=0x%08x, "
4125 "switchMask=0x%08x",
4126 args->eventTime, args->policyFlags, args->switchValues, args->switchMask);
4127 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004128
4129 uint32_t policyFlags = args->policyFlags;
4130 policyFlags |= POLICY_FLAG_TRUSTED;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004131 mPolicy->notifySwitch(args->eventTime, args->switchValues, args->switchMask, policyFlags);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004132}
4133
4134void InputDispatcher::notifyDeviceReset(const NotifyDeviceResetArgs* args) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004135 if (DEBUG_INBOUND_EVENT_DETAILS) {
4136 ALOGD("notifyDeviceReset - eventTime=%" PRId64 ", deviceId=%d", args->eventTime,
4137 args->deviceId);
4138 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004139
Antonio Kantekf16f2832021-09-28 04:39:20 +00004140 bool needWake = false;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004141 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004142 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004143
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004144 std::unique_ptr<DeviceResetEntry> newEntry =
4145 std::make_unique<DeviceResetEntry>(args->id, args->eventTime, args->deviceId);
4146 needWake = enqueueInboundEventLocked(std::move(newEntry));
Michael Wrightd02c5b62014-02-10 15:10:22 -08004147 } // release lock
4148
4149 if (needWake) {
4150 mLooper->wake();
4151 }
4152}
4153
Prabir Pradhan7e186182020-11-10 13:56:45 -08004154void InputDispatcher::notifyPointerCaptureChanged(const NotifyPointerCaptureChangedArgs* args) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004155 if (DEBUG_INBOUND_EVENT_DETAILS) {
4156 ALOGD("notifyPointerCaptureChanged - eventTime=%" PRId64 ", enabled=%s", args->eventTime,
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00004157 args->request.enable ? "true" : "false");
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004158 }
Prabir Pradhan7e186182020-11-10 13:56:45 -08004159
Antonio Kantekf16f2832021-09-28 04:39:20 +00004160 bool needWake = false;
Prabir Pradhan99987712020-11-10 18:43:05 -08004161 { // acquire lock
4162 std::scoped_lock _l(mLock);
4163 auto entry = std::make_unique<PointerCaptureChangedEntry>(args->id, args->eventTime,
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00004164 args->request);
Prabir Pradhan99987712020-11-10 18:43:05 -08004165 needWake = enqueueInboundEventLocked(std::move(entry));
4166 } // release lock
4167
4168 if (needWake) {
4169 mLooper->wake();
4170 }
Prabir Pradhan7e186182020-11-10 13:56:45 -08004171}
4172
Prabir Pradhan8a2b1a42022-04-11 17:23:34 +00004173InputEventInjectionResult InputDispatcher::injectInputEvent(const InputEvent* event,
4174 std::optional<int32_t> targetUid,
4175 InputEventInjectionSync syncMode,
4176 std::chrono::milliseconds timeout,
4177 uint32_t policyFlags) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004178 if (DEBUG_INBOUND_EVENT_DETAILS) {
Prabir Pradhan8a2b1a42022-04-11 17:23:34 +00004179 ALOGD("injectInputEvent - eventType=%d, targetUid=%s, syncMode=%d, timeout=%lld, "
4180 "policyFlags=0x%08x",
4181 event->getType(), targetUid ? std::to_string(*targetUid).c_str() : "none", syncMode,
4182 timeout.count(), policyFlags);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004183 }
Siarhei Vishniakou097c3db2020-05-06 14:18:38 -07004184 nsecs_t endTime = now() + std::chrono::duration_cast<std::chrono::nanoseconds>(timeout).count();
Michael Wrightd02c5b62014-02-10 15:10:22 -08004185
Prabir Pradhan8a2b1a42022-04-11 17:23:34 +00004186 policyFlags |= POLICY_FLAG_INJECTED | POLICY_FLAG_TRUSTED;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004187
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004188 // For all injected events, set device id = VIRTUAL_KEYBOARD_ID. The only exception is events
Siarhei Vishniakouf00a4ec2021-06-16 03:55:32 +00004189 // that have gone through the InputFilter. If the event passed through the InputFilter, assign
4190 // the provided device id. If the InputFilter is accessibility, and it modifies or synthesizes
4191 // the injected event, it is responsible for setting POLICY_FLAG_INJECTED_FROM_ACCESSIBILITY.
4192 // For those events, we will set FLAG_IS_ACCESSIBILITY_EVENT to allow apps to distinguish them
4193 // from events that originate from actual hardware.
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004194 int32_t resolvedDeviceId = VIRTUAL_KEYBOARD_ID;
Siarhei Vishniakouf00a4ec2021-06-16 03:55:32 +00004195 if (policyFlags & POLICY_FLAG_FILTERED) {
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004196 resolvedDeviceId = event->getDeviceId();
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004197 }
4198
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004199 std::queue<std::unique_ptr<EventEntry>> injectedEntries;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004200 switch (event->getType()) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004201 case AINPUT_EVENT_TYPE_KEY: {
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -08004202 const KeyEvent& incomingKey = static_cast<const KeyEvent&>(*event);
4203 int32_t action = incomingKey.getAction();
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004204 if (!validateKeyEvent(action)) {
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004205 return InputEventInjectionResult::FAILED;
Michael Wright2b3c3302018-03-02 17:19:13 +00004206 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004207
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -08004208 int32_t flags = incomingKey.getFlags();
Siarhei Vishniakouf00a4ec2021-06-16 03:55:32 +00004209 if (policyFlags & POLICY_FLAG_INJECTED_FROM_ACCESSIBILITY) {
4210 flags |= AKEY_EVENT_FLAG_IS_ACCESSIBILITY_EVENT;
4211 }
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -08004212 int32_t keyCode = incomingKey.getKeyCode();
4213 int32_t metaState = incomingKey.getMetaState();
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004214 accelerateMetaShortcuts(resolvedDeviceId, action,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004215 /*byref*/ keyCode, /*byref*/ metaState);
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -08004216 KeyEvent keyEvent;
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004217 keyEvent.initialize(incomingKey.getId(), resolvedDeviceId, incomingKey.getSource(),
Siarhei Vishniakou0d8ed6e2020-01-17 15:48:59 -08004218 incomingKey.getDisplayId(), INVALID_HMAC, action, flags, keyCode,
4219 incomingKey.getScanCode(), metaState, incomingKey.getRepeatCount(),
4220 incomingKey.getDownTime(), incomingKey.getEventTime());
Michael Wrightd02c5b62014-02-10 15:10:22 -08004221
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004222 if (flags & AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY) {
4223 policyFlags |= POLICY_FLAG_VIRTUAL;
Michael Wright2b3c3302018-03-02 17:19:13 +00004224 }
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004225
4226 if (!(policyFlags & POLICY_FLAG_FILTERED)) {
4227 android::base::Timer t;
4228 mPolicy->interceptKeyBeforeQueueing(&keyEvent, /*byref*/ policyFlags);
4229 if (t.duration() > SLOW_INTERCEPTION_THRESHOLD) {
4230 ALOGW("Excessive delay in interceptKeyBeforeQueueing; took %s ms",
4231 std::to_string(t.duration().count()).c_str());
4232 }
4233 }
4234
4235 mLock.lock();
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004236 std::unique_ptr<KeyEntry> injectedEntry =
4237 std::make_unique<KeyEntry>(incomingKey.getId(), incomingKey.getEventTime(),
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004238 resolvedDeviceId, incomingKey.getSource(),
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004239 incomingKey.getDisplayId(), policyFlags, action,
4240 flags, keyCode, incomingKey.getScanCode(), metaState,
4241 incomingKey.getRepeatCount(),
4242 incomingKey.getDownTime());
4243 injectedEntries.push(std::move(injectedEntry));
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004244 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004245 }
4246
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004247 case AINPUT_EVENT_TYPE_MOTION: {
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004248 const MotionEvent& motionEvent = static_cast<const MotionEvent&>(*event);
Prabir Pradhanaa561d12021-09-24 06:57:33 -07004249 const int32_t action = motionEvent.getAction();
4250 const bool isPointerEvent =
4251 isFromSource(event->getSource(), AINPUT_SOURCE_CLASS_POINTER);
4252 // If a pointer event has no displayId specified, inject it to the default display.
4253 const uint32_t displayId = isPointerEvent && (event->getDisplayId() == ADISPLAY_ID_NONE)
4254 ? ADISPLAY_ID_DEFAULT
4255 : event->getDisplayId();
4256 const size_t pointerCount = motionEvent.getPointerCount();
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004257 const PointerProperties* pointerProperties = motionEvent.getPointerProperties();
Prabir Pradhanaa561d12021-09-24 06:57:33 -07004258 const int32_t actionButton = motionEvent.getActionButton();
Siarhei Vishniakouf00a4ec2021-06-16 03:55:32 +00004259 int32_t flags = motionEvent.getFlags();
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004260 if (!validateMotionEvent(action, actionButton, pointerCount, pointerProperties)) {
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004261 return InputEventInjectionResult::FAILED;
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004262 }
4263
4264 if (!(policyFlags & POLICY_FLAG_FILTERED)) {
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004265 nsecs_t eventTime = motionEvent.getEventTime();
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004266 android::base::Timer t;
4267 mPolicy->interceptMotionBeforeQueueing(displayId, eventTime, /*byref*/ policyFlags);
4268 if (t.duration() > SLOW_INTERCEPTION_THRESHOLD) {
4269 ALOGW("Excessive delay in interceptMotionBeforeQueueing; took %s ms",
4270 std::to_string(t.duration().count()).c_str());
4271 }
4272 }
4273
Siarhei Vishniakouf00a4ec2021-06-16 03:55:32 +00004274 if (policyFlags & POLICY_FLAG_INJECTED_FROM_ACCESSIBILITY) {
4275 flags |= AMOTION_EVENT_FLAG_IS_ACCESSIBILITY_EVENT;
4276 }
4277
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004278 mLock.lock();
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004279 const nsecs_t* sampleEventTimes = motionEvent.getSampleEventTimes();
4280 const PointerCoords* samplePointerCoords = motionEvent.getSamplePointerCoords();
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004281 std::unique_ptr<MotionEntry> injectedEntry =
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004282 std::make_unique<MotionEntry>(motionEvent.getId(), *sampleEventTimes,
4283 resolvedDeviceId, motionEvent.getSource(),
Prabir Pradhanaa561d12021-09-24 06:57:33 -07004284 displayId, policyFlags, action, actionButton,
4285 flags, motionEvent.getMetaState(),
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004286 motionEvent.getButtonState(),
4287 motionEvent.getClassification(),
4288 motionEvent.getEdgeFlags(),
4289 motionEvent.getXPrecision(),
4290 motionEvent.getYPrecision(),
4291 motionEvent.getRawXCursorPosition(),
4292 motionEvent.getRawYCursorPosition(),
4293 motionEvent.getDownTime(), uint32_t(pointerCount),
Prabir Pradhan5beda762021-12-10 09:30:08 +00004294 pointerProperties, samplePointerCoords);
Prabir Pradhandaa2f142021-12-10 09:30:08 +00004295 transformMotionEntryForInjectionLocked(*injectedEntry, motionEvent.getTransform());
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004296 injectedEntries.push(std::move(injectedEntry));
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004297 for (size_t i = motionEvent.getHistorySize(); i > 0; i--) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004298 sampleEventTimes += 1;
4299 samplePointerCoords += pointerCount;
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004300 std::unique_ptr<MotionEntry> nextInjectedEntry =
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004301 std::make_unique<MotionEntry>(motionEvent.getId(), *sampleEventTimes,
4302 resolvedDeviceId, motionEvent.getSource(),
Prabir Pradhanaa561d12021-09-24 06:57:33 -07004303 displayId, policyFlags, action, actionButton,
4304 flags, motionEvent.getMetaState(),
Siarhei Vishniakou5d552c42021-05-21 05:02:22 +00004305 motionEvent.getButtonState(),
4306 motionEvent.getClassification(),
4307 motionEvent.getEdgeFlags(),
4308 motionEvent.getXPrecision(),
4309 motionEvent.getYPrecision(),
4310 motionEvent.getRawXCursorPosition(),
4311 motionEvent.getRawYCursorPosition(),
4312 motionEvent.getDownTime(),
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004313 uint32_t(pointerCount), pointerProperties,
Prabir Pradhan5beda762021-12-10 09:30:08 +00004314 samplePointerCoords);
Prabir Pradhandaa2f142021-12-10 09:30:08 +00004315 transformMotionEntryForInjectionLocked(*nextInjectedEntry,
4316 motionEvent.getTransform());
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004317 injectedEntries.push(std::move(nextInjectedEntry));
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004318 }
4319 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004320 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004321
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004322 default:
Siarhei Vishniakou7feb2ea2019-11-25 15:11:23 -08004323 ALOGW("Cannot inject %s events", inputEventTypeToString(event->getType()));
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004324 return InputEventInjectionResult::FAILED;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004325 }
4326
Prabir Pradhan8a2b1a42022-04-11 17:23:34 +00004327 InjectionState* injectionState = new InjectionState(targetUid);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004328 if (syncMode == InputEventInjectionSync::NONE) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004329 injectionState->injectionIsAsync = true;
4330 }
4331
4332 injectionState->refCount += 1;
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07004333 injectedEntries.back()->injectionState = injectionState;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004334
4335 bool needWake = false;
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07004336 while (!injectedEntries.empty()) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004337 needWake |= enqueueInboundEventLocked(std::move(injectedEntries.front()));
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07004338 injectedEntries.pop();
Michael Wrightd02c5b62014-02-10 15:10:22 -08004339 }
4340
4341 mLock.unlock();
4342
4343 if (needWake) {
4344 mLooper->wake();
4345 }
4346
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004347 InputEventInjectionResult injectionResult;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004348 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004349 std::unique_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004350
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004351 if (syncMode == InputEventInjectionSync::NONE) {
4352 injectionResult = InputEventInjectionResult::SUCCEEDED;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004353 } else {
4354 for (;;) {
4355 injectionResult = injectionState->injectionResult;
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004356 if (injectionResult != InputEventInjectionResult::PENDING) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004357 break;
4358 }
4359
4360 nsecs_t remainingTimeout = endTime - now();
4361 if (remainingTimeout <= 0) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004362 if (DEBUG_INJECTION) {
4363 ALOGD("injectInputEvent - Timed out waiting for injection result "
4364 "to become available.");
4365 }
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004366 injectionResult = InputEventInjectionResult::TIMED_OUT;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004367 break;
4368 }
4369
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004370 mInjectionResultAvailable.wait_for(_l, std::chrono::nanoseconds(remainingTimeout));
Michael Wrightd02c5b62014-02-10 15:10:22 -08004371 }
4372
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004373 if (injectionResult == InputEventInjectionResult::SUCCEEDED &&
4374 syncMode == InputEventInjectionSync::WAIT_FOR_FINISHED) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004375 while (injectionState->pendingForegroundDispatches != 0) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004376 if (DEBUG_INJECTION) {
4377 ALOGD("injectInputEvent - Waiting for %d pending foreground dispatches.",
4378 injectionState->pendingForegroundDispatches);
4379 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004380 nsecs_t remainingTimeout = endTime - now();
4381 if (remainingTimeout <= 0) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004382 if (DEBUG_INJECTION) {
4383 ALOGD("injectInputEvent - Timed out waiting for pending foreground "
4384 "dispatches to finish.");
4385 }
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004386 injectionResult = InputEventInjectionResult::TIMED_OUT;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004387 break;
4388 }
4389
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004390 mInjectionSyncFinished.wait_for(_l, std::chrono::nanoseconds(remainingTimeout));
Michael Wrightd02c5b62014-02-10 15:10:22 -08004391 }
4392 }
4393 }
4394
4395 injectionState->release();
4396 } // release lock
4397
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004398 if (DEBUG_INJECTION) {
Prabir Pradhan8a2b1a42022-04-11 17:23:34 +00004399 ALOGD("injectInputEvent - Finished with result %d.", injectionResult);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004400 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004401
4402 return injectionResult;
4403}
4404
Siarhei Vishniakou54d3e182020-01-15 17:38:38 -08004405std::unique_ptr<VerifiedInputEvent> InputDispatcher::verifyInputEvent(const InputEvent& event) {
Gang Wange9087892020-01-07 12:17:14 -05004406 std::array<uint8_t, 32> calculatedHmac;
4407 std::unique_ptr<VerifiedInputEvent> result;
4408 switch (event.getType()) {
4409 case AINPUT_EVENT_TYPE_KEY: {
4410 const KeyEvent& keyEvent = static_cast<const KeyEvent&>(event);
4411 VerifiedKeyEvent verifiedKeyEvent = verifiedKeyEventFromKeyEvent(keyEvent);
4412 result = std::make_unique<VerifiedKeyEvent>(verifiedKeyEvent);
chaviw09c8d2d2020-08-24 15:48:26 -07004413 calculatedHmac = sign(verifiedKeyEvent);
Gang Wange9087892020-01-07 12:17:14 -05004414 break;
4415 }
4416 case AINPUT_EVENT_TYPE_MOTION: {
4417 const MotionEvent& motionEvent = static_cast<const MotionEvent&>(event);
4418 VerifiedMotionEvent verifiedMotionEvent =
4419 verifiedMotionEventFromMotionEvent(motionEvent);
4420 result = std::make_unique<VerifiedMotionEvent>(verifiedMotionEvent);
chaviw09c8d2d2020-08-24 15:48:26 -07004421 calculatedHmac = sign(verifiedMotionEvent);
Gang Wange9087892020-01-07 12:17:14 -05004422 break;
4423 }
4424 default: {
4425 ALOGE("Cannot verify events of type %" PRId32, event.getType());
4426 return nullptr;
4427 }
4428 }
4429 if (calculatedHmac == INVALID_HMAC) {
4430 return nullptr;
4431 }
4432 if (calculatedHmac != event.getHmac()) {
4433 return nullptr;
4434 }
4435 return result;
Siarhei Vishniakou54d3e182020-01-15 17:38:38 -08004436}
4437
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004438void InputDispatcher::setInjectionResult(EventEntry& entry,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004439 InputEventInjectionResult injectionResult) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004440 InjectionState* injectionState = entry.injectionState;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004441 if (injectionState) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004442 if (DEBUG_INJECTION) {
Prabir Pradhan8a2b1a42022-04-11 17:23:34 +00004443 ALOGD("Setting input event injection result to %d.", injectionResult);
Prabir Pradhan61a5d242021-07-26 16:41:09 +00004444 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004445
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004446 if (injectionState->injectionIsAsync && !(entry.policyFlags & POLICY_FLAG_FILTERED)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08004447 // Log the outcome since the injector did not wait for the injection result.
4448 switch (injectionResult) {
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004449 case InputEventInjectionResult::SUCCEEDED:
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004450 ALOGV("Asynchronous input event injection succeeded.");
4451 break;
Prabir Pradhan8a2b1a42022-04-11 17:23:34 +00004452 case InputEventInjectionResult::TARGET_MISMATCH:
4453 ALOGV("Asynchronous input event injection target mismatch.");
4454 break;
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004455 case InputEventInjectionResult::FAILED:
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004456 ALOGW("Asynchronous input event injection failed.");
4457 break;
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004458 case InputEventInjectionResult::TIMED_OUT:
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004459 ALOGW("Asynchronous input event injection timed out.");
4460 break;
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004461 case InputEventInjectionResult::PENDING:
4462 ALOGE("Setting result to 'PENDING' for asynchronous injection");
4463 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004464 }
4465 }
4466
4467 injectionState->injectionResult = injectionResult;
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004468 mInjectionResultAvailable.notify_all();
Michael Wrightd02c5b62014-02-10 15:10:22 -08004469 }
4470}
4471
Prabir Pradhandaa2f142021-12-10 09:30:08 +00004472void InputDispatcher::transformMotionEntryForInjectionLocked(
4473 MotionEntry& entry, const ui::Transform& injectedTransform) const {
Prabir Pradhan81420cc2021-09-06 10:28:50 -07004474 // Input injection works in the logical display coordinate space, but the input pipeline works
4475 // display space, so we need to transform the injected events accordingly.
4476 const auto it = mDisplayInfos.find(entry.displayId);
4477 if (it == mDisplayInfos.end()) return;
Prabir Pradhandaa2f142021-12-10 09:30:08 +00004478 const auto& transformToDisplay = it->second.transform.inverse() * injectedTransform;
Prabir Pradhan81420cc2021-09-06 10:28:50 -07004479
Prabir Pradhand9a2ebe2022-07-20 19:25:13 +00004480 if (entry.xCursorPosition != AMOTION_EVENT_INVALID_CURSOR_POSITION &&
4481 entry.yCursorPosition != AMOTION_EVENT_INVALID_CURSOR_POSITION) {
4482 const vec2 cursor =
4483 MotionEvent::calculateTransformedXY(entry.source, transformToDisplay,
4484 {entry.xCursorPosition, entry.yCursorPosition});
4485 entry.xCursorPosition = cursor.x;
4486 entry.yCursorPosition = cursor.y;
4487 }
Prabir Pradhan81420cc2021-09-06 10:28:50 -07004488 for (uint32_t i = 0; i < entry.pointerCount; i++) {
Prabir Pradhan8e6ce222022-02-24 09:08:54 -08004489 entry.pointerCoords[i] =
4490 MotionEvent::calculateTransformedCoords(entry.source, transformToDisplay,
4491 entry.pointerCoords[i]);
Prabir Pradhan81420cc2021-09-06 10:28:50 -07004492 }
4493}
4494
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004495void InputDispatcher::incrementPendingForegroundDispatches(EventEntry& entry) {
4496 InjectionState* injectionState = entry.injectionState;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004497 if (injectionState) {
4498 injectionState->pendingForegroundDispatches += 1;
4499 }
4500}
4501
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07004502void InputDispatcher::decrementPendingForegroundDispatches(EventEntry& entry) {
4503 InjectionState* injectionState = entry.injectionState;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004504 if (injectionState) {
4505 injectionState->pendingForegroundDispatches -= 1;
4506
4507 if (injectionState->pendingForegroundDispatches == 0) {
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004508 mInjectionSyncFinished.notify_all();
Michael Wrightd02c5b62014-02-10 15:10:22 -08004509 }
4510 }
4511}
4512
chaviw98318de2021-05-19 16:45:23 -05004513const std::vector<sp<WindowInfoHandle>>& InputDispatcher::getWindowHandlesLocked(
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08004514 int32_t displayId) const {
chaviw98318de2021-05-19 16:45:23 -05004515 static const std::vector<sp<WindowInfoHandle>> EMPTY_WINDOW_HANDLES;
Vishnu Nairad321cd2020-08-20 16:40:21 -07004516 auto it = mWindowHandlesByDisplay.find(displayId);
4517 return it != mWindowHandlesByDisplay.end() ? it->second : EMPTY_WINDOW_HANDLES;
Arthur Hungb92218b2018-08-14 12:00:21 +08004518}
4519
chaviw98318de2021-05-19 16:45:23 -05004520sp<WindowInfoHandle> InputDispatcher::getWindowHandleLocked(
chaviwfbe5d9c2018-12-26 12:23:37 -08004521 const sp<IBinder>& windowHandleToken) const {
arthurhungbe737672020-06-24 12:29:21 +08004522 if (windowHandleToken == nullptr) {
4523 return nullptr;
4524 }
4525
Arthur Hungb92218b2018-08-14 12:00:21 +08004526 for (auto& it : mWindowHandlesByDisplay) {
chaviw98318de2021-05-19 16:45:23 -05004527 const std::vector<sp<WindowInfoHandle>>& windowHandles = it.second;
4528 for (const sp<WindowInfoHandle>& windowHandle : windowHandles) {
chaviwfbe5d9c2018-12-26 12:23:37 -08004529 if (windowHandle->getToken() == windowHandleToken) {
Arthur Hungb92218b2018-08-14 12:00:21 +08004530 return windowHandle;
4531 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004532 }
4533 }
Yi Kong9b14ac62018-07-17 13:48:38 -07004534 return nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004535}
4536
chaviw98318de2021-05-19 16:45:23 -05004537sp<WindowInfoHandle> InputDispatcher::getWindowHandleLocked(const sp<IBinder>& windowHandleToken,
4538 int displayId) const {
Vishnu Nairad321cd2020-08-20 16:40:21 -07004539 if (windowHandleToken == nullptr) {
4540 return nullptr;
4541 }
4542
chaviw98318de2021-05-19 16:45:23 -05004543 for (const sp<WindowInfoHandle>& windowHandle : getWindowHandlesLocked(displayId)) {
Vishnu Nairad321cd2020-08-20 16:40:21 -07004544 if (windowHandle->getToken() == windowHandleToken) {
4545 return windowHandle;
4546 }
4547 }
4548 return nullptr;
4549}
4550
chaviw98318de2021-05-19 16:45:23 -05004551sp<WindowInfoHandle> InputDispatcher::getWindowHandleLocked(
4552 const sp<WindowInfoHandle>& windowHandle) const {
Mady Mellor017bcd12020-06-23 19:12:00 +00004553 for (auto& it : mWindowHandlesByDisplay) {
chaviw98318de2021-05-19 16:45:23 -05004554 const std::vector<sp<WindowInfoHandle>>& windowHandles = it.second;
4555 for (const sp<WindowInfoHandle>& handle : windowHandles) {
arthurhungbe737672020-06-24 12:29:21 +08004556 if (handle->getId() == windowHandle->getId() &&
4557 handle->getToken() == windowHandle->getToken()) {
Mady Mellor017bcd12020-06-23 19:12:00 +00004558 if (windowHandle->getInfo()->displayId != it.first) {
4559 ALOGE("Found window %s in display %" PRId32
4560 ", but it should belong to display %" PRId32,
4561 windowHandle->getName().c_str(), it.first,
4562 windowHandle->getInfo()->displayId);
4563 }
Prabir Pradhan6a9a8312021-04-23 11:59:31 -07004564 return handle;
Arthur Hungb92218b2018-08-14 12:00:21 +08004565 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004566 }
4567 }
Prabir Pradhan6a9a8312021-04-23 11:59:31 -07004568 return nullptr;
4569}
4570
chaviw98318de2021-05-19 16:45:23 -05004571sp<WindowInfoHandle> InputDispatcher::getFocusedWindowHandleLocked(int displayId) const {
Prabir Pradhan6a9a8312021-04-23 11:59:31 -07004572 sp<IBinder> focusedToken = mFocusResolver.getFocusedWindowToken(displayId);
4573 return getWindowHandleLocked(focusedToken, displayId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004574}
4575
chaviw98318de2021-05-19 16:45:23 -05004576bool InputDispatcher::hasResponsiveConnectionLocked(WindowInfoHandle& windowHandle) const {
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05004577 sp<Connection> connection = getConnectionLocked(windowHandle.getToken());
4578 const bool noInputChannel =
Prabir Pradhan51e7db02022-02-07 06:02:57 -08004579 windowHandle.getInfo()->inputConfig.test(WindowInfo::InputConfig::NO_INPUT_CHANNEL);
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05004580 if (connection != nullptr && noInputChannel) {
4581 ALOGW("%s has feature NO_INPUT_CHANNEL, but it matched to connection %s",
4582 windowHandle.getName().c_str(), connection->inputChannel->getName().c_str());
4583 return false;
4584 }
4585
4586 if (connection == nullptr) {
4587 if (!noInputChannel) {
4588 ALOGI("Could not find connection for %s", windowHandle.getName().c_str());
4589 }
4590 return false;
4591 }
4592 if (!connection->responsive) {
4593 ALOGW("Window %s is not responsive", windowHandle.getName().c_str());
4594 return false;
4595 }
4596 return true;
4597}
4598
Siarhei Vishniakouce5ab082020-07-09 17:03:21 -05004599std::shared_ptr<InputChannel> InputDispatcher::getInputChannelLocked(
4600 const sp<IBinder>& token) const {
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00004601 auto connectionIt = mConnectionsByToken.find(token);
4602 if (connectionIt == mConnectionsByToken.end()) {
Robert Carr5c8a0262018-10-03 16:30:44 -07004603 return nullptr;
4604 }
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00004605 return connectionIt->second->inputChannel;
Robert Carr5c8a0262018-10-03 16:30:44 -07004606}
4607
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07004608void InputDispatcher::updateWindowHandlesForDisplayLocked(
chaviw98318de2021-05-19 16:45:23 -05004609 const std::vector<sp<WindowInfoHandle>>& windowInfoHandles, int32_t displayId) {
4610 if (windowInfoHandles.empty()) {
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07004611 // Remove all handles on a display if there are no windows left.
4612 mWindowHandlesByDisplay.erase(displayId);
4613 return;
4614 }
4615
4616 // Since we compare the pointer of input window handles across window updates, we need
4617 // to make sure the handle object for the same window stays unchanged across updates.
chaviw98318de2021-05-19 16:45:23 -05004618 const std::vector<sp<WindowInfoHandle>>& oldHandles = getWindowHandlesLocked(displayId);
4619 std::unordered_map<int32_t /*id*/, sp<WindowInfoHandle>> oldHandlesById;
4620 for (const sp<WindowInfoHandle>& handle : oldHandles) {
chaviwaf87b3e2019-10-01 16:59:28 -07004621 oldHandlesById[handle->getId()] = handle;
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07004622 }
4623
chaviw98318de2021-05-19 16:45:23 -05004624 std::vector<sp<WindowInfoHandle>> newHandles;
4625 for (const sp<WindowInfoHandle>& handle : windowInfoHandles) {
chaviw98318de2021-05-19 16:45:23 -05004626 const WindowInfo* info = handle->getInfo();
Siarhei Vishniakou64452932020-11-06 17:51:32 -06004627 if (getInputChannelLocked(handle->getToken()) == nullptr) {
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07004628 const bool noInputChannel =
Prabir Pradhan51e7db02022-02-07 06:02:57 -08004629 info->inputConfig.test(WindowInfo::InputConfig::NO_INPUT_CHANNEL);
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08004630 const bool canReceiveInput =
4631 !info->inputConfig.test(WindowInfo::InputConfig::NOT_TOUCHABLE) ||
4632 !info->inputConfig.test(WindowInfo::InputConfig::NOT_FOCUSABLE);
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07004633 if (canReceiveInput && !noInputChannel) {
John Recke0710582019-09-26 13:46:12 -07004634 ALOGV("Window handle %s has no registered input channel",
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07004635 handle->getName().c_str());
Robert Carr2984b7a2020-04-13 17:06:45 -07004636 continue;
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07004637 }
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07004638 }
4639
4640 if (info->displayId != displayId) {
4641 ALOGE("Window %s updated by wrong display %d, should belong to display %d",
4642 handle->getName().c_str(), displayId, info->displayId);
4643 continue;
4644 }
4645
Robert Carredd13602020-04-13 17:24:34 -07004646 if ((oldHandlesById.find(handle->getId()) != oldHandlesById.end()) &&
4647 (oldHandlesById.at(handle->getId())->getToken() == handle->getToken())) {
chaviw98318de2021-05-19 16:45:23 -05004648 const sp<WindowInfoHandle>& oldHandle = oldHandlesById.at(handle->getId());
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07004649 oldHandle->updateFrom(handle);
4650 newHandles.push_back(oldHandle);
4651 } else {
4652 newHandles.push_back(handle);
4653 }
4654 }
4655
4656 // Insert or replace
4657 mWindowHandlesByDisplay[displayId] = newHandles;
4658}
4659
Arthur Hung72d8dc32020-03-28 00:48:39 +00004660void InputDispatcher::setInputWindows(
chaviw98318de2021-05-19 16:45:23 -05004661 const std::unordered_map<int32_t, std::vector<sp<WindowInfoHandle>>>& handlesPerDisplay) {
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07004662 // TODO(b/198444055): Remove setInputWindows from InputDispatcher.
Arthur Hung72d8dc32020-03-28 00:48:39 +00004663 { // acquire lock
4664 std::scoped_lock _l(mLock);
Siarhei Vishniakou2508b872020-12-03 16:33:53 -10004665 for (const auto& [displayId, handles] : handlesPerDisplay) {
4666 setInputWindowsLocked(handles, displayId);
Arthur Hung72d8dc32020-03-28 00:48:39 +00004667 }
4668 }
4669 // Wake up poll loop since it may need to make new input dispatching choices.
4670 mLooper->wake();
4671}
4672
Arthur Hungb92218b2018-08-14 12:00:21 +08004673/**
4674 * Called from InputManagerService, update window handle list by displayId that can receive input.
4675 * A window handle contains information about InputChannel, Touch Region, Types, Focused,...
4676 * If set an empty list, remove all handles from the specific display.
4677 * For focused handle, check if need to change and send a cancel event to previous one.
4678 * For removed handle, check if need to send a cancel event if already in touch.
4679 */
Arthur Hung72d8dc32020-03-28 00:48:39 +00004680void InputDispatcher::setInputWindowsLocked(
chaviw98318de2021-05-19 16:45:23 -05004681 const std::vector<sp<WindowInfoHandle>>& windowInfoHandles, int32_t displayId) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01004682 if (DEBUG_FOCUS) {
4683 std::string windowList;
chaviw98318de2021-05-19 16:45:23 -05004684 for (const sp<WindowInfoHandle>& iwh : windowInfoHandles) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01004685 windowList += iwh->getName() + " ";
4686 }
4687 ALOGD("setInputWindows displayId=%" PRId32 " %s", displayId, windowList.c_str());
4688 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004689
Prabir Pradhand65552b2021-10-07 11:23:50 -07004690 // Check preconditions for new input windows
chaviw98318de2021-05-19 16:45:23 -05004691 for (const sp<WindowInfoHandle>& window : windowInfoHandles) {
Prabir Pradhand65552b2021-10-07 11:23:50 -07004692 const WindowInfo& info = *window->getInfo();
4693
4694 // Ensure all tokens are null if the window has feature NO_INPUT_CHANNEL
Prabir Pradhan51e7db02022-02-07 06:02:57 -08004695 const bool noInputWindow = info.inputConfig.test(WindowInfo::InputConfig::NO_INPUT_CHANNEL);
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05004696 if (noInputWindow && window->getToken() != nullptr) {
4697 ALOGE("%s has feature NO_INPUT_WINDOW, but a non-null token. Clearing",
4698 window->getName().c_str());
4699 window->releaseChannel();
4700 }
Prabir Pradhand65552b2021-10-07 11:23:50 -07004701
Prabir Pradhan5c85e052021-12-22 02:27:12 -08004702 // Ensure all spy windows are trusted overlays
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08004703 LOG_ALWAYS_FATAL_IF(info.isSpy() &&
4704 !info.inputConfig.test(
4705 WindowInfo::InputConfig::TRUSTED_OVERLAY),
Prabir Pradhan5c85e052021-12-22 02:27:12 -08004706 "%s has feature SPY, but is not a trusted overlay.",
4707 window->getName().c_str());
4708
Prabir Pradhand65552b2021-10-07 11:23:50 -07004709 // Ensure all stylus interceptors are trusted overlays
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08004710 LOG_ALWAYS_FATAL_IF(info.interceptsStylus() &&
4711 !info.inputConfig.test(
4712 WindowInfo::InputConfig::TRUSTED_OVERLAY),
Prabir Pradhand65552b2021-10-07 11:23:50 -07004713 "%s has feature INTERCEPTS_STYLUS, but is not a trusted overlay.",
4714 window->getName().c_str());
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05004715 }
4716
Arthur Hung72d8dc32020-03-28 00:48:39 +00004717 // Copy old handles for release if they are no longer present.
chaviw98318de2021-05-19 16:45:23 -05004718 const std::vector<sp<WindowInfoHandle>> oldWindowHandles = getWindowHandlesLocked(displayId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004719
Prabir Pradhan93a0f912021-04-21 13:47:42 -07004720 // Save the old windows' orientation by ID before it gets updated.
4721 std::unordered_map<int32_t, uint32_t> oldWindowOrientations;
chaviw98318de2021-05-19 16:45:23 -05004722 for (const sp<WindowInfoHandle>& handle : oldWindowHandles) {
Prabir Pradhan93a0f912021-04-21 13:47:42 -07004723 oldWindowOrientations.emplace(handle->getId(),
4724 handle->getInfo()->transform.getOrientation());
4725 }
4726
chaviw98318de2021-05-19 16:45:23 -05004727 updateWindowHandlesForDisplayLocked(windowInfoHandles, displayId);
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -07004728
chaviw98318de2021-05-19 16:45:23 -05004729 const std::vector<sp<WindowInfoHandle>>& windowHandles = getWindowHandlesLocked(displayId);
Vishnu Nair958da932020-08-21 17:12:37 -07004730 if (mLastHoverWindowHandle &&
4731 std::find(windowHandles.begin(), windowHandles.end(), mLastHoverWindowHandle) ==
4732 windowHandles.end()) {
Arthur Hung72d8dc32020-03-28 00:48:39 +00004733 mLastHoverWindowHandle = nullptr;
4734 }
4735
Vishnu Nairc519ff72021-01-21 08:23:08 -08004736 std::optional<FocusResolver::FocusChanges> changes =
4737 mFocusResolver.setInputWindows(displayId, windowHandles);
4738 if (changes) {
4739 onFocusChangedLocked(*changes);
Arthur Hung72d8dc32020-03-28 00:48:39 +00004740 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004741
Siarhei Vishniakou4700f822020-03-24 19:05:54 -07004742 std::unordered_map<int32_t, TouchState>::iterator stateIt =
4743 mTouchStatesByDisplay.find(displayId);
4744 if (stateIt != mTouchStatesByDisplay.end()) {
4745 TouchState& state = stateIt->second;
Arthur Hung72d8dc32020-03-28 00:48:39 +00004746 for (size_t i = 0; i < state.windows.size();) {
4747 TouchedWindow& touchedWindow = state.windows[i];
Prabir Pradhan6a9a8312021-04-23 11:59:31 -07004748 if (getWindowHandleLocked(touchedWindow.windowHandle) == nullptr) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01004749 if (DEBUG_FOCUS) {
Arthur Hung72d8dc32020-03-28 00:48:39 +00004750 ALOGD("Touched window was removed: %s in display %" PRId32,
4751 touchedWindow.windowHandle->getName().c_str(), displayId);
Siarhei Vishniakou86587282019-09-09 18:20:15 +01004752 }
Siarhei Vishniakouce5ab082020-07-09 17:03:21 -05004753 std::shared_ptr<InputChannel> touchedInputChannel =
Arthur Hung72d8dc32020-03-28 00:48:39 +00004754 getInputChannelLocked(touchedWindow.windowHandle->getToken());
4755 if (touchedInputChannel != nullptr) {
4756 CancelationOptions options(CancelationOptions::CANCEL_POINTER_EVENTS,
4757 "touched window was removed");
4758 synthesizeCancelationEventsForInputChannelLocked(touchedInputChannel, options);
Siarhei Vishniakouca205502021-07-16 21:31:58 +00004759 // Since we are about to drop the touch, cancel the events for the wallpaper as
4760 // well.
4761 if (touchedWindow.targetFlags & InputTarget::FLAG_FOREGROUND &&
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08004762 touchedWindow.windowHandle->getInfo()->inputConfig.test(
4763 gui::WindowInfo::InputConfig::DUPLICATE_TOUCH_TO_WALLPAPER)) {
Siarhei Vishniakouca205502021-07-16 21:31:58 +00004764 sp<WindowInfoHandle> wallpaper = state.getWallpaperWindow();
4765 if (wallpaper != nullptr) {
4766 sp<Connection> wallpaperConnection =
4767 getConnectionLocked(wallpaper->getToken());
Siarhei Vishniakou2b030972021-11-18 10:01:27 -08004768 if (wallpaperConnection != nullptr) {
4769 synthesizeCancelationEventsForConnectionLocked(wallpaperConnection,
4770 options);
4771 }
Siarhei Vishniakouca205502021-07-16 21:31:58 +00004772 }
4773 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004774 }
Arthur Hung72d8dc32020-03-28 00:48:39 +00004775 state.windows.erase(state.windows.begin() + i);
4776 } else {
4777 ++i;
Michael Wrightd02c5b62014-02-10 15:10:22 -08004778 }
4779 }
arthurhungb89ccb02020-12-30 16:19:01 +08004780
arthurhung6d4bed92021-03-17 11:59:33 +08004781 // If drag window is gone, it would receive a cancel event and broadcast the DRAG_END. We
arthurhungb89ccb02020-12-30 16:19:01 +08004782 // could just clear the state here.
Arthur Hung3915c1f2022-05-31 07:17:17 +00004783 if (mDragState && mDragState->dragWindow->getInfo()->displayId == displayId &&
arthurhung6d4bed92021-03-17 11:59:33 +08004784 std::find(windowHandles.begin(), windowHandles.end(), mDragState->dragWindow) ==
arthurhungb89ccb02020-12-30 16:19:01 +08004785 windowHandles.end()) {
Arthur Hung3915c1f2022-05-31 07:17:17 +00004786 ALOGI("Drag window went away: %s", mDragState->dragWindow->getName().c_str());
4787 sendDropWindowCommandLocked(nullptr, 0, 0);
arthurhung6d4bed92021-03-17 11:59:33 +08004788 mDragState.reset();
arthurhungb89ccb02020-12-30 16:19:01 +08004789 }
Arthur Hung72d8dc32020-03-28 00:48:39 +00004790 }
Arthur Hung25e2af12020-03-26 12:58:37 +00004791
Prabir Pradhan8b89c2f2021-07-29 16:30:14 +00004792 // Determine if the orientation of any of the input windows have changed, and cancel all
4793 // pointer events if necessary.
4794 for (const sp<WindowInfoHandle>& oldWindowHandle : oldWindowHandles) {
4795 const sp<WindowInfoHandle> newWindowHandle = getWindowHandleLocked(oldWindowHandle);
4796 if (newWindowHandle != nullptr &&
4797 newWindowHandle->getInfo()->transform.getOrientation() !=
4798 oldWindowOrientations[oldWindowHandle->getId()]) {
4799 std::shared_ptr<InputChannel> inputChannel =
4800 getInputChannelLocked(newWindowHandle->getToken());
4801 if (inputChannel != nullptr) {
4802 CancelationOptions options(CancelationOptions::CANCEL_POINTER_EVENTS,
4803 "touched window's orientation changed");
4804 synthesizeCancelationEventsForInputChannelLocked(inputChannel, options);
Prabir Pradhan93a0f912021-04-21 13:47:42 -07004805 }
4806 }
4807 }
4808
Arthur Hung72d8dc32020-03-28 00:48:39 +00004809 // Release information for windows that are no longer present.
4810 // This ensures that unused input channels are released promptly.
4811 // Otherwise, they might stick around until the window handle is destroyed
4812 // which might not happen until the next GC.
chaviw98318de2021-05-19 16:45:23 -05004813 for (const sp<WindowInfoHandle>& oldWindowHandle : oldWindowHandles) {
Prabir Pradhan6a9a8312021-04-23 11:59:31 -07004814 if (getWindowHandleLocked(oldWindowHandle) == nullptr) {
Arthur Hung72d8dc32020-03-28 00:48:39 +00004815 if (DEBUG_FOCUS) {
4816 ALOGD("Window went away: %s", oldWindowHandle->getName().c_str());
Arthur Hung25e2af12020-03-26 12:58:37 +00004817 }
Arthur Hung72d8dc32020-03-28 00:48:39 +00004818 oldWindowHandle->releaseChannel();
Arthur Hung25e2af12020-03-26 12:58:37 +00004819 }
chaviw291d88a2019-02-14 10:33:58 -08004820 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004821}
4822
4823void InputDispatcher::setFocusedApplication(
Chris Yea209fde2020-07-22 13:54:51 -07004824 int32_t displayId, const std::shared_ptr<InputApplicationHandle>& inputApplicationHandle) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01004825 if (DEBUG_FOCUS) {
4826 ALOGD("setFocusedApplication displayId=%" PRId32 " %s", displayId,
4827 inputApplicationHandle ? inputApplicationHandle->getName().c_str() : "<nullptr>");
4828 }
Siarhei Vishniakoue41c4512020-09-08 19:35:58 -05004829 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004830 std::scoped_lock _l(mLock);
Vishnu Nair599f1412021-06-21 10:39:58 -07004831 setFocusedApplicationLocked(displayId, inputApplicationHandle);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004832 } // release lock
4833
4834 // Wake up poll loop since it may need to make new input dispatching choices.
4835 mLooper->wake();
4836}
4837
Vishnu Nair599f1412021-06-21 10:39:58 -07004838void InputDispatcher::setFocusedApplicationLocked(
4839 int32_t displayId, const std::shared_ptr<InputApplicationHandle>& inputApplicationHandle) {
4840 std::shared_ptr<InputApplicationHandle> oldFocusedApplicationHandle =
4841 getValueByKey(mFocusedApplicationHandlesByDisplay, displayId);
4842
4843 if (sharedPointersEqual(oldFocusedApplicationHandle, inputApplicationHandle)) {
4844 return; // This application is already focused. No need to wake up or change anything.
4845 }
4846
4847 // Set the new application handle.
4848 if (inputApplicationHandle != nullptr) {
4849 mFocusedApplicationHandlesByDisplay[displayId] = inputApplicationHandle;
4850 } else {
4851 mFocusedApplicationHandlesByDisplay.erase(displayId);
4852 }
4853
4854 // No matter what the old focused application was, stop waiting on it because it is
4855 // no longer focused.
4856 resetNoFocusedWindowTimeoutLocked();
4857}
4858
Tiger Huang721e26f2018-07-24 22:26:19 +08004859/**
4860 * Sets the focused display, which is responsible for receiving focus-dispatched input events where
4861 * the display not specified.
4862 *
4863 * We track any unreleased events for each window. If a window loses the ability to receive the
4864 * released event, we will send a cancel event to it. So when the focused display is changed, we
4865 * cancel all the unreleased display-unspecified events for the focused window on the old focused
4866 * display. The display-specified events won't be affected.
4867 */
4868void InputDispatcher::setFocusedDisplay(int32_t displayId) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01004869 if (DEBUG_FOCUS) {
4870 ALOGD("setFocusedDisplay displayId=%" PRId32, displayId);
4871 }
Tiger Huang721e26f2018-07-24 22:26:19 +08004872 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004873 std::scoped_lock _l(mLock);
Tiger Huang721e26f2018-07-24 22:26:19 +08004874
4875 if (mFocusedDisplayId != displayId) {
Vishnu Nairad321cd2020-08-20 16:40:21 -07004876 sp<IBinder> oldFocusedWindowToken =
Vishnu Nairc519ff72021-01-21 08:23:08 -08004877 mFocusResolver.getFocusedWindowToken(mFocusedDisplayId);
Vishnu Nairad321cd2020-08-20 16:40:21 -07004878 if (oldFocusedWindowToken != nullptr) {
Siarhei Vishniakouce5ab082020-07-09 17:03:21 -05004879 std::shared_ptr<InputChannel> inputChannel =
Vishnu Nairad321cd2020-08-20 16:40:21 -07004880 getInputChannelLocked(oldFocusedWindowToken);
Tiger Huang721e26f2018-07-24 22:26:19 +08004881 if (inputChannel != nullptr) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07004882 CancelationOptions
4883 options(CancelationOptions::CANCEL_NON_POINTER_EVENTS,
4884 "The display which contains this window no longer has focus.");
Michael Wright3dd60e22019-03-27 22:06:44 +00004885 options.displayId = ADISPLAY_ID_NONE;
Tiger Huang721e26f2018-07-24 22:26:19 +08004886 synthesizeCancelationEventsForInputChannelLocked(inputChannel, options);
4887 }
4888 }
4889 mFocusedDisplayId = displayId;
4890
Chris Ye3c2d6f52020-08-09 10:39:48 -07004891 // Find new focused window and validate
Vishnu Nairc519ff72021-01-21 08:23:08 -08004892 sp<IBinder> newFocusedWindowToken = mFocusResolver.getFocusedWindowToken(displayId);
Prabir Pradhancef936d2021-07-21 16:17:52 +00004893 sendFocusChangedCommandLocked(oldFocusedWindowToken, newFocusedWindowToken);
Robert Carrf759f162018-11-13 12:57:11 -08004894
Vishnu Nairad321cd2020-08-20 16:40:21 -07004895 if (newFocusedWindowToken == nullptr) {
Tiger Huang721e26f2018-07-24 22:26:19 +08004896 ALOGW("Focused display #%" PRId32 " does not have a focused window.", displayId);
Vishnu Nairc519ff72021-01-21 08:23:08 -08004897 if (mFocusResolver.hasFocusedWindowTokens()) {
Vishnu Nairad321cd2020-08-20 16:40:21 -07004898 ALOGE("But another display has a focused window\n%s",
Vishnu Nairc519ff72021-01-21 08:23:08 -08004899 mFocusResolver.dumpFocusedWindows().c_str());
Tiger Huang721e26f2018-07-24 22:26:19 +08004900 }
4901 }
4902 }
4903
Siarhei Vishniakou86587282019-09-09 18:20:15 +01004904 if (DEBUG_FOCUS) {
4905 logDispatchStateLocked();
4906 }
Tiger Huang721e26f2018-07-24 22:26:19 +08004907 } // release lock
4908
4909 // Wake up poll loop since it may need to make new input dispatching choices.
4910 mLooper->wake();
4911}
4912
Michael Wrightd02c5b62014-02-10 15:10:22 -08004913void InputDispatcher::setInputDispatchMode(bool enabled, bool frozen) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01004914 if (DEBUG_FOCUS) {
4915 ALOGD("setInputDispatchMode: enabled=%d, frozen=%d", enabled, frozen);
4916 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004917
4918 bool changed;
4919 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004920 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004921
4922 if (mDispatchEnabled != enabled || mDispatchFrozen != frozen) {
4923 if (mDispatchFrozen && !frozen) {
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07004924 resetNoFocusedWindowTimeoutLocked();
Michael Wrightd02c5b62014-02-10 15:10:22 -08004925 }
4926
4927 if (mDispatchEnabled && !enabled) {
4928 resetAndDropEverythingLocked("dispatcher is being disabled");
4929 }
4930
4931 mDispatchEnabled = enabled;
4932 mDispatchFrozen = frozen;
4933 changed = true;
4934 } else {
4935 changed = false;
4936 }
4937
Siarhei Vishniakou86587282019-09-09 18:20:15 +01004938 if (DEBUG_FOCUS) {
4939 logDispatchStateLocked();
4940 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004941 } // release lock
4942
4943 if (changed) {
4944 // Wake up poll loop since it may need to make new input dispatching choices.
4945 mLooper->wake();
4946 }
4947}
4948
4949void InputDispatcher::setInputFilterEnabled(bool enabled) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01004950 if (DEBUG_FOCUS) {
4951 ALOGD("setInputFilterEnabled: enabled=%d", enabled);
4952 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08004953
4954 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08004955 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08004956
4957 if (mInputFilterEnabled == enabled) {
4958 return;
4959 }
4960
4961 mInputFilterEnabled = enabled;
4962 resetAndDropEverythingLocked("input filter is being enabled or disabled");
4963 } // release lock
4964
4965 // Wake up poll loop since there might be work to do to drop everything.
4966 mLooper->wake();
4967}
4968
Antonio Kantekea47acb2021-12-23 12:41:25 -08004969bool InputDispatcher::setInTouchMode(bool inTouchMode, int32_t pid, int32_t uid,
4970 bool hasPermission) {
Antonio Kantekf16f2832021-09-28 04:39:20 +00004971 bool needWake = false;
4972 {
4973 std::scoped_lock lock(mLock);
4974 if (mInTouchMode == inTouchMode) {
Antonio Kantekea47acb2021-12-23 12:41:25 -08004975 return false;
Antonio Kantekf16f2832021-09-28 04:39:20 +00004976 }
4977 if (DEBUG_TOUCH_MODE) {
Antonio Kantekea47acb2021-12-23 12:41:25 -08004978 ALOGD("Request to change touch mode from %s to %s (calling pid=%d, uid=%d, "
4979 "hasPermission=%s)",
4980 toString(mInTouchMode), toString(inTouchMode), pid, uid, toString(hasPermission));
4981 }
4982 if (!hasPermission) {
Antonio Kantek48710e42022-03-24 14:19:30 -07004983 if (!focusedWindowIsOwnedByLocked(pid, uid) &&
4984 !recentWindowsAreOwnedByLocked(pid, uid)) {
4985 ALOGD("Touch mode switch rejected, caller (pid=%d, uid=%d) doesn't own the focused "
4986 "window nor none of the previously interacted window",
4987 pid, uid);
Antonio Kantekea47acb2021-12-23 12:41:25 -08004988 return false;
4989 }
Antonio Kantekf16f2832021-09-28 04:39:20 +00004990 }
4991
4992 // TODO(b/198499018): Store touch mode per display.
4993 mInTouchMode = inTouchMode;
4994
Antonio Kantekf16f2832021-09-28 04:39:20 +00004995 auto entry = std::make_unique<TouchModeEntry>(mIdGenerator.nextId(), now(), inTouchMode);
4996 needWake = enqueueInboundEventLocked(std::move(entry));
4997 } // release lock
4998
4999 if (needWake) {
5000 mLooper->wake();
5001 }
Antonio Kantekea47acb2021-12-23 12:41:25 -08005002 return true;
Siarhei Vishniakouf3bc1aa2019-11-25 13:48:53 -08005003}
5004
Antonio Kantek48710e42022-03-24 14:19:30 -07005005bool InputDispatcher::focusedWindowIsOwnedByLocked(int32_t pid, int32_t uid) {
5006 const sp<IBinder> focusedToken = mFocusResolver.getFocusedWindowToken(mFocusedDisplayId);
5007 if (focusedToken == nullptr) {
5008 return false;
5009 }
5010 sp<WindowInfoHandle> windowHandle = getWindowHandleLocked(focusedToken);
5011 return isWindowOwnedBy(windowHandle, pid, uid);
5012}
5013
5014bool InputDispatcher::recentWindowsAreOwnedByLocked(int32_t pid, int32_t uid) {
5015 return std::find_if(mInteractionConnectionTokens.begin(), mInteractionConnectionTokens.end(),
5016 [&](const sp<IBinder>& connectionToken) REQUIRES(mLock) {
5017 const sp<WindowInfoHandle> windowHandle =
5018 getWindowHandleLocked(connectionToken);
5019 return isWindowOwnedBy(windowHandle, pid, uid);
5020 }) != mInteractionConnectionTokens.end();
5021}
5022
Bernardo Rufinoea97d182020-08-19 14:43:14 +01005023void InputDispatcher::setMaximumObscuringOpacityForTouch(float opacity) {
5024 if (opacity < 0 || opacity > 1) {
5025 LOG_ALWAYS_FATAL("Maximum obscuring opacity for touch should be >= 0 and <= 1");
5026 return;
5027 }
5028
5029 std::scoped_lock lock(mLock);
5030 mMaximumObscuringOpacityForTouch = opacity;
5031}
5032
5033void InputDispatcher::setBlockUntrustedTouchesMode(BlockUntrustedTouchesMode mode) {
5034 std::scoped_lock lock(mLock);
5035 mBlockUntrustedTouchesMode = mode;
5036}
5037
Arthur Hungabbb9d82021-09-01 14:52:30 +00005038std::pair<TouchState*, TouchedWindow*> InputDispatcher::findTouchStateAndWindowLocked(
5039 const sp<IBinder>& token) {
5040 for (auto& [displayId, state] : mTouchStatesByDisplay) {
5041 for (TouchedWindow& w : state.windows) {
5042 if (w.windowHandle->getToken() == token) {
5043 return std::make_pair(&state, &w);
5044 }
5045 }
5046 }
5047 return std::make_pair(nullptr, nullptr);
5048}
5049
arthurhungb89ccb02020-12-30 16:19:01 +08005050bool InputDispatcher::transferTouchFocus(const sp<IBinder>& fromToken, const sp<IBinder>& toToken,
5051 bool isDragDrop) {
chaviwfbe5d9c2018-12-26 12:23:37 -08005052 if (fromToken == toToken) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005053 if (DEBUG_FOCUS) {
5054 ALOGD("Trivial transfer to same window.");
5055 }
chaviwfbe5d9c2018-12-26 12:23:37 -08005056 return true;
5057 }
5058
Michael Wrightd02c5b62014-02-10 15:10:22 -08005059 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08005060 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005061
Arthur Hungabbb9d82021-09-01 14:52:30 +00005062 // Find the target touch state and touched window by fromToken.
5063 auto [state, touchedWindow] = findTouchStateAndWindowLocked(fromToken);
5064 if (state == nullptr || touchedWindow == nullptr) {
5065 ALOGD("Focus transfer failed because from window is not being touched.");
Michael Wrightd02c5b62014-02-10 15:10:22 -08005066 return false;
5067 }
Arthur Hungabbb9d82021-09-01 14:52:30 +00005068
5069 const int32_t displayId = state->displayId;
5070 sp<WindowInfoHandle> toWindowHandle = getWindowHandleLocked(toToken, displayId);
5071 if (toWindowHandle == nullptr) {
5072 ALOGW("Cannot transfer focus because to window not found.");
5073 return false;
5074 }
5075
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005076 if (DEBUG_FOCUS) {
5077 ALOGD("transferTouchFocus: fromWindowHandle=%s, toWindowHandle=%s",
Arthur Hungabbb9d82021-09-01 14:52:30 +00005078 touchedWindow->windowHandle->getName().c_str(),
5079 toWindowHandle->getName().c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08005080 }
5081
Arthur Hungabbb9d82021-09-01 14:52:30 +00005082 // Erase old window.
5083 int32_t oldTargetFlags = touchedWindow->targetFlags;
5084 BitSet32 pointerIds = touchedWindow->pointerIds;
5085 state->removeWindowByToken(fromToken);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005086
Arthur Hungabbb9d82021-09-01 14:52:30 +00005087 // Add new window.
Prabir Pradhan6dfbf262022-03-14 15:24:30 +00005088 int32_t newTargetFlags =
5089 oldTargetFlags & (InputTarget::FLAG_SPLIT | InputTarget::FLAG_DISPATCH_AS_IS);
5090 if (canReceiveForegroundTouches(*toWindowHandle->getInfo())) {
5091 newTargetFlags |= InputTarget::FLAG_FOREGROUND;
5092 }
Arthur Hungabbb9d82021-09-01 14:52:30 +00005093 state->addOrUpdateWindow(toWindowHandle, newTargetFlags, pointerIds);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005094
Arthur Hungabbb9d82021-09-01 14:52:30 +00005095 // Store the dragging window.
5096 if (isDragDrop) {
Arthur Hung02701602022-07-15 09:35:36 +00005097 if (pointerIds.count() != 1) {
5098 ALOGW("The drag and drop cannot be started when there is no pointer or more than 1"
5099 " pointer on the window.");
Arthur Hung54745652022-04-20 07:17:41 +00005100 return false;
5101 }
Arthur Hung02701602022-07-15 09:35:36 +00005102 // Track the pointer id for drag window and generate the drag state.
5103 const int32_t id = pointerIds.firstMarkedBit();
Arthur Hung54745652022-04-20 07:17:41 +00005104 mDragState = std::make_unique<DragState>(toWindowHandle, id);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005105 }
5106
Arthur Hungabbb9d82021-09-01 14:52:30 +00005107 // Synthesize cancel for old window and down for new window.
Siarhei Vishniakoud0d71b62019-10-14 14:50:45 -07005108 sp<Connection> fromConnection = getConnectionLocked(fromToken);
5109 sp<Connection> toConnection = getConnectionLocked(toToken);
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07005110 if (fromConnection != nullptr && toConnection != nullptr) {
Svet Ganov5d3bc372020-01-26 23:11:07 -08005111 fromConnection->inputState.mergePointerStateTo(toConnection->inputState);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07005112 CancelationOptions
5113 options(CancelationOptions::CANCEL_POINTER_EVENTS,
5114 "transferring touch focus from this window to another window");
Michael Wrightd02c5b62014-02-10 15:10:22 -08005115 synthesizeCancelationEventsForConnectionLocked(fromConnection, options);
Svet Ganov5d3bc372020-01-26 23:11:07 -08005116 synthesizePointerDownEventsForConnectionLocked(toConnection);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005117 }
5118
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005119 if (DEBUG_FOCUS) {
5120 logDispatchStateLocked();
5121 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005122 } // release lock
5123
5124 // Wake up poll loop since it may need to make new input dispatching choices.
5125 mLooper->wake();
5126 return true;
5127}
5128
Siarhei Vishniakou7ae7afd2022-03-31 15:26:13 -07005129/**
5130 * Get the touched foreground window on the given display.
5131 * Return null if there are no windows touched on that display, or if more than one foreground
5132 * window is being touched.
5133 */
5134sp<WindowInfoHandle> InputDispatcher::findTouchedForegroundWindowLocked(int32_t displayId) const {
5135 auto stateIt = mTouchStatesByDisplay.find(displayId);
5136 if (stateIt == mTouchStatesByDisplay.end()) {
5137 ALOGI("No touch state on display %" PRId32, displayId);
5138 return nullptr;
5139 }
5140
5141 const TouchState& state = stateIt->second;
5142 sp<WindowInfoHandle> touchedForegroundWindow;
5143 // If multiple foreground windows are touched, return nullptr
5144 for (const TouchedWindow& window : state.windows) {
5145 if (window.targetFlags & InputTarget::FLAG_FOREGROUND) {
5146 if (touchedForegroundWindow != nullptr) {
5147 ALOGI("Two or more foreground windows: %s and %s",
5148 touchedForegroundWindow->getName().c_str(),
5149 window.windowHandle->getName().c_str());
5150 return nullptr;
5151 }
5152 touchedForegroundWindow = window.windowHandle;
5153 }
5154 }
5155 return touchedForegroundWindow;
5156}
5157
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +00005158// Binder call
Siarhei Vishniakou7ae7afd2022-03-31 15:26:13 -07005159bool InputDispatcher::transferTouch(const sp<IBinder>& destChannelToken, int32_t displayId) {
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +00005160 sp<IBinder> fromToken;
5161 { // acquire lock
5162 std::scoped_lock _l(mLock);
Arthur Hungabbb9d82021-09-01 14:52:30 +00005163 sp<WindowInfoHandle> toWindowHandle = getWindowHandleLocked(destChannelToken, displayId);
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +00005164 if (toWindowHandle == nullptr) {
Siarhei Vishniakou7ae7afd2022-03-31 15:26:13 -07005165 ALOGW("Could not find window associated with token=%p on display %" PRId32,
5166 destChannelToken.get(), displayId);
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +00005167 return false;
5168 }
5169
Siarhei Vishniakou7ae7afd2022-03-31 15:26:13 -07005170 sp<WindowInfoHandle> from = findTouchedForegroundWindowLocked(displayId);
5171 if (from == nullptr) {
5172 ALOGE("Could not find a source window in %s for %p", __func__, destChannelToken.get());
5173 return false;
5174 }
5175
5176 fromToken = from->getToken();
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +00005177 } // release lock
5178
5179 return transferTouchFocus(fromToken, destChannelToken);
5180}
5181
Michael Wrightd02c5b62014-02-10 15:10:22 -08005182void InputDispatcher::resetAndDropEverythingLocked(const char* reason) {
Siarhei Vishniakou86587282019-09-09 18:20:15 +01005183 if (DEBUG_FOCUS) {
5184 ALOGD("Resetting and dropping all events (%s).", reason);
5185 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005186
5187 CancelationOptions options(CancelationOptions::CANCEL_ALL_EVENTS, reason);
5188 synthesizeCancelationEventsForAllConnectionsLocked(options);
5189
5190 resetKeyRepeatLocked();
5191 releasePendingEventLocked();
5192 drainInboundQueueLocked();
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005193 resetNoFocusedWindowTimeoutLocked();
Michael Wrightd02c5b62014-02-10 15:10:22 -08005194
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005195 mAnrTracker.clear();
Jeff Brownf086ddb2014-02-11 14:28:48 -08005196 mTouchStatesByDisplay.clear();
Michael Wrightd02c5b62014-02-10 15:10:22 -08005197 mLastHoverWindowHandle.clear();
Michael Wright78f24442014-08-06 15:55:28 -07005198 mReplacedKeys.clear();
Michael Wrightd02c5b62014-02-10 15:10:22 -08005199}
5200
5201void InputDispatcher::logDispatchStateLocked() {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005202 std::string dump;
Michael Wrightd02c5b62014-02-10 15:10:22 -08005203 dumpDispatchStateLocked(dump);
5204
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005205 std::istringstream stream(dump);
5206 std::string line;
5207
5208 while (std::getline(stream, line, '\n')) {
5209 ALOGD("%s", line.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08005210 }
5211}
5212
Prabir Pradhan99987712020-11-10 18:43:05 -08005213std::string InputDispatcher::dumpPointerCaptureStateLocked() {
5214 std::string dump;
5215
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00005216 dump += StringPrintf(INDENT "Pointer Capture Requested: %s\n",
5217 toString(mCurrentPointerCaptureRequest.enable));
Prabir Pradhan99987712020-11-10 18:43:05 -08005218
5219 std::string windowName = "None";
5220 if (mWindowTokenWithPointerCapture) {
chaviw98318de2021-05-19 16:45:23 -05005221 const sp<WindowInfoHandle> captureWindowHandle =
Prabir Pradhan99987712020-11-10 18:43:05 -08005222 getWindowHandleLocked(mWindowTokenWithPointerCapture);
5223 windowName = captureWindowHandle ? captureWindowHandle->getName().c_str()
5224 : "token has capture without window";
5225 }
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00005226 dump += StringPrintf(INDENT "Current Window with Pointer Capture: %s\n", windowName.c_str());
Prabir Pradhan99987712020-11-10 18:43:05 -08005227
5228 return dump;
5229}
5230
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005231void InputDispatcher::dumpDispatchStateLocked(std::string& dump) {
Siarhei Vishniakou043a3ec2019-05-01 11:30:46 -07005232 dump += StringPrintf(INDENT "DispatchEnabled: %s\n", toString(mDispatchEnabled));
5233 dump += StringPrintf(INDENT "DispatchFrozen: %s\n", toString(mDispatchFrozen));
5234 dump += StringPrintf(INDENT "InputFilterEnabled: %s\n", toString(mInputFilterEnabled));
Tiger Huang721e26f2018-07-24 22:26:19 +08005235 dump += StringPrintf(INDENT "FocusedDisplayId: %" PRId32 "\n", mFocusedDisplayId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005236
Tiger Huang721e26f2018-07-24 22:26:19 +08005237 if (!mFocusedApplicationHandlesByDisplay.empty()) {
5238 dump += StringPrintf(INDENT "FocusedApplications:\n");
5239 for (auto& it : mFocusedApplicationHandlesByDisplay) {
5240 const int32_t displayId = it.first;
Chris Yea209fde2020-07-22 13:54:51 -07005241 const std::shared_ptr<InputApplicationHandle>& applicationHandle = it.second;
Siarhei Vishniakou70622952020-07-30 11:17:23 -05005242 const std::chrono::duration timeout =
5243 applicationHandle->getDispatchingTimeout(DEFAULT_INPUT_DISPATCHING_TIMEOUT);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07005244 dump += StringPrintf(INDENT2 "displayId=%" PRId32
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07005245 ", name='%s', dispatchingTimeout=%" PRId64 "ms\n",
Siarhei Vishniakou70622952020-07-30 11:17:23 -05005246 displayId, applicationHandle->getName().c_str(), millis(timeout));
Tiger Huang721e26f2018-07-24 22:26:19 +08005247 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005248 } else {
Tiger Huang721e26f2018-07-24 22:26:19 +08005249 dump += StringPrintf(INDENT "FocusedApplications: <none>\n");
Michael Wrightd02c5b62014-02-10 15:10:22 -08005250 }
Tiger Huang721e26f2018-07-24 22:26:19 +08005251
Vishnu Nairc519ff72021-01-21 08:23:08 -08005252 dump += mFocusResolver.dump();
Prabir Pradhan99987712020-11-10 18:43:05 -08005253 dump += dumpPointerCaptureStateLocked();
Michael Wrightd02c5b62014-02-10 15:10:22 -08005254
Siarhei Vishniakou4700f822020-03-24 19:05:54 -07005255 if (!mTouchStatesByDisplay.empty()) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005256 dump += StringPrintf(INDENT "TouchStatesByDisplay:\n");
Siarhei Vishniakou4700f822020-03-24 19:05:54 -07005257 for (const std::pair<int32_t, TouchState>& pair : mTouchStatesByDisplay) {
5258 const TouchState& state = pair.second;
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005259 dump += StringPrintf(INDENT2 "%d: down=%s, split=%s, deviceId=%d, source=0x%08x\n",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07005260 state.displayId, toString(state.down), toString(state.split),
5261 state.deviceId, state.source);
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08005262 if (!state.windows.empty()) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005263 dump += INDENT3 "Windows:\n";
Jeff Brownf086ddb2014-02-11 14:28:48 -08005264 for (size_t i = 0; i < state.windows.size(); i++) {
5265 const TouchedWindow& touchedWindow = state.windows[i];
Garfield Tan0fc2fa72019-08-29 17:22:15 -07005266 dump += StringPrintf(INDENT4
5267 "%zu: name='%s', pointerIds=0x%0x, targetFlags=0x%x\n",
5268 i, touchedWindow.windowHandle->getName().c_str(),
5269 touchedWindow.pointerIds.value, touchedWindow.targetFlags);
Jeff Brownf086ddb2014-02-11 14:28:48 -08005270 }
5271 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005272 dump += INDENT3 "Windows: <none>\n";
Jeff Brownf086ddb2014-02-11 14:28:48 -08005273 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005274 }
5275 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005276 dump += INDENT "TouchStates: <no displays touched>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005277 }
5278
arthurhung6d4bed92021-03-17 11:59:33 +08005279 if (mDragState) {
5280 dump += StringPrintf(INDENT "DragState:\n");
5281 mDragState->dump(dump, INDENT2);
5282 }
5283
Arthur Hungb92218b2018-08-14 12:00:21 +08005284 if (!mWindowHandlesByDisplay.empty()) {
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07005285 for (const auto& [displayId, windowHandles] : mWindowHandlesByDisplay) {
5286 dump += StringPrintf(INDENT "Display: %" PRId32 "\n", displayId);
5287 if (const auto& it = mDisplayInfos.find(displayId); it != mDisplayInfos.end()) {
5288 const auto& displayInfo = it->second;
5289 dump += StringPrintf(INDENT2 "logicalSize=%dx%d\n", displayInfo.logicalWidth,
5290 displayInfo.logicalHeight);
5291 displayInfo.transform.dump(dump, "transform", INDENT4);
5292 } else {
5293 dump += INDENT2 "No DisplayInfo found!\n";
5294 }
5295
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08005296 if (!windowHandles.empty()) {
Arthur Hungb92218b2018-08-14 12:00:21 +08005297 dump += INDENT2 "Windows:\n";
5298 for (size_t i = 0; i < windowHandles.size(); i++) {
chaviw98318de2021-05-19 16:45:23 -05005299 const sp<WindowInfoHandle>& windowHandle = windowHandles[i];
5300 const WindowInfo* windowInfo = windowHandle->getInfo();
Michael Wrightd02c5b62014-02-10 15:10:22 -08005301
Bernardo Rufino0f6a36e2020-11-11 10:10:59 +00005302 dump += StringPrintf(INDENT3 "%zu: name='%s', id=%" PRId32 ", displayId=%d, "
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08005303 "inputConfig=%s, alpha=%.2f, "
Garfield Tan0fc2fa72019-08-29 17:22:15 -07005304 "frame=[%d,%d][%d,%d], globalScale=%f, "
Bernardo Rufino49d99e42021-01-18 15:16:59 +00005305 "applicationInfo.name=%s, "
5306 "applicationInfo.token=%s, "
chaviw1ff3d1e2020-07-01 15:53:47 -07005307 "touchableRegion=",
Bernardo Rufino0f6a36e2020-11-11 10:10:59 +00005308 i, windowInfo->name.c_str(), windowInfo->id,
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08005309 windowInfo->displayId,
5310 windowInfo->inputConfig.string().c_str(),
5311 windowInfo->alpha, windowInfo->frameLeft,
5312 windowInfo->frameTop, windowInfo->frameRight,
5313 windowInfo->frameBottom, windowInfo->globalScaleFactor,
Bernardo Rufino49d99e42021-01-18 15:16:59 +00005314 windowInfo->applicationInfo.name.c_str(),
5315 toString(windowInfo->applicationInfo.token).c_str());
Bernardo Rufino53fc31e2020-11-03 11:01:07 +00005316 dump += dumpRegion(windowInfo->touchableRegion);
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07005317 dump += StringPrintf(", ownerPid=%d, ownerUid=%d, dispatchingTimeout=%" PRId64
Prabir Pradhan4d5c52f2022-01-31 08:52:10 -08005318 "ms, hasToken=%s, "
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07005319 "touchOcclusionMode=%s\n",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07005320 windowInfo->ownerPid, windowInfo->ownerUid,
Bernardo Rufinoc2f1fad2020-11-04 17:30:57 +00005321 millis(windowInfo->dispatchingTimeout),
Bernardo Rufino5fd822d2020-11-13 16:11:39 +00005322 toString(windowInfo->token != nullptr),
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07005323 toString(windowInfo->touchOcclusionMode).c_str());
chaviw85b44202020-07-24 11:46:21 -07005324 windowInfo->transform.dump(dump, "transform", INDENT4);
Arthur Hungb92218b2018-08-14 12:00:21 +08005325 }
5326 } else {
5327 dump += INDENT2 "Windows: <none>\n";
5328 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005329 }
5330 } else {
Arthur Hungb92218b2018-08-14 12:00:21 +08005331 dump += INDENT "Displays: <none>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005332 }
5333
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08005334 if (!mGlobalMonitorsByDisplay.empty()) {
5335 for (const auto& [displayId, monitors] : mGlobalMonitorsByDisplay) {
5336 dump += StringPrintf(INDENT "Global monitors on display %d:\n", displayId);
Michael Wright3dd60e22019-03-27 22:06:44 +00005337 dumpMonitors(dump, monitors);
Garfield Tan0fc2fa72019-08-29 17:22:15 -07005338 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005339 } else {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08005340 dump += INDENT "Global Monitors: <none>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005341 }
5342
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08005343 const nsecs_t currentTime = now();
Michael Wrightd02c5b62014-02-10 15:10:22 -08005344
5345 // Dump recently dispatched or dropped events from oldest to newest.
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07005346 if (!mRecentQueue.empty()) {
5347 dump += StringPrintf(INDENT "RecentQueue: length=%zu\n", mRecentQueue.size());
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07005348 for (std::shared_ptr<EventEntry>& entry : mRecentQueue) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005349 dump += INDENT2;
Siarhei Vishniakou14411c92020-09-18 21:15:05 -05005350 dump += entry->getDescription();
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07005351 dump += StringPrintf(", age=%" PRId64 "ms\n", ns2ms(currentTime - entry->eventTime));
Michael Wrightd02c5b62014-02-10 15:10:22 -08005352 }
5353 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005354 dump += INDENT "RecentQueue: <empty>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005355 }
5356
5357 // Dump event currently being dispatched.
5358 if (mPendingEvent) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005359 dump += INDENT "PendingEvent:\n";
5360 dump += INDENT2;
Siarhei Vishniakou14411c92020-09-18 21:15:05 -05005361 dump += mPendingEvent->getDescription();
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07005362 dump += StringPrintf(", age=%" PRId64 "ms\n",
5363 ns2ms(currentTime - mPendingEvent->eventTime));
Michael Wrightd02c5b62014-02-10 15:10:22 -08005364 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005365 dump += INDENT "PendingEvent: <none>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005366 }
5367
5368 // Dump inbound events from oldest to newest.
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07005369 if (!mInboundQueue.empty()) {
5370 dump += StringPrintf(INDENT "InboundQueue: length=%zu\n", mInboundQueue.size());
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07005371 for (std::shared_ptr<EventEntry>& entry : mInboundQueue) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005372 dump += INDENT2;
Siarhei Vishniakou14411c92020-09-18 21:15:05 -05005373 dump += entry->getDescription();
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07005374 dump += StringPrintf(", age=%" PRId64 "ms\n", ns2ms(currentTime - entry->eventTime));
Michael Wrightd02c5b62014-02-10 15:10:22 -08005375 }
5376 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005377 dump += INDENT "InboundQueue: <empty>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005378 }
5379
Siarhei Vishniakou4700f822020-03-24 19:05:54 -07005380 if (!mReplacedKeys.empty()) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005381 dump += INDENT "ReplacedKeys:\n";
Siarhei Vishniakou4700f822020-03-24 19:05:54 -07005382 for (const std::pair<KeyReplacement, int32_t>& pair : mReplacedKeys) {
5383 const KeyReplacement& replacement = pair.first;
5384 int32_t newKeyCode = pair.second;
5385 dump += StringPrintf(INDENT2 "originalKeyCode=%d, deviceId=%d -> newKeyCode=%d\n",
Garfield Tan0fc2fa72019-08-29 17:22:15 -07005386 replacement.keyCode, replacement.deviceId, newKeyCode);
Michael Wright78f24442014-08-06 15:55:28 -07005387 }
5388 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005389 dump += INDENT "ReplacedKeys: <empty>\n";
Michael Wright78f24442014-08-06 15:55:28 -07005390 }
5391
Prabir Pradhancef936d2021-07-21 16:17:52 +00005392 if (!mCommandQueue.empty()) {
5393 dump += StringPrintf(INDENT "CommandQueue: size=%zu\n", mCommandQueue.size());
5394 } else {
5395 dump += INDENT "CommandQueue: <empty>\n";
5396 }
5397
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005398 if (!mConnectionsByToken.empty()) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005399 dump += INDENT "Connections:\n";
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005400 for (const auto& [token, connection] : mConnectionsByToken) {
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07005401 dump += StringPrintf(INDENT2 "%i: channelName='%s', windowName='%s', "
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005402 "status=%s, monitor=%s, responsive=%s\n",
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005403 connection->inputChannel->getFd().get(),
5404 connection->getInputChannelName().c_str(),
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08005405 connection->getWindowName().c_str(),
5406 ftl::enum_string(connection->status).c_str(),
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005407 toString(connection->monitor), toString(connection->responsive));
Michael Wrightd02c5b62014-02-10 15:10:22 -08005408
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07005409 if (!connection->outboundQueue.empty()) {
5410 dump += StringPrintf(INDENT3 "OutboundQueue: length=%zu\n",
5411 connection->outboundQueue.size());
Siarhei Vishniakou14411c92020-09-18 21:15:05 -05005412 dump += dumpQueue(connection->outboundQueue, currentTime);
5413
Michael Wrightd02c5b62014-02-10 15:10:22 -08005414 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005415 dump += INDENT3 "OutboundQueue: <empty>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005416 }
5417
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -07005418 if (!connection->waitQueue.empty()) {
5419 dump += StringPrintf(INDENT3 "WaitQueue: length=%zu\n",
5420 connection->waitQueue.size());
Siarhei Vishniakou14411c92020-09-18 21:15:05 -05005421 dump += dumpQueue(connection->waitQueue, currentTime);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005422 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005423 dump += INDENT3 "WaitQueue: <empty>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005424 }
5425 }
5426 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005427 dump += INDENT "Connections: <none>\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005428 }
5429
5430 if (isAppSwitchPendingLocked()) {
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07005431 dump += StringPrintf(INDENT "AppSwitch: pending, due in %" PRId64 "ms\n",
5432 ns2ms(mAppSwitchDueTime - now()));
Michael Wrightd02c5b62014-02-10 15:10:22 -08005433 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005434 dump += INDENT "AppSwitch: not pending\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08005435 }
5436
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08005437 dump += INDENT "Configuration:\n";
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07005438 dump += StringPrintf(INDENT2 "KeyRepeatDelay: %" PRId64 "ms\n", ns2ms(mConfig.keyRepeatDelay));
5439 dump += StringPrintf(INDENT2 "KeyRepeatTimeout: %" PRId64 "ms\n",
5440 ns2ms(mConfig.keyRepeatTimeout));
Siarhei Vishniakouf2652122021-03-05 21:39:46 +00005441 dump += mLatencyTracker.dump(INDENT2);
Siarhei Vishniakoua04181f2021-03-26 05:56:49 +00005442 dump += mLatencyAggregator.dump(INDENT2);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005443}
5444
Michael Wright3dd60e22019-03-27 22:06:44 +00005445void InputDispatcher::dumpMonitors(std::string& dump, const std::vector<Monitor>& monitors) {
5446 const size_t numMonitors = monitors.size();
5447 for (size_t i = 0; i < numMonitors; i++) {
5448 const Monitor& monitor = monitors[i];
Siarhei Vishniakouce5ab082020-07-09 17:03:21 -05005449 const std::shared_ptr<InputChannel>& channel = monitor.inputChannel;
Michael Wright3dd60e22019-03-27 22:06:44 +00005450 dump += StringPrintf(INDENT2 "%zu: '%s', ", i, channel->getName().c_str());
5451 dump += "\n";
5452 }
5453}
5454
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005455class LooperEventCallback : public LooperCallback {
5456public:
5457 LooperEventCallback(std::function<int(int events)> callback) : mCallback(callback) {}
5458 int handleEvent(int /*fd*/, int events, void* /*data*/) override { return mCallback(events); }
5459
5460private:
5461 std::function<int(int events)> mCallback;
5462};
5463
Siarhei Vishniakoueedd0fc2021-03-12 09:50:36 +00005464Result<std::unique_ptr<InputChannel>> InputDispatcher::createInputChannel(const std::string& name) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00005465 if (DEBUG_CHANNEL_CREATION) {
5466 ALOGD("channel '%s' ~ createInputChannel", name.c_str());
5467 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005468
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005469 std::unique_ptr<InputChannel> serverChannel;
Garfield Tan15601662020-09-22 15:32:38 -07005470 std::unique_ptr<InputChannel> clientChannel;
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005471 status_t result = InputChannel::openInputChannelPair(name, serverChannel, clientChannel);
Garfield Tan15601662020-09-22 15:32:38 -07005472
5473 if (result) {
5474 return base::Error(result) << "Failed to open input channel pair with name " << name;
5475 }
5476
Michael Wrightd02c5b62014-02-10 15:10:22 -08005477 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08005478 std::scoped_lock _l(mLock);
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005479 const sp<IBinder>& token = serverChannel->getConnectionToken();
Garfield Tan15601662020-09-22 15:32:38 -07005480 int fd = serverChannel->getFd();
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005481 sp<Connection> connection =
5482 new Connection(std::move(serverChannel), false /*monitor*/, mIdGenerator);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005483
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005484 if (mConnectionsByToken.find(token) != mConnectionsByToken.end()) {
5485 ALOGE("Created a new connection, but the token %p is already known", token.get());
5486 }
5487 mConnectionsByToken.emplace(token, connection);
5488
5489 std::function<int(int events)> callback = std::bind(&InputDispatcher::handleReceiveCallback,
5490 this, std::placeholders::_1, token);
5491
5492 mLooper->addFd(fd, 0, ALOOPER_EVENT_INPUT, new LooperEventCallback(callback), nullptr);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005493 } // release lock
5494
5495 // Wake the looper because some connections have changed.
5496 mLooper->wake();
Garfield Tan15601662020-09-22 15:32:38 -07005497 return clientChannel;
Michael Wrightd02c5b62014-02-10 15:10:22 -08005498}
5499
Siarhei Vishniakoueedd0fc2021-03-12 09:50:36 +00005500Result<std::unique_ptr<InputChannel>> InputDispatcher::createInputMonitor(int32_t displayId,
Siarhei Vishniakoueedd0fc2021-03-12 09:50:36 +00005501 const std::string& name,
5502 int32_t pid) {
Garfield Tan15601662020-09-22 15:32:38 -07005503 std::shared_ptr<InputChannel> serverChannel;
5504 std::unique_ptr<InputChannel> clientChannel;
5505 status_t result = openInputChannelPair(name, serverChannel, clientChannel);
5506 if (result) {
5507 return base::Error(result) << "Failed to open input channel pair with name " << name;
5508 }
5509
Michael Wright3dd60e22019-03-27 22:06:44 +00005510 { // acquire lock
5511 std::scoped_lock _l(mLock);
5512
5513 if (displayId < 0) {
Garfield Tan15601662020-09-22 15:32:38 -07005514 return base::Error(BAD_VALUE) << "Attempted to create input monitor with name " << name
5515 << " without a specified display.";
Michael Wright3dd60e22019-03-27 22:06:44 +00005516 }
5517
Garfield Tan15601662020-09-22 15:32:38 -07005518 sp<Connection> connection = new Connection(serverChannel, true /*monitor*/, mIdGenerator);
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005519 const sp<IBinder>& token = serverChannel->getConnectionToken();
Garfield Tan15601662020-09-22 15:32:38 -07005520 const int fd = serverChannel->getFd();
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005521
5522 if (mConnectionsByToken.find(token) != mConnectionsByToken.end()) {
5523 ALOGE("Created a new connection, but the token %p is already known", token.get());
5524 }
5525 mConnectionsByToken.emplace(token, connection);
5526 std::function<int(int events)> callback = std::bind(&InputDispatcher::handleReceiveCallback,
5527 this, std::placeholders::_1, token);
Michael Wright3dd60e22019-03-27 22:06:44 +00005528
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08005529 mGlobalMonitorsByDisplay[displayId].emplace_back(serverChannel, pid);
Michael Wright3dd60e22019-03-27 22:06:44 +00005530
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005531 mLooper->addFd(fd, 0, ALOOPER_EVENT_INPUT, new LooperEventCallback(callback), nullptr);
Michael Wright3dd60e22019-03-27 22:06:44 +00005532 }
Garfield Tan15601662020-09-22 15:32:38 -07005533
Michael Wright3dd60e22019-03-27 22:06:44 +00005534 // Wake the looper because some connections have changed.
5535 mLooper->wake();
Garfield Tan15601662020-09-22 15:32:38 -07005536 return clientChannel;
Michael Wright3dd60e22019-03-27 22:06:44 +00005537}
5538
Garfield Tan15601662020-09-22 15:32:38 -07005539status_t InputDispatcher::removeInputChannel(const sp<IBinder>& connectionToken) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08005540 { // acquire lock
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08005541 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005542
Garfield Tan15601662020-09-22 15:32:38 -07005543 status_t status = removeInputChannelLocked(connectionToken, false /*notify*/);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005544 if (status) {
5545 return status;
5546 }
5547 } // release lock
5548
5549 // Wake the poll loop because removing the connection may have changed the current
5550 // synchronization state.
5551 mLooper->wake();
5552 return OK;
5553}
5554
Garfield Tan15601662020-09-22 15:32:38 -07005555status_t InputDispatcher::removeInputChannelLocked(const sp<IBinder>& connectionToken,
5556 bool notify) {
Siarhei Vishniakouadefc3e2020-09-02 22:28:29 -05005557 sp<Connection> connection = getConnectionLocked(connectionToken);
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07005558 if (connection == nullptr) {
Siarhei Vishniakoud706a282021-02-13 00:08:48 +00005559 // Connection can be removed via socket hang up or an explicit call to 'removeInputChannel'
Michael Wrightd02c5b62014-02-10 15:10:22 -08005560 return BAD_VALUE;
5561 }
5562
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07005563 removeConnectionLocked(connection);
Robert Carr5c8a0262018-10-03 16:30:44 -07005564
Michael Wrightd02c5b62014-02-10 15:10:22 -08005565 if (connection->monitor) {
Siarhei Vishniakouadefc3e2020-09-02 22:28:29 -05005566 removeMonitorChannelLocked(connectionToken);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005567 }
5568
Siarhei Vishniakouadefc3e2020-09-02 22:28:29 -05005569 mLooper->removeFd(connection->inputChannel->getFd());
Michael Wrightd02c5b62014-02-10 15:10:22 -08005570
5571 nsecs_t currentTime = now();
5572 abortBrokenDispatchCycleLocked(currentTime, connection, notify);
5573
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08005574 connection->status = Connection::Status::ZOMBIE;
Michael Wrightd02c5b62014-02-10 15:10:22 -08005575 return OK;
5576}
5577
Siarhei Vishniakouadefc3e2020-09-02 22:28:29 -05005578void InputDispatcher::removeMonitorChannelLocked(const sp<IBinder>& connectionToken) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08005579 for (auto it = mGlobalMonitorsByDisplay.begin(); it != mGlobalMonitorsByDisplay.end();) {
5580 auto& [displayId, monitors] = *it;
5581 std::erase_if(monitors, [connectionToken](const Monitor& monitor) {
5582 return monitor.inputChannel->getConnectionToken() == connectionToken;
5583 });
Michael Wright3dd60e22019-03-27 22:06:44 +00005584
Michael Wright3dd60e22019-03-27 22:06:44 +00005585 if (monitors.empty()) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08005586 it = mGlobalMonitorsByDisplay.erase(it);
Arthur Hung2fbf37f2018-09-13 18:16:41 +08005587 } else {
5588 ++it;
5589 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005590 }
5591}
5592
Michael Wright3dd60e22019-03-27 22:06:44 +00005593status_t InputDispatcher::pilferPointers(const sp<IBinder>& token) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08005594 std::scoped_lock _l(mLock);
Michael Wright3dd60e22019-03-27 22:06:44 +00005595
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08005596 const std::shared_ptr<InputChannel> requestingChannel = getInputChannelLocked(token);
5597 if (!requestingChannel) {
5598 ALOGW("Attempted to pilfer pointers from an un-registered channel or invalid token");
5599 return BAD_VALUE;
Michael Wright3dd60e22019-03-27 22:06:44 +00005600 }
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08005601
5602 auto [statePtr, windowPtr] = findTouchStateAndWindowLocked(token);
5603 if (statePtr == nullptr || windowPtr == nullptr || !statePtr->down) {
5604 ALOGW("Attempted to pilfer points from a channel without any on-going pointer streams."
5605 " Ignoring.");
5606 return BAD_VALUE;
5607 }
5608
5609 TouchState& state = *statePtr;
5610
5611 // Send cancel events to all the input channels we're stealing from.
5612 CancelationOptions options(CancelationOptions::CANCEL_POINTER_EVENTS,
5613 "input channel stole pointer stream");
5614 options.deviceId = state.deviceId;
5615 options.displayId = state.displayId;
5616 std::string canceledWindows;
5617 for (const TouchedWindow& window : state.windows) {
5618 const std::shared_ptr<InputChannel> channel =
5619 getInputChannelLocked(window.windowHandle->getToken());
5620 if (channel != nullptr && channel->getConnectionToken() != token) {
5621 synthesizeCancelationEventsForInputChannelLocked(channel, options);
5622 canceledWindows += canceledWindows.empty() ? "[" : ", ";
5623 canceledWindows += channel->getName();
5624 }
5625 }
5626 canceledWindows += canceledWindows.empty() ? "[]" : "]";
5627 ALOGI("Channel %s is stealing touch from %s", requestingChannel->getName().c_str(),
5628 canceledWindows.c_str());
5629
Prabir Pradhane680f9b2022-02-04 04:24:00 -08005630 // Prevent the gesture from being sent to any other windows.
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08005631 state.filterWindowsExcept(token);
Prabir Pradhane680f9b2022-02-04 04:24:00 -08005632 state.preventNewTargets = true;
Michael Wright3dd60e22019-03-27 22:06:44 +00005633 return OK;
5634}
5635
Prabir Pradhan99987712020-11-10 18:43:05 -08005636void InputDispatcher::requestPointerCapture(const sp<IBinder>& windowToken, bool enabled) {
5637 { // acquire lock
5638 std::scoped_lock _l(mLock);
5639 if (DEBUG_FOCUS) {
chaviw98318de2021-05-19 16:45:23 -05005640 const sp<WindowInfoHandle> windowHandle = getWindowHandleLocked(windowToken);
Prabir Pradhan99987712020-11-10 18:43:05 -08005641 ALOGI("Request to %s Pointer Capture from: %s.", enabled ? "enable" : "disable",
5642 windowHandle != nullptr ? windowHandle->getName().c_str()
5643 : "token without window");
5644 }
5645
Vishnu Nairc519ff72021-01-21 08:23:08 -08005646 const sp<IBinder> focusedToken = mFocusResolver.getFocusedWindowToken(mFocusedDisplayId);
Prabir Pradhan99987712020-11-10 18:43:05 -08005647 if (focusedToken != windowToken) {
5648 ALOGW("Ignoring request to %s Pointer Capture: window does not have focus.",
5649 enabled ? "enable" : "disable");
5650 return;
5651 }
5652
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00005653 if (enabled == mCurrentPointerCaptureRequest.enable) {
Prabir Pradhan99987712020-11-10 18:43:05 -08005654 ALOGW("Ignoring request to %s Pointer Capture: "
5655 "window has %s requested pointer capture.",
5656 enabled ? "enable" : "disable", enabled ? "already" : "not");
5657 return;
5658 }
5659
Christine Franksb768bb42021-11-29 12:11:31 -08005660 if (enabled) {
5661 if (std::find(mIneligibleDisplaysForPointerCapture.begin(),
5662 mIneligibleDisplaysForPointerCapture.end(),
5663 mFocusedDisplayId) != mIneligibleDisplaysForPointerCapture.end()) {
5664 ALOGW("Ignoring request to enable Pointer Capture: display is not eligible");
5665 return;
5666 }
5667 }
5668
Prabir Pradhan99987712020-11-10 18:43:05 -08005669 setPointerCaptureLocked(enabled);
5670 } // release lock
5671
5672 // Wake the thread to process command entries.
5673 mLooper->wake();
5674}
5675
Christine Franksb768bb42021-11-29 12:11:31 -08005676void InputDispatcher::setDisplayEligibilityForPointerCapture(int32_t displayId, bool isEligible) {
5677 { // acquire lock
5678 std::scoped_lock _l(mLock);
5679 std::erase(mIneligibleDisplaysForPointerCapture, displayId);
5680 if (!isEligible) {
5681 mIneligibleDisplaysForPointerCapture.push_back(displayId);
5682 }
5683 } // release lock
5684}
5685
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08005686std::optional<int32_t> InputDispatcher::findMonitorPidByTokenLocked(const sp<IBinder>& token) {
5687 for (const auto& [_, monitors] : mGlobalMonitorsByDisplay) {
Michael Wright3dd60e22019-03-27 22:06:44 +00005688 for (const Monitor& monitor : monitors) {
Siarhei Vishniakou26d3cfb2019-10-15 17:02:32 -07005689 if (monitor.inputChannel->getConnectionToken() == token) {
Prabir Pradhandfabf8a2022-01-21 08:19:30 -08005690 return monitor.pid;
Michael Wright3dd60e22019-03-27 22:06:44 +00005691 }
5692 }
5693 }
5694 return std::nullopt;
5695}
5696
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07005697sp<Connection> InputDispatcher::getConnectionLocked(const sp<IBinder>& inputConnectionToken) const {
Siarhei Vishniakoud0d71b62019-10-14 14:50:45 -07005698 if (inputConnectionToken == nullptr) {
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07005699 return nullptr;
Arthur Hung3b413f22018-10-26 18:05:34 +08005700 }
5701
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005702 for (const auto& [token, connection] : mConnectionsByToken) {
5703 if (token == inputConnectionToken) {
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07005704 return connection;
Michael Wrightd02c5b62014-02-10 15:10:22 -08005705 }
5706 }
Robert Carr4e670e52018-08-15 13:26:12 -07005707
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -07005708 return nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08005709}
5710
Siarhei Vishniakouad991402020-10-28 11:40:09 -05005711std::string InputDispatcher::getConnectionNameLocked(const sp<IBinder>& connectionToken) const {
5712 sp<Connection> connection = getConnectionLocked(connectionToken);
5713 if (connection == nullptr) {
5714 return "<nullptr>";
5715 }
5716 return connection->getInputChannelName();
5717}
5718
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07005719void InputDispatcher::removeConnectionLocked(const sp<Connection>& connection) {
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005720 mAnrTracker.eraseToken(connection->inputChannel->getConnectionToken());
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +00005721 mConnectionsByToken.erase(connection->inputChannel->getConnectionToken());
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07005722}
5723
Prabir Pradhancef936d2021-07-21 16:17:52 +00005724void InputDispatcher::doDispatchCycleFinishedCommand(nsecs_t finishTime,
5725 const sp<Connection>& connection, uint32_t seq,
5726 bool handled, nsecs_t consumeTime) {
5727 // Handle post-event policy actions.
5728 std::deque<DispatchEntry*>::iterator dispatchEntryIt = connection->findWaitQueueEntry(seq);
5729 if (dispatchEntryIt == connection->waitQueue.end()) {
5730 return;
5731 }
5732 DispatchEntry* dispatchEntry = *dispatchEntryIt;
5733 const nsecs_t eventDuration = finishTime - dispatchEntry->deliveryTime;
5734 if (eventDuration > SLOW_EVENT_PROCESSING_WARNING_TIMEOUT) {
5735 ALOGI("%s spent %" PRId64 "ms processing %s", connection->getWindowName().c_str(),
5736 ns2ms(eventDuration), dispatchEntry->eventEntry->getDescription().c_str());
5737 }
5738 if (shouldReportFinishedEvent(*dispatchEntry, *connection)) {
5739 mLatencyTracker.trackFinishedEvent(dispatchEntry->eventEntry->id,
5740 connection->inputChannel->getConnectionToken(),
5741 dispatchEntry->deliveryTime, consumeTime, finishTime);
5742 }
5743
5744 bool restartEvent;
5745 if (dispatchEntry->eventEntry->type == EventEntry::Type::KEY) {
5746 KeyEntry& keyEntry = static_cast<KeyEntry&>(*(dispatchEntry->eventEntry));
5747 restartEvent =
5748 afterKeyEventLockedInterruptable(connection, dispatchEntry, keyEntry, handled);
5749 } else if (dispatchEntry->eventEntry->type == EventEntry::Type::MOTION) {
5750 MotionEntry& motionEntry = static_cast<MotionEntry&>(*(dispatchEntry->eventEntry));
5751 restartEvent = afterMotionEventLockedInterruptable(connection, dispatchEntry, motionEntry,
5752 handled);
5753 } else {
5754 restartEvent = false;
5755 }
5756
5757 // Dequeue the event and start the next cycle.
5758 // Because the lock might have been released, it is possible that the
5759 // contents of the wait queue to have been drained, so we need to double-check
5760 // a few things.
5761 dispatchEntryIt = connection->findWaitQueueEntry(seq);
5762 if (dispatchEntryIt != connection->waitQueue.end()) {
5763 dispatchEntry = *dispatchEntryIt;
5764 connection->waitQueue.erase(dispatchEntryIt);
5765 const sp<IBinder>& connectionToken = connection->inputChannel->getConnectionToken();
5766 mAnrTracker.erase(dispatchEntry->timeoutTime, connectionToken);
5767 if (!connection->responsive) {
5768 connection->responsive = isConnectionResponsive(*connection);
5769 if (connection->responsive) {
5770 // The connection was unresponsive, and now it's responsive.
5771 processConnectionResponsiveLocked(*connection);
5772 }
5773 }
5774 traceWaitQueueLength(*connection);
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08005775 if (restartEvent && connection->status == Connection::Status::NORMAL) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00005776 connection->outboundQueue.push_front(dispatchEntry);
5777 traceOutboundQueueLength(*connection);
5778 } else {
5779 releaseDispatchEntry(dispatchEntry);
5780 }
5781 }
5782
5783 // Start the next dispatch cycle for this connection.
5784 startDispatchCycleLocked(now(), connection);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005785}
5786
Prabir Pradhancef936d2021-07-21 16:17:52 +00005787void InputDispatcher::sendFocusChangedCommandLocked(const sp<IBinder>& oldToken,
5788 const sp<IBinder>& newToken) {
5789 auto command = [this, oldToken, newToken]() REQUIRES(mLock) {
5790 scoped_unlock unlock(mLock);
5791 mPolicy->notifyFocusChanged(oldToken, newToken);
5792 };
5793 postCommandLocked(std::move(command));
Michael Wrightd02c5b62014-02-10 15:10:22 -08005794}
5795
Prabir Pradhancef936d2021-07-21 16:17:52 +00005796void InputDispatcher::sendDropWindowCommandLocked(const sp<IBinder>& token, float x, float y) {
5797 auto command = [this, token, x, y]() REQUIRES(mLock) {
5798 scoped_unlock unlock(mLock);
5799 mPolicy->notifyDropWindow(token, x, y);
5800 };
5801 postCommandLocked(std::move(command));
Robert Carrf759f162018-11-13 12:57:11 -08005802}
5803
Prabir Pradhancef936d2021-07-21 16:17:52 +00005804void InputDispatcher::sendUntrustedTouchCommandLocked(const std::string& obscuringPackage) {
5805 auto command = [this, obscuringPackage]() REQUIRES(mLock) {
5806 scoped_unlock unlock(mLock);
5807 mPolicy->notifyUntrustedTouch(obscuringPackage);
5808 };
5809 postCommandLocked(std::move(command));
arthurhungf452d0b2021-01-06 00:19:52 +08005810}
5811
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00005812void InputDispatcher::onAnrLocked(const sp<Connection>& connection) {
5813 if (connection == nullptr) {
5814 LOG_ALWAYS_FATAL("Caller must check for nullness");
5815 }
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005816 // Since we are allowing the policy to extend the timeout, maybe the waitQueue
5817 // is already healthy again. Don't raise ANR in this situation
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00005818 if (connection->waitQueue.empty()) {
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005819 ALOGI("Not raising ANR because the connection %s has recovered",
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00005820 connection->inputChannel->getName().c_str());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005821 return;
5822 }
5823 /**
5824 * The "oldestEntry" is the entry that was first sent to the application. That entry, however,
5825 * may not be the one that caused the timeout to occur. One possibility is that window timeout
5826 * has changed. This could cause newer entries to time out before the already dispatched
5827 * entries. In that situation, the newest entries caused ANR. But in all likelihood, the app
5828 * processes the events linearly. So providing information about the oldest entry seems to be
5829 * most useful.
5830 */
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00005831 DispatchEntry* oldestEntry = *connection->waitQueue.begin();
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005832 const nsecs_t currentWait = now() - oldestEntry->deliveryTime;
5833 std::string reason =
5834 android::base::StringPrintf("%s is not responding. Waited %" PRId64 "ms for %s",
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00005835 connection->inputChannel->getName().c_str(),
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005836 ns2ms(currentWait),
5837 oldestEntry->eventEntry->getDescription().c_str());
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00005838 sp<IBinder> connectionToken = connection->inputChannel->getConnectionToken();
Siarhei Vishniakou2b4782c2020-11-07 01:51:18 -06005839 updateLastAnrStateLocked(getWindowHandleLocked(connectionToken), reason);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005840
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00005841 processConnectionUnresponsiveLocked(*connection, std::move(reason));
5842
5843 // Stop waking up for events on this connection, it is already unresponsive
5844 cancelEventsForAnrLocked(connection);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005845}
5846
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05005847void InputDispatcher::onAnrLocked(std::shared_ptr<InputApplicationHandle> application) {
5848 std::string reason =
5849 StringPrintf("%s does not have a focused window", application->getName().c_str());
5850 updateLastAnrStateLocked(*application, reason);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005851
Prabir Pradhancef936d2021-07-21 16:17:52 +00005852 auto command = [this, application = std::move(application)]() REQUIRES(mLock) {
5853 scoped_unlock unlock(mLock);
5854 mPolicy->notifyNoFocusedWindowAnr(application);
5855 };
5856 postCommandLocked(std::move(command));
Bernardo Rufino2e1f6512020-10-08 13:42:07 +00005857}
5858
chaviw98318de2021-05-19 16:45:23 -05005859void InputDispatcher::updateLastAnrStateLocked(const sp<WindowInfoHandle>& window,
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005860 const std::string& reason) {
5861 const std::string windowLabel = getApplicationWindowLabel(nullptr, window);
5862 updateLastAnrStateLocked(windowLabel, reason);
5863}
5864
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05005865void InputDispatcher::updateLastAnrStateLocked(const InputApplicationHandle& application,
5866 const std::string& reason) {
5867 const std::string windowLabel = getApplicationWindowLabel(&application, nullptr);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005868 updateLastAnrStateLocked(windowLabel, reason);
5869}
5870
5871void InputDispatcher::updateLastAnrStateLocked(const std::string& windowLabel,
5872 const std::string& reason) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08005873 // Capture a record of the InputDispatcher state at the time of the ANR.
Yi Kong9b14ac62018-07-17 13:48:38 -07005874 time_t t = time(nullptr);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005875 struct tm tm;
5876 localtime_r(&t, &tm);
5877 char timestr[64];
5878 strftime(timestr, sizeof(timestr), "%F %T", &tm);
Siarhei Vishniakoub1a16272020-05-06 16:09:19 -07005879 mLastAnrState.clear();
5880 mLastAnrState += INDENT "ANR:\n";
5881 mLastAnrState += StringPrintf(INDENT2 "Time: %s\n", timestr);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07005882 mLastAnrState += StringPrintf(INDENT2 "Reason: %s\n", reason.c_str());
5883 mLastAnrState += StringPrintf(INDENT2 "Window: %s\n", windowLabel.c_str());
Siarhei Vishniakoub1a16272020-05-06 16:09:19 -07005884 dumpDispatchStateLocked(mLastAnrState);
Michael Wrightd02c5b62014-02-10 15:10:22 -08005885}
5886
Prabir Pradhancef936d2021-07-21 16:17:52 +00005887void InputDispatcher::doInterceptKeyBeforeDispatchingCommand(const sp<IBinder>& focusedWindowToken,
5888 KeyEntry& entry) {
5889 const KeyEvent event = createKeyEvent(entry);
5890 nsecs_t delay = 0;
5891 { // release lock
5892 scoped_unlock unlock(mLock);
5893 android::base::Timer t;
5894 delay = mPolicy->interceptKeyBeforeDispatching(focusedWindowToken, &event,
5895 entry.policyFlags);
5896 if (t.duration() > SLOW_INTERCEPTION_THRESHOLD) {
5897 ALOGW("Excessive delay in interceptKeyBeforeDispatching; took %s ms",
5898 std::to_string(t.duration().count()).c_str());
5899 }
5900 } // acquire lock
Michael Wrightd02c5b62014-02-10 15:10:22 -08005901
5902 if (delay < 0) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07005903 entry.interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_SKIP;
Prabir Pradhancef936d2021-07-21 16:17:52 +00005904 } else if (delay == 0) {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07005905 entry.interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_CONTINUE;
Michael Wrightd02c5b62014-02-10 15:10:22 -08005906 } else {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07005907 entry.interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER;
5908 entry.interceptKeyWakeupTime = now() + delay;
Michael Wrightd02c5b62014-02-10 15:10:22 -08005909 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005910}
5911
Prabir Pradhancef936d2021-07-21 16:17:52 +00005912void InputDispatcher::sendWindowUnresponsiveCommandLocked(const sp<IBinder>& token,
Prabir Pradhanedd96402022-02-15 01:46:16 -08005913 std::optional<int32_t> pid,
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00005914 std::string reason) {
Prabir Pradhanedd96402022-02-15 01:46:16 -08005915 auto command = [this, token, pid, reason = std::move(reason)]() REQUIRES(mLock) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00005916 scoped_unlock unlock(mLock);
Prabir Pradhanedd96402022-02-15 01:46:16 -08005917 mPolicy->notifyWindowUnresponsive(token, pid, reason);
Prabir Pradhancef936d2021-07-21 16:17:52 +00005918 };
5919 postCommandLocked(std::move(command));
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00005920}
5921
Prabir Pradhanedd96402022-02-15 01:46:16 -08005922void InputDispatcher::sendWindowResponsiveCommandLocked(const sp<IBinder>& token,
5923 std::optional<int32_t> pid) {
5924 auto command = [this, token, pid]() REQUIRES(mLock) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00005925 scoped_unlock unlock(mLock);
Prabir Pradhanedd96402022-02-15 01:46:16 -08005926 mPolicy->notifyWindowResponsive(token, pid);
Prabir Pradhancef936d2021-07-21 16:17:52 +00005927 };
5928 postCommandLocked(std::move(command));
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00005929}
5930
5931/**
5932 * Tell the policy that a connection has become unresponsive so that it can start ANR.
5933 * Check whether the connection of interest is a monitor or a window, and add the corresponding
5934 * command entry to the command queue.
5935 */
5936void InputDispatcher::processConnectionUnresponsiveLocked(const Connection& connection,
5937 std::string reason) {
5938 const sp<IBinder>& connectionToken = connection.inputChannel->getConnectionToken();
Prabir Pradhanedd96402022-02-15 01:46:16 -08005939 std::optional<int32_t> pid;
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00005940 if (connection.monitor) {
5941 ALOGW("Monitor %s is unresponsive: %s", connection.inputChannel->getName().c_str(),
5942 reason.c_str());
Prabir Pradhanedd96402022-02-15 01:46:16 -08005943 pid = findMonitorPidByTokenLocked(connectionToken);
5944 } else {
5945 // The connection is a window
5946 ALOGW("Window %s is unresponsive: %s", connection.inputChannel->getName().c_str(),
5947 reason.c_str());
5948 const sp<WindowInfoHandle> handle = getWindowHandleLocked(connectionToken);
5949 if (handle != nullptr) {
5950 pid = handle->getInfo()->ownerPid;
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00005951 }
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00005952 }
Prabir Pradhanedd96402022-02-15 01:46:16 -08005953 sendWindowUnresponsiveCommandLocked(connectionToken, pid, std::move(reason));
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00005954}
5955
5956/**
5957 * Tell the policy that a connection has become responsive so that it can stop ANR.
5958 */
5959void InputDispatcher::processConnectionResponsiveLocked(const Connection& connection) {
5960 const sp<IBinder>& connectionToken = connection.inputChannel->getConnectionToken();
Prabir Pradhanedd96402022-02-15 01:46:16 -08005961 std::optional<int32_t> pid;
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00005962 if (connection.monitor) {
Prabir Pradhanedd96402022-02-15 01:46:16 -08005963 pid = findMonitorPidByTokenLocked(connectionToken);
5964 } else {
5965 // The connection is a window
5966 const sp<WindowInfoHandle> handle = getWindowHandleLocked(connectionToken);
5967 if (handle != nullptr) {
5968 pid = handle->getInfo()->ownerPid;
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00005969 }
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00005970 }
Prabir Pradhanedd96402022-02-15 01:46:16 -08005971 sendWindowResponsiveCommandLocked(connectionToken, pid);
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00005972}
5973
Prabir Pradhancef936d2021-07-21 16:17:52 +00005974bool InputDispatcher::afterKeyEventLockedInterruptable(const sp<Connection>& connection,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07005975 DispatchEntry* dispatchEntry,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07005976 KeyEntry& keyEntry, bool handled) {
5977 if (keyEntry.flags & AKEY_EVENT_FLAG_FALLBACK) {
Prabir Pradhanf93562f2018-11-29 12:13:37 -08005978 if (!handled) {
5979 // Report the key as unhandled, since the fallback was not handled.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07005980 mReporter->reportUnhandledKey(keyEntry.id);
Prabir Pradhanf93562f2018-11-29 12:13:37 -08005981 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08005982 return false;
5983 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08005984
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08005985 // Get the fallback key state.
5986 // Clear it out after dispatching the UP.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07005987 int32_t originalKeyCode = keyEntry.keyCode;
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08005988 int32_t fallbackKeyCode = connection->inputState.getFallbackKey(originalKeyCode);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07005989 if (keyEntry.action == AKEY_EVENT_ACTION_UP) {
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08005990 connection->inputState.removeFallbackKey(originalKeyCode);
5991 }
5992
5993 if (handled || !dispatchEntry->hasForegroundTarget()) {
5994 // If the application handles the original key for which we previously
5995 // generated a fallback or if the window is not a foreground window,
5996 // then cancel the associated fallback key, if any.
5997 if (fallbackKeyCode != -1) {
5998 // Dispatch the unhandled key to the policy with the cancel flag.
Prabir Pradhan61a5d242021-07-26 16:41:09 +00005999 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
6000 ALOGD("Unhandled key event: Asking policy to cancel fallback action. "
6001 "keyCode=%d, action=%d, repeatCount=%d, policyFlags=0x%08x",
6002 keyEntry.keyCode, keyEntry.action, keyEntry.repeatCount,
6003 keyEntry.policyFlags);
6004 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006005 KeyEvent event = createKeyEvent(keyEntry);
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006006 event.setFlags(event.getFlags() | AKEY_EVENT_FLAG_CANCELED);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006007
6008 mLock.unlock();
6009
Siarhei Vishniakou26d3cfb2019-10-15 17:02:32 -07006010 mPolicy->dispatchUnhandledKey(connection->inputChannel->getConnectionToken(), &event,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006011 keyEntry.policyFlags, &event);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006012
6013 mLock.lock();
6014
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006015 // Cancel the fallback key.
6016 if (fallbackKeyCode != AKEYCODE_UNKNOWN) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08006017 CancelationOptions options(CancelationOptions::CANCEL_FALLBACK_EVENTS,
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006018 "application handled the original non-fallback key "
6019 "or is no longer a foreground target, "
6020 "canceling previously dispatched fallback key");
Michael Wrightd02c5b62014-02-10 15:10:22 -08006021 options.keyCode = fallbackKeyCode;
6022 synthesizeCancelationEventsForConnectionLocked(connection, options);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006023 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006024 connection->inputState.removeFallbackKey(originalKeyCode);
6025 }
6026 } else {
6027 // If the application did not handle a non-fallback key, first check
6028 // that we are in a good state to perform unhandled key event processing
6029 // Then ask the policy what to do with it.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006030 bool initialDown = keyEntry.action == AKEY_EVENT_ACTION_DOWN && keyEntry.repeatCount == 0;
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006031 if (fallbackKeyCode == -1 && !initialDown) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006032 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
6033 ALOGD("Unhandled key event: Skipping unhandled key event processing "
6034 "since this is not an initial down. "
6035 "keyCode=%d, action=%d, repeatCount=%d, policyFlags=0x%08x",
6036 originalKeyCode, keyEntry.action, keyEntry.repeatCount, keyEntry.policyFlags);
6037 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006038 return false;
6039 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08006040
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006041 // Dispatch the unhandled key to the policy.
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006042 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
6043 ALOGD("Unhandled key event: Asking policy to perform fallback action. "
6044 "keyCode=%d, action=%d, repeatCount=%d, policyFlags=0x%08x",
6045 keyEntry.keyCode, keyEntry.action, keyEntry.repeatCount, keyEntry.policyFlags);
6046 }
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006047 KeyEvent event = createKeyEvent(keyEntry);
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006048
6049 mLock.unlock();
6050
Siarhei Vishniakou26d3cfb2019-10-15 17:02:32 -07006051 bool fallback =
6052 mPolicy->dispatchUnhandledKey(connection->inputChannel->getConnectionToken(),
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006053 &event, keyEntry.policyFlags, &event);
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006054
6055 mLock.lock();
6056
Siarhei Vishniakouf12f2f72021-11-17 17:49:45 -08006057 if (connection->status != Connection::Status::NORMAL) {
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006058 connection->inputState.removeFallbackKey(originalKeyCode);
6059 return false;
6060 }
6061
6062 // Latch the fallback keycode for this key on an initial down.
6063 // The fallback keycode cannot change at any other point in the lifecycle.
6064 if (initialDown) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08006065 if (fallback) {
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006066 fallbackKeyCode = event.getKeyCode();
6067 } else {
6068 fallbackKeyCode = AKEYCODE_UNKNOWN;
6069 }
6070 connection->inputState.setFallbackKey(originalKeyCode, fallbackKeyCode);
6071 }
6072
6073 ALOG_ASSERT(fallbackKeyCode != -1);
6074
6075 // Cancel the fallback key if the policy decides not to send it anymore.
6076 // We will continue to dispatch the key to the policy but we will no
6077 // longer dispatch a fallback key to the application.
Garfield Tan0fc2fa72019-08-29 17:22:15 -07006078 if (fallbackKeyCode != AKEYCODE_UNKNOWN &&
6079 (!fallback || fallbackKeyCode != event.getKeyCode())) {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006080 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
6081 if (fallback) {
6082 ALOGD("Unhandled key event: Policy requested to send key %d"
6083 "as a fallback for %d, but on the DOWN it had requested "
6084 "to send %d instead. Fallback canceled.",
6085 event.getKeyCode(), originalKeyCode, fallbackKeyCode);
6086 } else {
6087 ALOGD("Unhandled key event: Policy did not request fallback for %d, "
6088 "but on the DOWN it had requested to send %d. "
6089 "Fallback canceled.",
6090 originalKeyCode, fallbackKeyCode);
6091 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006092 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006093
6094 CancelationOptions options(CancelationOptions::CANCEL_FALLBACK_EVENTS,
6095 "canceling fallback, policy no longer desires it");
6096 options.keyCode = fallbackKeyCode;
6097 synthesizeCancelationEventsForConnectionLocked(connection, options);
6098
6099 fallback = false;
6100 fallbackKeyCode = AKEYCODE_UNKNOWN;
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006101 if (keyEntry.action != AKEY_EVENT_ACTION_UP) {
Garfield Tan0fc2fa72019-08-29 17:22:15 -07006102 connection->inputState.setFallbackKey(originalKeyCode, fallbackKeyCode);
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006103 }
6104 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08006105
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006106 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
6107 {
6108 std::string msg;
6109 const KeyedVector<int32_t, int32_t>& fallbackKeys =
6110 connection->inputState.getFallbackKeys();
6111 for (size_t i = 0; i < fallbackKeys.size(); i++) {
6112 msg += StringPrintf(", %d->%d", fallbackKeys.keyAt(i), fallbackKeys.valueAt(i));
6113 }
6114 ALOGD("Unhandled key event: %zu currently tracked fallback keys%s.",
6115 fallbackKeys.size(), msg.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08006116 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006117 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006118
6119 if (fallback) {
6120 // Restart the dispatch cycle using the fallback key.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006121 keyEntry.eventTime = event.getEventTime();
6122 keyEntry.deviceId = event.getDeviceId();
6123 keyEntry.source = event.getSource();
6124 keyEntry.displayId = event.getDisplayId();
6125 keyEntry.flags = event.getFlags() | AKEY_EVENT_FLAG_FALLBACK;
6126 keyEntry.keyCode = fallbackKeyCode;
6127 keyEntry.scanCode = event.getScanCode();
6128 keyEntry.metaState = event.getMetaState();
6129 keyEntry.repeatCount = event.getRepeatCount();
6130 keyEntry.downTime = event.getDownTime();
6131 keyEntry.syntheticRepeat = false;
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006132
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006133 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
6134 ALOGD("Unhandled key event: Dispatching fallback key. "
6135 "originalKeyCode=%d, fallbackKeyCode=%d, fallbackMetaState=%08x",
6136 originalKeyCode, fallbackKeyCode, keyEntry.metaState);
6137 }
Prabir Pradhanf557dcf2018-12-18 16:38:14 -08006138 return true; // restart the event
6139 } else {
Prabir Pradhan61a5d242021-07-26 16:41:09 +00006140 if (DEBUG_OUTBOUND_EVENT_DETAILS) {
6141 ALOGD("Unhandled key event: No fallback key.");
6142 }
Prabir Pradhanf93562f2018-11-29 12:13:37 -08006143
6144 // Report the key as unhandled, since there is no fallback key.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006145 mReporter->reportUnhandledKey(keyEntry.id);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006146 }
6147 }
6148 return false;
6149}
6150
Prabir Pradhancef936d2021-07-21 16:17:52 +00006151bool InputDispatcher::afterMotionEventLockedInterruptable(const sp<Connection>& connection,
Garfield Tan0fc2fa72019-08-29 17:22:15 -07006152 DispatchEntry* dispatchEntry,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -07006153 MotionEntry& motionEntry, bool handled) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08006154 return false;
6155}
6156
Michael Wrightd02c5b62014-02-10 15:10:22 -08006157void InputDispatcher::traceInboundQueueLengthLocked() {
6158 if (ATRACE_ENABLED()) {
Siarhei Vishniakou44a2aed2019-07-29 08:59:52 -07006159 ATRACE_INT("iq", mInboundQueue.size());
Michael Wrightd02c5b62014-02-10 15:10:22 -08006160 }
6161}
6162
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00006163void InputDispatcher::traceOutboundQueueLength(const Connection& connection) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08006164 if (ATRACE_ENABLED()) {
6165 char counterName[40];
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00006166 snprintf(counterName, sizeof(counterName), "oq:%s", connection.getWindowName().c_str());
6167 ATRACE_INT(counterName, connection.outboundQueue.size());
Michael Wrightd02c5b62014-02-10 15:10:22 -08006168 }
6169}
6170
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00006171void InputDispatcher::traceWaitQueueLength(const Connection& connection) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08006172 if (ATRACE_ENABLED()) {
6173 char counterName[40];
Siarhei Vishniakou060a7272021-02-03 19:40:10 +00006174 snprintf(counterName, sizeof(counterName), "wq:%s", connection.getWindowName().c_str());
6175 ATRACE_INT(counterName, connection.waitQueue.size());
Michael Wrightd02c5b62014-02-10 15:10:22 -08006176 }
6177}
6178
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08006179void InputDispatcher::dump(std::string& dump) {
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08006180 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006181
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08006182 dump += "Input Dispatcher State:\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08006183 dumpDispatchStateLocked(dump);
6184
Siarhei Vishniakoub1a16272020-05-06 16:09:19 -07006185 if (!mLastAnrState.empty()) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08006186 dump += "\nInput Dispatcher State at time of last ANR:\n";
Siarhei Vishniakoub1a16272020-05-06 16:09:19 -07006187 dump += mLastAnrState;
Michael Wrightd02c5b62014-02-10 15:10:22 -08006188 }
6189}
6190
6191void InputDispatcher::monitor() {
6192 // Acquire and release the lock to ensure that the dispatcher has not deadlocked.
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08006193 std::unique_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006194 mLooper->wake();
Siarhei Vishniakou443ad902019-03-06 17:25:41 -08006195 mDispatcherIsAlive.wait(_l);
Michael Wrightd02c5b62014-02-10 15:10:22 -08006196}
6197
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -08006198/**
6199 * Wake up the dispatcher and wait until it processes all events and commands.
6200 * The notification of mDispatcherEnteredIdle is guaranteed to happen after wake(), so
6201 * this method can be safely called from any thread, as long as you've ensured that
6202 * the work you are interested in completing has already been queued.
6203 */
6204bool InputDispatcher::waitForIdle() {
6205 /**
6206 * Timeout should represent the longest possible time that a device might spend processing
6207 * events and commands.
6208 */
6209 constexpr std::chrono::duration TIMEOUT = 100ms;
6210 std::unique_lock lock(mLock);
6211 mLooper->wake();
6212 std::cv_status result = mDispatcherEnteredIdle.wait_for(lock, TIMEOUT);
6213 return result == std::cv_status::no_timeout;
6214}
6215
Vishnu Naire798b472020-07-23 13:52:21 -07006216/**
6217 * Sets focus to the window identified by the token. This must be called
6218 * after updating any input window handles.
6219 *
6220 * Params:
6221 * request.token - input channel token used to identify the window that should gain focus.
6222 * request.focusedToken - the token that the caller expects currently to be focused. If the
6223 * specified token does not match the currently focused window, this request will be dropped.
6224 * If the specified focused token matches the currently focused window, the call will succeed.
6225 * Set this to "null" if this call should succeed no matter what the currently focused token is.
6226 * request.timestamp - SYSTEM_TIME_MONOTONIC timestamp in nanos set by the client (wm)
6227 * when requesting the focus change. This determines which request gets
6228 * precedence if there is a focus change request from another source such as pointer down.
6229 */
Vishnu Nair958da932020-08-21 17:12:37 -07006230void InputDispatcher::setFocusedWindow(const FocusRequest& request) {
6231 { // acquire lock
6232 std::scoped_lock _l(mLock);
Vishnu Nairc519ff72021-01-21 08:23:08 -08006233 std::optional<FocusResolver::FocusChanges> changes =
6234 mFocusResolver.setFocusedWindow(request, getWindowHandlesLocked(request.displayId));
6235 if (changes) {
6236 onFocusChangedLocked(*changes);
Vishnu Nair958da932020-08-21 17:12:37 -07006237 }
6238 } // release lock
6239 // Wake up poll loop since it may need to make new input dispatching choices.
6240 mLooper->wake();
6241}
6242
Vishnu Nairc519ff72021-01-21 08:23:08 -08006243void InputDispatcher::onFocusChangedLocked(const FocusResolver::FocusChanges& changes) {
6244 if (changes.oldFocus) {
6245 std::shared_ptr<InputChannel> focusedInputChannel = getInputChannelLocked(changes.oldFocus);
Vishnu Nair7d3d00d2020-08-03 11:20:42 -07006246 if (focusedInputChannel) {
6247 CancelationOptions options(CancelationOptions::CANCEL_NON_POINTER_EVENTS,
6248 "focus left window");
6249 synthesizeCancelationEventsForInputChannelLocked(focusedInputChannel, options);
Vishnu Nairc519ff72021-01-21 08:23:08 -08006250 enqueueFocusEventLocked(changes.oldFocus, false /*hasFocus*/, changes.reason);
Vishnu Nair7d3d00d2020-08-03 11:20:42 -07006251 }
Vishnu Nair7d3d00d2020-08-03 11:20:42 -07006252 }
Vishnu Nairc519ff72021-01-21 08:23:08 -08006253 if (changes.newFocus) {
6254 enqueueFocusEventLocked(changes.newFocus, true /*hasFocus*/, changes.reason);
Vishnu Nair7d3d00d2020-08-03 11:20:42 -07006255 }
6256
Prabir Pradhan99987712020-11-10 18:43:05 -08006257 // If a window has pointer capture, then it must have focus. We need to ensure that this
6258 // contract is upheld when pointer capture is being disabled due to a loss of window focus.
6259 // If the window loses focus before it loses pointer capture, then the window can be in a state
6260 // where it has pointer capture but not focus, violating the contract. Therefore we must
6261 // dispatch the pointer capture event before the focus event. Since focus events are added to
6262 // the front of the queue (above), we add the pointer capture event to the front of the queue
6263 // after the focus events are added. This ensures the pointer capture event ends up at the
6264 // front.
6265 disablePointerCaptureForcedLocked();
6266
Vishnu Nairc519ff72021-01-21 08:23:08 -08006267 if (mFocusedDisplayId == changes.displayId) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00006268 sendFocusChangedCommandLocked(changes.oldFocus, changes.newFocus);
Vishnu Nair7d3d00d2020-08-03 11:20:42 -07006269 }
6270}
Vishnu Nair958da932020-08-21 17:12:37 -07006271
Prabir Pradhan99987712020-11-10 18:43:05 -08006272void InputDispatcher::disablePointerCaptureForcedLocked() {
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00006273 if (!mCurrentPointerCaptureRequest.enable && !mWindowTokenWithPointerCapture) {
Prabir Pradhan99987712020-11-10 18:43:05 -08006274 return;
6275 }
6276
6277 ALOGD_IF(DEBUG_FOCUS, "Disabling Pointer Capture because the window lost focus.");
6278
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00006279 if (mCurrentPointerCaptureRequest.enable) {
Prabir Pradhan99987712020-11-10 18:43:05 -08006280 setPointerCaptureLocked(false);
6281 }
6282
6283 if (!mWindowTokenWithPointerCapture) {
6284 // No need to send capture changes because no window has capture.
6285 return;
6286 }
6287
6288 if (mPendingEvent != nullptr) {
6289 // Move the pending event to the front of the queue. This will give the chance
6290 // for the pending event to be dropped if it is a captured event.
6291 mInboundQueue.push_front(mPendingEvent);
6292 mPendingEvent = nullptr;
6293 }
6294
6295 auto entry = std::make_unique<PointerCaptureChangedEntry>(mIdGenerator.nextId(), now(),
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00006296 mCurrentPointerCaptureRequest);
Prabir Pradhan99987712020-11-10 18:43:05 -08006297 mInboundQueue.push_front(std::move(entry));
6298}
6299
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00006300void InputDispatcher::setPointerCaptureLocked(bool enable) {
6301 mCurrentPointerCaptureRequest.enable = enable;
6302 mCurrentPointerCaptureRequest.seq++;
6303 auto command = [this, request = mCurrentPointerCaptureRequest]() REQUIRES(mLock) {
Prabir Pradhancef936d2021-07-21 16:17:52 +00006304 scoped_unlock unlock(mLock);
Prabir Pradhan5cc1a692021-08-06 14:01:18 +00006305 mPolicy->setPointerCapture(request);
Prabir Pradhancef936d2021-07-21 16:17:52 +00006306 };
6307 postCommandLocked(std::move(command));
Prabir Pradhan99987712020-11-10 18:43:05 -08006308}
6309
Vishnu Nair599f1412021-06-21 10:39:58 -07006310void InputDispatcher::displayRemoved(int32_t displayId) {
6311 { // acquire lock
6312 std::scoped_lock _l(mLock);
6313 // Set an empty list to remove all handles from the specific display.
6314 setInputWindowsLocked(/* window handles */ {}, displayId);
6315 setFocusedApplicationLocked(displayId, nullptr);
6316 // Call focus resolver to clean up stale requests. This must be called after input windows
6317 // have been removed for the removed display.
6318 mFocusResolver.displayRemoved(displayId);
Christine Franksb768bb42021-11-29 12:11:31 -08006319 // Reset pointer capture eligibility, regardless of previous state.
6320 std::erase(mIneligibleDisplaysForPointerCapture, displayId);
Vishnu Nair599f1412021-06-21 10:39:58 -07006321 } // release lock
6322
6323 // Wake up poll loop since it may need to make new input dispatching choices.
6324 mLooper->wake();
6325}
6326
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07006327void InputDispatcher::onWindowInfosChanged(const std::vector<WindowInfo>& windowInfos,
6328 const std::vector<DisplayInfo>& displayInfos) {
chaviw15fab6f2021-06-07 14:15:52 -05006329 // The listener sends the windows as a flattened array. Separate the windows by display for
6330 // more convenient parsing.
6331 std::unordered_map<int32_t, std::vector<sp<WindowInfoHandle>>> handlesPerDisplay;
chaviw15fab6f2021-06-07 14:15:52 -05006332 for (const auto& info : windowInfos) {
6333 handlesPerDisplay.emplace(info.displayId, std::vector<sp<WindowInfoHandle>>());
6334 handlesPerDisplay[info.displayId].push_back(new WindowInfoHandle(info));
6335 }
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07006336
6337 { // acquire lock
6338 std::scoped_lock _l(mLock);
Prabir Pradhan73fe4812022-07-22 20:22:18 +00006339
6340 // Ensure that we have an entry created for all existing displays so that if a displayId has
6341 // no windows, we can tell that the windows were removed from the display.
6342 for (const auto& [displayId, _] : mWindowHandlesByDisplay) {
6343 handlesPerDisplay[displayId];
6344 }
6345
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07006346 mDisplayInfos.clear();
6347 for (const auto& displayInfo : displayInfos) {
6348 mDisplayInfos.emplace(displayInfo.displayId, displayInfo);
6349 }
6350
6351 for (const auto& [displayId, handles] : handlesPerDisplay) {
6352 setInputWindowsLocked(handles, displayId);
6353 }
6354 }
6355 // Wake up poll loop since it may need to make new input dispatching choices.
6356 mLooper->wake();
chaviw15fab6f2021-06-07 14:15:52 -05006357}
6358
Vishnu Nair062a8672021-09-03 16:07:44 -07006359bool InputDispatcher::shouldDropInput(
6360 const EventEntry& entry, const sp<android::gui::WindowInfoHandle>& windowHandle) const {
Prabir Pradhan51e7db02022-02-07 06:02:57 -08006361 if (windowHandle->getInfo()->inputConfig.test(WindowInfo::InputConfig::DROP_INPUT) ||
6362 (windowHandle->getInfo()->inputConfig.test(
6363 WindowInfo::InputConfig::DROP_INPUT_IF_OBSCURED) &&
Vishnu Nair062a8672021-09-03 16:07:44 -07006364 isWindowObscuredLocked(windowHandle))) {
Prabir Pradhan51e7db02022-02-07 06:02:57 -08006365 ALOGW("Dropping %s event targeting %s as requested by the input configuration {%s} on "
6366 "display %" PRId32 ".",
Vishnu Nair062a8672021-09-03 16:07:44 -07006367 ftl::enum_string(entry.type).c_str(), windowHandle->getName().c_str(),
Prabir Pradhan51e7db02022-02-07 06:02:57 -08006368 windowHandle->getInfo()->inputConfig.string().c_str(),
Vishnu Nair062a8672021-09-03 16:07:44 -07006369 windowHandle->getInfo()->displayId);
6370 return true;
6371 }
6372 return false;
6373}
6374
Siarhei Vishniakou18050092021-09-01 13:32:49 -07006375void InputDispatcher::DispatcherWindowListener::onWindowInfosChanged(
6376 const std::vector<gui::WindowInfo>& windowInfos,
6377 const std::vector<DisplayInfo>& displayInfos) {
6378 mDispatcher.onWindowInfosChanged(windowInfos, displayInfos);
6379}
6380
Arthur Hungdfd528e2021-12-08 13:23:04 +00006381void InputDispatcher::cancelCurrentTouch() {
6382 {
6383 std::scoped_lock _l(mLock);
6384 ALOGD("Canceling all ongoing pointer gestures on all displays.");
6385 CancelationOptions options(CancelationOptions::CANCEL_POINTER_EVENTS,
6386 "cancel current touch");
6387 synthesizeCancelationEventsForAllConnectionsLocked(options);
6388
6389 mTouchStatesByDisplay.clear();
6390 mLastHoverWindowHandle.clear();
6391 }
6392 // Wake up poll loop since there might be work to do.
6393 mLooper->wake();
6394}
6395
Prabir Pradhan1376fcd2022-01-21 09:56:35 -08006396void InputDispatcher::setMonitorDispatchingTimeoutForTest(std::chrono::nanoseconds timeout) {
6397 std::scoped_lock _l(mLock);
6398 mMonitorDispatchingTimeout = timeout;
6399}
6400
Garfield Tane84e6f92019-08-29 17:28:41 -07006401} // namespace android::inputdispatcher