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 <ui/Input.h> 21 #include <ui/InputTransport.h> 22 #include <utils/KeyedVector.h> 23 #include <utils/Vector.h> 24 #include <utils/threads.h> 25 #include <utils/Timers.h> 26 #include <utils/RefBase.h> 27 #include <utils/String8.h> 28 #include <utils/Looper.h> 29 #include <utils/Pool.h> 30 #include <utils/BitSet.h> 31 32 #include <stddef.h> 33 #include <unistd.h> 34 #include <limits.h> 35 36 37 namespace android { 38 39 /* 40 * Constants used to report the outcome of input event injection. 41 */ 42 enum { 43 /* (INTERNAL USE ONLY) Specifies that injection is pending and its outcome is unknown. */ 44 INPUT_EVENT_INJECTION_PENDING = -1, 45 46 /* Injection succeeded. */ 47 INPUT_EVENT_INJECTION_SUCCEEDED = 0, 48 49 /* Injection failed because the injector did not have permission to inject 50 * into the application with input focus. */ 51 INPUT_EVENT_INJECTION_PERMISSION_DENIED = 1, 52 53 /* Injection failed because there were no available input targets. */ 54 INPUT_EVENT_INJECTION_FAILED = 2, 55 56 /* Injection failed due to a timeout. */ 57 INPUT_EVENT_INJECTION_TIMED_OUT = 3 58 }; 59 60 /* 61 * Constants used to determine the input event injection synchronization mode. 62 */ 63 enum { 64 /* Injection is asynchronous and is assumed always to be successful. */ 65 INPUT_EVENT_INJECTION_SYNC_NONE = 0, 66 67 /* Waits for previous events to be dispatched so that the input dispatcher can determine 68 * whether input event injection willbe permitted based on the current input focus. 69 * Does not wait for the input event to finish processing. */ 70 INPUT_EVENT_INJECTION_SYNC_WAIT_FOR_RESULT = 1, 71 72 /* Waits for the input event to be completely processed. */ 73 INPUT_EVENT_INJECTION_SYNC_WAIT_FOR_FINISHED = 2, 74 }; 75 76 77 /* 78 * An input target specifies how an input event is to be dispatched to a particular window 79 * including the window's input channel, control flags, a timeout, and an X / Y offset to 80 * be added to input event coordinates to compensate for the absolute position of the 81 * window area. 82 */ 83 struct InputTarget { 84 enum { 85 /* This flag indicates that the event is being delivered to a foreground application. */ 86 FLAG_FOREGROUND = 0x01, 87 88 /* This flag indicates that a MotionEvent with AMOTION_EVENT_ACTION_DOWN falls outside 89 * of the area of this target and so should instead be delivered as an 90 * AMOTION_EVENT_ACTION_OUTSIDE to this target. */ 91 FLAG_OUTSIDE = 0x02, 92 93 /* This flag indicates that the target of a MotionEvent is partly or wholly 94 * obscured by another visible window above it. The motion event should be 95 * delivered with flag AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED. */ 96 FLAG_WINDOW_IS_OBSCURED = 0x04, 97 98 /* This flag indicates that a motion event is being split across multiple windows. */ 99 FLAG_SPLIT = 0x08, 100 }; 101 102 // The input channel to be targeted. 103 sp<InputChannel> inputChannel; 104 105 // Flags for the input target. 106 int32_t flags; 107 108 // The x and y offset to add to a MotionEvent as it is delivered. 109 // (ignored for KeyEvents) 110 float xOffset, yOffset; 111 112 // The subset of pointer ids to include in motion events dispatched to this input target 113 // if FLAG_SPLIT is set. 114 BitSet32 pointerIds; 115 }; 116 117 118 /* 119 * An input window describes the bounds of a window that can receive input. 120 */ 121 struct InputWindow { 122 // Window flags from WindowManager.LayoutParams 123 enum { 124 FLAG_ALLOW_LOCK_WHILE_SCREEN_ON = 0x00000001, 125 FLAG_DIM_BEHIND = 0x00000002, 126 FLAG_BLUR_BEHIND = 0x00000004, 127 FLAG_NOT_FOCUSABLE = 0x00000008, 128 FLAG_NOT_TOUCHABLE = 0x00000010, 129 FLAG_NOT_TOUCH_MODAL = 0x00000020, 130 FLAG_TOUCHABLE_WHEN_WAKING = 0x00000040, 131 FLAG_KEEP_SCREEN_ON = 0x00000080, 132 FLAG_LAYOUT_IN_SCREEN = 0x00000100, 133 FLAG_LAYOUT_NO_LIMITS = 0x00000200, 134 FLAG_FULLSCREEN = 0x00000400, 135 FLAG_FORCE_NOT_FULLSCREEN = 0x00000800, 136 FLAG_DITHER = 0x00001000, 137 FLAG_SECURE = 0x00002000, 138 FLAG_SCALED = 0x00004000, 139 FLAG_IGNORE_CHEEK_PRESSES = 0x00008000, 140 FLAG_LAYOUT_INSET_DECOR = 0x00010000, 141 FLAG_ALT_FOCUSABLE_IM = 0x00020000, 142 FLAG_WATCH_OUTSIDE_TOUCH = 0x00040000, 143 FLAG_SHOW_WHEN_LOCKED = 0x00080000, 144 FLAG_SHOW_WALLPAPER = 0x00100000, 145 FLAG_TURN_SCREEN_ON = 0x00200000, 146 FLAG_DISMISS_KEYGUARD = 0x00400000, 147 FLAG_SPLIT_TOUCH = 0x00800000, 148 FLAG_KEEP_SURFACE_WHILE_ANIMATING = 0x10000000, 149 FLAG_COMPATIBLE_WINDOW = 0x20000000, 150 FLAG_SYSTEM_ERROR = 0x40000000, 151 }; 152 153 // Window types from WindowManager.LayoutParams 154 enum { 155 FIRST_APPLICATION_WINDOW = 1, 156 TYPE_BASE_APPLICATION = 1, 157 TYPE_APPLICATION = 2, 158 TYPE_APPLICATION_STARTING = 3, 159 LAST_APPLICATION_WINDOW = 99, 160 FIRST_SUB_WINDOW = 1000, 161 TYPE_APPLICATION_PANEL = FIRST_SUB_WINDOW, 162 TYPE_APPLICATION_MEDIA = FIRST_SUB_WINDOW+1, 163 TYPE_APPLICATION_SUB_PANEL = FIRST_SUB_WINDOW+2, 164 TYPE_APPLICATION_ATTACHED_DIALOG = FIRST_SUB_WINDOW+3, 165 TYPE_APPLICATION_MEDIA_OVERLAY = FIRST_SUB_WINDOW+4, 166 LAST_SUB_WINDOW = 1999, 167 FIRST_SYSTEM_WINDOW = 2000, 168 TYPE_STATUS_BAR = FIRST_SYSTEM_WINDOW, 169 TYPE_SEARCH_BAR = FIRST_SYSTEM_WINDOW+1, 170 TYPE_PHONE = FIRST_SYSTEM_WINDOW+2, 171 TYPE_SYSTEM_ALERT = FIRST_SYSTEM_WINDOW+3, 172 TYPE_KEYGUARD = FIRST_SYSTEM_WINDOW+4, 173 TYPE_TOAST = FIRST_SYSTEM_WINDOW+5, 174 TYPE_SYSTEM_OVERLAY = FIRST_SYSTEM_WINDOW+6, 175 TYPE_PRIORITY_PHONE = FIRST_SYSTEM_WINDOW+7, 176 TYPE_SYSTEM_DIALOG = FIRST_SYSTEM_WINDOW+8, 177 TYPE_KEYGUARD_DIALOG = FIRST_SYSTEM_WINDOW+9, 178 TYPE_SYSTEM_ERROR = FIRST_SYSTEM_WINDOW+10, 179 TYPE_INPUT_METHOD = FIRST_SYSTEM_WINDOW+11, 180 TYPE_INPUT_METHOD_DIALOG= FIRST_SYSTEM_WINDOW+12, 181 TYPE_WALLPAPER = FIRST_SYSTEM_WINDOW+13, 182 TYPE_STATUS_BAR_PANEL = FIRST_SYSTEM_WINDOW+14, 183 TYPE_SECURE_SYSTEM_OVERLAY = FIRST_SYSTEM_WINDOW+15, 184 LAST_SYSTEM_WINDOW = 2999, 185 }; 186 187 sp<InputChannel> inputChannel; 188 String8 name; 189 int32_t layoutParamsFlags; 190 int32_t layoutParamsType; 191 nsecs_t dispatchingTimeout; 192 int32_t frameLeft; 193 int32_t frameTop; 194 int32_t frameRight; 195 int32_t frameBottom; 196 int32_t visibleFrameLeft; 197 int32_t visibleFrameTop; 198 int32_t visibleFrameRight; 199 int32_t visibleFrameBottom; 200 int32_t touchableAreaLeft; 201 int32_t touchableAreaTop; 202 int32_t touchableAreaRight; 203 int32_t touchableAreaBottom; 204 bool visible; 205 bool canReceiveKeys; 206 bool hasFocus; 207 bool hasWallpaper; 208 bool paused; 209 int32_t layer; 210 int32_t ownerPid; 211 int32_t ownerUid; 212 213 bool touchableAreaContainsPoint(int32_t x, int32_t y) const; 214 bool frameContainsPoint(int32_t x, int32_t y) const; 215 216 /* Returns true if the window is of a trusted type that is allowed to silently 217 * overlay other windows for the purpose of implementing the secure views feature. 218 * Trusted overlays, such as IME windows, can partly obscure other windows without causing 219 * motion events to be delivered to them with AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED. 220 */ 221 bool isTrustedOverlay() const; 222 }; 223 224 225 /* 226 * A private handle type used by the input manager to track the window. 227 */ 228 class InputApplicationHandle : public RefBase { 229 protected: 230 InputApplicationHandle() { } 231 virtual ~InputApplicationHandle() { } 232 }; 233 234 235 /* 236 * An input application describes properties of an application that can receive input. 237 */ 238 struct InputApplication { 239 String8 name; 240 nsecs_t dispatchingTimeout; 241 sp<InputApplicationHandle> handle; 242 }; 243 244 245 /* 246 * Input dispatcher policy interface. 247 * 248 * The input reader policy is used by the input reader to interact with the Window Manager 249 * and other system components. 250 * 251 * The actual implementation is partially supported by callbacks into the DVM 252 * via JNI. This interface is also mocked in the unit tests. 253 */ 254 class InputDispatcherPolicyInterface : public virtual RefBase { 255 protected: 256 InputDispatcherPolicyInterface() { } 257 virtual ~InputDispatcherPolicyInterface() { } 258 259 public: 260 /* Notifies the system that a configuration change has occurred. */ 261 virtual void notifyConfigurationChanged(nsecs_t when) = 0; 262 263 /* Notifies the system that an application is not responding. 264 * Returns a new timeout to continue waiting, or 0 to abort dispatch. */ 265 virtual nsecs_t notifyANR(const sp<InputApplicationHandle>& inputApplicationHandle, 266 const sp<InputChannel>& inputChannel) = 0; 267 268 /* Notifies the system that an input channel is unrecoverably broken. */ 269 virtual void notifyInputChannelBroken(const sp<InputChannel>& inputChannel) = 0; 270 271 /* Gets the key repeat initial timeout or -1 if automatic key repeating is disabled. */ 272 virtual nsecs_t getKeyRepeatTimeout() = 0; 273 274 /* Gets the key repeat inter-key delay. */ 275 virtual nsecs_t getKeyRepeatDelay() = 0; 276 277 /* Gets the maximum suggested event delivery rate per second. 278 * This value is used to throttle motion event movement actions on a per-device 279 * basis. It is not intended to be a hard limit. 280 */ 281 virtual int32_t getMaxEventsPerSecond() = 0; 282 283 /* Intercepts a key event immediately before queueing it. 284 * The policy can use this method as an opportunity to perform power management functions 285 * and early event preprocessing such as updating policy flags. 286 * 287 * This method is expected to set the POLICY_FLAG_PASS_TO_USER policy flag if the event 288 * should be dispatched to applications. 289 */ 290 virtual void interceptKeyBeforeQueueing(nsecs_t when, int32_t deviceId, 291 int32_t action, int32_t& flags, int32_t keyCode, int32_t scanCode, 292 uint32_t& policyFlags) = 0; 293 294 /* Intercepts a generic touch, trackball or other event before queueing it. 295 * The policy can use this method as an opportunity to perform power management functions 296 * and early event preprocessing such as updating policy flags. 297 * 298 * This method is expected to set the POLICY_FLAG_PASS_TO_USER policy flag if the event 299 * should be dispatched to applications. 300 */ 301 virtual void interceptGenericBeforeQueueing(nsecs_t when, uint32_t& policyFlags) = 0; 302 303 /* Allows the policy a chance to intercept a key before dispatching. */ 304 virtual bool interceptKeyBeforeDispatching(const sp<InputChannel>& inputChannel, 305 const KeyEvent* keyEvent, uint32_t policyFlags) = 0; 306 307 /* Notifies the policy about switch events. 308 */ 309 virtual void notifySwitch(nsecs_t when, 310 int32_t switchCode, int32_t switchValue, uint32_t policyFlags) = 0; 311 312 /* Poke user activity for an event dispatched to a window. */ 313 virtual void pokeUserActivity(nsecs_t eventTime, int32_t eventType) = 0; 314 315 /* Checks whether a given application pid/uid has permission to inject input events 316 * into other applications. 317 * 318 * This method is special in that its implementation promises to be non-reentrant and 319 * is safe to call while holding other locks. (Most other methods make no such guarantees!) 320 */ 321 virtual bool checkInjectEventsPermissionNonReentrant( 322 int32_t injectorPid, int32_t injectorUid) = 0; 323 }; 324 325 326 /* Notifies the system about input events generated by the input reader. 327 * The dispatcher is expected to be mostly asynchronous. */ 328 class InputDispatcherInterface : public virtual RefBase { 329 protected: 330 InputDispatcherInterface() { } 331 virtual ~InputDispatcherInterface() { } 332 333 public: 334 /* Dumps the state of the input dispatcher. 335 * 336 * This method may be called on any thread (usually by the input manager). */ 337 virtual void dump(String8& dump) = 0; 338 339 /* Runs a single iteration of the dispatch loop. 340 * Nominally processes one queued event, a timeout, or a response from an input consumer. 341 * 342 * This method should only be called on the input dispatcher thread. 343 */ 344 virtual void dispatchOnce() = 0; 345 346 /* Notifies the dispatcher about new events. 347 * 348 * These methods should only be called on the input reader thread. 349 */ 350 virtual void notifyConfigurationChanged(nsecs_t eventTime) = 0; 351 virtual void notifyKey(nsecs_t eventTime, int32_t deviceId, int32_t source, 352 uint32_t policyFlags, int32_t action, int32_t flags, int32_t keyCode, 353 int32_t scanCode, int32_t metaState, nsecs_t downTime) = 0; 354 virtual void notifyMotion(nsecs_t eventTime, int32_t deviceId, int32_t source, 355 uint32_t policyFlags, int32_t action, int32_t flags, 356 int32_t metaState, int32_t edgeFlags, 357 uint32_t pointerCount, const int32_t* pointerIds, const PointerCoords* pointerCoords, 358 float xPrecision, float yPrecision, nsecs_t downTime) = 0; 359 virtual void notifySwitch(nsecs_t when, 360 int32_t switchCode, int32_t switchValue, uint32_t policyFlags) = 0; 361 362 /* Injects an input event and optionally waits for sync. 363 * The synchronization mode determines whether the method blocks while waiting for 364 * input injection to proceed. 365 * Returns one of the INPUT_EVENT_INJECTION_XXX constants. 366 * 367 * This method may be called on any thread (usually by the input manager). 368 */ 369 virtual int32_t injectInputEvent(const InputEvent* event, 370 int32_t injectorPid, int32_t injectorUid, int32_t syncMode, int32_t timeoutMillis) = 0; 371 372 /* Sets the list of input windows. 373 * 374 * This method may be called on any thread (usually by the input manager). 375 */ 376 virtual void setInputWindows(const Vector<InputWindow>& inputWindows) = 0; 377 378 /* Sets the focused application. 379 * 380 * This method may be called on any thread (usually by the input manager). 381 */ 382 virtual void setFocusedApplication(const InputApplication* inputApplication) = 0; 383 384 /* Sets the input dispatching mode. 385 * 386 * This method may be called on any thread (usually by the input manager). 387 */ 388 virtual void setInputDispatchMode(bool enabled, bool frozen) = 0; 389 390 /* Registers or unregister input channels that may be used as targets for input events. 391 * If monitor is true, the channel will receive a copy of all input events. 392 * 393 * These methods may be called on any thread (usually by the input manager). 394 */ 395 virtual status_t registerInputChannel(const sp<InputChannel>& inputChannel, bool monitor) = 0; 396 virtual status_t unregisterInputChannel(const sp<InputChannel>& inputChannel) = 0; 397 }; 398 399 /* Dispatches events to input targets. Some functions of the input dispatcher, such as 400 * identifying input targets, are controlled by a separate policy object. 401 * 402 * IMPORTANT INVARIANT: 403 * Because the policy can potentially block or cause re-entrance into the input dispatcher, 404 * the input dispatcher never calls into the policy while holding its internal locks. 405 * The implementation is also carefully designed to recover from scenarios such as an 406 * input channel becoming unregistered while identifying input targets or processing timeouts. 407 * 408 * Methods marked 'Locked' must be called with the lock acquired. 409 * 410 * Methods marked 'LockedInterruptible' must be called with the lock acquired but 411 * may during the course of their execution release the lock, call into the policy, and 412 * then reacquire the lock. The caller is responsible for recovering gracefully. 413 * 414 * A 'LockedInterruptible' method may called a 'Locked' method, but NOT vice-versa. 415 */ 416 class InputDispatcher : public InputDispatcherInterface { 417 protected: 418 virtual ~InputDispatcher(); 419 420 public: 421 explicit InputDispatcher(const sp<InputDispatcherPolicyInterface>& policy); 422 423 virtual void dump(String8& dump); 424 425 virtual void dispatchOnce(); 426 427 virtual void notifyConfigurationChanged(nsecs_t eventTime); 428 virtual void notifyKey(nsecs_t eventTime, int32_t deviceId, int32_t source, 429 uint32_t policyFlags, int32_t action, int32_t flags, int32_t keyCode, 430 int32_t scanCode, int32_t metaState, nsecs_t downTime); 431 virtual void notifyMotion(nsecs_t eventTime, int32_t deviceId, int32_t source, 432 uint32_t policyFlags, int32_t action, int32_t flags, 433 int32_t metaState, int32_t edgeFlags, 434 uint32_t pointerCount, const int32_t* pointerIds, const PointerCoords* pointerCoords, 435 float xPrecision, float yPrecision, nsecs_t downTime); 436 virtual void notifySwitch(nsecs_t when, 437 int32_t switchCode, int32_t switchValue, uint32_t policyFlags) ; 438 439 virtual int32_t injectInputEvent(const InputEvent* event, 440 int32_t injectorPid, int32_t injectorUid, int32_t syncMode, int32_t timeoutMillis); 441 442 virtual void setInputWindows(const Vector<InputWindow>& inputWindows); 443 virtual void setFocusedApplication(const InputApplication* inputApplication); 444 virtual void setInputDispatchMode(bool enabled, bool frozen); 445 446 virtual status_t registerInputChannel(const sp<InputChannel>& inputChannel, bool monitor); 447 virtual status_t unregisterInputChannel(const sp<InputChannel>& inputChannel); 448 449 private: 450 template <typename T> 451 struct Link { 452 T* next; 453 T* prev; 454 }; 455 456 struct InjectionState { 457 mutable int32_t refCount; 458 459 int32_t injectorPid; 460 int32_t injectorUid; 461 int32_t injectionResult; // initially INPUT_EVENT_INJECTION_PENDING 462 bool injectionIsAsync; // set to true if injection is not waiting for the result 463 int32_t pendingForegroundDispatches; // the number of foreground dispatches in progress 464 }; 465 466 struct EventEntry : Link<EventEntry> { 467 enum { 468 TYPE_SENTINEL, 469 TYPE_CONFIGURATION_CHANGED, 470 TYPE_KEY, 471 TYPE_MOTION 472 }; 473 474 mutable int32_t refCount; 475 int32_t type; 476 nsecs_t eventTime; 477 uint32_t policyFlags; 478 InjectionState* injectionState; 479 480 bool dispatchInProgress; // initially false, set to true while dispatching 481 482 inline bool isInjected() { return injectionState != NULL; } 483 }; 484 485 struct ConfigurationChangedEntry : EventEntry { 486 }; 487 488 struct KeyEntry : EventEntry { 489 int32_t deviceId; 490 int32_t source; 491 int32_t action; 492 int32_t flags; 493 int32_t keyCode; 494 int32_t scanCode; 495 int32_t metaState; 496 int32_t repeatCount; 497 nsecs_t downTime; 498 499 bool syntheticRepeat; // set to true for synthetic key repeats 500 501 enum InterceptKeyResult { 502 INTERCEPT_KEY_RESULT_UNKNOWN, 503 INTERCEPT_KEY_RESULT_SKIP, 504 INTERCEPT_KEY_RESULT_CONTINUE, 505 }; 506 InterceptKeyResult interceptKeyResult; // set based on the interception result 507 }; 508 509 struct MotionSample { 510 MotionSample* next; 511 512 nsecs_t eventTime; 513 PointerCoords pointerCoords[MAX_POINTERS]; 514 }; 515 516 struct MotionEntry : EventEntry { 517 int32_t deviceId; 518 int32_t source; 519 int32_t action; 520 int32_t flags; 521 int32_t metaState; 522 int32_t edgeFlags; 523 float xPrecision; 524 float yPrecision; 525 nsecs_t downTime; 526 uint32_t pointerCount; 527 int32_t pointerIds[MAX_POINTERS]; 528 529 // Linked list of motion samples associated with this motion event. 530 MotionSample firstSample; 531 MotionSample* lastSample; 532 533 uint32_t countSamples() const; 534 }; 535 536 // Tracks the progress of dispatching a particular event to a particular connection. 537 struct DispatchEntry : Link<DispatchEntry> { 538 EventEntry* eventEntry; // the event to dispatch 539 int32_t targetFlags; 540 float xOffset; 541 float yOffset; 542 543 // True if dispatch has started. 544 bool inProgress; 545 546 // For motion events: 547 // Pointer to the first motion sample to dispatch in this cycle. 548 // Usually NULL to indicate that the list of motion samples begins at 549 // MotionEntry::firstSample. Otherwise, some samples were dispatched in a previous 550 // cycle and this pointer indicates the location of the first remainining sample 551 // to dispatch during the current cycle. 552 MotionSample* headMotionSample; 553 // Pointer to a motion sample to dispatch in the next cycle if the dispatcher was 554 // unable to send all motion samples during this cycle. On the next cycle, 555 // headMotionSample will be initialized to tailMotionSample and tailMotionSample 556 // will be set to NULL. 557 MotionSample* tailMotionSample; 558 559 inline bool hasForegroundTarget() const { 560 return targetFlags & InputTarget::FLAG_FOREGROUND; 561 } 562 563 inline bool isSplit() const { 564 return targetFlags & InputTarget::FLAG_SPLIT; 565 } 566 }; 567 568 // A command entry captures state and behavior for an action to be performed in the 569 // dispatch loop after the initial processing has taken place. It is essentially 570 // a kind of continuation used to postpone sensitive policy interactions to a point 571 // in the dispatch loop where it is safe to release the lock (generally after finishing 572 // the critical parts of the dispatch cycle). 573 // 574 // The special thing about commands is that they can voluntarily release and reacquire 575 // the dispatcher lock at will. Initially when the command starts running, the 576 // dispatcher lock is held. However, if the command needs to call into the policy to 577 // do some work, it can release the lock, do the work, then reacquire the lock again 578 // before returning. 579 // 580 // This mechanism is a bit clunky but it helps to preserve the invariant that the dispatch 581 // never calls into the policy while holding its lock. 582 // 583 // Commands are implicitly 'LockedInterruptible'. 584 struct CommandEntry; 585 typedef void (InputDispatcher::*Command)(CommandEntry* commandEntry); 586 587 class Connection; 588 struct CommandEntry : Link<CommandEntry> { 589 CommandEntry(); 590 ~CommandEntry(); 591 592 Command command; 593 594 // parameters for the command (usage varies by command) 595 sp<Connection> connection; 596 nsecs_t eventTime; 597 KeyEntry* keyEntry; 598 sp<InputChannel> inputChannel; 599 sp<InputApplicationHandle> inputApplicationHandle; 600 int32_t userActivityEventType; 601 }; 602 603 // Generic queue implementation. 604 template <typename T> 605 struct Queue { 606 T headSentinel; 607 T tailSentinel; 608 609 inline Queue() { 610 headSentinel.prev = NULL; 611 headSentinel.next = & tailSentinel; 612 tailSentinel.prev = & headSentinel; 613 tailSentinel.next = NULL; 614 } 615 616 inline bool isEmpty() const { 617 return headSentinel.next == & tailSentinel; 618 } 619 620 inline void enqueueAtTail(T* entry) { 621 T* last = tailSentinel.prev; 622 last->next = entry; 623 entry->prev = last; 624 entry->next = & tailSentinel; 625 tailSentinel.prev = entry; 626 } 627 628 inline void enqueueAtHead(T* entry) { 629 T* first = headSentinel.next; 630 headSentinel.next = entry; 631 entry->prev = & headSentinel; 632 entry->next = first; 633 first->prev = entry; 634 } 635 636 inline void dequeue(T* entry) { 637 entry->prev->next = entry->next; 638 entry->next->prev = entry->prev; 639 } 640 641 inline T* dequeueAtHead() { 642 T* first = headSentinel.next; 643 dequeue(first); 644 return first; 645 } 646 647 uint32_t count() const; 648 }; 649 650 /* Allocates queue entries and performs reference counting as needed. */ 651 class Allocator { 652 public: 653 Allocator(); 654 655 InjectionState* obtainInjectionState(int32_t injectorPid, int32_t injectorUid); 656 ConfigurationChangedEntry* obtainConfigurationChangedEntry(nsecs_t eventTime); 657 KeyEntry* obtainKeyEntry(nsecs_t eventTime, 658 int32_t deviceId, int32_t source, uint32_t policyFlags, int32_t action, 659 int32_t flags, int32_t keyCode, int32_t scanCode, int32_t metaState, 660 int32_t repeatCount, nsecs_t downTime); 661 MotionEntry* obtainMotionEntry(nsecs_t eventTime, 662 int32_t deviceId, int32_t source, uint32_t policyFlags, int32_t action, 663 int32_t flags, int32_t metaState, int32_t edgeFlags, 664 float xPrecision, float yPrecision, 665 nsecs_t downTime, uint32_t pointerCount, 666 const int32_t* pointerIds, const PointerCoords* pointerCoords); 667 DispatchEntry* obtainDispatchEntry(EventEntry* eventEntry, 668 int32_t targetFlags, float xOffset, float yOffset); 669 CommandEntry* obtainCommandEntry(Command command); 670 671 void releaseInjectionState(InjectionState* injectionState); 672 void releaseEventEntry(EventEntry* entry); 673 void releaseConfigurationChangedEntry(ConfigurationChangedEntry* entry); 674 void releaseKeyEntry(KeyEntry* entry); 675 void releaseMotionEntry(MotionEntry* entry); 676 void releaseDispatchEntry(DispatchEntry* entry); 677 void releaseCommandEntry(CommandEntry* entry); 678 679 void recycleKeyEntry(KeyEntry* entry); 680 681 void appendMotionSample(MotionEntry* motionEntry, 682 nsecs_t eventTime, const PointerCoords* pointerCoords); 683 684 private: 685 Pool<InjectionState> mInjectionStatePool; 686 Pool<ConfigurationChangedEntry> mConfigurationChangeEntryPool; 687 Pool<KeyEntry> mKeyEntryPool; 688 Pool<MotionEntry> mMotionEntryPool; 689 Pool<MotionSample> mMotionSamplePool; 690 Pool<DispatchEntry> mDispatchEntryPool; 691 Pool<CommandEntry> mCommandEntryPool; 692 693 void initializeEventEntry(EventEntry* entry, int32_t type, nsecs_t eventTime, 694 uint32_t policyFlags); 695 void releaseEventEntryInjectionState(EventEntry* entry); 696 }; 697 698 /* Tracks dispatched key and motion event state so that cancelation events can be 699 * synthesized when events are dropped. */ 700 class InputState { 701 public: 702 // Specifies whether a given event will violate input state consistency. 703 enum Consistency { 704 // The event is consistent with the current input state. 705 CONSISTENT, 706 // The event is inconsistent with the current input state but applications 707 // will tolerate it. eg. Down followed by another down. 708 TOLERABLE, 709 // The event is inconsistent with the current input state and will probably 710 // cause applications to crash. eg. Up without prior down, move with 711 // unexpected number of pointers. 712 BROKEN 713 }; 714 715 // Specifies the sources to cancel. 716 enum CancelationOptions { 717 CANCEL_ALL_EVENTS = 0, 718 CANCEL_POINTER_EVENTS = 1, 719 CANCEL_NON_POINTER_EVENTS = 2, 720 }; 721 722 InputState(); 723 ~InputState(); 724 725 // Returns true if there is no state to be canceled. 726 bool isNeutral() const; 727 728 // Records tracking information for an event that has just been published. 729 // Returns whether the event is consistent with the current input state. 730 Consistency trackEvent(const EventEntry* entry); 731 732 // Records tracking information for a key event that has just been published. 733 // Returns whether the event is consistent with the current input state. 734 Consistency trackKey(const KeyEntry* entry); 735 736 // Records tracking information for a motion event that has just been published. 737 // Returns whether the event is consistent with the current input state. 738 Consistency trackMotion(const MotionEntry* entry); 739 740 // Synthesizes cancelation events for the current state and resets the tracked state. 741 void synthesizeCancelationEvents(nsecs_t currentTime, Allocator* allocator, 742 Vector<EventEntry*>& outEvents, CancelationOptions options); 743 744 // Clears the current state. 745 void clear(); 746 747 private: 748 struct KeyMemento { 749 int32_t deviceId; 750 int32_t source; 751 int32_t keyCode; 752 int32_t scanCode; 753 nsecs_t downTime; 754 }; 755 756 struct MotionMemento { 757 int32_t deviceId; 758 int32_t source; 759 float xPrecision; 760 float yPrecision; 761 nsecs_t downTime; 762 uint32_t pointerCount; 763 int32_t pointerIds[MAX_POINTERS]; 764 PointerCoords pointerCoords[MAX_POINTERS]; 765 766 void setPointers(const MotionEntry* entry); 767 }; 768 769 Vector<KeyMemento> mKeyMementos; 770 Vector<MotionMemento> mMotionMementos; 771 772 static bool shouldCancelEvent(int32_t eventSource, CancelationOptions options); 773 }; 774 775 /* Manages the dispatch state associated with a single input channel. */ 776 class Connection : public RefBase { 777 protected: 778 virtual ~Connection(); 779 780 public: 781 enum Status { 782 // Everything is peachy. 783 STATUS_NORMAL, 784 // An unrecoverable communication error has occurred. 785 STATUS_BROKEN, 786 // The input channel has been unregistered. 787 STATUS_ZOMBIE 788 }; 789 790 Status status; 791 sp<InputChannel> inputChannel; 792 InputPublisher inputPublisher; 793 InputState inputState; 794 Queue<DispatchEntry> outboundQueue; 795 796 nsecs_t lastEventTime; // the time when the event was originally captured 797 nsecs_t lastDispatchTime; // the time when the last event was dispatched 798 799 explicit Connection(const sp<InputChannel>& inputChannel); 800 801 inline const char* getInputChannelName() const { return inputChannel->getName().string(); } 802 803 const char* getStatusLabel() const; 804 805 // Finds a DispatchEntry in the outbound queue associated with the specified event. 806 // Returns NULL if not found. 807 DispatchEntry* findQueuedDispatchEntryForEvent(const EventEntry* eventEntry) const; 808 809 // Gets the time since the current event was originally obtained from the input driver. 810 inline double getEventLatencyMillis(nsecs_t currentTime) const { 811 return (currentTime - lastEventTime) / 1000000.0; 812 } 813 814 // Gets the time since the current event entered the outbound dispatch queue. 815 inline double getDispatchLatencyMillis(nsecs_t currentTime) const { 816 return (currentTime - lastDispatchTime) / 1000000.0; 817 } 818 819 status_t initialize(); 820 }; 821 822 enum DropReason { 823 DROP_REASON_NOT_DROPPED = 0, 824 DROP_REASON_POLICY = 1, 825 DROP_REASON_APP_SWITCH = 2, 826 DROP_REASON_DISABLED = 3, 827 }; 828 829 sp<InputDispatcherPolicyInterface> mPolicy; 830 831 Mutex mLock; 832 833 Allocator mAllocator; 834 sp<Looper> mLooper; 835 836 EventEntry* mPendingEvent; 837 Queue<EventEntry> mInboundQueue; 838 Queue<CommandEntry> mCommandQueue; 839 840 Vector<EventEntry*> mTempCancelationEvents; 841 842 void dispatchOnceInnerLocked(nsecs_t keyRepeatTimeout, nsecs_t keyRepeatDelay, 843 nsecs_t* nextWakeupTime); 844 845 // Enqueues an inbound event. Returns true if mLooper->wake() should be called. 846 bool enqueueInboundEventLocked(EventEntry* entry); 847 848 // Cleans up input state when dropping an inbound event. 849 void dropInboundEventLocked(EventEntry* entry, DropReason dropReason); 850 851 // App switch latency optimization. 852 bool mAppSwitchSawKeyDown; 853 nsecs_t mAppSwitchDueTime; 854 855 static bool isAppSwitchKeyCode(int32_t keyCode); 856 bool isAppSwitchKeyEventLocked(KeyEntry* keyEntry); 857 bool isAppSwitchPendingLocked(); 858 void resetPendingAppSwitchLocked(bool handled); 859 860 // All registered connections mapped by receive pipe file descriptor. 861 KeyedVector<int, sp<Connection> > mConnectionsByReceiveFd; 862 863 ssize_t getConnectionIndexLocked(const sp<InputChannel>& inputChannel); 864 865 // Active connections are connections that have a non-empty outbound queue. 866 // We don't use a ref-counted pointer here because we explicitly abort connections 867 // during unregistration which causes the connection's outbound queue to be cleared 868 // and the connection itself to be deactivated. 869 Vector<Connection*> mActiveConnections; 870 871 // Input channels that will receive a copy of all input events. 872 Vector<sp<InputChannel> > mMonitoringChannels; 873 874 // Preallocated key event object used for policy inquiries. 875 KeyEvent mReusableKeyEvent; 876 877 // Event injection and synchronization. 878 Condition mInjectionResultAvailableCondition; 879 bool hasInjectionPermission(int32_t injectorPid, int32_t injectorUid); 880 void setInjectionResultLocked(EventEntry* entry, int32_t injectionResult); 881 882 Condition mInjectionSyncFinishedCondition; 883 void incrementPendingForegroundDispatchesLocked(EventEntry* entry); 884 void decrementPendingForegroundDispatchesLocked(EventEntry* entry); 885 886 // Throttling state. 887 struct ThrottleState { 888 nsecs_t minTimeBetweenEvents; 889 890 nsecs_t lastEventTime; 891 int32_t lastDeviceId; 892 uint32_t lastSource; 893 894 uint32_t originalSampleCount; // only collected during debugging 895 } mThrottleState; 896 897 // Key repeat tracking. 898 struct KeyRepeatState { 899 KeyEntry* lastKeyEntry; // or null if no repeat 900 nsecs_t nextRepeatTime; 901 } mKeyRepeatState; 902 903 void resetKeyRepeatLocked(); 904 KeyEntry* synthesizeKeyRepeatLocked(nsecs_t currentTime, nsecs_t keyRepeatTimeout); 905 906 // Deferred command processing. 907 bool runCommandsLockedInterruptible(); 908 CommandEntry* postCommandLocked(Command command); 909 910 // Inbound event processing. 911 void drainInboundQueueLocked(); 912 void releasePendingEventLocked(); 913 void releaseInboundEventLocked(EventEntry* entry); 914 915 // Dispatch state. 916 bool mDispatchEnabled; 917 bool mDispatchFrozen; 918 919 Vector<InputWindow> mWindows; 920 921 const InputWindow* getWindowLocked(const sp<InputChannel>& inputChannel); 922 923 // Focus tracking for keys, trackball, etc. 924 const InputWindow* mFocusedWindow; 925 926 // Focus tracking for touch. 927 struct TouchedWindow { 928 const InputWindow* window; 929 int32_t targetFlags; 930 BitSet32 pointerIds; 931 sp<InputChannel> channel; 932 }; 933 struct TouchState { 934 bool down; 935 bool split; 936 Vector<TouchedWindow> windows; 937 938 TouchState(); 939 ~TouchState(); 940 void reset(); 941 void copyFrom(const TouchState& other); 942 void addOrUpdateWindow(const InputWindow* window, int32_t targetFlags, BitSet32 pointerIds); 943 void removeOutsideTouchWindows(); 944 const InputWindow* getFirstForegroundWindow(); 945 }; 946 947 TouchState mTouchState; 948 TouchState mTempTouchState; 949 950 // Focused application. 951 InputApplication* mFocusedApplication; 952 InputApplication mFocusedApplicationStorage; // preallocated storage for mFocusedApplication 953 void releaseFocusedApplicationLocked(); 954 955 // Dispatch inbound events. 956 bool dispatchConfigurationChangedLocked( 957 nsecs_t currentTime, ConfigurationChangedEntry* entry); 958 bool dispatchKeyLocked( 959 nsecs_t currentTime, KeyEntry* entry, nsecs_t keyRepeatTimeout, 960 DropReason* dropReason, nsecs_t* nextWakeupTime); 961 bool dispatchMotionLocked( 962 nsecs_t currentTime, MotionEntry* entry, 963 DropReason* dropReason, nsecs_t* nextWakeupTime); 964 void dispatchEventToCurrentInputTargetsLocked( 965 nsecs_t currentTime, EventEntry* entry, bool resumeWithAppendedMotionSample); 966 967 void logOutboundKeyDetailsLocked(const char* prefix, const KeyEntry* entry); 968 void logOutboundMotionDetailsLocked(const char* prefix, const MotionEntry* entry); 969 970 // The input targets that were most recently identified for dispatch. 971 bool mCurrentInputTargetsValid; // false while targets are being recomputed 972 Vector<InputTarget> mCurrentInputTargets; 973 974 enum InputTargetWaitCause { 975 INPUT_TARGET_WAIT_CAUSE_NONE, 976 INPUT_TARGET_WAIT_CAUSE_SYSTEM_NOT_READY, 977 INPUT_TARGET_WAIT_CAUSE_APPLICATION_NOT_READY, 978 }; 979 980 InputTargetWaitCause mInputTargetWaitCause; 981 nsecs_t mInputTargetWaitStartTime; 982 nsecs_t mInputTargetWaitTimeoutTime; 983 bool mInputTargetWaitTimeoutExpired; 984 985 // Finding targets for input events. 986 void resetTargetsLocked(); 987 void commitTargetsLocked(); 988 int32_t handleTargetsNotReadyLocked(nsecs_t currentTime, const EventEntry* entry, 989 const InputApplication* application, const InputWindow* window, 990 nsecs_t* nextWakeupTime); 991 void resumeAfterTargetsNotReadyTimeoutLocked(nsecs_t newTimeout, 992 const sp<InputChannel>& inputChannel); 993 nsecs_t getTimeSpentWaitingForApplicationLocked(nsecs_t currentTime); 994 void resetANRTimeoutsLocked(); 995 996 int32_t findFocusedWindowTargetsLocked(nsecs_t currentTime, const EventEntry* entry, 997 nsecs_t* nextWakeupTime); 998 int32_t findTouchedWindowTargetsLocked(nsecs_t currentTime, const MotionEntry* entry, 999 nsecs_t* nextWakeupTime); 1000 1001 void addWindowTargetLocked(const InputWindow* window, int32_t targetFlags, 1002 BitSet32 pointerIds); 1003 void addMonitoringTargetsLocked(); 1004 void pokeUserActivityLocked(const EventEntry* eventEntry); 1005 bool checkInjectionPermission(const InputWindow* window, const InjectionState* injectionState); 1006 bool isWindowObscuredAtPointLocked(const InputWindow* window, int32_t x, int32_t y) const; 1007 bool isWindowFinishedWithPreviousInputLocked(const InputWindow* window); 1008 String8 getApplicationWindowLabelLocked(const InputApplication* application, 1009 const InputWindow* window); 1010 1011 // Manage the dispatch cycle for a single connection. 1012 // These methods are deliberately not Interruptible because doing all of the work 1013 // with the mutex held makes it easier to ensure that connection invariants are maintained. 1014 // If needed, the methods post commands to run later once the critical bits are done. 1015 void prepareDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection, 1016 EventEntry* eventEntry, const InputTarget* inputTarget, 1017 bool resumeWithAppendedMotionSample); 1018 void startDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection); 1019 void finishDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection); 1020 void startNextDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection); 1021 void abortBrokenDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection); 1022 void drainOutboundQueueLocked(Connection* connection); 1023 static int handleReceiveCallback(int receiveFd, int events, void* data); 1024 1025 void synthesizeCancelationEventsForAllConnectionsLocked( 1026 InputState::CancelationOptions options, const char* reason); 1027 void synthesizeCancelationEventsForInputChannelLocked(const sp<InputChannel>& channel, 1028 InputState::CancelationOptions options, const char* reason); 1029 void synthesizeCancelationEventsForConnectionLocked(const sp<Connection>& connection, 1030 InputState::CancelationOptions options, const char* reason); 1031 1032 // Splitting motion events across windows. 1033 MotionEntry* splitMotionEvent(const MotionEntry* originalMotionEntry, BitSet32 pointerIds); 1034 1035 // Reset and drop everything the dispatcher is doing. 1036 void resetAndDropEverythingLocked(const char* reason); 1037 1038 // Dump state. 1039 void dumpDispatchStateLocked(String8& dump); 1040 void logDispatchStateLocked(); 1041 1042 // Add or remove a connection to the mActiveConnections vector. 1043 void activateConnectionLocked(Connection* connection); 1044 void deactivateConnectionLocked(Connection* connection); 1045 1046 // Interesting events that we might like to log or tell the framework about. 1047 void onDispatchCycleStartedLocked( 1048 nsecs_t currentTime, const sp<Connection>& connection); 1049 void onDispatchCycleFinishedLocked( 1050 nsecs_t currentTime, const sp<Connection>& connection); 1051 void onDispatchCycleBrokenLocked( 1052 nsecs_t currentTime, const sp<Connection>& connection); 1053 void onANRLocked( 1054 nsecs_t currentTime, const InputApplication* application, const InputWindow* window, 1055 nsecs_t eventTime, nsecs_t waitStartTime); 1056 1057 // Outbound policy interactions. 1058 void doNotifyConfigurationChangedInterruptible(CommandEntry* commandEntry); 1059 void doNotifyInputChannelBrokenLockedInterruptible(CommandEntry* commandEntry); 1060 void doNotifyANRLockedInterruptible(CommandEntry* commandEntry); 1061 void doInterceptKeyBeforeDispatchingLockedInterruptible(CommandEntry* commandEntry); 1062 void doPokeUserActivityLockedInterruptible(CommandEntry* commandEntry); 1063 1064 // Statistics gathering. 1065 void updateDispatchStatisticsLocked(nsecs_t currentTime, const EventEntry* entry, 1066 int32_t injectionResult, nsecs_t timeSpentWaitingForApplication); 1067 }; 1068 1069 /* Enqueues and dispatches input events, endlessly. */ 1070 class InputDispatcherThread : public Thread { 1071 public: 1072 explicit InputDispatcherThread(const sp<InputDispatcherInterface>& dispatcher); 1073 ~InputDispatcherThread(); 1074 1075 private: 1076 virtual bool threadLoop(); 1077 1078 sp<InputDispatcherInterface> mDispatcher; 1079 }; 1080 1081 } // namespace android 1082 1083 #endif // _UI_INPUT_DISPATCHER_H 1084
