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