InputDispatcher.h revision 9831d90db8fba7e967d22b1f86eea1d6ac831541
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/BitSet.h> 30 31#include <stddef.h> 32#include <unistd.h> 33#include <limits.h> 34 35#include "InputWindow.h" 36#include "InputApplication.h" 37#include "InputListener.h" 38 39 40namespace android { 41 42/* 43 * Constants used to report the outcome of input event injection. 44 */ 45enum { 46 /* (INTERNAL USE ONLY) Specifies that injection is pending and its outcome is unknown. */ 47 INPUT_EVENT_INJECTION_PENDING = -1, 48 49 /* Injection succeeded. */ 50 INPUT_EVENT_INJECTION_SUCCEEDED = 0, 51 52 /* Injection failed because the injector did not have permission to inject 53 * into the application with input focus. */ 54 INPUT_EVENT_INJECTION_PERMISSION_DENIED = 1, 55 56 /* Injection failed because there were no available input targets. */ 57 INPUT_EVENT_INJECTION_FAILED = 2, 58 59 /* Injection failed due to a timeout. */ 60 INPUT_EVENT_INJECTION_TIMED_OUT = 3 61}; 62 63/* 64 * Constants used to determine the input event injection synchronization mode. 65 */ 66enum { 67 /* Injection is asynchronous and is assumed always to be successful. */ 68 INPUT_EVENT_INJECTION_SYNC_NONE = 0, 69 70 /* Waits for previous events to be dispatched so that the input dispatcher can determine 71 * whether input event injection willbe permitted based on the current input focus. 72 * Does not wait for the input event to finish processing. */ 73 INPUT_EVENT_INJECTION_SYNC_WAIT_FOR_RESULT = 1, 74 75 /* Waits for the input event to be completely processed. */ 76 INPUT_EVENT_INJECTION_SYNC_WAIT_FOR_FINISHED = 2, 77}; 78 79 80/* 81 * An input target specifies how an input event is to be dispatched to a particular window 82 * including the window's input channel, control flags, a timeout, and an X / Y offset to 83 * be added to input event coordinates to compensate for the absolute position of the 84 * window area. 85 */ 86struct InputTarget { 87 enum { 88 /* This flag indicates that the event is being delivered to a foreground application. */ 89 FLAG_FOREGROUND = 1 << 0, 90 91 /* This flag indicates that the target of a MotionEvent is partly or wholly 92 * obscured by another visible window above it. The motion event should be 93 * delivered with flag AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED. */ 94 FLAG_WINDOW_IS_OBSCURED = 1 << 1, 95 96 /* This flag indicates that a motion event is being split across multiple windows. */ 97 FLAG_SPLIT = 1 << 2, 98 99 /* This flag indicates that the pointer coordinates dispatched to the application 100 * will be zeroed out to avoid revealing information to an application. This is 101 * used in conjunction with FLAG_DISPATCH_AS_OUTSIDE to prevent apps not sharing 102 * the same UID from watching all touches. */ 103 FLAG_ZERO_COORDS = 1 << 3, 104 105 /* This flag indicates that the event should be sent as is. 106 * Should always be set unless the event is to be transmuted. */ 107 FLAG_DISPATCH_AS_IS = 1 << 8, 108 109 /* This flag indicates that a MotionEvent with AMOTION_EVENT_ACTION_DOWN falls outside 110 * of the area of this target and so should instead be delivered as an 111 * AMOTION_EVENT_ACTION_OUTSIDE to this target. */ 112 FLAG_DISPATCH_AS_OUTSIDE = 1 << 9, 113 114 /* This flag indicates that a hover sequence is starting in the given window. 115 * The event is transmuted into ACTION_HOVER_ENTER. */ 116 FLAG_DISPATCH_AS_HOVER_ENTER = 1 << 10, 117 118 /* This flag indicates that a hover event happened outside of a window which handled 119 * previous hover events, signifying the end of the current hover sequence for that 120 * window. 121 * The event is transmuted into ACTION_HOVER_ENTER. */ 122 FLAG_DISPATCH_AS_HOVER_EXIT = 1 << 11, 123 124 /* This flag indicates that the event should be canceled. 125 * It is used to transmute ACTION_MOVE into ACTION_CANCEL when a touch slips 126 * outside of a window. */ 127 FLAG_DISPATCH_AS_SLIPPERY_EXIT = 1 << 12, 128 129 /* This flag indicates that the event should be dispatched as an initial down. 130 * It is used to transmute ACTION_MOVE into ACTION_DOWN when a touch slips 131 * into a new window. */ 132 FLAG_DISPATCH_AS_SLIPPERY_ENTER = 1 << 13, 133 134 /* Mask for all dispatch modes. */ 135 FLAG_DISPATCH_MASK = FLAG_DISPATCH_AS_IS 136 | FLAG_DISPATCH_AS_OUTSIDE 137 | FLAG_DISPATCH_AS_HOVER_ENTER 138 | FLAG_DISPATCH_AS_HOVER_EXIT 139 | FLAG_DISPATCH_AS_SLIPPERY_EXIT 140 | FLAG_DISPATCH_AS_SLIPPERY_ENTER, 141 }; 142 143 // The input channel to be targeted. 144 sp<InputChannel> inputChannel; 145 146 // Flags for the input target. 147 int32_t flags; 148 149 // The x and y offset to add to a MotionEvent as it is delivered. 150 // (ignored for KeyEvents) 151 float xOffset, yOffset; 152 153 // Scaling factor to apply to MotionEvent as it is delivered. 154 // (ignored for KeyEvents) 155 float scaleFactor; 156 157 // The subset of pointer ids to include in motion events dispatched to this input target 158 // if FLAG_SPLIT is set. 159 BitSet32 pointerIds; 160}; 161 162 163/* 164 * Input dispatcher configuration. 165 * 166 * Specifies various options that modify the behavior of the input dispatcher. 167 */ 168struct InputDispatcherConfiguration { 169 // The key repeat initial timeout. 170 nsecs_t keyRepeatTimeout; 171 172 // The key repeat inter-key delay. 173 nsecs_t keyRepeatDelay; 174 175 InputDispatcherConfiguration() : 176 keyRepeatTimeout(500 * 1000000LL), 177 keyRepeatDelay(50 * 1000000LL) { } 178}; 179 180 181/* 182 * Input dispatcher policy interface. 183 * 184 * The input reader policy is used by the input reader to interact with the Window Manager 185 * and other system components. 186 * 187 * The actual implementation is partially supported by callbacks into the DVM 188 * via JNI. This interface is also mocked in the unit tests. 189 */ 190class InputDispatcherPolicyInterface : public virtual RefBase { 191protected: 192 InputDispatcherPolicyInterface() { } 193 virtual ~InputDispatcherPolicyInterface() { } 194 195public: 196 /* Notifies the system that a configuration change has occurred. */ 197 virtual void notifyConfigurationChanged(nsecs_t when) = 0; 198 199 /* Notifies the system that an application is not responding. 200 * Returns a new timeout to continue waiting, or 0 to abort dispatch. */ 201 virtual nsecs_t notifyANR(const sp<InputApplicationHandle>& inputApplicationHandle, 202 const sp<InputWindowHandle>& inputWindowHandle) = 0; 203 204 /* Notifies the system that an input channel is unrecoverably broken. */ 205 virtual void notifyInputChannelBroken(const sp<InputWindowHandle>& inputWindowHandle) = 0; 206 207 /* Gets the input dispatcher configuration. */ 208 virtual void getDispatcherConfiguration(InputDispatcherConfiguration* outConfig) = 0; 209 210 /* Returns true if automatic key repeating is enabled. */ 211 virtual bool isKeyRepeatEnabled() = 0; 212 213 /* Filters an input event. 214 * Return true to dispatch the event unmodified, false to consume the event. 215 * A filter can also transform and inject events later by passing POLICY_FLAG_FILTERED 216 * to injectInputEvent. 217 */ 218 virtual bool filterInputEvent(const InputEvent* inputEvent, uint32_t policyFlags) = 0; 219 220 /* Intercepts a key event immediately before queueing it. 221 * The policy can use this method as an opportunity to perform power management functions 222 * and early event preprocessing such as updating policy flags. 223 * 224 * This method is expected to set the POLICY_FLAG_PASS_TO_USER policy flag if the event 225 * should be dispatched to applications. 226 */ 227 virtual void interceptKeyBeforeQueueing(const KeyEvent* keyEvent, uint32_t& policyFlags) = 0; 228 229 /* Intercepts a touch, trackball or other motion event before queueing it. 230 * The policy can use this method as an opportunity to perform power management functions 231 * and early event preprocessing such as updating policy flags. 232 * 233 * This method is expected to set the POLICY_FLAG_PASS_TO_USER policy flag if the event 234 * should be dispatched to applications. 235 */ 236 virtual void interceptMotionBeforeQueueing(nsecs_t when, uint32_t& policyFlags) = 0; 237 238 /* Allows the policy a chance to intercept a key before dispatching. */ 239 virtual nsecs_t interceptKeyBeforeDispatching(const sp<InputWindowHandle>& inputWindowHandle, 240 const KeyEvent* keyEvent, uint32_t policyFlags) = 0; 241 242 /* Allows the policy a chance to perform default processing for an unhandled key. 243 * Returns an alternate keycode to redispatch as a fallback, or 0 to give up. */ 244 virtual bool dispatchUnhandledKey(const sp<InputWindowHandle>& inputWindowHandle, 245 const KeyEvent* keyEvent, uint32_t policyFlags, KeyEvent* outFallbackKeyEvent) = 0; 246 247 /* Notifies the policy about switch events. 248 */ 249 virtual void notifySwitch(nsecs_t when, 250 int32_t switchCode, int32_t switchValue, uint32_t policyFlags) = 0; 251 252 /* Poke user activity for an event dispatched to a window. */ 253 virtual void pokeUserActivity(nsecs_t eventTime, int32_t eventType) = 0; 254 255 /* Checks whether a given application pid/uid has permission to inject input events 256 * into other applications. 257 * 258 * This method is special in that its implementation promises to be non-reentrant and 259 * is safe to call while holding other locks. (Most other methods make no such guarantees!) 260 */ 261 virtual bool checkInjectEventsPermissionNonReentrant( 262 int32_t injectorPid, int32_t injectorUid) = 0; 263}; 264 265 266/* Notifies the system about input events generated by the input reader. 267 * The dispatcher is expected to be mostly asynchronous. */ 268class InputDispatcherInterface : public virtual RefBase, public InputListenerInterface { 269protected: 270 InputDispatcherInterface() { } 271 virtual ~InputDispatcherInterface() { } 272 273public: 274 /* Dumps the state of the input dispatcher. 275 * 276 * This method may be called on any thread (usually by the input manager). */ 277 virtual void dump(String8& dump) = 0; 278 279 /* Called by the heatbeat to ensures that the dispatcher has not deadlocked. */ 280 virtual void monitor() = 0; 281 282 /* Runs a single iteration of the dispatch loop. 283 * Nominally processes one queued event, a timeout, or a response from an input consumer. 284 * 285 * This method should only be called on the input dispatcher thread. 286 */ 287 virtual void dispatchOnce() = 0; 288 289 /* Injects an input event and optionally waits for sync. 290 * The synchronization mode determines whether the method blocks while waiting for 291 * input injection to proceed. 292 * Returns one of the INPUT_EVENT_INJECTION_XXX constants. 293 * 294 * This method may be called on any thread (usually by the input manager). 295 */ 296 virtual int32_t injectInputEvent(const InputEvent* event, 297 int32_t injectorPid, int32_t injectorUid, int32_t syncMode, int32_t timeoutMillis, 298 uint32_t policyFlags) = 0; 299 300 /* Sets the list of input windows. 301 * 302 * This method may be called on any thread (usually by the input manager). 303 */ 304 virtual void setInputWindows(const Vector<sp<InputWindowHandle> >& inputWindowHandles) = 0; 305 306 /* Sets the focused application. 307 * 308 * This method may be called on any thread (usually by the input manager). 309 */ 310 virtual void setFocusedApplication( 311 const sp<InputApplicationHandle>& inputApplicationHandle) = 0; 312 313 /* Sets the input dispatching mode. 314 * 315 * This method may be called on any thread (usually by the input manager). 316 */ 317 virtual void setInputDispatchMode(bool enabled, bool frozen) = 0; 318 319 /* Sets whether input event filtering is enabled. 320 * When enabled, incoming input events are sent to the policy's filterInputEvent 321 * method instead of being dispatched. The filter is expected to use 322 * injectInputEvent to inject the events it would like to have dispatched. 323 * It should include POLICY_FLAG_FILTERED in the policy flags during injection. 324 */ 325 virtual void setInputFilterEnabled(bool enabled) = 0; 326 327 /* Transfers touch focus from the window associated with one channel to the 328 * window associated with the other channel. 329 * 330 * Returns true on success. False if the window did not actually have touch focus. 331 */ 332 virtual bool transferTouchFocus(const sp<InputChannel>& fromChannel, 333 const sp<InputChannel>& toChannel) = 0; 334 335 /* Registers or unregister input channels that may be used as targets for input events. 336 * If monitor is true, the channel will receive a copy of all input events. 337 * 338 * These methods may be called on any thread (usually by the input manager). 339 */ 340 virtual status_t registerInputChannel(const sp<InputChannel>& inputChannel, 341 const sp<InputWindowHandle>& inputWindowHandle, bool monitor) = 0; 342 virtual status_t unregisterInputChannel(const sp<InputChannel>& inputChannel) = 0; 343}; 344 345/* Dispatches events to input targets. Some functions of the input dispatcher, such as 346 * identifying input targets, are controlled by a separate policy object. 347 * 348 * IMPORTANT INVARIANT: 349 * Because the policy can potentially block or cause re-entrance into the input dispatcher, 350 * the input dispatcher never calls into the policy while holding its internal locks. 351 * The implementation is also carefully designed to recover from scenarios such as an 352 * input channel becoming unregistered while identifying input targets or processing timeouts. 353 * 354 * Methods marked 'Locked' must be called with the lock acquired. 355 * 356 * Methods marked 'LockedInterruptible' must be called with the lock acquired but 357 * may during the course of their execution release the lock, call into the policy, and 358 * then reacquire the lock. The caller is responsible for recovering gracefully. 359 * 360 * A 'LockedInterruptible' method may called a 'Locked' method, but NOT vice-versa. 361 */ 362class InputDispatcher : public InputDispatcherInterface { 363protected: 364 virtual ~InputDispatcher(); 365 366public: 367 explicit InputDispatcher(const sp<InputDispatcherPolicyInterface>& policy); 368 369 virtual void dump(String8& dump); 370 virtual void monitor(); 371 372 virtual void dispatchOnce(); 373 374 virtual void notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args); 375 virtual void notifyKey(const NotifyKeyArgs* args); 376 virtual void notifyMotion(const NotifyMotionArgs* args); 377 virtual void notifySwitch(const NotifySwitchArgs* args); 378 virtual void notifyDeviceReset(const NotifyDeviceResetArgs* args); 379 380 virtual int32_t injectInputEvent(const InputEvent* event, 381 int32_t injectorPid, int32_t injectorUid, int32_t syncMode, int32_t timeoutMillis, 382 uint32_t policyFlags); 383 384 virtual void setInputWindows(const Vector<sp<InputWindowHandle> >& inputWindowHandles); 385 virtual void setFocusedApplication(const sp<InputApplicationHandle>& inputApplicationHandle); 386 virtual void setInputDispatchMode(bool enabled, bool frozen); 387 virtual void setInputFilterEnabled(bool enabled); 388 389 virtual bool transferTouchFocus(const sp<InputChannel>& fromChannel, 390 const sp<InputChannel>& toChannel); 391 392 virtual status_t registerInputChannel(const sp<InputChannel>& inputChannel, 393 const sp<InputWindowHandle>& inputWindowHandle, bool monitor); 394 virtual status_t unregisterInputChannel(const sp<InputChannel>& inputChannel); 395 396private: 397 template <typename T> 398 struct Link { 399 T* next; 400 T* prev; 401 402 protected: 403 inline Link() : next(NULL), prev(NULL) { } 404 }; 405 406 struct InjectionState { 407 mutable int32_t refCount; 408 409 int32_t injectorPid; 410 int32_t injectorUid; 411 int32_t injectionResult; // initially INPUT_EVENT_INJECTION_PENDING 412 bool injectionIsAsync; // set to true if injection is not waiting for the result 413 int32_t pendingForegroundDispatches; // the number of foreground dispatches in progress 414 415 InjectionState(int32_t injectorPid, int32_t injectorUid); 416 void release(); 417 418 private: 419 ~InjectionState(); 420 }; 421 422 struct EventEntry : Link<EventEntry> { 423 enum { 424 TYPE_CONFIGURATION_CHANGED, 425 TYPE_DEVICE_RESET, 426 TYPE_KEY, 427 TYPE_MOTION 428 }; 429 430 mutable int32_t refCount; 431 int32_t type; 432 nsecs_t eventTime; 433 uint32_t policyFlags; 434 InjectionState* injectionState; 435 436 bool dispatchInProgress; // initially false, set to true while dispatching 437 438 inline bool isInjected() const { return injectionState != NULL; } 439 440 void release(); 441 442 protected: 443 EventEntry(int32_t type, nsecs_t eventTime, uint32_t policyFlags); 444 virtual ~EventEntry(); 445 void releaseInjectionState(); 446 }; 447 448 struct ConfigurationChangedEntry : EventEntry { 449 ConfigurationChangedEntry(nsecs_t eventTime); 450 451 protected: 452 virtual ~ConfigurationChangedEntry(); 453 }; 454 455 struct DeviceResetEntry : EventEntry { 456 int32_t deviceId; 457 458 DeviceResetEntry(nsecs_t eventTime, int32_t deviceId); 459 460 protected: 461 virtual ~DeviceResetEntry(); 462 }; 463 464 struct KeyEntry : EventEntry { 465 int32_t deviceId; 466 uint32_t source; 467 int32_t action; 468 int32_t flags; 469 int32_t keyCode; 470 int32_t scanCode; 471 int32_t metaState; 472 int32_t repeatCount; 473 nsecs_t downTime; 474 475 bool syntheticRepeat; // set to true for synthetic key repeats 476 477 enum InterceptKeyResult { 478 INTERCEPT_KEY_RESULT_UNKNOWN, 479 INTERCEPT_KEY_RESULT_SKIP, 480 INTERCEPT_KEY_RESULT_CONTINUE, 481 INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER, 482 }; 483 InterceptKeyResult interceptKeyResult; // set based on the interception result 484 nsecs_t interceptKeyWakeupTime; // used with INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER 485 486 KeyEntry(nsecs_t eventTime, 487 int32_t deviceId, uint32_t source, uint32_t policyFlags, int32_t action, 488 int32_t flags, int32_t keyCode, int32_t scanCode, int32_t metaState, 489 int32_t repeatCount, nsecs_t downTime); 490 void recycle(); 491 492 protected: 493 virtual ~KeyEntry(); 494 }; 495 496 struct MotionEntry : EventEntry { 497 nsecs_t eventTime; 498 int32_t deviceId; 499 uint32_t source; 500 int32_t action; 501 int32_t flags; 502 int32_t metaState; 503 int32_t buttonState; 504 int32_t edgeFlags; 505 float xPrecision; 506 float yPrecision; 507 nsecs_t downTime; 508 uint32_t pointerCount; 509 PointerProperties pointerProperties[MAX_POINTERS]; 510 PointerCoords pointerCoords[MAX_POINTERS]; 511 512 MotionEntry(nsecs_t eventTime, 513 int32_t deviceId, uint32_t source, uint32_t policyFlags, int32_t action, 514 int32_t flags, int32_t metaState, int32_t buttonState, int32_t edgeFlags, 515 float xPrecision, float yPrecision, 516 nsecs_t downTime, uint32_t pointerCount, 517 const PointerProperties* pointerProperties, const PointerCoords* pointerCoords); 518 519 protected: 520 virtual ~MotionEntry(); 521 }; 522 523 // Tracks the progress of dispatching a particular event to a particular connection. 524 struct DispatchEntry : Link<DispatchEntry> { 525 EventEntry* eventEntry; // the event to dispatch 526 int32_t targetFlags; 527 float xOffset; 528 float yOffset; 529 float scaleFactor; 530 531 // True if dispatch has started. 532 bool inProgress; 533 534 // Set to the resolved action and flags when the event is enqueued. 535 int32_t resolvedAction; 536 int32_t resolvedFlags; 537 538 DispatchEntry(EventEntry* eventEntry, 539 int32_t targetFlags, float xOffset, float yOffset, float scaleFactor); 540 ~DispatchEntry(); 541 542 inline bool hasForegroundTarget() const { 543 return targetFlags & InputTarget::FLAG_FOREGROUND; 544 } 545 546 inline bool isSplit() const { 547 return targetFlags & InputTarget::FLAG_SPLIT; 548 } 549 }; 550 551 // A command entry captures state and behavior for an action to be performed in the 552 // dispatch loop after the initial processing has taken place. It is essentially 553 // a kind of continuation used to postpone sensitive policy interactions to a point 554 // in the dispatch loop where it is safe to release the lock (generally after finishing 555 // the critical parts of the dispatch cycle). 556 // 557 // The special thing about commands is that they can voluntarily release and reacquire 558 // the dispatcher lock at will. Initially when the command starts running, the 559 // dispatcher lock is held. However, if the command needs to call into the policy to 560 // do some work, it can release the lock, do the work, then reacquire the lock again 561 // before returning. 562 // 563 // This mechanism is a bit clunky but it helps to preserve the invariant that the dispatch 564 // never calls into the policy while holding its lock. 565 // 566 // Commands are implicitly 'LockedInterruptible'. 567 struct CommandEntry; 568 typedef void (InputDispatcher::*Command)(CommandEntry* commandEntry); 569 570 class Connection; 571 struct CommandEntry : Link<CommandEntry> { 572 CommandEntry(Command command); 573 ~CommandEntry(); 574 575 Command command; 576 577 // parameters for the command (usage varies by command) 578 sp<Connection> connection; 579 nsecs_t eventTime; 580 KeyEntry* keyEntry; 581 sp<InputApplicationHandle> inputApplicationHandle; 582 sp<InputWindowHandle> inputWindowHandle; 583 int32_t userActivityEventType; 584 bool handled; 585 }; 586 587 // Generic queue implementation. 588 template <typename T> 589 struct Queue { 590 T* head; 591 T* tail; 592 593 inline Queue() : head(NULL), tail(NULL) { 594 } 595 596 inline bool isEmpty() const { 597 return !head; 598 } 599 600 inline void enqueueAtTail(T* entry) { 601 entry->prev = tail; 602 if (tail) { 603 tail->next = entry; 604 } else { 605 head = entry; 606 } 607 entry->next = NULL; 608 tail = entry; 609 } 610 611 inline void enqueueAtHead(T* entry) { 612 entry->next = head; 613 if (head) { 614 head->prev = entry; 615 } else { 616 tail = entry; 617 } 618 entry->prev = NULL; 619 head = entry; 620 } 621 622 inline void dequeue(T* entry) { 623 if (entry->prev) { 624 entry->prev->next = entry->next; 625 } else { 626 head = entry->next; 627 } 628 if (entry->next) { 629 entry->next->prev = entry->prev; 630 } else { 631 tail = entry->prev; 632 } 633 } 634 635 inline T* dequeueAtHead() { 636 T* entry = head; 637 head = entry->next; 638 if (head) { 639 head->prev = NULL; 640 } else { 641 tail = NULL; 642 } 643 return entry; 644 } 645 646 uint32_t count() const; 647 }; 648 649 /* Specifies which events are to be canceled and why. */ 650 struct CancelationOptions { 651 enum Mode { 652 CANCEL_ALL_EVENTS = 0, 653 CANCEL_POINTER_EVENTS = 1, 654 CANCEL_NON_POINTER_EVENTS = 2, 655 CANCEL_FALLBACK_EVENTS = 3, 656 }; 657 658 // The criterion to use to determine which events should be canceled. 659 Mode mode; 660 661 // Descriptive reason for the cancelation. 662 const char* reason; 663 664 // The specific keycode of the key event to cancel, or -1 to cancel any key event. 665 int32_t keyCode; 666 667 // The specific device id of events to cancel, or -1 to cancel events from any device. 668 int32_t deviceId; 669 670 CancelationOptions(Mode mode, const char* reason) : 671 mode(mode), reason(reason), keyCode(-1), deviceId(-1) { } 672 }; 673 674 /* Tracks dispatched key and motion event state so that cancelation events can be 675 * synthesized when events are dropped. */ 676 class InputState { 677 public: 678 InputState(); 679 ~InputState(); 680 681 // Returns true if there is no state to be canceled. 682 bool isNeutral() const; 683 684 // Returns true if the specified source is known to have received a hover enter 685 // motion event. 686 bool isHovering(int32_t deviceId, uint32_t source) const; 687 688 // Records tracking information for a key event that has just been published. 689 // Returns true if the event should be delivered, false if it is inconsistent 690 // and should be skipped. 691 bool trackKey(const KeyEntry* entry, int32_t action, int32_t flags); 692 693 // Records tracking information for a motion event that has just been published. 694 // Returns true if the event should be delivered, false if it is inconsistent 695 // and should be skipped. 696 bool trackMotion(const MotionEntry* entry, int32_t action, int32_t flags); 697 698 // Synthesizes cancelation events for the current state and resets the tracked state. 699 void synthesizeCancelationEvents(nsecs_t currentTime, 700 Vector<EventEntry*>& outEvents, const CancelationOptions& options); 701 702 // Clears the current state. 703 void clear(); 704 705 // Copies pointer-related parts of the input state to another instance. 706 void copyPointerStateTo(InputState& other) const; 707 708 // Gets the fallback key associated with a keycode. 709 // Returns -1 if none. 710 // Returns AKEYCODE_UNKNOWN if we are only dispatching the unhandled key to the policy. 711 int32_t getFallbackKey(int32_t originalKeyCode); 712 713 // Sets the fallback key for a particular keycode. 714 void setFallbackKey(int32_t originalKeyCode, int32_t fallbackKeyCode); 715 716 // Removes the fallback key for a particular keycode. 717 void removeFallbackKey(int32_t originalKeyCode); 718 719 inline const KeyedVector<int32_t, int32_t>& getFallbackKeys() const { 720 return mFallbackKeys; 721 } 722 723 private: 724 struct KeyMemento { 725 int32_t deviceId; 726 uint32_t source; 727 int32_t keyCode; 728 int32_t scanCode; 729 int32_t flags; 730 nsecs_t downTime; 731 }; 732 733 struct MotionMemento { 734 int32_t deviceId; 735 uint32_t source; 736 int32_t flags; 737 float xPrecision; 738 float yPrecision; 739 nsecs_t downTime; 740 uint32_t pointerCount; 741 PointerProperties pointerProperties[MAX_POINTERS]; 742 PointerCoords pointerCoords[MAX_POINTERS]; 743 bool hovering; 744 745 void setPointers(const MotionEntry* entry); 746 }; 747 748 Vector<KeyMemento> mKeyMementos; 749 Vector<MotionMemento> mMotionMementos; 750 KeyedVector<int32_t, int32_t> mFallbackKeys; 751 752 ssize_t findKeyMemento(const KeyEntry* entry) const; 753 ssize_t findMotionMemento(const MotionEntry* entry, bool hovering) const; 754 755 void addKeyMemento(const KeyEntry* entry, int32_t flags); 756 void addMotionMemento(const MotionEntry* entry, int32_t flags, bool hovering); 757 758 static bool shouldCancelKey(const KeyMemento& memento, 759 const CancelationOptions& options); 760 static bool shouldCancelMotion(const MotionMemento& memento, 761 const CancelationOptions& options); 762 }; 763 764 /* Manages the dispatch state associated with a single input channel. */ 765 class Connection : public RefBase { 766 protected: 767 virtual ~Connection(); 768 769 public: 770 enum Status { 771 // Everything is peachy. 772 STATUS_NORMAL, 773 // An unrecoverable communication error has occurred. 774 STATUS_BROKEN, 775 // The input channel has been unregistered. 776 STATUS_ZOMBIE 777 }; 778 779 Status status; 780 sp<InputChannel> inputChannel; // never null 781 sp<InputWindowHandle> inputWindowHandle; // may be null 782 bool monitor; 783 InputPublisher inputPublisher; 784 InputState inputState; 785 Queue<DispatchEntry> outboundQueue; 786 787 nsecs_t lastEventTime; // the time when the event was originally captured 788 nsecs_t lastDispatchTime; // the time when the last event was dispatched 789 790 explicit Connection(const sp<InputChannel>& inputChannel, 791 const sp<InputWindowHandle>& inputWindowHandle, bool monitor); 792 793 inline const char* getInputChannelName() const { return inputChannel->getName().string(); } 794 795 const char* getStatusLabel() const; 796 797 // Finds a DispatchEntry in the outbound queue associated with the specified event. 798 // Returns NULL if not found. 799 DispatchEntry* findQueuedDispatchEntryForEvent(const EventEntry* eventEntry) const; 800 801 // Gets the time since the current event was originally obtained from the input driver. 802 inline double getEventLatencyMillis(nsecs_t currentTime) const { 803 return (currentTime - lastEventTime) / 1000000.0; 804 } 805 806 // Gets the time since the current event entered the outbound dispatch queue. 807 inline double getDispatchLatencyMillis(nsecs_t currentTime) const { 808 return (currentTime - lastDispatchTime) / 1000000.0; 809 } 810 }; 811 812 enum DropReason { 813 DROP_REASON_NOT_DROPPED = 0, 814 DROP_REASON_POLICY = 1, 815 DROP_REASON_APP_SWITCH = 2, 816 DROP_REASON_DISABLED = 3, 817 DROP_REASON_BLOCKED = 4, 818 DROP_REASON_STALE = 5, 819 }; 820 821 sp<InputDispatcherPolicyInterface> mPolicy; 822 InputDispatcherConfiguration mConfig; 823 824 Mutex mLock; 825 826 Condition mDispatcherIsAliveCondition; 827 828 sp<Looper> mLooper; 829 830 EventEntry* mPendingEvent; 831 Queue<EventEntry> mInboundQueue; 832 Queue<CommandEntry> mCommandQueue; 833 834 Vector<EventEntry*> mTempCancelationEvents; 835 836 void dispatchOnceInnerLocked(nsecs_t* nextWakeupTime); 837 838 // Enqueues an inbound event. Returns true if mLooper->wake() should be called. 839 bool enqueueInboundEventLocked(EventEntry* entry); 840 841 // Cleans up input state when dropping an inbound event. 842 void dropInboundEventLocked(EventEntry* entry, DropReason dropReason); 843 844 // App switch latency optimization. 845 bool mAppSwitchSawKeyDown; 846 nsecs_t mAppSwitchDueTime; 847 848 static bool isAppSwitchKeyCode(int32_t keyCode); 849 bool isAppSwitchKeyEventLocked(KeyEntry* keyEntry); 850 bool isAppSwitchPendingLocked(); 851 void resetPendingAppSwitchLocked(bool handled); 852 853 // Stale event latency optimization. 854 static bool isStaleEventLocked(nsecs_t currentTime, EventEntry* entry); 855 856 // Blocked event latency optimization. Drops old events when the user intends 857 // to transfer focus to a new application. 858 EventEntry* mNextUnblockedEvent; 859 860 sp<InputWindowHandle> findTouchedWindowAtLocked(int32_t x, int32_t y); 861 862 // All registered connections mapped by channel file descriptor. 863 KeyedVector<int, sp<Connection> > mConnectionsByFd; 864 865 ssize_t getConnectionIndexLocked(const sp<InputChannel>& inputChannel); 866 867 // Input channels that will receive a copy of all input events. 868 Vector<sp<InputChannel> > mMonitoringChannels; 869 870 // Event injection and synchronization. 871 Condition mInjectionResultAvailableCondition; 872 bool hasInjectionPermission(int32_t injectorPid, int32_t injectorUid); 873 void setInjectionResultLocked(EventEntry* entry, int32_t injectionResult); 874 875 Condition mInjectionSyncFinishedCondition; 876 void incrementPendingForegroundDispatchesLocked(EventEntry* entry); 877 void decrementPendingForegroundDispatchesLocked(EventEntry* entry); 878 879 // Key repeat tracking. 880 struct KeyRepeatState { 881 KeyEntry* lastKeyEntry; // or null if no repeat 882 nsecs_t nextRepeatTime; 883 } mKeyRepeatState; 884 885 void resetKeyRepeatLocked(); 886 KeyEntry* synthesizeKeyRepeatLocked(nsecs_t currentTime); 887 888 // Deferred command processing. 889 bool runCommandsLockedInterruptible(); 890 CommandEntry* postCommandLocked(Command command); 891 892 // Inbound event processing. 893 void drainInboundQueueLocked(); 894 void releasePendingEventLocked(); 895 void releaseInboundEventLocked(EventEntry* entry); 896 897 // Dispatch state. 898 bool mDispatchEnabled; 899 bool mDispatchFrozen; 900 bool mInputFilterEnabled; 901 902 Vector<sp<InputWindowHandle> > mWindowHandles; 903 904 sp<InputWindowHandle> getWindowHandleLocked(const sp<InputChannel>& inputChannel) const; 905 bool hasWindowHandleLocked(const sp<InputWindowHandle>& windowHandle) const; 906 907 // Focus tracking for keys, trackball, etc. 908 sp<InputWindowHandle> mFocusedWindowHandle; 909 910 // Focus tracking for touch. 911 struct TouchedWindow { 912 sp<InputWindowHandle> windowHandle; 913 int32_t targetFlags; 914 BitSet32 pointerIds; // zero unless target flag FLAG_SPLIT is set 915 }; 916 struct TouchState { 917 bool down; 918 bool split; 919 int32_t deviceId; // id of the device that is currently down, others are rejected 920 uint32_t source; // source of the device that is current down, others are rejected 921 Vector<TouchedWindow> windows; 922 923 TouchState(); 924 ~TouchState(); 925 void reset(); 926 void copyFrom(const TouchState& other); 927 void addOrUpdateWindow(const sp<InputWindowHandle>& windowHandle, 928 int32_t targetFlags, BitSet32 pointerIds); 929 void filterNonAsIsTouchWindows(); 930 sp<InputWindowHandle> getFirstForegroundWindowHandle() const; 931 bool isSlippery() const; 932 }; 933 934 TouchState mTouchState; 935 TouchState mTempTouchState; 936 937 // Focused application. 938 sp<InputApplicationHandle> mFocusedApplicationHandle; 939 940 // Dispatch inbound events. 941 bool dispatchConfigurationChangedLocked( 942 nsecs_t currentTime, ConfigurationChangedEntry* entry); 943 bool dispatchDeviceResetLocked( 944 nsecs_t currentTime, DeviceResetEntry* entry); 945 bool dispatchKeyLocked( 946 nsecs_t currentTime, KeyEntry* entry, 947 DropReason* dropReason, nsecs_t* nextWakeupTime); 948 bool dispatchMotionLocked( 949 nsecs_t currentTime, MotionEntry* entry, 950 DropReason* dropReason, nsecs_t* nextWakeupTime); 951 void dispatchEventLocked(nsecs_t currentTime, EventEntry* entry, 952 const Vector<InputTarget>& inputTargets); 953 954 void logOutboundKeyDetailsLocked(const char* prefix, const KeyEntry* entry); 955 void logOutboundMotionDetailsLocked(const char* prefix, const MotionEntry* entry); 956 957 // Keeping track of ANR timeouts. 958 enum InputTargetWaitCause { 959 INPUT_TARGET_WAIT_CAUSE_NONE, 960 INPUT_TARGET_WAIT_CAUSE_SYSTEM_NOT_READY, 961 INPUT_TARGET_WAIT_CAUSE_APPLICATION_NOT_READY, 962 }; 963 964 InputTargetWaitCause mInputTargetWaitCause; 965 nsecs_t mInputTargetWaitStartTime; 966 nsecs_t mInputTargetWaitTimeoutTime; 967 bool mInputTargetWaitTimeoutExpired; 968 sp<InputApplicationHandle> mInputTargetWaitApplicationHandle; 969 970 // Contains the last window which received a hover event. 971 sp<InputWindowHandle> mLastHoverWindowHandle; 972 973 // Finding targets for input events. 974 int32_t handleTargetsNotReadyLocked(nsecs_t currentTime, const EventEntry* entry, 975 const sp<InputApplicationHandle>& applicationHandle, 976 const sp<InputWindowHandle>& windowHandle, 977 nsecs_t* nextWakeupTime); 978 void resumeAfterTargetsNotReadyTimeoutLocked(nsecs_t newTimeout, 979 const sp<InputChannel>& inputChannel); 980 nsecs_t getTimeSpentWaitingForApplicationLocked(nsecs_t currentTime); 981 void resetANRTimeoutsLocked(); 982 983 int32_t findFocusedWindowTargetsLocked(nsecs_t currentTime, const EventEntry* entry, 984 Vector<InputTarget>& inputTargets, nsecs_t* nextWakeupTime); 985 int32_t findTouchedWindowTargetsLocked(nsecs_t currentTime, const MotionEntry* entry, 986 Vector<InputTarget>& inputTargets, nsecs_t* nextWakeupTime, 987 bool* outConflictingPointerActions); 988 989 void addWindowTargetLocked(const sp<InputWindowHandle>& windowHandle, 990 int32_t targetFlags, BitSet32 pointerIds, Vector<InputTarget>& inputTargets); 991 void addMonitoringTargetsLocked(Vector<InputTarget>& inputTargets); 992 993 void pokeUserActivityLocked(const EventEntry* eventEntry); 994 bool checkInjectionPermission(const sp<InputWindowHandle>& windowHandle, 995 const InjectionState* injectionState); 996 bool isWindowObscuredAtPointLocked(const sp<InputWindowHandle>& windowHandle, 997 int32_t x, int32_t y) const; 998 bool isWindowFinishedWithPreviousInputLocked(const sp<InputWindowHandle>& windowHandle); 999 String8 getApplicationWindowLabelLocked(const sp<InputApplicationHandle>& applicationHandle, 1000 const sp<InputWindowHandle>& windowHandle); 1001 1002 // Manage the dispatch cycle for a single connection. 1003 // These methods are deliberately not Interruptible because doing all of the work 1004 // with the mutex held makes it easier to ensure that connection invariants are maintained. 1005 // If needed, the methods post commands to run later once the critical bits are done. 1006 void prepareDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection, 1007 EventEntry* eventEntry, const InputTarget* inputTarget); 1008 void enqueueDispatchEntriesLocked(nsecs_t currentTime, const sp<Connection>& connection, 1009 EventEntry* eventEntry, const InputTarget* inputTarget); 1010 void enqueueDispatchEntryLocked(const sp<Connection>& connection, 1011 EventEntry* eventEntry, const InputTarget* inputTarget, int32_t dispatchMode); 1012 void startDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection); 1013 void finishDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection, 1014 bool handled); 1015 void startNextDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection); 1016 void abortBrokenDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection, 1017 bool notify); 1018 void drainOutboundQueueLocked(Connection* connection); 1019 static int handleReceiveCallback(int fd, int events, void* data); 1020 1021 void synthesizeCancelationEventsForAllConnectionsLocked( 1022 const CancelationOptions& options); 1023 void synthesizeCancelationEventsForInputChannelLocked(const sp<InputChannel>& channel, 1024 const CancelationOptions& options); 1025 void synthesizeCancelationEventsForConnectionLocked(const sp<Connection>& connection, 1026 const CancelationOptions& options); 1027 1028 // Splitting motion events across windows. 1029 MotionEntry* splitMotionEvent(const MotionEntry* originalMotionEntry, BitSet32 pointerIds); 1030 1031 // Reset and drop everything the dispatcher is doing. 1032 void resetAndDropEverythingLocked(const char* reason); 1033 1034 // Dump state. 1035 void dumpDispatchStateLocked(String8& dump); 1036 void logDispatchStateLocked(); 1037 1038 // Registration. 1039 void removeMonitorChannelLocked(const sp<InputChannel>& inputChannel); 1040 status_t unregisterInputChannelLocked(const sp<InputChannel>& inputChannel, bool notify); 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, bool handled); 1051 void onDispatchCycleBrokenLocked( 1052 nsecs_t currentTime, const sp<Connection>& connection); 1053 void onANRLocked( 1054 nsecs_t currentTime, const sp<InputApplicationHandle>& applicationHandle, 1055 const sp<InputWindowHandle>& windowHandle, 1056 nsecs_t eventTime, nsecs_t waitStartTime); 1057 1058 // Outbound policy interactions. 1059 void doNotifyConfigurationChangedInterruptible(CommandEntry* commandEntry); 1060 void doNotifyInputChannelBrokenLockedInterruptible(CommandEntry* commandEntry); 1061 void doNotifyANRLockedInterruptible(CommandEntry* commandEntry); 1062 void doInterceptKeyBeforeDispatchingLockedInterruptible(CommandEntry* commandEntry); 1063 void doDispatchCycleFinishedLockedInterruptible(CommandEntry* commandEntry); 1064 bool afterKeyEventLockedInterruptible(const sp<Connection>& connection, 1065 DispatchEntry* dispatchEntry, KeyEntry* keyEntry, bool handled); 1066 bool afterMotionEventLockedInterruptible(const sp<Connection>& connection, 1067 DispatchEntry* dispatchEntry, MotionEntry* motionEntry, bool handled); 1068 void doPokeUserActivityLockedInterruptible(CommandEntry* commandEntry); 1069 void initializeKeyEvent(KeyEvent* event, const KeyEntry* entry); 1070 1071 // Statistics gathering. 1072 void updateDispatchStatisticsLocked(nsecs_t currentTime, const EventEntry* entry, 1073 int32_t injectionResult, nsecs_t timeSpentWaitingForApplication); 1074}; 1075 1076/* Enqueues and dispatches input events, endlessly. */ 1077class InputDispatcherThread : public Thread { 1078public: 1079 explicit InputDispatcherThread(const sp<InputDispatcherInterface>& dispatcher); 1080 ~InputDispatcherThread(); 1081 1082private: 1083 virtual bool threadLoop(); 1084 1085 sp<InputDispatcherInterface> mDispatcher; 1086}; 1087 1088} // namespace android 1089 1090#endif // _UI_INPUT_DISPATCHER_H 1091