1 /* 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 #ifndef _UI_INPUT_DISPATCHER_H 18 #define _UI_INPUT_DISPATCHER_H 19 20 #include "AnrTracker.h" 21 #include "CancelationOptions.h" 22 #include "DragState.h" 23 #include "Entry.h" 24 #include "FocusResolver.h" 25 #include "InjectionState.h" 26 #include "InputDispatcherConfiguration.h" 27 #include "InputDispatcherInterface.h" 28 #include "InputDispatcherPolicyInterface.h" 29 #include "InputState.h" 30 #include "InputTarget.h" 31 #include "InputThread.h" 32 #include "LatencyAggregator.h" 33 #include "LatencyTracker.h" 34 #include "Monitor.h" 35 #include "TouchState.h" 36 #include "TouchedWindow.h" 37 38 #include <attestation/HmacKeyManager.h> 39 #include <com/android/internal/compat/IPlatformCompatNative.h> 40 #include <input/Input.h> 41 #include <input/InputApplication.h> 42 #include <input/InputTransport.h> 43 #include <input/InputWindow.h> 44 #include <limits.h> 45 #include <stddef.h> 46 #include <ui/Region.h> 47 #include <unistd.h> 48 #include <utils/BitSet.h> 49 #include <utils/Looper.h> 50 #include <utils/RefBase.h> 51 #include <utils/Timers.h> 52 #include <utils/threads.h> 53 #include <condition_variable> 54 #include <deque> 55 #include <optional> 56 #include <unordered_map> 57 #include <unordered_set> 58 59 #include <InputListener.h> 60 #include <InputReporterInterface.h> 61 62 namespace android::inputdispatcher { 63 64 class Connection; 65 66 /* Dispatches events to input targets. Some functions of the input dispatcher, such as 67 * identifying input targets, are controlled by a separate policy object. 68 * 69 * IMPORTANT INVARIANT: 70 * Because the policy can potentially block or cause re-entrance into the input dispatcher, 71 * the input dispatcher never calls into the policy while holding its internal locks. 72 * The implementation is also carefully designed to recover from scenarios such as an 73 * input channel becoming unregistered while identifying input targets or processing timeouts. 74 * 75 * Methods marked 'Locked' must be called with the lock acquired. 76 * 77 * Methods marked 'LockedInterruptible' must be called with the lock acquired but 78 * may during the course of their execution release the lock, call into the policy, and 79 * then reacquire the lock. The caller is responsible for recovering gracefully. 80 * 81 * A 'LockedInterruptible' method may called a 'Locked' method, but NOT vice-versa. 82 */ 83 class InputDispatcher : public android::InputDispatcherInterface { 84 protected: 85 ~InputDispatcher() override; 86 87 public: 88 explicit InputDispatcher(const sp<InputDispatcherPolicyInterface>& policy); 89 90 void dump(std::string& dump) override; 91 void monitor() override; 92 bool waitForIdle() override; 93 status_t start() override; 94 status_t stop() override; 95 96 void notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args) override; 97 void notifyKey(const NotifyKeyArgs* args) override; 98 void notifyMotion(const NotifyMotionArgs* args) override; 99 void notifySwitch(const NotifySwitchArgs* args) override; 100 void notifySensor(const NotifySensorArgs* args) override; 101 void notifyVibratorState(const NotifyVibratorStateArgs* args) override; 102 void notifyDeviceReset(const NotifyDeviceResetArgs* args) override; 103 void notifyPointerCaptureChanged(const NotifyPointerCaptureChangedArgs* args) override; 104 105 android::os::InputEventInjectionResult injectInputEvent( 106 const InputEvent* event, int32_t injectorPid, int32_t injectorUid, 107 android::os::InputEventInjectionSync syncMode, std::chrono::milliseconds timeout, 108 uint32_t policyFlags) override; 109 110 std::unique_ptr<VerifiedInputEvent> verifyInputEvent(const InputEvent& event) override; 111 112 void setInputWindows(const std::unordered_map<int32_t, std::vector<sp<InputWindowHandle>>>& 113 handlesPerDisplay) override; 114 void setFocusedApplication( 115 int32_t displayId, 116 const std::shared_ptr<InputApplicationHandle>& inputApplicationHandle) override; 117 void setFocusedDisplay(int32_t displayId) override; 118 void setInputDispatchMode(bool enabled, bool frozen) override; 119 void setInputFilterEnabled(bool enabled) override; 120 void setInTouchMode(bool inTouchMode) override; 121 void setMaximumObscuringOpacityForTouch(float opacity) override; 122 void setBlockUntrustedTouchesMode(android::os::BlockUntrustedTouchesMode mode) override; 123 124 bool transferTouchFocus(const sp<IBinder>& fromToken, const sp<IBinder>& toToken, 125 bool isDragDrop = false) override; 126 bool transferTouch(const sp<IBinder>& destChannelToken) override; 127 128 base::Result<std::unique_ptr<InputChannel>> createInputChannel( 129 const std::string& name) override; 130 void setFocusedWindow(const FocusRequest&) override; 131 base::Result<std::unique_ptr<InputChannel>> createInputMonitor(int32_t displayId, 132 bool isGestureMonitor, 133 const std::string& name, 134 int32_t pid) override; 135 status_t removeInputChannel(const sp<IBinder>& connectionToken) override; 136 status_t pilferPointers(const sp<IBinder>& token) override; 137 void requestPointerCapture(const sp<IBinder>& windowToken, bool enabled) override; 138 bool flushSensor(int deviceId, InputDeviceSensorType sensorType) override; 139 140 std::array<uint8_t, 32> sign(const VerifiedInputEvent& event) const; 141 142 void displayRemoved(int32_t displayId) override; 143 144 private: 145 enum class DropReason { 146 NOT_DROPPED, 147 POLICY, 148 APP_SWITCH, 149 DISABLED, 150 BLOCKED, 151 STALE, 152 NO_POINTER_CAPTURE, 153 }; 154 155 std::unique_ptr<InputThread> mThread; 156 157 sp<InputDispatcherPolicyInterface> mPolicy; 158 android::InputDispatcherConfiguration mConfig; 159 160 std::mutex mLock; 161 162 std::condition_variable mDispatcherIsAlive; 163 std::condition_variable mDispatcherEnteredIdle; 164 165 sp<Looper> mLooper; 166 167 std::shared_ptr<EventEntry> mPendingEvent GUARDED_BY(mLock); 168 std::deque<std::shared_ptr<EventEntry>> mInboundQueue GUARDED_BY(mLock); 169 std::deque<std::shared_ptr<EventEntry>> mRecentQueue GUARDED_BY(mLock); 170 std::deque<std::unique_ptr<CommandEntry>> mCommandQueue GUARDED_BY(mLock); 171 172 DropReason mLastDropReason GUARDED_BY(mLock); 173 174 const IdGenerator mIdGenerator; 175 176 // With each iteration, InputDispatcher nominally processes one queued event, 177 // a timeout, or a response from an input consumer. 178 // This method should only be called on the input dispatcher's own thread. 179 void dispatchOnce(); 180 181 void dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) REQUIRES(mLock); 182 183 // Enqueues an inbound event. Returns true if mLooper->wake() should be called. 184 bool enqueueInboundEventLocked(std::unique_ptr<EventEntry> entry) REQUIRES(mLock); 185 186 // Cleans up input state when dropping an inbound event. 187 void dropInboundEventLocked(const EventEntry& entry, DropReason dropReason) REQUIRES(mLock); 188 189 // Enqueues a focus event. 190 void enqueueFocusEventLocked(const sp<IBinder>& windowToken, bool hasFocus, 191 const std::string& reason) REQUIRES(mLock); 192 // Enqueues a drag event. 193 void enqueueDragEventLocked(const sp<InputWindowHandle>& windowToken, bool isExiting, 194 const MotionEntry& motionEntry) REQUIRES(mLock); 195 196 // Adds an event to a queue of recent events for debugging purposes. 197 void addRecentEventLocked(std::shared_ptr<EventEntry> entry) REQUIRES(mLock); 198 199 // App switch latency optimization. 200 bool mAppSwitchSawKeyDown GUARDED_BY(mLock); 201 nsecs_t mAppSwitchDueTime GUARDED_BY(mLock); 202 203 bool isAppSwitchKeyEvent(const KeyEntry& keyEntry); 204 bool isAppSwitchPendingLocked() REQUIRES(mLock); 205 void resetPendingAppSwitchLocked(bool handled) REQUIRES(mLock); 206 207 // Blocked event latency optimization. Drops old events when the user intends 208 // to transfer focus to a new application. 209 std::shared_ptr<EventEntry> mNextUnblockedEvent GUARDED_BY(mLock); 210 211 sp<InputWindowHandle> findTouchedWindowAtLocked(int32_t displayId, int32_t x, int32_t y, 212 TouchState* touchState, 213 bool addOutsideTargets = false, 214 bool addPortalWindows = false, 215 bool ignoreDragWindow = false) REQUIRES(mLock); 216 217 sp<Connection> getConnectionLocked(const sp<IBinder>& inputConnectionToken) const 218 REQUIRES(mLock); 219 220 std::string getConnectionNameLocked(const sp<IBinder>& connectionToken) const REQUIRES(mLock); 221 222 void removeConnectionLocked(const sp<Connection>& connection) REQUIRES(mLock); 223 224 template <typename T> 225 struct StrongPointerHash { operatorStrongPointerHash226 std::size_t operator()(const sp<T>& b) const { return std::hash<T*>{}(b.get()); } 227 }; 228 229 // All registered connections mapped by input channel token. 230 std::unordered_map<sp<IBinder>, sp<Connection>, StrongPointerHash<IBinder>> mConnectionsByToken 231 GUARDED_BY(mLock); 232 233 // Finds the display ID of the gesture monitor identified by the provided token. 234 std::optional<int32_t> findGestureMonitorDisplayByTokenLocked(const sp<IBinder>& token) 235 REQUIRES(mLock); 236 // Find a monitor pid by the provided token. 237 std::optional<int32_t> findMonitorPidByTokenLocked(const sp<IBinder>& token) REQUIRES(mLock); 238 239 // Input channels that will receive a copy of all input events sent to the provided display. 240 std::unordered_map<int32_t, std::vector<Monitor>> mGlobalMonitorsByDisplay GUARDED_BY(mLock); 241 242 // Input channels that will receive pointer events that start within the corresponding display. 243 // These are a bit special when compared to global monitors since they'll cause gesture streams 244 // to continue even when there isn't a touched window,and have the ability to steal the rest of 245 // the pointer stream in order to claim it for a system gesture. 246 std::unordered_map<int32_t, std::vector<Monitor>> mGestureMonitorsByDisplay GUARDED_BY(mLock); 247 248 const HmacKeyManager mHmacKeyManager; 249 const std::array<uint8_t, 32> getSignature(const MotionEntry& motionEntry, 250 const DispatchEntry& dispatchEntry) const; 251 const std::array<uint8_t, 32> getSignature(const KeyEntry& keyEntry, 252 const DispatchEntry& dispatchEntry) const; 253 254 // Event injection and synchronization. 255 std::condition_variable mInjectionResultAvailable; 256 bool hasInjectionPermission(int32_t injectorPid, int32_t injectorUid); 257 void setInjectionResult(EventEntry& entry, 258 android::os::InputEventInjectionResult injectionResult); 259 260 std::condition_variable mInjectionSyncFinished; 261 void incrementPendingForegroundDispatches(EventEntry& entry); 262 void decrementPendingForegroundDispatches(EventEntry& entry); 263 264 // Key repeat tracking. 265 struct KeyRepeatState { 266 std::shared_ptr<KeyEntry> lastKeyEntry; // or null if no repeat 267 nsecs_t nextRepeatTime; 268 } mKeyRepeatState GUARDED_BY(mLock); 269 270 void resetKeyRepeatLocked() REQUIRES(mLock); 271 std::shared_ptr<KeyEntry> synthesizeKeyRepeatLocked(nsecs_t currentTime) REQUIRES(mLock); 272 273 // Key replacement tracking 274 struct KeyReplacement { 275 int32_t keyCode; 276 int32_t deviceId; 277 bool operator==(const KeyReplacement& rhs) const { 278 return keyCode == rhs.keyCode && deviceId == rhs.deviceId; 279 } 280 }; 281 struct KeyReplacementHash { operatorKeyReplacementHash282 size_t operator()(const KeyReplacement& key) const { 283 return std::hash<int32_t>()(key.keyCode) ^ (std::hash<int32_t>()(key.deviceId) << 1); 284 } 285 }; 286 // Maps the key code replaced, device id tuple to the key code it was replaced with 287 std::unordered_map<KeyReplacement, int32_t, KeyReplacementHash> mReplacedKeys GUARDED_BY(mLock); 288 // Process certain Meta + Key combinations 289 void accelerateMetaShortcuts(const int32_t deviceId, const int32_t action, int32_t& keyCode, 290 int32_t& metaState); 291 292 // Deferred command processing. 293 bool haveCommandsLocked() const REQUIRES(mLock); 294 bool runCommandsLockedInterruptible() REQUIRES(mLock); 295 void postCommandLocked(std::unique_ptr<CommandEntry> commandEntry) REQUIRES(mLock); 296 297 nsecs_t processAnrsLocked() REQUIRES(mLock); 298 std::chrono::nanoseconds getDispatchingTimeoutLocked(const sp<IBinder>& token) REQUIRES(mLock); 299 300 // Input filter processing. 301 bool shouldSendKeyToInputFilterLocked(const NotifyKeyArgs* args) REQUIRES(mLock); 302 bool shouldSendMotionToInputFilterLocked(const NotifyMotionArgs* args) REQUIRES(mLock); 303 304 // Inbound event processing. 305 void drainInboundQueueLocked() REQUIRES(mLock); 306 void releasePendingEventLocked() REQUIRES(mLock); 307 void releaseInboundEventLocked(std::shared_ptr<EventEntry> entry) REQUIRES(mLock); 308 309 // Dispatch state. 310 bool mDispatchEnabled GUARDED_BY(mLock); 311 bool mDispatchFrozen GUARDED_BY(mLock); 312 bool mInputFilterEnabled GUARDED_BY(mLock); 313 bool mInTouchMode GUARDED_BY(mLock); 314 float mMaximumObscuringOpacityForTouch GUARDED_BY(mLock); 315 android::os::BlockUntrustedTouchesMode mBlockUntrustedTouchesMode GUARDED_BY(mLock); 316 317 std::unordered_map<int32_t, std::vector<sp<InputWindowHandle>>> mWindowHandlesByDisplay 318 GUARDED_BY(mLock); 319 void setInputWindowsLocked(const std::vector<sp<InputWindowHandle>>& inputWindowHandles, 320 int32_t displayId) REQUIRES(mLock); 321 // Get a reference to window handles by display, return an empty vector if not found. 322 const std::vector<sp<InputWindowHandle>>& getWindowHandlesLocked(int32_t displayId) const 323 REQUIRES(mLock); 324 sp<InputWindowHandle> getWindowHandleLocked(const sp<IBinder>& windowHandleToken) const 325 REQUIRES(mLock); 326 327 // Same function as above, but faster. Since displayId is provided, this avoids the need 328 // to loop through all displays. 329 sp<InputWindowHandle> getWindowHandleLocked(const sp<IBinder>& windowHandleToken, 330 int displayId) const REQUIRES(mLock); 331 sp<InputWindowHandle> getWindowHandleLocked(const sp<InputWindowHandle>& windowHandle) const 332 REQUIRES(mLock); 333 std::shared_ptr<InputChannel> getInputChannelLocked(const sp<IBinder>& windowToken) const 334 REQUIRES(mLock); 335 sp<InputWindowHandle> getFocusedWindowHandleLocked(int displayId) const REQUIRES(mLock); 336 bool hasResponsiveConnectionLocked(InputWindowHandle& windowHandle) const REQUIRES(mLock); 337 338 /* 339 * Validate and update InputWindowHandles for a given display. 340 */ 341 void updateWindowHandlesForDisplayLocked( 342 const std::vector<sp<InputWindowHandle>>& inputWindowHandles, int32_t displayId) 343 REQUIRES(mLock); 344 345 std::unordered_map<int32_t, TouchState> mTouchStatesByDisplay GUARDED_BY(mLock); 346 std::unique_ptr<DragState> mDragState GUARDED_BY(mLock); 347 348 void setFocusedApplicationLocked( 349 int32_t displayId, 350 const std::shared_ptr<InputApplicationHandle>& inputApplicationHandle) REQUIRES(mLock); 351 // Focused applications. 352 std::unordered_map<int32_t, std::shared_ptr<InputApplicationHandle>> 353 mFocusedApplicationHandlesByDisplay GUARDED_BY(mLock); 354 355 // Top focused display. 356 int32_t mFocusedDisplayId GUARDED_BY(mLock); 357 358 // Keeps track of the focused window per display and determines focus changes. 359 FocusResolver mFocusResolver GUARDED_BY(mLock); 360 // Whether the focused window on the focused display has requested Pointer Capture. 361 // The state of this variable should always be in sync with the state of Pointer Capture in the 362 // policy, which is updated through setPointerCaptureLocked(enabled). 363 bool mFocusedWindowRequestedPointerCapture GUARDED_BY(mLock); 364 365 // The window token that has Pointer Capture. 366 // This should be in sync with PointerCaptureChangedEvents dispatched to the input channel. 367 sp<IBinder> mWindowTokenWithPointerCapture GUARDED_BY(mLock); 368 369 // Disable Pointer Capture as a result of loss of window focus. 370 void disablePointerCaptureForcedLocked() REQUIRES(mLock); 371 372 // Set the Pointer Capture state in the Policy. 373 void setPointerCaptureLocked(bool enabled) REQUIRES(mLock); 374 375 // Dispatcher state at time of last ANR. 376 std::string mLastAnrState GUARDED_BY(mLock); 377 378 // The connection tokens of the channels that the user last interacted, for debugging 379 std::unordered_set<sp<IBinder>, StrongPointerHash<IBinder>> mInteractionConnectionTokens 380 GUARDED_BY(mLock); 381 void updateInteractionTokensLocked(const EventEntry& entry, 382 const std::vector<InputTarget>& targets) REQUIRES(mLock); 383 384 // Dispatch inbound events. 385 bool dispatchConfigurationChangedLocked(nsecs_t currentTime, 386 const ConfigurationChangedEntry& entry) REQUIRES(mLock); 387 bool dispatchDeviceResetLocked(nsecs_t currentTime, const DeviceResetEntry& entry) 388 REQUIRES(mLock); 389 bool dispatchKeyLocked(nsecs_t currentTime, std::shared_ptr<KeyEntry> entry, 390 DropReason* dropReason, nsecs_t* nextWakeupTime) REQUIRES(mLock); 391 bool dispatchMotionLocked(nsecs_t currentTime, std::shared_ptr<MotionEntry> entry, 392 DropReason* dropReason, nsecs_t* nextWakeupTime) REQUIRES(mLock); 393 void dispatchFocusLocked(nsecs_t currentTime, std::shared_ptr<FocusEntry> entry) 394 REQUIRES(mLock); 395 void dispatchPointerCaptureChangedLocked( 396 nsecs_t currentTime, const std::shared_ptr<PointerCaptureChangedEntry>& entry, 397 DropReason& dropReason) REQUIRES(mLock); 398 void dispatchEventLocked(nsecs_t currentTime, std::shared_ptr<EventEntry> entry, 399 const std::vector<InputTarget>& inputTargets) REQUIRES(mLock); 400 void dispatchSensorLocked(nsecs_t currentTime, std::shared_ptr<SensorEntry> entry, 401 DropReason* dropReason, nsecs_t* nextWakeupTime) REQUIRES(mLock); 402 void dispatchDragLocked(nsecs_t currentTime, std::shared_ptr<DragEntry> entry) REQUIRES(mLock); 403 void logOutboundKeyDetails(const char* prefix, const KeyEntry& entry); 404 void logOutboundMotionDetails(const char* prefix, const MotionEntry& entry); 405 406 /** 407 * This field is set if there is no focused window, and we have an event that requires 408 * a focused window to be dispatched (for example, a KeyEvent). 409 * When this happens, we will wait until *mNoFocusedWindowTimeoutTime before 410 * dropping the event and raising an ANR for that application. 411 * This is useful if an application is slow to add a focused window. 412 */ 413 std::optional<nsecs_t> mNoFocusedWindowTimeoutTime GUARDED_BY(mLock); 414 415 bool shouldPruneInboundQueueLocked(const MotionEntry& motionEntry) REQUIRES(mLock); 416 417 /** 418 * Time to stop waiting for the events to be processed while trying to dispatch a key. 419 * When this time expires, we just send the pending key event to the currently focused window, 420 * without waiting on other events to be processed first. 421 */ 422 std::optional<nsecs_t> mKeyIsWaitingForEventsTimeout GUARDED_BY(mLock); 423 bool shouldWaitToSendKeyLocked(nsecs_t currentTime, const char* focusedWindowName) 424 REQUIRES(mLock); 425 426 /** 427 * The focused application at the time when no focused window was present. 428 * Used to raise an ANR when we have no focused window. 429 */ 430 std::shared_ptr<InputApplicationHandle> mAwaitedFocusedApplication GUARDED_BY(mLock); 431 /** 432 * The displayId that the focused application is associated with. 433 */ 434 int32_t mAwaitedApplicationDisplayId GUARDED_BY(mLock); 435 void processNoFocusedWindowAnrLocked() REQUIRES(mLock); 436 437 /** 438 * Tell policy about a window or a monitor that just became unresponsive. Starts ANR. 439 */ 440 void processConnectionUnresponsiveLocked(const Connection& connection, std::string reason) 441 REQUIRES(mLock); 442 /** 443 * Tell policy about a window or a monitor that just became responsive. 444 */ 445 void processConnectionResponsiveLocked(const Connection& connection) REQUIRES(mLock); 446 447 /** 448 * Post `doNotifyMonitorUnresponsiveLockedInterruptible` command. 449 */ 450 void sendMonitorUnresponsiveCommandLocked(int32_t pid, std::string reason) REQUIRES(mLock); 451 /** 452 * Post `doNotifyWindowUnresponsiveLockedInterruptible` command. 453 */ 454 void sendWindowUnresponsiveCommandLocked(sp<IBinder> connectionToken, std::string reason) 455 REQUIRES(mLock); 456 /** 457 * Post `doNotifyMonitorResponsiveLockedInterruptible` command. 458 */ 459 void sendMonitorResponsiveCommandLocked(int32_t pid) REQUIRES(mLock); 460 /** 461 * Post `doNotifyWindowResponsiveLockedInterruptible` command. 462 */ 463 void sendWindowResponsiveCommandLocked(sp<IBinder> connectionToken) REQUIRES(mLock); 464 465 466 // Optimization: AnrTracker is used to quickly find which connection is due for a timeout next. 467 // AnrTracker must be kept in-sync with all responsive connection.waitQueues. 468 // If a connection is not responsive, then the entries should not be added to the AnrTracker. 469 // Once a connection becomes unresponsive, its entries are removed from AnrTracker to 470 // prevent unneeded wakeups. 471 AnrTracker mAnrTracker GUARDED_BY(mLock); 472 473 // Contains the last window which received a hover event. 474 sp<InputWindowHandle> mLastHoverWindowHandle GUARDED_BY(mLock); 475 476 void cancelEventsForAnrLocked(const sp<Connection>& connection) REQUIRES(mLock); 477 nsecs_t getTimeSpentWaitingForApplicationLocked(nsecs_t currentTime) REQUIRES(mLock); 478 // If a focused application changes, we should stop counting down the "no focused window" time, 479 // because we will have no way of knowing when the previous application actually added a window. 480 // This also means that we will miss cases like pulling down notification shade when the 481 // focused application does not have a focused window (no ANR will be raised if notification 482 // shade is pulled down while we are counting down the timeout). 483 void resetNoFocusedWindowTimeoutLocked() REQUIRES(mLock); 484 485 int32_t getTargetDisplayId(const EventEntry& entry); 486 android::os::InputEventInjectionResult findFocusedWindowTargetsLocked( 487 nsecs_t currentTime, const EventEntry& entry, std::vector<InputTarget>& inputTargets, 488 nsecs_t* nextWakeupTime) REQUIRES(mLock); 489 android::os::InputEventInjectionResult findTouchedWindowTargetsLocked( 490 nsecs_t currentTime, const MotionEntry& entry, std::vector<InputTarget>& inputTargets, 491 nsecs_t* nextWakeupTime, bool* outConflictingPointerActions) REQUIRES(mLock); 492 std::vector<TouchedMonitor> findTouchedGestureMonitorsLocked( 493 int32_t displayId, const std::vector<sp<InputWindowHandle>>& portalWindows) const 494 REQUIRES(mLock); 495 std::vector<TouchedMonitor> selectResponsiveMonitorsLocked( 496 const std::vector<TouchedMonitor>& gestureMonitors) const REQUIRES(mLock); 497 498 void addWindowTargetLocked(const sp<InputWindowHandle>& windowHandle, int32_t targetFlags, 499 BitSet32 pointerIds, std::vector<InputTarget>& inputTargets) 500 REQUIRES(mLock); 501 void addMonitoringTargetLocked(const Monitor& monitor, float xOffset, float yOffset, 502 std::vector<InputTarget>& inputTargets) REQUIRES(mLock); 503 void addGlobalMonitoringTargetsLocked(std::vector<InputTarget>& inputTargets, int32_t displayId, 504 float xOffset = 0, float yOffset = 0) REQUIRES(mLock); 505 void pokeUserActivityLocked(const EventEntry& eventEntry) REQUIRES(mLock); 506 bool checkInjectionPermission(const sp<InputWindowHandle>& windowHandle, 507 const InjectionState* injectionState); 508 // Enqueue a drag event if needed, and update the touch state. 509 // Uses findTouchedWindowTargetsLocked to make the decision 510 void addDragEventLocked(const MotionEntry& entry) REQUIRES(mLock); 511 void finishDragAndDrop(int32_t displayId, float x, float y) REQUIRES(mLock); 512 513 struct TouchOcclusionInfo { 514 bool hasBlockingOcclusion; 515 float obscuringOpacity; 516 std::string obscuringPackage; 517 int32_t obscuringUid; 518 std::vector<std::string> debugInfo; 519 }; 520 521 TouchOcclusionInfo computeTouchOcclusionInfoLocked(const sp<InputWindowHandle>& windowHandle, 522 int32_t x, int32_t y) const REQUIRES(mLock); 523 bool isTouchTrustedLocked(const TouchOcclusionInfo& occlusionInfo) const REQUIRES(mLock); 524 bool isWindowObscuredAtPointLocked(const sp<InputWindowHandle>& windowHandle, int32_t x, 525 int32_t y) const REQUIRES(mLock); 526 bool isWindowObscuredLocked(const sp<InputWindowHandle>& windowHandle) const REQUIRES(mLock); 527 std::string dumpWindowForTouchOcclusion(const InputWindowInfo* info, bool isTouchWindow) const; 528 std::string getApplicationWindowLabel(const InputApplicationHandle* applicationHandle, 529 const sp<InputWindowHandle>& windowHandle); 530 531 // Manage the dispatch cycle for a single connection. 532 // These methods are deliberately not Interruptible because doing all of the work 533 // with the mutex held makes it easier to ensure that connection invariants are maintained. 534 // If needed, the methods post commands to run later once the critical bits are done. 535 void prepareDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection, 536 std::shared_ptr<EventEntry>, const InputTarget& inputTarget) 537 REQUIRES(mLock); 538 void enqueueDispatchEntriesLocked(nsecs_t currentTime, const sp<Connection>& connection, 539 std::shared_ptr<EventEntry>, const InputTarget& inputTarget) 540 REQUIRES(mLock); 541 void enqueueDispatchEntryLocked(const sp<Connection>& connection, std::shared_ptr<EventEntry>, 542 const InputTarget& inputTarget, int32_t dispatchMode) 543 REQUIRES(mLock); 544 void startDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection) 545 REQUIRES(mLock); 546 void finishDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection, 547 uint32_t seq, bool handled, nsecs_t consumeTime) REQUIRES(mLock); 548 void abortBrokenDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection, 549 bool notify) REQUIRES(mLock); 550 void drainDispatchQueue(std::deque<DispatchEntry*>& queue); 551 void releaseDispatchEntry(DispatchEntry* dispatchEntry); 552 int handleReceiveCallback(int events, sp<IBinder> connectionToken); 553 // The action sent should only be of type AMOTION_EVENT_* 554 void dispatchPointerDownOutsideFocus(uint32_t source, int32_t action, 555 const sp<IBinder>& newToken) REQUIRES(mLock); 556 557 void synthesizeCancelationEventsForAllConnectionsLocked(const CancelationOptions& options) 558 REQUIRES(mLock); 559 void synthesizeCancelationEventsForMonitorsLocked(const CancelationOptions& options) 560 REQUIRES(mLock); 561 void synthesizeCancelationEventsForMonitorsLocked( 562 const CancelationOptions& options, 563 std::unordered_map<int32_t, std::vector<Monitor>>& monitorsByDisplay) REQUIRES(mLock); 564 void synthesizeCancelationEventsForInputChannelLocked( 565 const std::shared_ptr<InputChannel>& channel, const CancelationOptions& options) 566 REQUIRES(mLock); 567 void synthesizeCancelationEventsForConnectionLocked(const sp<Connection>& connection, 568 const CancelationOptions& options) 569 REQUIRES(mLock); 570 571 void synthesizePointerDownEventsForConnectionLocked(const sp<Connection>& connection) 572 REQUIRES(mLock); 573 574 // Splitting motion events across windows. 575 std::unique_ptr<MotionEntry> splitMotionEvent(const MotionEntry& originalMotionEntry, 576 BitSet32 pointerIds); 577 578 // Reset and drop everything the dispatcher is doing. 579 void resetAndDropEverythingLocked(const char* reason) REQUIRES(mLock); 580 581 // Dump state. 582 void dumpDispatchStateLocked(std::string& dump) REQUIRES(mLock); 583 void dumpMonitors(std::string& dump, const std::vector<Monitor>& monitors); 584 void logDispatchStateLocked() REQUIRES(mLock); 585 std::string dumpPointerCaptureStateLocked() REQUIRES(mLock); 586 587 // Registration. 588 void removeMonitorChannelLocked(const sp<IBinder>& connectionToken) REQUIRES(mLock); 589 void removeMonitorChannelLocked( 590 const sp<IBinder>& connectionToken, 591 std::unordered_map<int32_t, std::vector<Monitor>>& monitorsByDisplay) REQUIRES(mLock); 592 status_t removeInputChannelLocked(const sp<IBinder>& connectionToken, bool notify) 593 REQUIRES(mLock); 594 595 // Interesting events that we might like to log or tell the framework about. 596 void onDispatchCycleFinishedLocked(nsecs_t currentTime, const sp<Connection>& connection, 597 uint32_t seq, bool handled, nsecs_t consumeTime) 598 REQUIRES(mLock); 599 void onDispatchCycleBrokenLocked(nsecs_t currentTime, const sp<Connection>& connection) 600 REQUIRES(mLock); 601 void onFocusChangedLocked(const FocusResolver::FocusChanges& changes) REQUIRES(mLock); 602 void notifyFocusChangedLocked(const sp<IBinder>& oldFocus, const sp<IBinder>& newFocus) 603 REQUIRES(mLock); 604 void notifyDropWindowLocked(const sp<IBinder>& token, float x, float y) REQUIRES(mLock); 605 void onAnrLocked(const sp<Connection>& connection) REQUIRES(mLock); 606 void onAnrLocked(std::shared_ptr<InputApplicationHandle> application) REQUIRES(mLock); 607 void onUntrustedTouchLocked(const std::string& obscuringPackage) REQUIRES(mLock); 608 void updateLastAnrStateLocked(const sp<InputWindowHandle>& window, const std::string& reason) 609 REQUIRES(mLock); 610 void updateLastAnrStateLocked(const InputApplicationHandle& application, 611 const std::string& reason) REQUIRES(mLock); 612 void updateLastAnrStateLocked(const std::string& windowLabel, const std::string& reason) 613 REQUIRES(mLock); 614 615 // Outbound policy interactions. 616 void doNotifyConfigurationChangedLockedInterruptible(CommandEntry* commandEntry) 617 REQUIRES(mLock); 618 void doNotifyInputChannelBrokenLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); 619 void doNotifyFocusChangedLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); 620 void doNotifyDropWindowLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); 621 622 // ANR-related callbacks - start 623 void doNotifyNoFocusedWindowAnrLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); 624 void doNotifyWindowUnresponsiveLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); 625 void doNotifyMonitorUnresponsiveLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); 626 void doNotifyWindowResponsiveLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); 627 void doNotifyMonitorResponsiveLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); 628 // ANR-related callbacks - end 629 void doNotifySensorLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); 630 void doNotifyUntrustedTouchLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); 631 void doInterceptKeyBeforeDispatchingLockedInterruptible(CommandEntry* commandEntry) 632 REQUIRES(mLock); 633 void doDispatchCycleFinishedLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); 634 void doSetPointerCaptureLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); 635 bool afterKeyEventLockedInterruptible(const sp<Connection>& connection, 636 DispatchEntry* dispatchEntry, KeyEntry& keyEntry, 637 bool handled) REQUIRES(mLock); 638 bool afterMotionEventLockedInterruptible(const sp<Connection>& connection, 639 DispatchEntry* dispatchEntry, MotionEntry& motionEntry, 640 bool handled) REQUIRES(mLock); 641 void doPokeUserActivityLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); 642 void doOnPointerDownOutsideFocusLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); 643 644 // Statistics gathering. 645 LatencyAggregator mLatencyAggregator GUARDED_BY(mLock); 646 LatencyTracker mLatencyTracker GUARDED_BY(mLock); 647 void traceInboundQueueLengthLocked() REQUIRES(mLock); 648 void traceOutboundQueueLength(const Connection& connection); 649 void traceWaitQueueLength(const Connection& connection); 650 651 sp<InputReporterInterface> mReporter; 652 sp<com::android::internal::compat::IPlatformCompatNative> mCompatService; 653 }; 654 655 } // namespace android::inputdispatcher 656 657 #endif // _UI_INPUT_DISPATCHER_H 658