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