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 "Entry.h" 23 #include "InjectionState.h" 24 #include "InputDispatcherConfiguration.h" 25 #include "InputDispatcherInterface.h" 26 #include "InputDispatcherPolicyInterface.h" 27 #include "InputState.h" 28 #include "InputTarget.h" 29 #include "InputThread.h" 30 #include "Monitor.h" 31 #include "TouchState.h" 32 #include "TouchedWindow.h" 33 34 #include <input/Input.h> 35 #include <input/InputApplication.h> 36 #include <input/InputTransport.h> 37 #include <input/InputWindow.h> 38 #include <input/LatencyStatistics.h> 39 #include <limits.h> 40 #include <stddef.h> 41 #include <ui/Region.h> 42 #include <unistd.h> 43 #include <utils/BitSet.h> 44 #include <utils/Looper.h> 45 #include <utils/RefBase.h> 46 #include <utils/Timers.h> 47 #include <utils/threads.h> 48 #include <condition_variable> 49 #include <deque> 50 #include <optional> 51 #include <unordered_map> 52 53 #include <InputListener.h> 54 #include <InputReporterInterface.h> 55 56 namespace android::inputdispatcher { 57 58 class Connection; 59 60 class HmacKeyManager { 61 public: 62 HmacKeyManager(); 63 std::array<uint8_t, 32> sign(const VerifiedInputEvent& event) const; 64 65 private: 66 std::array<uint8_t, 32> sign(const uint8_t* data, size_t size) const; 67 const std::array<uint8_t, 128> mHmacKey; 68 }; 69 70 /* Dispatches events to input targets. Some functions of the input dispatcher, such as 71 * identifying input targets, are controlled by a separate policy object. 72 * 73 * IMPORTANT INVARIANT: 74 * Because the policy can potentially block or cause re-entrance into the input dispatcher, 75 * the input dispatcher never calls into the policy while holding its internal locks. 76 * The implementation is also carefully designed to recover from scenarios such as an 77 * input channel becoming unregistered while identifying input targets or processing timeouts. 78 * 79 * Methods marked 'Locked' must be called with the lock acquired. 80 * 81 * Methods marked 'LockedInterruptible' must be called with the lock acquired but 82 * may during the course of their execution release the lock, call into the policy, and 83 * then reacquire the lock. The caller is responsible for recovering gracefully. 84 * 85 * A 'LockedInterruptible' method may called a 'Locked' method, but NOT vice-versa. 86 */ 87 class InputDispatcher : public android::InputDispatcherInterface { 88 protected: 89 virtual ~InputDispatcher(); 90 91 public: 92 explicit InputDispatcher(const sp<InputDispatcherPolicyInterface>& policy); 93 94 virtual void dump(std::string& dump) override; 95 virtual void monitor() override; 96 virtual bool waitForIdle() override; 97 virtual status_t start() override; 98 virtual status_t stop() override; 99 100 virtual void notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args) override; 101 virtual void notifyKey(const NotifyKeyArgs* args) override; 102 virtual void notifyMotion(const NotifyMotionArgs* args) override; 103 virtual void notifySwitch(const NotifySwitchArgs* args) override; 104 virtual void notifyDeviceReset(const NotifyDeviceResetArgs* args) override; 105 106 virtual int32_t injectInputEvent(const InputEvent* event, int32_t injectorPid, 107 int32_t injectorUid, int32_t syncMode, 108 std::chrono::milliseconds timeout, 109 uint32_t policyFlags) override; 110 111 virtual std::unique_ptr<VerifiedInputEvent> verifyInputEvent(const InputEvent& event) override; 112 113 virtual void setInputWindows( 114 const std::unordered_map<int32_t, std::vector<sp<InputWindowHandle>>>& 115 handlesPerDisplay) override; 116 virtual void setFocusedApplication( 117 int32_t displayId, const sp<InputApplicationHandle>& inputApplicationHandle) override; 118 virtual void setFocusedDisplay(int32_t displayId) override; 119 virtual void setInputDispatchMode(bool enabled, bool frozen) override; 120 virtual void setInputFilterEnabled(bool enabled) override; 121 virtual void setInTouchMode(bool inTouchMode) override; 122 123 virtual bool transferTouchFocus(const sp<IBinder>& fromToken, 124 const sp<IBinder>& toToken) override; 125 126 virtual status_t registerInputChannel(const sp<InputChannel>& inputChannel) override; 127 virtual status_t registerInputMonitor(const sp<InputChannel>& inputChannel, int32_t displayId, 128 bool isGestureMonitor) override; 129 virtual status_t unregisterInputChannel(const sp<InputChannel>& inputChannel) override; 130 virtual status_t pilferPointers(const sp<IBinder>& token) override; 131 132 private: 133 enum class DropReason { 134 NOT_DROPPED, 135 POLICY, 136 APP_SWITCH, 137 DISABLED, 138 BLOCKED, 139 STALE, 140 }; 141 142 std::unique_ptr<InputThread> mThread; 143 144 sp<InputDispatcherPolicyInterface> mPolicy; 145 android::InputDispatcherConfiguration mConfig; 146 147 std::mutex mLock; 148 149 std::condition_variable mDispatcherIsAlive; 150 std::condition_variable mDispatcherEnteredIdle; 151 152 sp<Looper> mLooper; 153 154 EventEntry* mPendingEvent GUARDED_BY(mLock); 155 std::deque<EventEntry*> mInboundQueue GUARDED_BY(mLock); 156 std::deque<EventEntry*> mRecentQueue GUARDED_BY(mLock); 157 std::deque<std::unique_ptr<CommandEntry>> mCommandQueue GUARDED_BY(mLock); 158 159 DropReason mLastDropReason GUARDED_BY(mLock); 160 161 const IdGenerator mIdGenerator; 162 163 // With each iteration, InputDispatcher nominally processes one queued event, 164 // a timeout, or a response from an input consumer. 165 // This method should only be called on the input dispatcher's own thread. 166 void dispatchOnce(); 167 168 void dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) REQUIRES(mLock); 169 170 // Enqueues an inbound event. Returns true if mLooper->wake() should be called. 171 bool enqueueInboundEventLocked(EventEntry* entry) REQUIRES(mLock); 172 173 // Cleans up input state when dropping an inbound event. 174 void dropInboundEventLocked(const EventEntry& entry, DropReason dropReason) REQUIRES(mLock); 175 176 // Enqueues a focus event. 177 void enqueueFocusEventLocked(const InputWindowHandle& window, bool hasFocus) REQUIRES(mLock); 178 179 // Adds an event to a queue of recent events for debugging purposes. 180 void addRecentEventLocked(EventEntry* entry) REQUIRES(mLock); 181 182 // App switch latency optimization. 183 bool mAppSwitchSawKeyDown GUARDED_BY(mLock); 184 nsecs_t mAppSwitchDueTime GUARDED_BY(mLock); 185 186 bool isAppSwitchKeyEvent(const KeyEntry& keyEntry); 187 bool isAppSwitchPendingLocked() REQUIRES(mLock); 188 void resetPendingAppSwitchLocked(bool handled) REQUIRES(mLock); 189 190 // Blocked event latency optimization. Drops old events when the user intends 191 // to transfer focus to a new application. 192 EventEntry* mNextUnblockedEvent GUARDED_BY(mLock); 193 194 sp<InputWindowHandle> findTouchedWindowAtLocked(int32_t displayId, int32_t x, int32_t y, 195 TouchState* touchState, 196 bool addOutsideTargets = false, 197 bool addPortalWindows = false) REQUIRES(mLock); 198 199 // All registered connections mapped by channel file descriptor. 200 std::unordered_map<int, sp<Connection>> mConnectionsByFd GUARDED_BY(mLock); 201 202 sp<Connection> getConnectionLocked(const sp<IBinder>& inputConnectionToken) const 203 REQUIRES(mLock); 204 205 void removeConnectionLocked(const sp<Connection>& connection) REQUIRES(mLock); 206 207 struct IBinderHash { operatorIBinderHash208 std::size_t operator()(const sp<IBinder>& b) const { 209 return std::hash<IBinder*>{}(b.get()); 210 } 211 }; 212 std::unordered_map<sp<IBinder>, sp<InputChannel>, IBinderHash> mInputChannelsByToken 213 GUARDED_BY(mLock); 214 215 // Finds the display ID of the gesture monitor identified by the provided token. 216 std::optional<int32_t> findGestureMonitorDisplayByTokenLocked(const sp<IBinder>& token) 217 REQUIRES(mLock); 218 219 // Input channels that will receive a copy of all input events sent to the provided display. 220 std::unordered_map<int32_t, std::vector<Monitor>> mGlobalMonitorsByDisplay GUARDED_BY(mLock); 221 222 // Input channels that will receive pointer events that start within the corresponding display. 223 // These are a bit special when compared to global monitors since they'll cause gesture streams 224 // to continue even when there isn't a touched window,and have the ability to steal the rest of 225 // the pointer stream in order to claim it for a system gesture. 226 std::unordered_map<int32_t, std::vector<Monitor>> mGestureMonitorsByDisplay GUARDED_BY(mLock); 227 228 const HmacKeyManager mHmacKeyManager; 229 const std::array<uint8_t, 32> getSignature(const MotionEntry& motionEntry, 230 const DispatchEntry& dispatchEntry) const; 231 const std::array<uint8_t, 32> getSignature(const KeyEntry& keyEntry, 232 const DispatchEntry& dispatchEntry) const; 233 234 // Event injection and synchronization. 235 std::condition_variable mInjectionResultAvailable; 236 bool hasInjectionPermission(int32_t injectorPid, int32_t injectorUid); 237 void setInjectionResult(EventEntry* entry, int32_t injectionResult); 238 239 std::condition_variable mInjectionSyncFinished; 240 void incrementPendingForegroundDispatches(EventEntry* entry); 241 void decrementPendingForegroundDispatches(EventEntry* entry); 242 243 // Key repeat tracking. 244 struct KeyRepeatState { 245 KeyEntry* lastKeyEntry; // or null if no repeat 246 nsecs_t nextRepeatTime; 247 } mKeyRepeatState GUARDED_BY(mLock); 248 249 void resetKeyRepeatLocked() REQUIRES(mLock); 250 KeyEntry* synthesizeKeyRepeatLocked(nsecs_t currentTime) REQUIRES(mLock); 251 252 // Key replacement tracking 253 struct KeyReplacement { 254 int32_t keyCode; 255 int32_t deviceId; 256 bool operator==(const KeyReplacement& rhs) const { 257 return keyCode == rhs.keyCode && deviceId == rhs.deviceId; 258 } 259 }; 260 struct KeyReplacementHash { operatorKeyReplacementHash261 size_t operator()(const KeyReplacement& key) const { 262 return std::hash<int32_t>()(key.keyCode) ^ (std::hash<int32_t>()(key.deviceId) << 1); 263 } 264 }; 265 // Maps the key code replaced, device id tuple to the key code it was replaced with 266 std::unordered_map<KeyReplacement, int32_t, KeyReplacementHash> mReplacedKeys GUARDED_BY(mLock); 267 // Process certain Meta + Key combinations 268 void accelerateMetaShortcuts(const int32_t deviceId, const int32_t action, int32_t& keyCode, 269 int32_t& metaState); 270 271 // Deferred command processing. 272 bool haveCommandsLocked() const REQUIRES(mLock); 273 bool runCommandsLockedInterruptible() REQUIRES(mLock); 274 void postCommandLocked(std::unique_ptr<CommandEntry> commandEntry) REQUIRES(mLock); 275 276 nsecs_t processAnrsLocked() REQUIRES(mLock); 277 nsecs_t getDispatchingTimeoutLocked(const sp<IBinder>& token) REQUIRES(mLock); 278 279 // Input filter processing. 280 bool shouldSendKeyToInputFilterLocked(const NotifyKeyArgs* args) REQUIRES(mLock); 281 bool shouldSendMotionToInputFilterLocked(const NotifyMotionArgs* args) REQUIRES(mLock); 282 283 // Inbound event processing. 284 void drainInboundQueueLocked() REQUIRES(mLock); 285 void releasePendingEventLocked() REQUIRES(mLock); 286 void releaseInboundEventLocked(EventEntry* entry) REQUIRES(mLock); 287 288 // Dispatch state. 289 bool mDispatchEnabled GUARDED_BY(mLock); 290 bool mDispatchFrozen GUARDED_BY(mLock); 291 bool mInputFilterEnabled GUARDED_BY(mLock); 292 bool mInTouchMode GUARDED_BY(mLock); 293 294 std::unordered_map<int32_t, std::vector<sp<InputWindowHandle>>> mWindowHandlesByDisplay 295 GUARDED_BY(mLock); 296 void setInputWindowsLocked(const std::vector<sp<InputWindowHandle>>& inputWindowHandles, 297 int32_t displayId) REQUIRES(mLock); 298 // Get window handles by display, return an empty vector if not found. 299 std::vector<sp<InputWindowHandle>> getWindowHandlesLocked(int32_t displayId) const 300 REQUIRES(mLock); 301 sp<InputWindowHandle> getWindowHandleLocked(const sp<IBinder>& windowHandleToken) const 302 REQUIRES(mLock); 303 sp<InputChannel> getInputChannelLocked(const sp<IBinder>& windowToken) const REQUIRES(mLock); 304 bool hasWindowHandleLocked(const sp<InputWindowHandle>& windowHandle) const REQUIRES(mLock); 305 306 /* 307 * Validate and update InputWindowHandles for a given display. 308 */ 309 void updateWindowHandlesForDisplayLocked( 310 const std::vector<sp<InputWindowHandle>>& inputWindowHandles, int32_t displayId) 311 REQUIRES(mLock); 312 313 // Focus tracking for keys, trackball, etc. 314 std::unordered_map<int32_t, sp<InputWindowHandle>> mFocusedWindowHandlesByDisplay 315 GUARDED_BY(mLock); 316 317 std::unordered_map<int32_t, TouchState> mTouchStatesByDisplay GUARDED_BY(mLock); 318 319 // Focused applications. 320 std::unordered_map<int32_t, sp<InputApplicationHandle>> mFocusedApplicationHandlesByDisplay 321 GUARDED_BY(mLock); 322 323 // Top focused display. 324 int32_t mFocusedDisplayId GUARDED_BY(mLock); 325 326 // Dispatcher state at time of last ANR. 327 std::string mLastAnrState GUARDED_BY(mLock); 328 329 // Dispatch inbound events. 330 bool dispatchConfigurationChangedLocked(nsecs_t currentTime, ConfigurationChangedEntry* entry) 331 REQUIRES(mLock); 332 bool dispatchDeviceResetLocked(nsecs_t currentTime, DeviceResetEntry* entry) REQUIRES(mLock); 333 bool dispatchKeyLocked(nsecs_t currentTime, KeyEntry* entry, DropReason* dropReason, 334 nsecs_t* nextWakeupTime) REQUIRES(mLock); 335 bool dispatchMotionLocked(nsecs_t currentTime, MotionEntry* entry, DropReason* dropReason, 336 nsecs_t* nextWakeupTime) REQUIRES(mLock); 337 void dispatchFocusLocked(nsecs_t currentTime, FocusEntry* entry) REQUIRES(mLock); 338 void dispatchEventLocked(nsecs_t currentTime, EventEntry* entry, 339 const std::vector<InputTarget>& inputTargets) REQUIRES(mLock); 340 341 void logOutboundKeyDetails(const char* prefix, const KeyEntry& entry); 342 void logOutboundMotionDetails(const char* prefix, const MotionEntry& entry); 343 344 /** 345 * This field is set if there is no focused window, and we have an event that requires 346 * a focused window to be dispatched (for example, a KeyEvent). 347 * When this happens, we will wait until *mNoFocusedWindowTimeoutTime before 348 * dropping the event and raising an ANR for that application. 349 * This is useful if an application is slow to add a focused window. 350 */ 351 std::optional<nsecs_t> mNoFocusedWindowTimeoutTime GUARDED_BY(mLock); 352 353 bool shouldPruneInboundQueueLocked(const MotionEntry& motionEntry) REQUIRES(mLock); 354 355 /** 356 * Time to stop waiting for the events to be processed while trying to dispatch a key. 357 * When this time expires, we just send the pending key event to the currently focused window, 358 * without waiting on other events to be processed first. 359 */ 360 std::optional<nsecs_t> mKeyIsWaitingForEventsTimeout GUARDED_BY(mLock); 361 bool shouldWaitToSendKeyLocked(nsecs_t currentTime, const char* focusedWindowName) 362 REQUIRES(mLock); 363 364 /** 365 * The focused application at the time when no focused window was present. 366 * Used to raise an ANR when we have no focused window. 367 */ 368 sp<InputApplicationHandle> mAwaitedFocusedApplication GUARDED_BY(mLock); 369 370 // Optimization: AnrTracker is used to quickly find which connection is due for a timeout next. 371 // AnrTracker must be kept in-sync with all responsive connection.waitQueues. 372 // If a connection is not responsive, then the entries should not be added to the AnrTracker. 373 // Once a connection becomes unresponsive, its entries are removed from AnrTracker to 374 // prevent unneeded wakeups. 375 AnrTracker mAnrTracker GUARDED_BY(mLock); 376 void extendAnrTimeoutsLocked(const sp<InputApplicationHandle>& application, 377 const sp<IBinder>& connectionToken, nsecs_t timeoutExtension) 378 REQUIRES(mLock); 379 380 // Contains the last window which received a hover event. 381 sp<InputWindowHandle> mLastHoverWindowHandle GUARDED_BY(mLock); 382 383 void cancelEventsForAnrLocked(const sp<Connection>& connection) REQUIRES(mLock); 384 nsecs_t getTimeSpentWaitingForApplicationLocked(nsecs_t currentTime) REQUIRES(mLock); 385 // If a focused application changes, we should stop counting down the "no focused window" time, 386 // because we will have no way of knowing when the previous application actually added a window. 387 // This also means that we will miss cases like pulling down notification shade when the 388 // focused application does not have a focused window (no ANR will be raised if notification 389 // shade is pulled down while we are counting down the timeout). 390 void resetNoFocusedWindowTimeoutLocked() REQUIRES(mLock); 391 392 int32_t getTargetDisplayId(const EventEntry& entry); 393 int32_t findFocusedWindowTargetsLocked(nsecs_t currentTime, const EventEntry& entry, 394 std::vector<InputTarget>& inputTargets, 395 nsecs_t* nextWakeupTime) REQUIRES(mLock); 396 int32_t findTouchedWindowTargetsLocked(nsecs_t currentTime, const MotionEntry& entry, 397 std::vector<InputTarget>& inputTargets, 398 nsecs_t* nextWakeupTime, 399 bool* outConflictingPointerActions) REQUIRES(mLock); 400 std::vector<TouchedMonitor> findTouchedGestureMonitorsLocked( 401 int32_t displayId, const std::vector<sp<InputWindowHandle>>& portalWindows) const 402 REQUIRES(mLock); 403 std::vector<TouchedMonitor> selectResponsiveMonitorsLocked( 404 const std::vector<TouchedMonitor>& gestureMonitors) const REQUIRES(mLock); 405 406 void addWindowTargetLocked(const sp<InputWindowHandle>& windowHandle, int32_t targetFlags, 407 BitSet32 pointerIds, std::vector<InputTarget>& inputTargets) 408 REQUIRES(mLock); 409 void addMonitoringTargetLocked(const Monitor& monitor, float xOffset, float yOffset, 410 std::vector<InputTarget>& inputTargets) REQUIRES(mLock); 411 void addGlobalMonitoringTargetsLocked(std::vector<InputTarget>& inputTargets, int32_t displayId, 412 float xOffset = 0, float yOffset = 0) REQUIRES(mLock); 413 414 void pokeUserActivityLocked(const EventEntry& eventEntry) REQUIRES(mLock); 415 bool checkInjectionPermission(const sp<InputWindowHandle>& windowHandle, 416 const InjectionState* injectionState); 417 bool isWindowObscuredAtPointLocked(const sp<InputWindowHandle>& windowHandle, int32_t x, 418 int32_t y) const REQUIRES(mLock); 419 bool isWindowObscuredLocked(const sp<InputWindowHandle>& windowHandle) const REQUIRES(mLock); 420 std::string getApplicationWindowLabel(const sp<InputApplicationHandle>& applicationHandle, 421 const sp<InputWindowHandle>& windowHandle); 422 423 // Manage the dispatch cycle for a single connection. 424 // These methods are deliberately not Interruptible because doing all of the work 425 // with the mutex held makes it easier to ensure that connection invariants are maintained. 426 // If needed, the methods post commands to run later once the critical bits are done. 427 void prepareDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection, 428 EventEntry* eventEntry, const InputTarget& inputTarget) 429 REQUIRES(mLock); 430 void enqueueDispatchEntriesLocked(nsecs_t currentTime, const sp<Connection>& connection, 431 EventEntry* eventEntry, const InputTarget& inputTarget) 432 REQUIRES(mLock); 433 void enqueueDispatchEntryLocked(const sp<Connection>& connection, EventEntry* eventEntry, 434 const InputTarget& inputTarget, int32_t dispatchMode) 435 REQUIRES(mLock); 436 void startDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection) 437 REQUIRES(mLock); 438 void finishDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection, 439 uint32_t seq, bool handled) REQUIRES(mLock); 440 void abortBrokenDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection, 441 bool notify) REQUIRES(mLock); 442 void drainDispatchQueue(std::deque<DispatchEntry*>& queue); 443 void releaseDispatchEntry(DispatchEntry* dispatchEntry); 444 static int handleReceiveCallback(int fd, int events, void* data); 445 // The action sent should only be of type AMOTION_EVENT_* 446 void dispatchPointerDownOutsideFocus(uint32_t source, int32_t action, 447 const sp<IBinder>& newToken) REQUIRES(mLock); 448 449 void synthesizeCancelationEventsForAllConnectionsLocked(const CancelationOptions& options) 450 REQUIRES(mLock); 451 void synthesizeCancelationEventsForMonitorsLocked(const CancelationOptions& options) 452 REQUIRES(mLock); 453 void synthesizeCancelationEventsForMonitorsLocked( 454 const CancelationOptions& options, 455 std::unordered_map<int32_t, std::vector<Monitor>>& monitorsByDisplay) REQUIRES(mLock); 456 void synthesizeCancelationEventsForInputChannelLocked(const sp<InputChannel>& channel, 457 const CancelationOptions& options) 458 REQUIRES(mLock); 459 void synthesizeCancelationEventsForConnectionLocked(const sp<Connection>& connection, 460 const CancelationOptions& options) 461 REQUIRES(mLock); 462 463 void synthesizePointerDownEventsForConnectionLocked(const sp<Connection>& connection) 464 REQUIRES(mLock); 465 466 // Splitting motion events across windows. 467 MotionEntry* splitMotionEvent(const MotionEntry& originalMotionEntry, BitSet32 pointerIds); 468 469 // Reset and drop everything the dispatcher is doing. 470 void resetAndDropEverythingLocked(const char* reason) REQUIRES(mLock); 471 472 // Dump state. 473 void dumpDispatchStateLocked(std::string& dump) REQUIRES(mLock); 474 void dumpMonitors(std::string& dump, const std::vector<Monitor>& monitors); 475 void logDispatchStateLocked() REQUIRES(mLock); 476 477 // Registration. 478 void removeMonitorChannelLocked(const sp<InputChannel>& inputChannel) REQUIRES(mLock); 479 void removeMonitorChannelLocked( 480 const sp<InputChannel>& inputChannel, 481 std::unordered_map<int32_t, std::vector<Monitor>>& monitorsByDisplay) REQUIRES(mLock); 482 status_t unregisterInputChannelLocked(const sp<InputChannel>& inputChannel, bool notify) 483 REQUIRES(mLock); 484 485 // Interesting events that we might like to log or tell the framework about. 486 void onDispatchCycleFinishedLocked(nsecs_t currentTime, const sp<Connection>& connection, 487 uint32_t seq, bool handled) REQUIRES(mLock); 488 void onDispatchCycleBrokenLocked(nsecs_t currentTime, const sp<Connection>& connection) 489 REQUIRES(mLock); 490 void onFocusChangedLocked(const sp<InputWindowHandle>& oldFocus, 491 const sp<InputWindowHandle>& newFocus) REQUIRES(mLock); 492 void onAnrLocked(const sp<Connection>& connection) REQUIRES(mLock); 493 void onAnrLocked(const sp<InputApplicationHandle>& application) REQUIRES(mLock); 494 void updateLastAnrStateLocked(const sp<InputWindowHandle>& window, const std::string& reason) 495 REQUIRES(mLock); 496 void updateLastAnrStateLocked(const sp<InputApplicationHandle>& application, 497 const std::string& reason) REQUIRES(mLock); 498 void updateLastAnrStateLocked(const std::string& windowLabel, const std::string& reason) 499 REQUIRES(mLock); 500 501 // Outbound policy interactions. 502 void doNotifyConfigurationChangedLockedInterruptible(CommandEntry* commandEntry) 503 REQUIRES(mLock); 504 void doNotifyInputChannelBrokenLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); 505 void doNotifyFocusChangedLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); 506 void doNotifyAnrLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); 507 void doInterceptKeyBeforeDispatchingLockedInterruptible(CommandEntry* commandEntry) 508 REQUIRES(mLock); 509 void doDispatchCycleFinishedLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); 510 bool afterKeyEventLockedInterruptible(const sp<Connection>& connection, 511 DispatchEntry* dispatchEntry, KeyEntry* keyEntry, 512 bool handled) REQUIRES(mLock); 513 bool afterMotionEventLockedInterruptible(const sp<Connection>& connection, 514 DispatchEntry* dispatchEntry, MotionEntry* motionEntry, 515 bool handled) REQUIRES(mLock); 516 void doPokeUserActivityLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); 517 KeyEvent createKeyEvent(const KeyEntry& entry); 518 void doOnPointerDownOutsideFocusLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); 519 520 // Statistics gathering. 521 static constexpr std::chrono::duration TOUCH_STATS_REPORT_PERIOD = 5min; 522 LatencyStatistics mTouchStatistics{TOUCH_STATS_REPORT_PERIOD}; 523 524 void reportTouchEventForStatistics(const MotionEntry& entry); 525 void reportDispatchStatistics(std::chrono::nanoseconds eventDuration, 526 const Connection& connection, bool handled); 527 void traceInboundQueueLengthLocked() REQUIRES(mLock); 528 void traceOutboundQueueLength(const sp<Connection>& connection); 529 void traceWaitQueueLength(const sp<Connection>& connection); 530 531 sp<InputReporterInterface> mReporter; 532 }; 533 534 } // namespace android::inputdispatcher 535 536 #endif // _UI_INPUT_DISPATCHER_H 537