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 <condition_variable> 21 #include <input/Input.h> 22 #include <input/InputApplication.h> 23 #include <input/InputTransport.h> 24 #include <input/InputWindow.h> 25 #include <input/ISetInputWindowsListener.h> 26 #include <optional> 27 #include <ui/Region.h> 28 #include <utils/threads.h> 29 #include <utils/Timers.h> 30 #include <utils/RefBase.h> 31 #include <utils/Looper.h> 32 #include <utils/BitSet.h> 33 #include <cutils/atomic.h> 34 #include <unordered_map> 35 36 #include <stddef.h> 37 #include <unistd.h> 38 #include <limits.h> 39 #include <unordered_map> 40 41 #include "InputListener.h" 42 #include "InputReporterInterface.h" 43 44 namespace android { 45 46 /* 47 * Constants used to report the outcome of input event injection. 48 */ 49 enum { 50 /* (INTERNAL USE ONLY) Specifies that injection is pending and its outcome is unknown. */ 51 INPUT_EVENT_INJECTION_PENDING = -1, 52 53 /* Injection succeeded. */ 54 INPUT_EVENT_INJECTION_SUCCEEDED = 0, 55 56 /* Injection failed because the injector did not have permission to inject 57 * into the application with input focus. */ 58 INPUT_EVENT_INJECTION_PERMISSION_DENIED = 1, 59 60 /* Injection failed because there were no available input targets. */ 61 INPUT_EVENT_INJECTION_FAILED = 2, 62 63 /* Injection failed due to a timeout. */ 64 INPUT_EVENT_INJECTION_TIMED_OUT = 3 65 }; 66 67 /* 68 * Constants used to determine the input event injection synchronization mode. 69 */ 70 enum { 71 /* Injection is asynchronous and is assumed always to be successful. */ 72 INPUT_EVENT_INJECTION_SYNC_NONE = 0, 73 74 /* Waits for previous events to be dispatched so that the input dispatcher can determine 75 * whether input event injection willbe permitted based on the current input focus. 76 * Does not wait for the input event to finish processing. */ 77 INPUT_EVENT_INJECTION_SYNC_WAIT_FOR_RESULT = 1, 78 79 /* Waits for the input event to be completely processed. */ 80 INPUT_EVENT_INJECTION_SYNC_WAIT_FOR_FINISHED = 2, 81 }; 82 83 84 /* 85 * An input target specifies how an input event is to be dispatched to a particular window 86 * including the window's input channel, control flags, a timeout, and an X / Y offset to 87 * be added to input event coordinates to compensate for the absolute position of the 88 * window area. 89 */ 90 struct InputTarget { 91 enum { 92 /* This flag indicates that the event is being delivered to a foreground application. */ 93 FLAG_FOREGROUND = 1 << 0, 94 95 /* This flag indicates that the MotionEvent falls within the area of the target 96 * obscured by another visible window above it. The motion event should be 97 * delivered with flag AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED. */ 98 FLAG_WINDOW_IS_OBSCURED = 1 << 1, 99 100 /* This flag indicates that a motion event is being split across multiple windows. */ 101 FLAG_SPLIT = 1 << 2, 102 103 /* This flag indicates that the pointer coordinates dispatched to the application 104 * will be zeroed out to avoid revealing information to an application. This is 105 * used in conjunction with FLAG_DISPATCH_AS_OUTSIDE to prevent apps not sharing 106 * the same UID from watching all touches. */ 107 FLAG_ZERO_COORDS = 1 << 3, 108 109 /* This flag indicates that the event should be sent as is. 110 * Should always be set unless the event is to be transmuted. */ 111 FLAG_DISPATCH_AS_IS = 1 << 8, 112 113 /* This flag indicates that a MotionEvent with AMOTION_EVENT_ACTION_DOWN falls outside 114 * of the area of this target and so should instead be delivered as an 115 * AMOTION_EVENT_ACTION_OUTSIDE to this target. */ 116 FLAG_DISPATCH_AS_OUTSIDE = 1 << 9, 117 118 /* This flag indicates that a hover sequence is starting in the given window. 119 * The event is transmuted into ACTION_HOVER_ENTER. */ 120 FLAG_DISPATCH_AS_HOVER_ENTER = 1 << 10, 121 122 /* This flag indicates that a hover event happened outside of a window which handled 123 * previous hover events, signifying the end of the current hover sequence for that 124 * window. 125 * The event is transmuted into ACTION_HOVER_ENTER. */ 126 FLAG_DISPATCH_AS_HOVER_EXIT = 1 << 11, 127 128 /* This flag indicates that the event should be canceled. 129 * It is used to transmute ACTION_MOVE into ACTION_CANCEL when a touch slips 130 * outside of a window. */ 131 FLAG_DISPATCH_AS_SLIPPERY_EXIT = 1 << 12, 132 133 /* This flag indicates that the event should be dispatched as an initial down. 134 * It is used to transmute ACTION_MOVE into ACTION_DOWN when a touch slips 135 * into a new window. */ 136 FLAG_DISPATCH_AS_SLIPPERY_ENTER = 1 << 13, 137 138 /* Mask for all dispatch modes. */ 139 FLAG_DISPATCH_MASK = FLAG_DISPATCH_AS_IS 140 | FLAG_DISPATCH_AS_OUTSIDE 141 | FLAG_DISPATCH_AS_HOVER_ENTER 142 | FLAG_DISPATCH_AS_HOVER_EXIT 143 | FLAG_DISPATCH_AS_SLIPPERY_EXIT 144 | FLAG_DISPATCH_AS_SLIPPERY_ENTER, 145 146 /* This flag indicates that the target of a MotionEvent is partly or wholly 147 * obscured by another visible window above it. The motion event should be 148 * delivered with flag AMOTION_EVENT_FLAG_WINDOW_IS_PARTIALLY_OBSCURED. */ 149 FLAG_WINDOW_IS_PARTIALLY_OBSCURED = 1 << 14, 150 151 }; 152 153 // The input channel to be targeted. 154 sp<InputChannel> inputChannel; 155 156 // Flags for the input target. 157 int32_t flags; 158 159 // The x and y offset to add to a MotionEvent as it is delivered. 160 // (ignored for KeyEvents) 161 float xOffset, yOffset; 162 163 // Scaling factor to apply to MotionEvent as it is delivered. 164 // (ignored for KeyEvents) 165 float globalScaleFactor; 166 float windowXScale = 1.0f; 167 float windowYScale = 1.0f; 168 169 // The subset of pointer ids to include in motion events dispatched to this input target 170 // if FLAG_SPLIT is set. 171 BitSet32 pointerIds; 172 }; 173 174 175 /* 176 * Input dispatcher configuration. 177 * 178 * Specifies various options that modify the behavior of the input dispatcher. 179 * The values provided here are merely defaults. The actual values will come from ViewConfiguration 180 * and are passed into the dispatcher during initialization. 181 */ 182 struct InputDispatcherConfiguration { 183 // The key repeat initial timeout. 184 nsecs_t keyRepeatTimeout; 185 186 // The key repeat inter-key delay. 187 nsecs_t keyRepeatDelay; 188 InputDispatcherConfigurationInputDispatcherConfiguration189 InputDispatcherConfiguration() : 190 keyRepeatTimeout(500 * 1000000LL), 191 keyRepeatDelay(50 * 1000000LL) { } 192 }; 193 194 195 /* 196 * Input dispatcher policy interface. 197 * 198 * The input reader policy is used by the input reader to interact with the Window Manager 199 * and other system components. 200 * 201 * The actual implementation is partially supported by callbacks into the DVM 202 * via JNI. This interface is also mocked in the unit tests. 203 */ 204 class InputDispatcherPolicyInterface : public virtual RefBase { 205 protected: InputDispatcherPolicyInterface()206 InputDispatcherPolicyInterface() { } ~InputDispatcherPolicyInterface()207 virtual ~InputDispatcherPolicyInterface() { } 208 209 public: 210 /* Notifies the system that a configuration change has occurred. */ 211 virtual void notifyConfigurationChanged(nsecs_t when) = 0; 212 213 /* Notifies the system that an application is not responding. 214 * Returns a new timeout to continue waiting, or 0 to abort dispatch. */ 215 virtual nsecs_t notifyANR(const sp<InputApplicationHandle>& inputApplicationHandle, 216 const sp<IBinder>& token, 217 const std::string& reason) = 0; 218 219 /* Notifies the system that an input channel is unrecoverably broken. */ 220 virtual void notifyInputChannelBroken(const sp<IBinder>& token) = 0; 221 virtual void notifyFocusChanged(const sp<IBinder>& oldToken, const sp<IBinder>& newToken) = 0; 222 223 /* Gets the input dispatcher configuration. */ 224 virtual void getDispatcherConfiguration(InputDispatcherConfiguration* outConfig) = 0; 225 226 /* Filters an input event. 227 * Return true to dispatch the event unmodified, false to consume the event. 228 * A filter can also transform and inject events later by passing POLICY_FLAG_FILTERED 229 * to injectInputEvent. 230 */ 231 virtual bool filterInputEvent(const InputEvent* inputEvent, uint32_t policyFlags) = 0; 232 233 /* Intercepts a key event immediately before queueing it. 234 * The policy can use this method as an opportunity to perform power management functions 235 * and early event preprocessing such as updating policy flags. 236 * 237 * This method is expected to set the POLICY_FLAG_PASS_TO_USER policy flag if the event 238 * should be dispatched to applications. 239 */ 240 virtual void interceptKeyBeforeQueueing(const KeyEvent* keyEvent, uint32_t& policyFlags) = 0; 241 242 /* Intercepts a touch, trackball or other motion event before queueing it. 243 * The policy can use this method as an opportunity to perform power management functions 244 * and early event preprocessing such as updating policy flags. 245 * 246 * This method is expected to set the POLICY_FLAG_PASS_TO_USER policy flag if the event 247 * should be dispatched to applications. 248 */ 249 virtual void interceptMotionBeforeQueueing(const int32_t displayId, nsecs_t when, 250 uint32_t& policyFlags) = 0; 251 252 /* Allows the policy a chance to intercept a key before dispatching. */ 253 virtual nsecs_t interceptKeyBeforeDispatching(const sp<IBinder>& token, 254 const KeyEvent* keyEvent, uint32_t policyFlags) = 0; 255 256 /* Allows the policy a chance to perform default processing for an unhandled key. 257 * Returns an alternate keycode to redispatch as a fallback, or 0 to give up. */ 258 virtual bool dispatchUnhandledKey(const sp<IBinder>& token, 259 const KeyEvent* keyEvent, uint32_t policyFlags, KeyEvent* outFallbackKeyEvent) = 0; 260 261 /* Notifies the policy about switch events. 262 */ 263 virtual void notifySwitch(nsecs_t when, 264 uint32_t switchValues, uint32_t switchMask, uint32_t policyFlags) = 0; 265 266 /* Poke user activity for an event dispatched to a window. */ 267 virtual void pokeUserActivity(nsecs_t eventTime, int32_t eventType) = 0; 268 269 /* Checks whether a given application pid/uid has permission to inject input events 270 * into other applications. 271 * 272 * This method is special in that its implementation promises to be non-reentrant and 273 * is safe to call while holding other locks. (Most other methods make no such guarantees!) 274 */ 275 virtual bool checkInjectEventsPermissionNonReentrant( 276 int32_t injectorPid, int32_t injectorUid) = 0; 277 278 /* Notifies the policy that a pointer down event has occurred outside the current focused 279 * window. 280 * 281 * The touchedToken passed as an argument is the window that received the input event. 282 */ 283 virtual void onPointerDownOutsideFocus(const sp<IBinder>& touchedToken) = 0; 284 }; 285 286 287 /* Notifies the system about input events generated by the input reader. 288 * The dispatcher is expected to be mostly asynchronous. */ 289 class InputDispatcherInterface : public virtual RefBase, public InputListenerInterface { 290 protected: InputDispatcherInterface()291 InputDispatcherInterface() { } ~InputDispatcherInterface()292 virtual ~InputDispatcherInterface() { } 293 294 public: 295 /* Dumps the state of the input dispatcher. 296 * 297 * This method may be called on any thread (usually by the input manager). */ 298 virtual void dump(std::string& dump) = 0; 299 300 /* Called by the heatbeat to ensures that the dispatcher has not deadlocked. */ 301 virtual void monitor() = 0; 302 303 /* Runs a single iteration of the dispatch loop. 304 * Nominally processes one queued event, a timeout, or a response from an input consumer. 305 * 306 * This method should only be called on the input dispatcher thread. 307 */ 308 virtual void dispatchOnce() = 0; 309 310 /* Injects an input event and optionally waits for sync. 311 * The synchronization mode determines whether the method blocks while waiting for 312 * input injection to proceed. 313 * Returns one of the INPUT_EVENT_INJECTION_XXX constants. 314 * 315 * This method may be called on any thread (usually by the input manager). 316 */ 317 virtual int32_t injectInputEvent(const InputEvent* event, 318 int32_t injectorPid, int32_t injectorUid, int32_t syncMode, int32_t timeoutMillis, 319 uint32_t policyFlags) = 0; 320 321 /* Sets the list of input windows. 322 * 323 * This method may be called on any thread (usually by the input manager). 324 */ 325 virtual void setInputWindows(const std::vector<sp<InputWindowHandle> >& inputWindowHandles, 326 int32_t displayId, 327 const sp<ISetInputWindowsListener>& setInputWindowsListener = nullptr) = 0; 328 329 /* Sets the focused application on the given display. 330 * 331 * This method may be called on any thread (usually by the input manager). 332 */ 333 virtual void setFocusedApplication( 334 int32_t displayId, const sp<InputApplicationHandle>& inputApplicationHandle) = 0; 335 336 /* Sets the focused display. 337 * 338 * This method may be called on any thread (usually by the input manager). 339 */ 340 virtual void setFocusedDisplay(int32_t displayId) = 0; 341 342 /* Sets the input dispatching mode. 343 * 344 * This method may be called on any thread (usually by the input manager). 345 */ 346 virtual void setInputDispatchMode(bool enabled, bool frozen) = 0; 347 348 /* Sets whether input event filtering is enabled. 349 * When enabled, incoming input events are sent to the policy's filterInputEvent 350 * method instead of being dispatched. The filter is expected to use 351 * injectInputEvent to inject the events it would like to have dispatched. 352 * It should include POLICY_FLAG_FILTERED in the policy flags during injection. 353 */ 354 virtual void setInputFilterEnabled(bool enabled) = 0; 355 356 /* Transfers touch focus from one window to another window. 357 * 358 * Returns true on success. False if the window did not actually have touch focus. 359 */ 360 virtual bool transferTouchFocus(const sp<IBinder>& fromToken, const sp<IBinder>& toToken) = 0; 361 362 /* Registers input channels that may be used as targets for input events. 363 * 364 * This method may be called on any thread (usually by the input manager). 365 */ 366 virtual status_t registerInputChannel( 367 const sp<InputChannel>& inputChannel, int32_t displayId) = 0; 368 369 /* Registers input channels to be used to monitor input events. 370 * 371 * Each monitor must target a specific display and will only receive input events sent to that 372 * display. If the monitor is a gesture monitor, it will only receive pointer events on the 373 * targeted display. 374 * 375 * This method may be called on any thread (usually by the input manager). 376 */ 377 virtual status_t registerInputMonitor( 378 const sp<InputChannel>& inputChannel, int32_t displayId, bool gestureMonitor) = 0; 379 380 /* Unregister input channels that will no longer receive input events. 381 * 382 * This method may be called on any thread (usually by the input manager). 383 */ 384 virtual status_t unregisterInputChannel(const sp<InputChannel>& inputChannel) = 0; 385 386 /* Allows an input monitor steal the current pointer stream away from normal input windows. 387 * 388 * This method may be called on any thread (usually by the input manager). 389 */ 390 virtual status_t pilferPointers(const sp<IBinder>& token) = 0; 391 392 }; 393 394 /* Dispatches events to input targets. Some functions of the input dispatcher, such as 395 * identifying input targets, are controlled by a separate policy object. 396 * 397 * IMPORTANT INVARIANT: 398 * Because the policy can potentially block or cause re-entrance into the input dispatcher, 399 * the input dispatcher never calls into the policy while holding its internal locks. 400 * The implementation is also carefully designed to recover from scenarios such as an 401 * input channel becoming unregistered while identifying input targets or processing timeouts. 402 * 403 * Methods marked 'Locked' must be called with the lock acquired. 404 * 405 * Methods marked 'LockedInterruptible' must be called with the lock acquired but 406 * may during the course of their execution release the lock, call into the policy, and 407 * then reacquire the lock. The caller is responsible for recovering gracefully. 408 * 409 * A 'LockedInterruptible' method may called a 'Locked' method, but NOT vice-versa. 410 */ 411 class InputDispatcher : public InputDispatcherInterface { 412 protected: 413 virtual ~InputDispatcher(); 414 415 public: 416 explicit InputDispatcher(const sp<InputDispatcherPolicyInterface>& policy); 417 418 virtual void dump(std::string& dump) override; 419 virtual void monitor() override; 420 421 virtual void dispatchOnce() override; 422 423 virtual void notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args) override; 424 virtual void notifyKey(const NotifyKeyArgs* args) override; 425 virtual void notifyMotion(const NotifyMotionArgs* args) override; 426 virtual void notifySwitch(const NotifySwitchArgs* args) override; 427 virtual void notifyDeviceReset(const NotifyDeviceResetArgs* args) override; 428 429 virtual int32_t injectInputEvent(const InputEvent* event, 430 int32_t injectorPid, int32_t injectorUid, int32_t syncMode, int32_t timeoutMillis, 431 uint32_t policyFlags) override; 432 433 virtual void setInputWindows(const std::vector<sp<InputWindowHandle> >& inputWindowHandles, 434 int32_t displayId, 435 const sp<ISetInputWindowsListener>& setInputWindowsListener = nullptr) override; 436 virtual void setFocusedApplication(int32_t displayId, 437 const sp<InputApplicationHandle>& inputApplicationHandle) override; 438 virtual void setFocusedDisplay(int32_t displayId) override; 439 virtual void setInputDispatchMode(bool enabled, bool frozen) override; 440 virtual void setInputFilterEnabled(bool enabled) override; 441 442 virtual bool transferTouchFocus(const sp<IBinder>& fromToken, const sp<IBinder>& toToken) 443 override; 444 445 virtual status_t registerInputChannel(const sp<InputChannel>& inputChannel, 446 int32_t displayId) override; 447 virtual status_t registerInputMonitor(const sp<InputChannel>& inputChannel, 448 int32_t displayId, bool isGestureMonitor) override; 449 virtual status_t unregisterInputChannel(const sp<InputChannel>& inputChannel) override; 450 virtual status_t pilferPointers(const sp<IBinder>& token) override; 451 452 private: 453 template <typename T> 454 struct Link { 455 T* next; 456 T* prev; 457 458 protected: LinkLink459 inline Link() : next(nullptr), prev(nullptr) { } 460 }; 461 462 struct InjectionState { 463 mutable int32_t refCount; 464 465 int32_t injectorPid; 466 int32_t injectorUid; 467 int32_t injectionResult; // initially INPUT_EVENT_INJECTION_PENDING 468 bool injectionIsAsync; // set to true if injection is not waiting for the result 469 int32_t pendingForegroundDispatches; // the number of foreground dispatches in progress 470 471 InjectionState(int32_t injectorPid, int32_t injectorUid); 472 void release(); 473 474 private: 475 ~InjectionState(); 476 }; 477 478 struct EventEntry : Link<EventEntry> { 479 enum { 480 TYPE_CONFIGURATION_CHANGED, 481 TYPE_DEVICE_RESET, 482 TYPE_KEY, 483 TYPE_MOTION 484 }; 485 486 uint32_t sequenceNum; 487 mutable int32_t refCount; 488 int32_t type; 489 nsecs_t eventTime; 490 uint32_t policyFlags; 491 InjectionState* injectionState; 492 493 bool dispatchInProgress; // initially false, set to true while dispatching 494 isInjectedEventEntry495 inline bool isInjected() const { return injectionState != nullptr; } 496 497 void release(); 498 499 virtual void appendDescription(std::string& msg) const = 0; 500 501 protected: 502 EventEntry(uint32_t sequenceNum, int32_t type, nsecs_t eventTime, uint32_t policyFlags); 503 virtual ~EventEntry(); 504 void releaseInjectionState(); 505 }; 506 507 struct ConfigurationChangedEntry : EventEntry { 508 explicit ConfigurationChangedEntry(uint32_t sequenceNum, nsecs_t eventTime); 509 virtual void appendDescription(std::string& msg) const; 510 511 protected: 512 virtual ~ConfigurationChangedEntry(); 513 }; 514 515 struct DeviceResetEntry : EventEntry { 516 int32_t deviceId; 517 518 DeviceResetEntry(uint32_t sequenceNum, nsecs_t eventTime, int32_t deviceId); 519 virtual void appendDescription(std::string& msg) const; 520 521 protected: 522 virtual ~DeviceResetEntry(); 523 }; 524 525 struct KeyEntry : EventEntry { 526 int32_t deviceId; 527 uint32_t source; 528 int32_t displayId; 529 int32_t action; 530 int32_t flags; 531 int32_t keyCode; 532 int32_t scanCode; 533 int32_t metaState; 534 int32_t repeatCount; 535 nsecs_t downTime; 536 537 bool syntheticRepeat; // set to true for synthetic key repeats 538 539 enum InterceptKeyResult { 540 INTERCEPT_KEY_RESULT_UNKNOWN, 541 INTERCEPT_KEY_RESULT_SKIP, 542 INTERCEPT_KEY_RESULT_CONTINUE, 543 INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER, 544 }; 545 InterceptKeyResult interceptKeyResult; // set based on the interception result 546 nsecs_t interceptKeyWakeupTime; // used with INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER 547 548 KeyEntry(uint32_t sequenceNum, nsecs_t eventTime, 549 int32_t deviceId, uint32_t source, int32_t displayId, uint32_t policyFlags, 550 int32_t action, int32_t flags, int32_t keyCode, int32_t scanCode, int32_t metaState, 551 int32_t repeatCount, nsecs_t downTime); 552 virtual void appendDescription(std::string& msg) const; 553 void recycle(); 554 555 protected: 556 virtual ~KeyEntry(); 557 }; 558 559 struct MotionEntry : EventEntry { 560 nsecs_t eventTime; 561 int32_t deviceId; 562 uint32_t source; 563 int32_t displayId; 564 int32_t action; 565 int32_t actionButton; 566 int32_t flags; 567 int32_t metaState; 568 int32_t buttonState; 569 MotionClassification classification; 570 int32_t edgeFlags; 571 float xPrecision; 572 float yPrecision; 573 nsecs_t downTime; 574 uint32_t pointerCount; 575 PointerProperties pointerProperties[MAX_POINTERS]; 576 PointerCoords pointerCoords[MAX_POINTERS]; 577 578 MotionEntry(uint32_t sequenceNum, nsecs_t eventTime, 579 int32_t deviceId, uint32_t source, int32_t displayId, uint32_t policyFlags, 580 int32_t action, int32_t actionButton, int32_t flags, 581 int32_t metaState, int32_t buttonState, MotionClassification classification, 582 int32_t edgeFlags, float xPrecision, float yPrecision, 583 nsecs_t downTime, uint32_t pointerCount, 584 const PointerProperties* pointerProperties, const PointerCoords* pointerCoords, 585 float xOffset, float yOffset); 586 virtual void appendDescription(std::string& msg) const; 587 588 protected: 589 virtual ~MotionEntry(); 590 }; 591 592 // Tracks the progress of dispatching a particular event to a particular connection. 593 struct DispatchEntry : Link<DispatchEntry> { 594 const uint32_t seq; // unique sequence number, never 0 595 596 EventEntry* eventEntry; // the event to dispatch 597 int32_t targetFlags; 598 float xOffset; 599 float yOffset; 600 float globalScaleFactor; 601 float windowXScale = 1.0f; 602 float windowYScale = 1.0f; 603 nsecs_t deliveryTime; // time when the event was actually delivered 604 605 // Set to the resolved action and flags when the event is enqueued. 606 int32_t resolvedAction; 607 int32_t resolvedFlags; 608 609 DispatchEntry(EventEntry* eventEntry, 610 int32_t targetFlags, float xOffset, float yOffset, 611 float globalScaleFactor, float windowXScale, float windowYScale); 612 ~DispatchEntry(); 613 hasForegroundTargetDispatchEntry614 inline bool hasForegroundTarget() const { 615 return targetFlags & InputTarget::FLAG_FOREGROUND; 616 } 617 isSplitDispatchEntry618 inline bool isSplit() const { 619 return targetFlags & InputTarget::FLAG_SPLIT; 620 } 621 622 private: 623 static volatile int32_t sNextSeqAtomic; 624 625 static uint32_t nextSeq(); 626 }; 627 628 // A command entry captures state and behavior for an action to be performed in the 629 // dispatch loop after the initial processing has taken place. It is essentially 630 // a kind of continuation used to postpone sensitive policy interactions to a point 631 // in the dispatch loop where it is safe to release the lock (generally after finishing 632 // the critical parts of the dispatch cycle). 633 // 634 // The special thing about commands is that they can voluntarily release and reacquire 635 // the dispatcher lock at will. Initially when the command starts running, the 636 // dispatcher lock is held. However, if the command needs to call into the policy to 637 // do some work, it can release the lock, do the work, then reacquire the lock again 638 // before returning. 639 // 640 // This mechanism is a bit clunky but it helps to preserve the invariant that the dispatch 641 // never calls into the policy while holding its lock. 642 // 643 // Commands are implicitly 'LockedInterruptible'. 644 struct CommandEntry; 645 typedef void (InputDispatcher::*Command)(CommandEntry* commandEntry); 646 647 class Connection; 648 struct CommandEntry : Link<CommandEntry> { 649 explicit CommandEntry(Command command); 650 ~CommandEntry(); 651 652 Command command; 653 654 // parameters for the command (usage varies by command) 655 sp<Connection> connection; 656 nsecs_t eventTime; 657 KeyEntry* keyEntry; 658 sp<InputApplicationHandle> inputApplicationHandle; 659 std::string reason; 660 int32_t userActivityEventType; 661 uint32_t seq; 662 bool handled; 663 sp<InputChannel> inputChannel; 664 sp<IBinder> oldToken; 665 sp<IBinder> newToken; 666 }; 667 668 // Generic queue implementation. 669 template <typename T> 670 struct Queue { 671 T* head; 672 T* tail; 673 uint32_t entryCount; 674 QueueQueue675 inline Queue() : head(nullptr), tail(nullptr), entryCount(0) { 676 } 677 isEmptyQueue678 inline bool isEmpty() const { 679 return !head; 680 } 681 enqueueAtTailQueue682 inline void enqueueAtTail(T* entry) { 683 entryCount++; 684 entry->prev = tail; 685 if (tail) { 686 tail->next = entry; 687 } else { 688 head = entry; 689 } 690 entry->next = nullptr; 691 tail = entry; 692 } 693 enqueueAtHeadQueue694 inline void enqueueAtHead(T* entry) { 695 entryCount++; 696 entry->next = head; 697 if (head) { 698 head->prev = entry; 699 } else { 700 tail = entry; 701 } 702 entry->prev = nullptr; 703 head = entry; 704 } 705 dequeueQueue706 inline void dequeue(T* entry) { 707 entryCount--; 708 if (entry->prev) { 709 entry->prev->next = entry->next; 710 } else { 711 head = entry->next; 712 } 713 if (entry->next) { 714 entry->next->prev = entry->prev; 715 } else { 716 tail = entry->prev; 717 } 718 } 719 dequeueAtHeadQueue720 inline T* dequeueAtHead() { 721 entryCount--; 722 T* entry = head; 723 head = entry->next; 724 if (head) { 725 head->prev = nullptr; 726 } else { 727 tail = nullptr; 728 } 729 return entry; 730 } 731 countQueue732 uint32_t count() const { 733 return entryCount; 734 } 735 }; 736 737 /* Specifies which events are to be canceled and why. */ 738 struct CancelationOptions { 739 enum Mode { 740 CANCEL_ALL_EVENTS = 0, 741 CANCEL_POINTER_EVENTS = 1, 742 CANCEL_NON_POINTER_EVENTS = 2, 743 CANCEL_FALLBACK_EVENTS = 3, 744 }; 745 746 // The criterion to use to determine which events should be canceled. 747 Mode mode; 748 749 // Descriptive reason for the cancelation. 750 const char* reason; 751 752 // The specific keycode of the key event to cancel, or nullopt to cancel any key event. 753 std::optional<int32_t> keyCode = std::nullopt; 754 755 // The specific device id of events to cancel, or nullopt to cancel events from any device. 756 std::optional<int32_t> deviceId = std::nullopt; 757 758 // The specific display id of events to cancel, or nullopt to cancel events on any display. 759 std::optional<int32_t> displayId = std::nullopt; 760 CancelationOptionsCancelationOptions761 CancelationOptions(Mode mode, const char* reason) : mode(mode), reason(reason) { } 762 }; 763 764 /* Tracks dispatched key and motion event state so that cancelation events can be 765 * synthesized when events are dropped. */ 766 class InputState { 767 public: 768 InputState(); 769 ~InputState(); 770 771 // Returns true if there is no state to be canceled. 772 bool isNeutral() const; 773 774 // Returns true if the specified source is known to have received a hover enter 775 // motion event. 776 bool isHovering(int32_t deviceId, uint32_t source, int32_t displayId) const; 777 778 // Records tracking information for a key event that has just been published. 779 // Returns true if the event should be delivered, false if it is inconsistent 780 // and should be skipped. 781 bool trackKey(const KeyEntry* entry, int32_t action, int32_t flags); 782 783 // Records tracking information for a motion event that has just been published. 784 // Returns true if the event should be delivered, false if it is inconsistent 785 // and should be skipped. 786 bool trackMotion(const MotionEntry* entry, int32_t action, int32_t flags); 787 788 // Synthesizes cancelation events for the current state and resets the tracked state. 789 void synthesizeCancelationEvents(nsecs_t currentTime, 790 std::vector<EventEntry*>& outEvents, const CancelationOptions& options); 791 792 // Clears the current state. 793 void clear(); 794 795 // Copies pointer-related parts of the input state to another instance. 796 void copyPointerStateTo(InputState& other) const; 797 798 // Gets the fallback key associated with a keycode. 799 // Returns -1 if none. 800 // Returns AKEYCODE_UNKNOWN if we are only dispatching the unhandled key to the policy. 801 int32_t getFallbackKey(int32_t originalKeyCode); 802 803 // Sets the fallback key for a particular keycode. 804 void setFallbackKey(int32_t originalKeyCode, int32_t fallbackKeyCode); 805 806 // Removes the fallback key for a particular keycode. 807 void removeFallbackKey(int32_t originalKeyCode); 808 getFallbackKeys()809 inline const KeyedVector<int32_t, int32_t>& getFallbackKeys() const { 810 return mFallbackKeys; 811 } 812 813 private: 814 struct KeyMemento { 815 int32_t deviceId; 816 uint32_t source; 817 int32_t displayId; 818 int32_t keyCode; 819 int32_t scanCode; 820 int32_t metaState; 821 int32_t flags; 822 nsecs_t downTime; 823 uint32_t policyFlags; 824 }; 825 826 struct MotionMemento { 827 int32_t deviceId; 828 uint32_t source; 829 int32_t displayId; 830 int32_t flags; 831 float xPrecision; 832 float yPrecision; 833 nsecs_t downTime; 834 uint32_t pointerCount; 835 PointerProperties pointerProperties[MAX_POINTERS]; 836 PointerCoords pointerCoords[MAX_POINTERS]; 837 bool hovering; 838 uint32_t policyFlags; 839 840 void setPointers(const MotionEntry* entry); 841 }; 842 843 std::vector<KeyMemento> mKeyMementos; 844 std::vector<MotionMemento> mMotionMementos; 845 KeyedVector<int32_t, int32_t> mFallbackKeys; 846 847 ssize_t findKeyMemento(const KeyEntry* entry) const; 848 ssize_t findMotionMemento(const MotionEntry* entry, bool hovering) const; 849 850 void addKeyMemento(const KeyEntry* entry, int32_t flags); 851 void addMotionMemento(const MotionEntry* entry, int32_t flags, bool hovering); 852 853 static bool shouldCancelKey(const KeyMemento& memento, 854 const CancelationOptions& options); 855 static bool shouldCancelMotion(const MotionMemento& memento, 856 const CancelationOptions& options); 857 }; 858 859 /* Manages the dispatch state associated with a single input channel. */ 860 class Connection : public RefBase { 861 protected: 862 virtual ~Connection(); 863 864 public: 865 enum Status { 866 // Everything is peachy. 867 STATUS_NORMAL, 868 // An unrecoverable communication error has occurred. 869 STATUS_BROKEN, 870 // The input channel has been unregistered. 871 STATUS_ZOMBIE 872 }; 873 874 Status status; 875 sp<InputChannel> inputChannel; // never null 876 bool monitor; 877 InputPublisher inputPublisher; 878 InputState inputState; 879 880 // True if the socket is full and no further events can be published until 881 // the application consumes some of the input. 882 bool inputPublisherBlocked; 883 884 // Queue of events that need to be published to the connection. 885 Queue<DispatchEntry> outboundQueue; 886 887 // Queue of events that have been published to the connection but that have not 888 // yet received a "finished" response from the application. 889 Queue<DispatchEntry> waitQueue; 890 891 explicit Connection(const sp<InputChannel>& inputChannel, bool monitor); 892 getInputChannelName()893 inline const std::string getInputChannelName() const { return inputChannel->getName(); } 894 895 const std::string getWindowName() const; 896 const char* getStatusLabel() const; 897 898 DispatchEntry* findWaitQueueEntry(uint32_t seq); 899 }; 900 901 struct Monitor { 902 sp<InputChannel> inputChannel; // never null 903 904 explicit Monitor(const sp<InputChannel>& inputChannel); 905 }; 906 907 enum DropReason { 908 DROP_REASON_NOT_DROPPED = 0, 909 DROP_REASON_POLICY = 1, 910 DROP_REASON_APP_SWITCH = 2, 911 DROP_REASON_DISABLED = 3, 912 DROP_REASON_BLOCKED = 4, 913 DROP_REASON_STALE = 5, 914 }; 915 916 sp<InputDispatcherPolicyInterface> mPolicy; 917 InputDispatcherConfiguration mConfig; 918 919 std::mutex mLock; 920 921 std::condition_variable mDispatcherIsAlive; 922 923 sp<Looper> mLooper; 924 925 EventEntry* mPendingEvent GUARDED_BY(mLock); 926 Queue<EventEntry> mInboundQueue GUARDED_BY(mLock); 927 Queue<EventEntry> mRecentQueue GUARDED_BY(mLock); 928 Queue<CommandEntry> mCommandQueue GUARDED_BY(mLock); 929 930 DropReason mLastDropReason GUARDED_BY(mLock); 931 932 void dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) REQUIRES(mLock); 933 934 // Enqueues an inbound event. Returns true if mLooper->wake() should be called. 935 bool enqueueInboundEventLocked(EventEntry* entry) REQUIRES(mLock); 936 937 // Cleans up input state when dropping an inbound event. 938 void dropInboundEventLocked(EventEntry* entry, DropReason dropReason) REQUIRES(mLock); 939 940 // Adds an event to a queue of recent events for debugging purposes. 941 void addRecentEventLocked(EventEntry* entry) REQUIRES(mLock); 942 943 // App switch latency optimization. 944 bool mAppSwitchSawKeyDown GUARDED_BY(mLock); 945 nsecs_t mAppSwitchDueTime GUARDED_BY(mLock); 946 947 bool isAppSwitchKeyEvent(KeyEntry* keyEntry); 948 bool isAppSwitchPendingLocked() REQUIRES(mLock); 949 void resetPendingAppSwitchLocked(bool handled) REQUIRES(mLock); 950 951 // Stale event latency optimization. 952 static bool isStaleEvent(nsecs_t currentTime, EventEntry* entry); 953 954 // Blocked event latency optimization. Drops old events when the user intends 955 // to transfer focus to a new application. 956 EventEntry* mNextUnblockedEvent GUARDED_BY(mLock); 957 958 sp<InputWindowHandle> findTouchedWindowAtLocked(int32_t displayId, int32_t x, int32_t y, 959 bool addOutsideTargets = false, bool addPortalWindows = false) REQUIRES(mLock); 960 961 // All registered connections mapped by channel file descriptor. 962 KeyedVector<int, sp<Connection> > mConnectionsByFd GUARDED_BY(mLock); 963 964 struct IBinderHash { operatorIBinderHash965 std::size_t operator()(const sp<IBinder>& b) const { 966 return std::hash<IBinder *>{}(b.get()); 967 } 968 }; 969 std::unordered_map<sp<IBinder>, sp<InputChannel>, IBinderHash> mInputChannelsByToken 970 GUARDED_BY(mLock); 971 972 // Finds the display ID of the gesture monitor identified by the provided token. 973 std::optional<int32_t> findGestureMonitorDisplayByTokenLocked(const sp<IBinder>& token) 974 REQUIRES(mLock); 975 976 ssize_t getConnectionIndexLocked(const sp<InputChannel>& inputChannel) REQUIRES(mLock); 977 978 // Input channels that will receive a copy of all input events sent to the provided display. 979 std::unordered_map<int32_t, std::vector<Monitor>> mGlobalMonitorsByDisplay 980 GUARDED_BY(mLock); 981 982 // Input channels that will receive pointer events that start within the corresponding display. 983 // These are a bit special when compared to global monitors since they'll cause gesture streams 984 // to continue even when there isn't a touched window,and have the ability to steal the rest of 985 // the pointer stream in order to claim it for a system gesture. 986 std::unordered_map<int32_t, std::vector<Monitor>> mGestureMonitorsByDisplay 987 GUARDED_BY(mLock); 988 989 990 // Event injection and synchronization. 991 std::condition_variable mInjectionResultAvailable; 992 bool hasInjectionPermission(int32_t injectorPid, int32_t injectorUid); 993 void setInjectionResult(EventEntry* entry, int32_t injectionResult); 994 995 std::condition_variable mInjectionSyncFinished; 996 void incrementPendingForegroundDispatches(EventEntry* entry); 997 void decrementPendingForegroundDispatches(EventEntry* entry); 998 999 // Key repeat tracking. 1000 struct KeyRepeatState { 1001 KeyEntry* lastKeyEntry; // or null if no repeat 1002 nsecs_t nextRepeatTime; 1003 } mKeyRepeatState GUARDED_BY(mLock); 1004 1005 void resetKeyRepeatLocked() REQUIRES(mLock); 1006 KeyEntry* synthesizeKeyRepeatLocked(nsecs_t currentTime) REQUIRES(mLock); 1007 1008 // Key replacement tracking 1009 struct KeyReplacement { 1010 int32_t keyCode; 1011 int32_t deviceId; 1012 bool operator==(const KeyReplacement& rhs) const { 1013 return keyCode == rhs.keyCode && deviceId == rhs.deviceId; 1014 } 1015 bool operator<(const KeyReplacement& rhs) const { 1016 return keyCode != rhs.keyCode ? keyCode < rhs.keyCode : deviceId < rhs.deviceId; 1017 } 1018 }; 1019 // Maps the key code replaced, device id tuple to the key code it was replaced with 1020 KeyedVector<KeyReplacement, int32_t> mReplacedKeys GUARDED_BY(mLock); 1021 // Process certain Meta + Key combinations 1022 void accelerateMetaShortcuts(const int32_t deviceId, const int32_t action, 1023 int32_t& keyCode, int32_t& metaState); 1024 1025 // Deferred command processing. 1026 bool haveCommandsLocked() const REQUIRES(mLock); 1027 bool runCommandsLockedInterruptible() REQUIRES(mLock); 1028 CommandEntry* postCommandLocked(Command command) REQUIRES(mLock); 1029 1030 // Input filter processing. 1031 bool shouldSendKeyToInputFilterLocked(const NotifyKeyArgs* args) REQUIRES(mLock); 1032 bool shouldSendMotionToInputFilterLocked(const NotifyMotionArgs* args) REQUIRES(mLock); 1033 1034 // Inbound event processing. 1035 void drainInboundQueueLocked() REQUIRES(mLock); 1036 void releasePendingEventLocked() REQUIRES(mLock); 1037 void releaseInboundEventLocked(EventEntry* entry) REQUIRES(mLock); 1038 1039 // Dispatch state. 1040 bool mDispatchEnabled GUARDED_BY(mLock); 1041 bool mDispatchFrozen GUARDED_BY(mLock); 1042 bool mInputFilterEnabled GUARDED_BY(mLock); 1043 1044 std::unordered_map<int32_t, std::vector<sp<InputWindowHandle>>> mWindowHandlesByDisplay 1045 GUARDED_BY(mLock); 1046 // Get window handles by display, return an empty vector if not found. 1047 std::vector<sp<InputWindowHandle>> getWindowHandlesLocked(int32_t displayId) const 1048 REQUIRES(mLock); 1049 sp<InputWindowHandle> getWindowHandleLocked(const sp<IBinder>& windowHandleToken) const 1050 REQUIRES(mLock); 1051 sp<InputChannel> getInputChannelLocked(const sp<IBinder>& windowToken) const REQUIRES(mLock); 1052 bool hasWindowHandleLocked(const sp<InputWindowHandle>& windowHandle) const REQUIRES(mLock); 1053 1054 // Focus tracking for keys, trackball, etc. 1055 std::unordered_map<int32_t, sp<InputWindowHandle>> mFocusedWindowHandlesByDisplay 1056 GUARDED_BY(mLock); 1057 1058 // Focus tracking for touch. 1059 struct TouchedWindow { 1060 sp<InputWindowHandle> windowHandle; 1061 int32_t targetFlags; 1062 BitSet32 pointerIds; // zero unless target flag FLAG_SPLIT is set 1063 }; 1064 1065 // For tracking the offsets we need to apply when adding gesture monitor targets. 1066 struct TouchedMonitor { 1067 Monitor monitor; 1068 float xOffset = 0.f; 1069 float yOffset = 0.f; 1070 1071 explicit TouchedMonitor(const Monitor& monitor, float xOffset, float yOffset); 1072 }; 1073 1074 struct TouchState { 1075 bool down; 1076 bool split; 1077 int32_t deviceId; // id of the device that is currently down, others are rejected 1078 uint32_t source; // source of the device that is current down, others are rejected 1079 int32_t displayId; // id to the display that currently has a touch, others are rejected 1080 std::vector<TouchedWindow> windows; 1081 1082 // This collects the portal windows that the touch has gone through. Each portal window 1083 // targets a display (embedded display for most cases). With this info, we can add the 1084 // monitoring channels of the displays touched. 1085 std::vector<sp<InputWindowHandle>> portalWindows; 1086 1087 std::vector<TouchedMonitor> gestureMonitors; 1088 1089 TouchState(); 1090 ~TouchState(); 1091 void reset(); 1092 void copyFrom(const TouchState& other); 1093 void addOrUpdateWindow(const sp<InputWindowHandle>& windowHandle, 1094 int32_t targetFlags, BitSet32 pointerIds); 1095 void addPortalWindow(const sp<InputWindowHandle>& windowHandle); 1096 void addGestureMonitors(const std::vector<TouchedMonitor>& monitors); 1097 void removeWindow(const sp<InputWindowHandle>& windowHandle); 1098 void removeWindowByToken(const sp<IBinder>& token); 1099 void filterNonAsIsTouchWindows(); 1100 void filterNonMonitors(); 1101 sp<InputWindowHandle> getFirstForegroundWindowHandle() const; 1102 bool isSlippery() const; 1103 }; 1104 1105 KeyedVector<int32_t, TouchState> mTouchStatesByDisplay GUARDED_BY(mLock); 1106 TouchState mTempTouchState GUARDED_BY(mLock); 1107 1108 // Focused applications. 1109 std::unordered_map<int32_t, sp<InputApplicationHandle>> mFocusedApplicationHandlesByDisplay 1110 GUARDED_BY(mLock); 1111 1112 // Top focused display. 1113 int32_t mFocusedDisplayId GUARDED_BY(mLock); 1114 1115 // Dispatcher state at time of last ANR. 1116 std::string mLastANRState GUARDED_BY(mLock); 1117 1118 // Dispatch inbound events. 1119 bool dispatchConfigurationChangedLocked( 1120 nsecs_t currentTime, ConfigurationChangedEntry* entry) REQUIRES(mLock); 1121 bool dispatchDeviceResetLocked( 1122 nsecs_t currentTime, DeviceResetEntry* entry) REQUIRES(mLock); 1123 bool dispatchKeyLocked( 1124 nsecs_t currentTime, KeyEntry* entry, 1125 DropReason* dropReason, nsecs_t* nextWakeupTime) REQUIRES(mLock); 1126 bool dispatchMotionLocked( 1127 nsecs_t currentTime, MotionEntry* entry, 1128 DropReason* dropReason, nsecs_t* nextWakeupTime) REQUIRES(mLock); 1129 void dispatchEventLocked(nsecs_t currentTime, EventEntry* entry, 1130 const std::vector<InputTarget>& inputTargets) REQUIRES(mLock); 1131 1132 void logOutboundKeyDetails(const char* prefix, const KeyEntry* entry); 1133 void logOutboundMotionDetails(const char* prefix, const MotionEntry* entry); 1134 1135 // Keeping track of ANR timeouts. 1136 enum InputTargetWaitCause { 1137 INPUT_TARGET_WAIT_CAUSE_NONE, 1138 INPUT_TARGET_WAIT_CAUSE_SYSTEM_NOT_READY, 1139 INPUT_TARGET_WAIT_CAUSE_APPLICATION_NOT_READY, 1140 }; 1141 1142 InputTargetWaitCause mInputTargetWaitCause GUARDED_BY(mLock); 1143 nsecs_t mInputTargetWaitStartTime GUARDED_BY(mLock); 1144 nsecs_t mInputTargetWaitTimeoutTime GUARDED_BY(mLock); 1145 bool mInputTargetWaitTimeoutExpired GUARDED_BY(mLock); 1146 sp<IBinder> mInputTargetWaitApplicationToken GUARDED_BY(mLock); 1147 1148 // Contains the last window which received a hover event. 1149 sp<InputWindowHandle> mLastHoverWindowHandle GUARDED_BY(mLock); 1150 1151 // Finding targets for input events. 1152 int32_t handleTargetsNotReadyLocked(nsecs_t currentTime, const EventEntry* entry, 1153 const sp<InputApplicationHandle>& applicationHandle, 1154 const sp<InputWindowHandle>& windowHandle, 1155 nsecs_t* nextWakeupTime, const char* reason) REQUIRES(mLock); 1156 1157 void removeWindowByTokenLocked(const sp<IBinder>& token) REQUIRES(mLock); 1158 1159 void resumeAfterTargetsNotReadyTimeoutLocked(nsecs_t newTimeout, 1160 const sp<InputChannel>& inputChannel) REQUIRES(mLock); 1161 nsecs_t getTimeSpentWaitingForApplicationLocked(nsecs_t currentTime) REQUIRES(mLock); 1162 void resetANRTimeoutsLocked() REQUIRES(mLock); 1163 1164 int32_t getTargetDisplayId(const EventEntry* entry); 1165 int32_t findFocusedWindowTargetsLocked(nsecs_t currentTime, const EventEntry* entry, 1166 std::vector<InputTarget>& inputTargets, nsecs_t* nextWakeupTime) REQUIRES(mLock); 1167 int32_t findTouchedWindowTargetsLocked(nsecs_t currentTime, const MotionEntry* entry, 1168 std::vector<InputTarget>& inputTargets, nsecs_t* nextWakeupTime, 1169 bool* outConflictingPointerActions) REQUIRES(mLock); 1170 std::vector<TouchedMonitor> findTouchedGestureMonitorsLocked(int32_t displayId, 1171 const std::vector<sp<InputWindowHandle>>& portalWindows) REQUIRES(mLock); 1172 void addGestureMonitors(const std::vector<Monitor>& monitors, 1173 std::vector<TouchedMonitor>& outTouchedMonitors, float xOffset = 0, float yOffset = 0); 1174 1175 void addWindowTargetLocked(const sp<InputWindowHandle>& windowHandle, 1176 int32_t targetFlags, BitSet32 pointerIds, std::vector<InputTarget>& inputTargets) 1177 REQUIRES(mLock); 1178 void addMonitoringTargetLocked(const Monitor& monitor, float xOffset, float yOffset, 1179 std::vector<InputTarget>& inputTargets) REQUIRES(mLock); 1180 void addGlobalMonitoringTargetsLocked(std::vector<InputTarget>& inputTargets, 1181 int32_t displayId, float xOffset = 0, float yOffset = 0) REQUIRES(mLock); 1182 1183 void pokeUserActivityLocked(const EventEntry* eventEntry) REQUIRES(mLock); 1184 bool checkInjectionPermission(const sp<InputWindowHandle>& windowHandle, 1185 const InjectionState* injectionState); 1186 bool isWindowObscuredAtPointLocked(const sp<InputWindowHandle>& windowHandle, 1187 int32_t x, int32_t y) const REQUIRES(mLock); 1188 bool isWindowObscuredLocked(const sp<InputWindowHandle>& windowHandle) const REQUIRES(mLock); 1189 std::string getApplicationWindowLabel(const sp<InputApplicationHandle>& applicationHandle, 1190 const sp<InputWindowHandle>& windowHandle); 1191 1192 std::string checkWindowReadyForMoreInputLocked(nsecs_t currentTime, 1193 const sp<InputWindowHandle>& windowHandle, const EventEntry* eventEntry, 1194 const char* targetType) REQUIRES(mLock); 1195 1196 // Manage the dispatch cycle for a single connection. 1197 // These methods are deliberately not Interruptible because doing all of the work 1198 // with the mutex held makes it easier to ensure that connection invariants are maintained. 1199 // If needed, the methods post commands to run later once the critical bits are done. 1200 void prepareDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection, 1201 EventEntry* eventEntry, const InputTarget* inputTarget) REQUIRES(mLock); 1202 void enqueueDispatchEntriesLocked(nsecs_t currentTime, const sp<Connection>& connection, 1203 EventEntry* eventEntry, const InputTarget* inputTarget) REQUIRES(mLock); 1204 void enqueueDispatchEntryLocked(const sp<Connection>& connection, 1205 EventEntry* eventEntry, const InputTarget* inputTarget, int32_t dispatchMode) 1206 REQUIRES(mLock); 1207 void startDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection) 1208 REQUIRES(mLock); 1209 void finishDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection, 1210 uint32_t seq, bool handled) REQUIRES(mLock); 1211 void abortBrokenDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection, 1212 bool notify) REQUIRES(mLock); 1213 void drainDispatchQueue(Queue<DispatchEntry>* queue); 1214 void releaseDispatchEntry(DispatchEntry* dispatchEntry); 1215 static int handleReceiveCallback(int fd, int events, void* data); 1216 // The action sent should only be of type AMOTION_EVENT_* 1217 void dispatchPointerDownOutsideFocus(uint32_t source, int32_t action, 1218 const sp<IBinder>& newToken) REQUIRES(mLock); 1219 1220 void synthesizeCancelationEventsForAllConnectionsLocked( 1221 const CancelationOptions& options) REQUIRES(mLock); 1222 void synthesizeCancelationEventsForMonitorsLocked( 1223 const CancelationOptions& options) REQUIRES(mLock); 1224 void synthesizeCancelationEventsForMonitorsLocked(const CancelationOptions& options, 1225 std::unordered_map<int32_t, std::vector<Monitor>>& monitorsByDisplay) REQUIRES(mLock); 1226 void synthesizeCancelationEventsForInputChannelLocked(const sp<InputChannel>& channel, 1227 const CancelationOptions& options) REQUIRES(mLock); 1228 void synthesizeCancelationEventsForConnectionLocked(const sp<Connection>& connection, 1229 const CancelationOptions& options) REQUIRES(mLock); 1230 1231 // Splitting motion events across windows. 1232 MotionEntry* splitMotionEvent(const MotionEntry* originalMotionEntry, BitSet32 pointerIds); 1233 1234 // Reset and drop everything the dispatcher is doing. 1235 void resetAndDropEverythingLocked(const char* reason) REQUIRES(mLock); 1236 1237 // Dump state. 1238 void dumpDispatchStateLocked(std::string& dump) REQUIRES(mLock); 1239 void dumpMonitors(std::string& dump, const std::vector<Monitor>& monitors); 1240 void logDispatchStateLocked() REQUIRES(mLock); 1241 1242 // Registration. 1243 void removeMonitorChannelLocked(const sp<InputChannel>& inputChannel) REQUIRES(mLock); 1244 void removeMonitorChannelLocked(const sp<InputChannel>& inputChannel, 1245 std::unordered_map<int32_t, std::vector<Monitor>>& monitorsByDisplay) 1246 REQUIRES(mLock); 1247 status_t unregisterInputChannelLocked(const sp<InputChannel>& inputChannel, bool notify) 1248 REQUIRES(mLock); 1249 1250 // Interesting events that we might like to log or tell the framework about. 1251 void onDispatchCycleFinishedLocked( 1252 nsecs_t currentTime, const sp<Connection>& connection, uint32_t seq, bool handled) 1253 REQUIRES(mLock); 1254 void onDispatchCycleBrokenLocked( 1255 nsecs_t currentTime, const sp<Connection>& connection) REQUIRES(mLock); 1256 void onFocusChangedLocked(const sp<InputWindowHandle>& oldFocus, 1257 const sp<InputWindowHandle>& newFocus) REQUIRES(mLock); 1258 void onANRLocked( 1259 nsecs_t currentTime, const sp<InputApplicationHandle>& applicationHandle, 1260 const sp<InputWindowHandle>& windowHandle, 1261 nsecs_t eventTime, nsecs_t waitStartTime, const char* reason) REQUIRES(mLock); 1262 1263 // Outbound policy interactions. 1264 void doNotifyConfigurationChangedLockedInterruptible(CommandEntry* commandEntry) 1265 REQUIRES(mLock); 1266 void doNotifyInputChannelBrokenLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); 1267 void doNotifyFocusChangedLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); 1268 void doNotifyANRLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); 1269 void doInterceptKeyBeforeDispatchingLockedInterruptible(CommandEntry* commandEntry) 1270 REQUIRES(mLock); 1271 void doDispatchCycleFinishedLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); 1272 bool afterKeyEventLockedInterruptible(const sp<Connection>& connection, 1273 DispatchEntry* dispatchEntry, KeyEntry* keyEntry, bool handled) REQUIRES(mLock); 1274 bool afterMotionEventLockedInterruptible(const sp<Connection>& connection, 1275 DispatchEntry* dispatchEntry, MotionEntry* motionEntry, bool handled) REQUIRES(mLock); 1276 void doPokeUserActivityLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); 1277 void initializeKeyEvent(KeyEvent* event, const KeyEntry* entry); 1278 void doOnPointerDownOutsideFocusLockedInterruptible(CommandEntry* commandEntry) 1279 REQUIRES(mLock); 1280 1281 // Statistics gathering. 1282 void updateDispatchStatistics(nsecs_t currentTime, const EventEntry* entry, 1283 int32_t injectionResult, nsecs_t timeSpentWaitingForApplication); 1284 void traceInboundQueueLengthLocked() REQUIRES(mLock); 1285 void traceOutboundQueueLength(const sp<Connection>& connection); 1286 void traceWaitQueueLength(const sp<Connection>& connection); 1287 1288 sp<InputReporterInterface> mReporter; 1289 }; 1290 1291 /* Enqueues and dispatches input events, endlessly. */ 1292 class InputDispatcherThread : public Thread { 1293 public: 1294 explicit InputDispatcherThread(const sp<InputDispatcherInterface>& dispatcher); 1295 ~InputDispatcherThread(); 1296 1297 private: 1298 virtual bool threadLoop(); 1299 1300 sp<InputDispatcherInterface> mDispatcher; 1301 }; 1302 1303 } // namespace android 1304 1305 #endif // _UI_INPUT_DISPATCHER_H 1306