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