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_READER_H 18 #define _UI_INPUT_READER_H 19 20 #include "EventHub.h" 21 #include "PointerControllerInterface.h" 22 #include "InputListener.h" 23 24 #include <input/DisplayViewport.h> 25 #include <input/Input.h> 26 #include <input/VelocityControl.h> 27 #include <input/VelocityTracker.h> 28 #include <ui/DisplayInfo.h> 29 #include <utils/KeyedVector.h> 30 #include <utils/Condition.h> 31 #include <utils/Thread.h> 32 #include <utils/Mutex.h> 33 #include <utils/Timers.h> 34 #include <utils/RefBase.h> 35 #include <utils/String8.h> 36 #include <utils/BitSet.h> 37 #include <utils/SortedVector.h> 38 39 #include <stddef.h> 40 #include <unistd.h> 41 42 // Maximum supported size of a vibration pattern. 43 // Must be at least 2. 44 #define MAX_VIBRATE_PATTERN_SIZE 100 45 46 // Maximum allowable delay value in a vibration pattern before 47 // which the delay will be truncated. 48 #define MAX_VIBRATE_PATTERN_DELAY_NSECS (1000000 * 1000000000LL) 49 50 namespace android { 51 52 class InputDevice; 53 class InputMapper; 54 55 /* 56 * Input reader configuration. 57 * 58 * Specifies various options that modify the behavior of the input reader. 59 */ 60 struct InputReaderConfiguration { 61 // Describes changes that have occurred. 62 enum { 63 // The pointer speed changed. 64 CHANGE_POINTER_SPEED = 1 << 0, 65 66 // The pointer gesture control changed. 67 CHANGE_POINTER_GESTURE_ENABLEMENT = 1 << 1, 68 69 // The display size or orientation changed. 70 CHANGE_DISPLAY_INFO = 1 << 2, 71 72 // The visible touches option changed. 73 CHANGE_SHOW_TOUCHES = 1 << 3, 74 75 // The keyboard layouts must be reloaded. 76 CHANGE_KEYBOARD_LAYOUTS = 1 << 4, 77 78 // The device name alias supplied by the may have changed for some devices. 79 CHANGE_DEVICE_ALIAS = 1 << 5, 80 81 // The location calibration matrix changed. 82 CHANGE_TOUCH_AFFINE_TRANSFORMATION = 1 << 6, 83 84 // The presence of an external stylus has changed. 85 CHANGE_EXTERNAL_STYLUS_PRESENCE = 1 << 7, 86 87 // The pointer capture mode has changed. 88 CHANGE_POINTER_CAPTURE = 1 << 8, 89 90 // The set of disabled input devices (disabledDevices) has changed. 91 CHANGE_ENABLED_STATE = 1 << 9, 92 93 // All devices must be reopened. 94 CHANGE_MUST_REOPEN = 1 << 31, 95 }; 96 97 // Gets the amount of time to disable virtual keys after the screen is touched 98 // in order to filter out accidental virtual key presses due to swiping gestures 99 // or taps near the edge of the display. May be 0 to disable the feature. 100 nsecs_t virtualKeyQuietTime; 101 102 // The excluded device names for the platform. 103 // Devices with these names will be ignored. 104 Vector<String8> excludedDeviceNames; 105 106 // Velocity control parameters for mouse pointer movements. 107 VelocityControlParameters pointerVelocityControlParameters; 108 109 // Velocity control parameters for mouse wheel movements. 110 VelocityControlParameters wheelVelocityControlParameters; 111 112 // True if pointer gestures are enabled. 113 bool pointerGesturesEnabled; 114 115 // Quiet time between certain pointer gesture transitions. 116 // Time to allow for all fingers or buttons to settle into a stable state before 117 // starting a new gesture. 118 nsecs_t pointerGestureQuietInterval; 119 120 // The minimum speed that a pointer must travel for us to consider switching the active 121 // touch pointer to it during a drag. This threshold is set to avoid switching due 122 // to noise from a finger resting on the touch pad (perhaps just pressing it down). 123 float pointerGestureDragMinSwitchSpeed; // in pixels per second 124 125 // Tap gesture delay time. 126 // The time between down and up must be less than this to be considered a tap. 127 nsecs_t pointerGestureTapInterval; 128 129 // Tap drag gesture delay time. 130 // The time between the previous tap's up and the next down must be less than 131 // this to be considered a drag. Otherwise, the previous tap is finished and a 132 // new tap begins. 133 // 134 // Note that the previous tap will be held down for this entire duration so this 135 // interval must be shorter than the long press timeout. 136 nsecs_t pointerGestureTapDragInterval; 137 138 // The distance in pixels that the pointer is allowed to move from initial down 139 // to up and still be called a tap. 140 float pointerGestureTapSlop; // in pixels 141 142 // Time after the first touch points go down to settle on an initial centroid. 143 // This is intended to be enough time to handle cases where the user puts down two 144 // fingers at almost but not quite exactly the same time. 145 nsecs_t pointerGestureMultitouchSettleInterval; 146 147 // The transition from PRESS to SWIPE or FREEFORM gesture mode is made when 148 // at least two pointers have moved at least this far from their starting place. 149 float pointerGestureMultitouchMinDistance; // in pixels 150 151 // The transition from PRESS to SWIPE gesture mode can only occur when the 152 // cosine of the angle between the two vectors is greater than or equal to than this value 153 // which indicates that the vectors are oriented in the same direction. 154 // When the vectors are oriented in the exactly same direction, the cosine is 1.0. 155 // (In exactly opposite directions, the cosine is -1.0.) 156 float pointerGestureSwipeTransitionAngleCosine; 157 158 // The transition from PRESS to SWIPE gesture mode can only occur when the 159 // fingers are no more than this far apart relative to the diagonal size of 160 // the touch pad. For example, a ratio of 0.5 means that the fingers must be 161 // no more than half the diagonal size of the touch pad apart. 162 float pointerGestureSwipeMaxWidthRatio; 163 164 // The gesture movement speed factor relative to the size of the display. 165 // Movement speed applies when the fingers are moving in the same direction. 166 // Without acceleration, a full swipe of the touch pad diagonal in movement mode 167 // will cover this portion of the display diagonal. 168 float pointerGestureMovementSpeedRatio; 169 170 // The gesture zoom speed factor relative to the size of the display. 171 // Zoom speed applies when the fingers are mostly moving relative to each other 172 // to execute a scale gesture or similar. 173 // Without acceleration, a full swipe of the touch pad diagonal in zoom mode 174 // will cover this portion of the display diagonal. 175 float pointerGestureZoomSpeedRatio; 176 177 // True to show the location of touches on the touch screen as spots. 178 bool showTouches; 179 180 // True if pointer capture is enabled. 181 bool pointerCapture; 182 183 // The set of currently disabled input devices. 184 SortedVector<int32_t> disabledDevices; 185 InputReaderConfigurationInputReaderConfiguration186 InputReaderConfiguration() : 187 virtualKeyQuietTime(0), 188 pointerVelocityControlParameters(1.0f, 500.0f, 3000.0f, 3.0f), 189 wheelVelocityControlParameters(1.0f, 15.0f, 50.0f, 4.0f), 190 pointerGesturesEnabled(true), 191 pointerGestureQuietInterval(100 * 1000000LL), // 100 ms 192 pointerGestureDragMinSwitchSpeed(50), // 50 pixels per second 193 pointerGestureTapInterval(150 * 1000000LL), // 150 ms 194 pointerGestureTapDragInterval(150 * 1000000LL), // 150 ms 195 pointerGestureTapSlop(10.0f), // 10 pixels 196 pointerGestureMultitouchSettleInterval(100 * 1000000LL), // 100 ms 197 pointerGestureMultitouchMinDistance(15), // 15 pixels 198 pointerGestureSwipeTransitionAngleCosine(0.2588f), // cosine of 75 degrees 199 pointerGestureSwipeMaxWidthRatio(0.25f), 200 pointerGestureMovementSpeedRatio(0.8f), 201 pointerGestureZoomSpeedRatio(0.3f), 202 showTouches(false) { } 203 204 bool getDisplayViewport(ViewportType viewportType, const String8* displayId, 205 DisplayViewport* outViewport) const; 206 void setPhysicalDisplayViewport(ViewportType viewportType, const DisplayViewport& viewport); 207 void setVirtualDisplayViewports(const Vector<DisplayViewport>& viewports); 208 209 210 void dump(String8& dump) const; 211 void dumpViewport(String8& dump, const DisplayViewport& viewport) const; 212 213 private: 214 DisplayViewport mInternalDisplay; 215 DisplayViewport mExternalDisplay; 216 Vector<DisplayViewport> mVirtualDisplays; 217 }; 218 219 220 struct TouchAffineTransformation { 221 float x_scale; 222 float x_ymix; 223 float x_offset; 224 float y_xmix; 225 float y_scale; 226 float y_offset; 227 TouchAffineTransformationTouchAffineTransformation228 TouchAffineTransformation() : 229 x_scale(1.0f), x_ymix(0.0f), x_offset(0.0f), 230 y_xmix(0.0f), y_scale(1.0f), y_offset(0.0f) { 231 } 232 TouchAffineTransformationTouchAffineTransformation233 TouchAffineTransformation(float xscale, float xymix, float xoffset, 234 float yxmix, float yscale, float yoffset) : 235 x_scale(xscale), x_ymix(xymix), x_offset(xoffset), 236 y_xmix(yxmix), y_scale(yscale), y_offset(yoffset) { 237 } 238 239 void applyTo(float& x, float& y) const; 240 }; 241 242 243 /* 244 * Input reader policy interface. 245 * 246 * The input reader policy is used by the input reader to interact with the Window Manager 247 * and other system components. 248 * 249 * The actual implementation is partially supported by callbacks into the DVM 250 * via JNI. This interface is also mocked in the unit tests. 251 * 252 * These methods must NOT re-enter the input reader since they may be called while 253 * holding the input reader lock. 254 */ 255 class InputReaderPolicyInterface : public virtual RefBase { 256 protected: InputReaderPolicyInterface()257 InputReaderPolicyInterface() { } ~InputReaderPolicyInterface()258 virtual ~InputReaderPolicyInterface() { } 259 260 public: 261 /* Gets the input reader configuration. */ 262 virtual void getReaderConfiguration(InputReaderConfiguration* outConfig) = 0; 263 264 /* Gets a pointer controller associated with the specified cursor device (ie. a mouse). */ 265 virtual sp<PointerControllerInterface> obtainPointerController(int32_t deviceId) = 0; 266 267 /* Notifies the input reader policy that some input devices have changed 268 * and provides information about all current input devices. 269 */ 270 virtual void notifyInputDevicesChanged(const Vector<InputDeviceInfo>& inputDevices) = 0; 271 272 /* Gets the keyboard layout for a particular input device. */ 273 virtual sp<KeyCharacterMap> getKeyboardLayoutOverlay( 274 const InputDeviceIdentifier& identifier) = 0; 275 276 /* Gets a user-supplied alias for a particular input device, or an empty string if none. */ 277 virtual String8 getDeviceAlias(const InputDeviceIdentifier& identifier) = 0; 278 279 /* Gets the affine calibration associated with the specified device. */ 280 virtual TouchAffineTransformation getTouchAffineTransformation( 281 const String8& inputDeviceDescriptor, int32_t surfaceRotation) = 0; 282 }; 283 284 285 /* Processes raw input events and sends cooked event data to an input listener. */ 286 class InputReaderInterface : public virtual RefBase { 287 protected: InputReaderInterface()288 InputReaderInterface() { } ~InputReaderInterface()289 virtual ~InputReaderInterface() { } 290 291 public: 292 /* Dumps the state of the input reader. 293 * 294 * This method may be called on any thread (usually by the input manager). */ 295 virtual void dump(String8& dump) = 0; 296 297 /* Called by the heatbeat to ensures that the reader has not deadlocked. */ 298 virtual void monitor() = 0; 299 300 /* Returns true if the input device is enabled. */ 301 virtual bool isInputDeviceEnabled(int32_t deviceId) = 0; 302 303 /* Runs a single iteration of the processing loop. 304 * Nominally reads and processes one incoming message from the EventHub. 305 * 306 * This method should be called on the input reader thread. 307 */ 308 virtual void loopOnce() = 0; 309 310 /* Gets information about all input devices. 311 * 312 * This method may be called on any thread (usually by the input manager). 313 */ 314 virtual void getInputDevices(Vector<InputDeviceInfo>& outInputDevices) = 0; 315 316 /* Query current input state. */ 317 virtual int32_t getScanCodeState(int32_t deviceId, uint32_t sourceMask, 318 int32_t scanCode) = 0; 319 virtual int32_t getKeyCodeState(int32_t deviceId, uint32_t sourceMask, 320 int32_t keyCode) = 0; 321 virtual int32_t getSwitchState(int32_t deviceId, uint32_t sourceMask, 322 int32_t sw) = 0; 323 324 /* Toggle Caps Lock */ 325 virtual void toggleCapsLockState(int32_t deviceId) = 0; 326 327 /* Determine whether physical keys exist for the given framework-domain key codes. */ 328 virtual bool hasKeys(int32_t deviceId, uint32_t sourceMask, 329 size_t numCodes, const int32_t* keyCodes, uint8_t* outFlags) = 0; 330 331 /* Requests that a reconfiguration of all input devices. 332 * The changes flag is a bitfield that indicates what has changed and whether 333 * the input devices must all be reopened. */ 334 virtual void requestRefreshConfiguration(uint32_t changes) = 0; 335 336 /* Controls the vibrator of a particular input device. */ 337 virtual void vibrate(int32_t deviceId, const nsecs_t* pattern, size_t patternSize, 338 ssize_t repeat, int32_t token) = 0; 339 virtual void cancelVibrate(int32_t deviceId, int32_t token) = 0; 340 }; 341 342 struct StylusState { 343 /* Time the stylus event was received. */ 344 nsecs_t when; 345 /* Pressure as reported by the stylus, normalized to the range [0, 1.0]. */ 346 float pressure; 347 /* The state of the stylus buttons as a bitfield (e.g. AMOTION_EVENT_BUTTON_SECONDARY). */ 348 uint32_t buttons; 349 /* Which tool type the stylus is currently using (e.g. AMOTION_EVENT_TOOL_TYPE_ERASER). */ 350 int32_t toolType; 351 copyFromStylusState352 void copyFrom(const StylusState& other) { 353 when = other.when; 354 pressure = other.pressure; 355 buttons = other.buttons; 356 toolType = other.toolType; 357 } 358 clearStylusState359 void clear() { 360 when = LLONG_MAX; 361 pressure = 0.f; 362 buttons = 0; 363 toolType = AMOTION_EVENT_TOOL_TYPE_UNKNOWN; 364 } 365 }; 366 367 368 /* Internal interface used by individual input devices to access global input device state 369 * and parameters maintained by the input reader. 370 */ 371 class InputReaderContext { 372 public: InputReaderContext()373 InputReaderContext() { } ~InputReaderContext()374 virtual ~InputReaderContext() { } 375 376 virtual void updateGlobalMetaState() = 0; 377 virtual int32_t getGlobalMetaState() = 0; 378 379 virtual void disableVirtualKeysUntil(nsecs_t time) = 0; 380 virtual bool shouldDropVirtualKey(nsecs_t now, 381 InputDevice* device, int32_t keyCode, int32_t scanCode) = 0; 382 383 virtual void fadePointer() = 0; 384 385 virtual void requestTimeoutAtTime(nsecs_t when) = 0; 386 virtual int32_t bumpGeneration() = 0; 387 388 virtual void getExternalStylusDevices(Vector<InputDeviceInfo>& outDevices) = 0; 389 virtual void dispatchExternalStylusState(const StylusState& outState) = 0; 390 391 virtual InputReaderPolicyInterface* getPolicy() = 0; 392 virtual InputListenerInterface* getListener() = 0; 393 virtual EventHubInterface* getEventHub() = 0; 394 }; 395 396 397 /* The input reader reads raw event data from the event hub and processes it into input events 398 * that it sends to the input listener. Some functions of the input reader, such as early 399 * event filtering in low power states, are controlled by a separate policy object. 400 * 401 * The InputReader owns a collection of InputMappers. Most of the work it does happens 402 * on the input reader thread but the InputReader can receive queries from other system 403 * components running on arbitrary threads. To keep things manageable, the InputReader 404 * uses a single Mutex to guard its state. The Mutex may be held while calling into the 405 * EventHub or the InputReaderPolicy but it is never held while calling into the 406 * InputListener. 407 */ 408 class InputReader : public InputReaderInterface { 409 public: 410 InputReader(const sp<EventHubInterface>& eventHub, 411 const sp<InputReaderPolicyInterface>& policy, 412 const sp<InputListenerInterface>& listener); 413 virtual ~InputReader(); 414 415 virtual void dump(String8& dump); 416 virtual void monitor(); 417 418 virtual void loopOnce(); 419 420 virtual void getInputDevices(Vector<InputDeviceInfo>& outInputDevices); 421 422 virtual bool isInputDeviceEnabled(int32_t deviceId); 423 424 virtual int32_t getScanCodeState(int32_t deviceId, uint32_t sourceMask, 425 int32_t scanCode); 426 virtual int32_t getKeyCodeState(int32_t deviceId, uint32_t sourceMask, 427 int32_t keyCode); 428 virtual int32_t getSwitchState(int32_t deviceId, uint32_t sourceMask, 429 int32_t sw); 430 431 virtual void toggleCapsLockState(int32_t deviceId); 432 433 virtual bool hasKeys(int32_t deviceId, uint32_t sourceMask, 434 size_t numCodes, const int32_t* keyCodes, uint8_t* outFlags); 435 436 virtual void requestRefreshConfiguration(uint32_t changes); 437 438 virtual void vibrate(int32_t deviceId, const nsecs_t* pattern, size_t patternSize, 439 ssize_t repeat, int32_t token); 440 virtual void cancelVibrate(int32_t deviceId, int32_t token); 441 442 protected: 443 // These members are protected so they can be instrumented by test cases. 444 virtual InputDevice* createDeviceLocked(int32_t deviceId, int32_t controllerNumber, 445 const InputDeviceIdentifier& identifier, uint32_t classes); 446 447 class ContextImpl : public InputReaderContext { 448 InputReader* mReader; 449 450 public: 451 explicit ContextImpl(InputReader* reader); 452 453 virtual void updateGlobalMetaState(); 454 virtual int32_t getGlobalMetaState(); 455 virtual void disableVirtualKeysUntil(nsecs_t time); 456 virtual bool shouldDropVirtualKey(nsecs_t now, 457 InputDevice* device, int32_t keyCode, int32_t scanCode); 458 virtual void fadePointer(); 459 virtual void requestTimeoutAtTime(nsecs_t when); 460 virtual int32_t bumpGeneration(); 461 virtual void getExternalStylusDevices(Vector<InputDeviceInfo>& outDevices); 462 virtual void dispatchExternalStylusState(const StylusState& outState); 463 virtual InputReaderPolicyInterface* getPolicy(); 464 virtual InputListenerInterface* getListener(); 465 virtual EventHubInterface* getEventHub(); 466 } mContext; 467 468 friend class ContextImpl; 469 470 private: 471 Mutex mLock; 472 473 Condition mReaderIsAliveCondition; 474 475 sp<EventHubInterface> mEventHub; 476 sp<InputReaderPolicyInterface> mPolicy; 477 sp<QueuedInputListener> mQueuedListener; 478 479 InputReaderConfiguration mConfig; 480 481 // The event queue. 482 static const int EVENT_BUFFER_SIZE = 256; 483 RawEvent mEventBuffer[EVENT_BUFFER_SIZE]; 484 485 KeyedVector<int32_t, InputDevice*> mDevices; 486 487 // low-level input event decoding and device management 488 void processEventsLocked(const RawEvent* rawEvents, size_t count); 489 490 void addDeviceLocked(nsecs_t when, int32_t deviceId); 491 void removeDeviceLocked(nsecs_t when, int32_t deviceId); 492 void processEventsForDeviceLocked(int32_t deviceId, const RawEvent* rawEvents, size_t count); 493 void timeoutExpiredLocked(nsecs_t when); 494 495 void handleConfigurationChangedLocked(nsecs_t when); 496 497 int32_t mGlobalMetaState; 498 void updateGlobalMetaStateLocked(); 499 int32_t getGlobalMetaStateLocked(); 500 501 void notifyExternalStylusPresenceChanged(); 502 void getExternalStylusDevicesLocked(Vector<InputDeviceInfo>& outDevices); 503 void dispatchExternalStylusState(const StylusState& state); 504 505 void fadePointerLocked(); 506 507 int32_t mGeneration; 508 int32_t bumpGenerationLocked(); 509 510 void getInputDevicesLocked(Vector<InputDeviceInfo>& outInputDevices); 511 512 nsecs_t mDisableVirtualKeysTimeout; 513 void disableVirtualKeysUntilLocked(nsecs_t time); 514 bool shouldDropVirtualKeyLocked(nsecs_t now, 515 InputDevice* device, int32_t keyCode, int32_t scanCode); 516 517 nsecs_t mNextTimeout; 518 void requestTimeoutAtTimeLocked(nsecs_t when); 519 520 uint32_t mConfigurationChangesToRefresh; 521 void refreshConfigurationLocked(uint32_t changes); 522 523 // state queries 524 typedef int32_t (InputDevice::*GetStateFunc)(uint32_t sourceMask, int32_t code); 525 int32_t getStateLocked(int32_t deviceId, uint32_t sourceMask, int32_t code, 526 GetStateFunc getStateFunc); 527 bool markSupportedKeyCodesLocked(int32_t deviceId, uint32_t sourceMask, size_t numCodes, 528 const int32_t* keyCodes, uint8_t* outFlags); 529 }; 530 531 532 /* Reads raw events from the event hub and processes them, endlessly. */ 533 class InputReaderThread : public Thread { 534 public: 535 explicit InputReaderThread(const sp<InputReaderInterface>& reader); 536 virtual ~InputReaderThread(); 537 538 private: 539 sp<InputReaderInterface> mReader; 540 541 virtual bool threadLoop(); 542 }; 543 544 545 /* Represents the state of a single input device. */ 546 class InputDevice { 547 public: 548 InputDevice(InputReaderContext* context, int32_t id, int32_t generation, int32_t 549 controllerNumber, const InputDeviceIdentifier& identifier, uint32_t classes); 550 ~InputDevice(); 551 getContext()552 inline InputReaderContext* getContext() { return mContext; } getId()553 inline int32_t getId() const { return mId; } getControllerNumber()554 inline int32_t getControllerNumber() const { return mControllerNumber; } getGeneration()555 inline int32_t getGeneration() const { return mGeneration; } getName()556 inline const String8& getName() const { return mIdentifier.name; } getDescriptor()557 inline const String8& getDescriptor() { return mIdentifier.descriptor; } getClasses()558 inline uint32_t getClasses() const { return mClasses; } getSources()559 inline uint32_t getSources() const { return mSources; } 560 isExternal()561 inline bool isExternal() { return mIsExternal; } setExternal(bool external)562 inline void setExternal(bool external) { mIsExternal = external; } 563 setMic(bool hasMic)564 inline void setMic(bool hasMic) { mHasMic = hasMic; } hasMic()565 inline bool hasMic() const { return mHasMic; } 566 isIgnored()567 inline bool isIgnored() { return mMappers.isEmpty(); } 568 569 bool isEnabled(); 570 void setEnabled(bool enabled, nsecs_t when); 571 572 void dump(String8& dump); 573 void addMapper(InputMapper* mapper); 574 void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes); 575 void reset(nsecs_t when); 576 void process(const RawEvent* rawEvents, size_t count); 577 void timeoutExpired(nsecs_t when); 578 void updateExternalStylusState(const StylusState& state); 579 580 void getDeviceInfo(InputDeviceInfo* outDeviceInfo); 581 int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode); 582 int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode); 583 int32_t getSwitchState(uint32_t sourceMask, int32_t switchCode); 584 bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes, 585 const int32_t* keyCodes, uint8_t* outFlags); 586 void vibrate(const nsecs_t* pattern, size_t patternSize, ssize_t repeat, int32_t token); 587 void cancelVibrate(int32_t token); 588 void cancelTouch(nsecs_t when); 589 590 int32_t getMetaState(); 591 void updateMetaState(int32_t keyCode); 592 593 void fadePointer(); 594 595 void bumpGeneration(); 596 597 void notifyReset(nsecs_t when); 598 getConfiguration()599 inline const PropertyMap& getConfiguration() { return mConfiguration; } getEventHub()600 inline EventHubInterface* getEventHub() { return mContext->getEventHub(); } 601 hasKey(int32_t code)602 bool hasKey(int32_t code) { 603 return getEventHub()->hasScanCode(mId, code); 604 } 605 hasAbsoluteAxis(int32_t code)606 bool hasAbsoluteAxis(int32_t code) { 607 RawAbsoluteAxisInfo info; 608 getEventHub()->getAbsoluteAxisInfo(mId, code, &info); 609 return info.valid; 610 } 611 isKeyPressed(int32_t code)612 bool isKeyPressed(int32_t code) { 613 return getEventHub()->getScanCodeState(mId, code) == AKEY_STATE_DOWN; 614 } 615 getAbsoluteAxisValue(int32_t code)616 int32_t getAbsoluteAxisValue(int32_t code) { 617 int32_t value; 618 getEventHub()->getAbsoluteAxisValue(mId, code, &value); 619 return value; 620 } 621 622 private: 623 InputReaderContext* mContext; 624 int32_t mId; 625 int32_t mGeneration; 626 int32_t mControllerNumber; 627 InputDeviceIdentifier mIdentifier; 628 String8 mAlias; 629 uint32_t mClasses; 630 631 Vector<InputMapper*> mMappers; 632 633 uint32_t mSources; 634 bool mIsExternal; 635 bool mHasMic; 636 bool mDropUntilNextSync; 637 638 typedef int32_t (InputMapper::*GetStateFunc)(uint32_t sourceMask, int32_t code); 639 int32_t getState(uint32_t sourceMask, int32_t code, GetStateFunc getStateFunc); 640 641 PropertyMap mConfiguration; 642 }; 643 644 645 /* Keeps track of the state of mouse or touch pad buttons. */ 646 class CursorButtonAccumulator { 647 public: 648 CursorButtonAccumulator(); 649 void reset(InputDevice* device); 650 651 void process(const RawEvent* rawEvent); 652 653 uint32_t getButtonState() const; 654 655 private: 656 bool mBtnLeft; 657 bool mBtnRight; 658 bool mBtnMiddle; 659 bool mBtnBack; 660 bool mBtnSide; 661 bool mBtnForward; 662 bool mBtnExtra; 663 bool mBtnTask; 664 665 void clearButtons(); 666 }; 667 668 669 /* Keeps track of cursor movements. */ 670 671 class CursorMotionAccumulator { 672 public: 673 CursorMotionAccumulator(); 674 void reset(InputDevice* device); 675 676 void process(const RawEvent* rawEvent); 677 void finishSync(); 678 getRelativeX()679 inline int32_t getRelativeX() const { return mRelX; } getRelativeY()680 inline int32_t getRelativeY() const { return mRelY; } 681 682 private: 683 int32_t mRelX; 684 int32_t mRelY; 685 686 void clearRelativeAxes(); 687 }; 688 689 690 /* Keeps track of cursor scrolling motions. */ 691 692 class CursorScrollAccumulator { 693 public: 694 CursorScrollAccumulator(); 695 void configure(InputDevice* device); 696 void reset(InputDevice* device); 697 698 void process(const RawEvent* rawEvent); 699 void finishSync(); 700 haveRelativeVWheel()701 inline bool haveRelativeVWheel() const { return mHaveRelWheel; } haveRelativeHWheel()702 inline bool haveRelativeHWheel() const { return mHaveRelHWheel; } 703 getRelativeX()704 inline int32_t getRelativeX() const { return mRelX; } getRelativeY()705 inline int32_t getRelativeY() const { return mRelY; } getRelativeVWheel()706 inline int32_t getRelativeVWheel() const { return mRelWheel; } getRelativeHWheel()707 inline int32_t getRelativeHWheel() const { return mRelHWheel; } 708 709 private: 710 bool mHaveRelWheel; 711 bool mHaveRelHWheel; 712 713 int32_t mRelX; 714 int32_t mRelY; 715 int32_t mRelWheel; 716 int32_t mRelHWheel; 717 718 void clearRelativeAxes(); 719 }; 720 721 722 /* Keeps track of the state of touch, stylus and tool buttons. */ 723 class TouchButtonAccumulator { 724 public: 725 TouchButtonAccumulator(); 726 void configure(InputDevice* device); 727 void reset(InputDevice* device); 728 729 void process(const RawEvent* rawEvent); 730 731 uint32_t getButtonState() const; 732 int32_t getToolType() const; 733 bool isToolActive() const; 734 bool isHovering() const; 735 bool hasStylus() const; 736 737 private: 738 bool mHaveBtnTouch; 739 bool mHaveStylus; 740 741 bool mBtnTouch; 742 bool mBtnStylus; 743 bool mBtnStylus2; 744 bool mBtnToolFinger; 745 bool mBtnToolPen; 746 bool mBtnToolRubber; 747 bool mBtnToolBrush; 748 bool mBtnToolPencil; 749 bool mBtnToolAirbrush; 750 bool mBtnToolMouse; 751 bool mBtnToolLens; 752 bool mBtnToolDoubleTap; 753 bool mBtnToolTripleTap; 754 bool mBtnToolQuadTap; 755 756 void clearButtons(); 757 }; 758 759 760 /* Raw axis information from the driver. */ 761 struct RawPointerAxes { 762 RawAbsoluteAxisInfo x; 763 RawAbsoluteAxisInfo y; 764 RawAbsoluteAxisInfo pressure; 765 RawAbsoluteAxisInfo touchMajor; 766 RawAbsoluteAxisInfo touchMinor; 767 RawAbsoluteAxisInfo toolMajor; 768 RawAbsoluteAxisInfo toolMinor; 769 RawAbsoluteAxisInfo orientation; 770 RawAbsoluteAxisInfo distance; 771 RawAbsoluteAxisInfo tiltX; 772 RawAbsoluteAxisInfo tiltY; 773 RawAbsoluteAxisInfo trackingId; 774 RawAbsoluteAxisInfo slot; 775 776 RawPointerAxes(); 777 void clear(); 778 }; 779 780 781 /* Raw data for a collection of pointers including a pointer id mapping table. */ 782 struct RawPointerData { 783 struct Pointer { 784 uint32_t id; 785 int32_t x; 786 int32_t y; 787 int32_t pressure; 788 int32_t touchMajor; 789 int32_t touchMinor; 790 int32_t toolMajor; 791 int32_t toolMinor; 792 int32_t orientation; 793 int32_t distance; 794 int32_t tiltX; 795 int32_t tiltY; 796 int32_t toolType; // a fully decoded AMOTION_EVENT_TOOL_TYPE constant 797 bool isHovering; 798 }; 799 800 uint32_t pointerCount; 801 Pointer pointers[MAX_POINTERS]; 802 BitSet32 hoveringIdBits, touchingIdBits; 803 uint32_t idToIndex[MAX_POINTER_ID + 1]; 804 805 RawPointerData(); 806 void clear(); 807 void copyFrom(const RawPointerData& other); 808 void getCentroidOfTouchingPointers(float* outX, float* outY) const; 809 markIdBitRawPointerData810 inline void markIdBit(uint32_t id, bool isHovering) { 811 if (isHovering) { 812 hoveringIdBits.markBit(id); 813 } else { 814 touchingIdBits.markBit(id); 815 } 816 } 817 clearIdBitsRawPointerData818 inline void clearIdBits() { 819 hoveringIdBits.clear(); 820 touchingIdBits.clear(); 821 } 822 pointerForIdRawPointerData823 inline const Pointer& pointerForId(uint32_t id) const { 824 return pointers[idToIndex[id]]; 825 } 826 isHoveringRawPointerData827 inline bool isHovering(uint32_t pointerIndex) { 828 return pointers[pointerIndex].isHovering; 829 } 830 }; 831 832 833 /* Cooked data for a collection of pointers including a pointer id mapping table. */ 834 struct CookedPointerData { 835 uint32_t pointerCount; 836 PointerProperties pointerProperties[MAX_POINTERS]; 837 PointerCoords pointerCoords[MAX_POINTERS]; 838 BitSet32 hoveringIdBits, touchingIdBits; 839 uint32_t idToIndex[MAX_POINTER_ID + 1]; 840 841 CookedPointerData(); 842 void clear(); 843 void copyFrom(const CookedPointerData& other); 844 pointerCoordsForIdCookedPointerData845 inline const PointerCoords& pointerCoordsForId(uint32_t id) const { 846 return pointerCoords[idToIndex[id]]; 847 } 848 editPointerCoordsWithIdCookedPointerData849 inline PointerCoords& editPointerCoordsWithId(uint32_t id) { 850 return pointerCoords[idToIndex[id]]; 851 } 852 editPointerPropertiesWithIdCookedPointerData853 inline PointerProperties& editPointerPropertiesWithId(uint32_t id) { 854 return pointerProperties[idToIndex[id]]; 855 } 856 isHoveringCookedPointerData857 inline bool isHovering(uint32_t pointerIndex) const { 858 return hoveringIdBits.hasBit(pointerProperties[pointerIndex].id); 859 } 860 isTouchingCookedPointerData861 inline bool isTouching(uint32_t pointerIndex) const { 862 return touchingIdBits.hasBit(pointerProperties[pointerIndex].id); 863 } 864 }; 865 866 867 /* Keeps track of the state of single-touch protocol. */ 868 class SingleTouchMotionAccumulator { 869 public: 870 SingleTouchMotionAccumulator(); 871 872 void process(const RawEvent* rawEvent); 873 void reset(InputDevice* device); 874 getAbsoluteX()875 inline int32_t getAbsoluteX() const { return mAbsX; } getAbsoluteY()876 inline int32_t getAbsoluteY() const { return mAbsY; } getAbsolutePressure()877 inline int32_t getAbsolutePressure() const { return mAbsPressure; } getAbsoluteToolWidth()878 inline int32_t getAbsoluteToolWidth() const { return mAbsToolWidth; } getAbsoluteDistance()879 inline int32_t getAbsoluteDistance() const { return mAbsDistance; } getAbsoluteTiltX()880 inline int32_t getAbsoluteTiltX() const { return mAbsTiltX; } getAbsoluteTiltY()881 inline int32_t getAbsoluteTiltY() const { return mAbsTiltY; } 882 883 private: 884 int32_t mAbsX; 885 int32_t mAbsY; 886 int32_t mAbsPressure; 887 int32_t mAbsToolWidth; 888 int32_t mAbsDistance; 889 int32_t mAbsTiltX; 890 int32_t mAbsTiltY; 891 892 void clearAbsoluteAxes(); 893 }; 894 895 896 /* Keeps track of the state of multi-touch protocol. */ 897 class MultiTouchMotionAccumulator { 898 public: 899 class Slot { 900 public: isInUse()901 inline bool isInUse() const { return mInUse; } getX()902 inline int32_t getX() const { return mAbsMTPositionX; } getY()903 inline int32_t getY() const { return mAbsMTPositionY; } getTouchMajor()904 inline int32_t getTouchMajor() const { return mAbsMTTouchMajor; } getTouchMinor()905 inline int32_t getTouchMinor() const { 906 return mHaveAbsMTTouchMinor ? mAbsMTTouchMinor : mAbsMTTouchMajor; } getToolMajor()907 inline int32_t getToolMajor() const { return mAbsMTWidthMajor; } getToolMinor()908 inline int32_t getToolMinor() const { 909 return mHaveAbsMTWidthMinor ? mAbsMTWidthMinor : mAbsMTWidthMajor; } getOrientation()910 inline int32_t getOrientation() const { return mAbsMTOrientation; } getTrackingId()911 inline int32_t getTrackingId() const { return mAbsMTTrackingId; } getPressure()912 inline int32_t getPressure() const { return mAbsMTPressure; } getDistance()913 inline int32_t getDistance() const { return mAbsMTDistance; } 914 inline int32_t getToolType() const; 915 916 private: 917 friend class MultiTouchMotionAccumulator; 918 919 bool mInUse; 920 bool mHaveAbsMTTouchMinor; 921 bool mHaveAbsMTWidthMinor; 922 bool mHaveAbsMTToolType; 923 924 int32_t mAbsMTPositionX; 925 int32_t mAbsMTPositionY; 926 int32_t mAbsMTTouchMajor; 927 int32_t mAbsMTTouchMinor; 928 int32_t mAbsMTWidthMajor; 929 int32_t mAbsMTWidthMinor; 930 int32_t mAbsMTOrientation; 931 int32_t mAbsMTTrackingId; 932 int32_t mAbsMTPressure; 933 int32_t mAbsMTDistance; 934 int32_t mAbsMTToolType; 935 936 Slot(); 937 void clear(); 938 }; 939 940 MultiTouchMotionAccumulator(); 941 ~MultiTouchMotionAccumulator(); 942 943 void configure(InputDevice* device, size_t slotCount, bool usingSlotsProtocol); 944 void reset(InputDevice* device); 945 void process(const RawEvent* rawEvent); 946 void finishSync(); 947 bool hasStylus() const; 948 getSlotCount()949 inline size_t getSlotCount() const { return mSlotCount; } getSlot(size_t index)950 inline const Slot* getSlot(size_t index) const { return &mSlots[index]; } 951 952 private: 953 int32_t mCurrentSlot; 954 Slot* mSlots; 955 size_t mSlotCount; 956 bool mUsingSlotsProtocol; 957 bool mHaveStylus; 958 959 void clearSlots(int32_t initialSlot); 960 }; 961 962 963 /* An input mapper transforms raw input events into cooked event data. 964 * A single input device can have multiple associated input mappers in order to interpret 965 * different classes of events. 966 * 967 * InputMapper lifecycle: 968 * - create 969 * - configure with 0 changes 970 * - reset 971 * - process, process, process (may occasionally reconfigure with non-zero changes or reset) 972 * - reset 973 * - destroy 974 */ 975 class InputMapper { 976 public: 977 explicit InputMapper(InputDevice* device); 978 virtual ~InputMapper(); 979 getDevice()980 inline InputDevice* getDevice() { return mDevice; } getDeviceId()981 inline int32_t getDeviceId() { return mDevice->getId(); } getDeviceName()982 inline const String8 getDeviceName() { return mDevice->getName(); } getContext()983 inline InputReaderContext* getContext() { return mContext; } getPolicy()984 inline InputReaderPolicyInterface* getPolicy() { return mContext->getPolicy(); } getListener()985 inline InputListenerInterface* getListener() { return mContext->getListener(); } getEventHub()986 inline EventHubInterface* getEventHub() { return mContext->getEventHub(); } 987 988 virtual uint32_t getSources() = 0; 989 virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo); 990 virtual void dump(String8& dump); 991 virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes); 992 virtual void reset(nsecs_t when); 993 virtual void process(const RawEvent* rawEvent) = 0; 994 virtual void timeoutExpired(nsecs_t when); 995 996 virtual int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode); 997 virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode); 998 virtual int32_t getSwitchState(uint32_t sourceMask, int32_t switchCode); 999 virtual bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes, 1000 const int32_t* keyCodes, uint8_t* outFlags); 1001 virtual void vibrate(const nsecs_t* pattern, size_t patternSize, ssize_t repeat, 1002 int32_t token); 1003 virtual void cancelVibrate(int32_t token); 1004 virtual void cancelTouch(nsecs_t when); 1005 1006 virtual int32_t getMetaState(); 1007 virtual void updateMetaState(int32_t keyCode); 1008 1009 virtual void updateExternalStylusState(const StylusState& state); 1010 1011 virtual void fadePointer(); 1012 1013 protected: 1014 InputDevice* mDevice; 1015 InputReaderContext* mContext; 1016 1017 status_t getAbsoluteAxisInfo(int32_t axis, RawAbsoluteAxisInfo* axisInfo); 1018 void bumpGeneration(); 1019 1020 static void dumpRawAbsoluteAxisInfo(String8& dump, 1021 const RawAbsoluteAxisInfo& axis, const char* name); 1022 static void dumpStylusState(String8& dump, const StylusState& state); 1023 }; 1024 1025 1026 class SwitchInputMapper : public InputMapper { 1027 public: 1028 explicit SwitchInputMapper(InputDevice* device); 1029 virtual ~SwitchInputMapper(); 1030 1031 virtual uint32_t getSources(); 1032 virtual void process(const RawEvent* rawEvent); 1033 1034 virtual int32_t getSwitchState(uint32_t sourceMask, int32_t switchCode); 1035 virtual void dump(String8& dump); 1036 1037 private: 1038 uint32_t mSwitchValues; 1039 uint32_t mUpdatedSwitchMask; 1040 1041 void processSwitch(int32_t switchCode, int32_t switchValue); 1042 void sync(nsecs_t when); 1043 }; 1044 1045 1046 class VibratorInputMapper : public InputMapper { 1047 public: 1048 explicit VibratorInputMapper(InputDevice* device); 1049 virtual ~VibratorInputMapper(); 1050 1051 virtual uint32_t getSources(); 1052 virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo); 1053 virtual void process(const RawEvent* rawEvent); 1054 1055 virtual void vibrate(const nsecs_t* pattern, size_t patternSize, ssize_t repeat, 1056 int32_t token); 1057 virtual void cancelVibrate(int32_t token); 1058 virtual void timeoutExpired(nsecs_t when); 1059 virtual void dump(String8& dump); 1060 1061 private: 1062 bool mVibrating; 1063 nsecs_t mPattern[MAX_VIBRATE_PATTERN_SIZE]; 1064 size_t mPatternSize; 1065 ssize_t mRepeat; 1066 int32_t mToken; 1067 ssize_t mIndex; 1068 nsecs_t mNextStepTime; 1069 1070 void nextStep(); 1071 void stopVibrating(); 1072 }; 1073 1074 1075 class KeyboardInputMapper : public InputMapper { 1076 public: 1077 KeyboardInputMapper(InputDevice* device, uint32_t source, int32_t keyboardType); 1078 virtual ~KeyboardInputMapper(); 1079 1080 virtual uint32_t getSources(); 1081 virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo); 1082 virtual void dump(String8& dump); 1083 virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes); 1084 virtual void reset(nsecs_t when); 1085 virtual void process(const RawEvent* rawEvent); 1086 1087 virtual int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode); 1088 virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode); 1089 virtual bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes, 1090 const int32_t* keyCodes, uint8_t* outFlags); 1091 1092 virtual int32_t getMetaState(); 1093 virtual void updateMetaState(int32_t keyCode); 1094 1095 private: 1096 struct KeyDown { 1097 int32_t keyCode; 1098 int32_t scanCode; 1099 }; 1100 1101 uint32_t mSource; 1102 int32_t mKeyboardType; 1103 1104 int32_t mOrientation; // orientation for dpad keys 1105 1106 Vector<KeyDown> mKeyDowns; // keys that are down 1107 int32_t mMetaState; 1108 nsecs_t mDownTime; // time of most recent key down 1109 1110 int32_t mCurrentHidUsage; // most recent HID usage seen this packet, or 0 if none 1111 1112 struct LedState { 1113 bool avail; // led is available 1114 bool on; // we think the led is currently on 1115 }; 1116 LedState mCapsLockLedState; 1117 LedState mNumLockLedState; 1118 LedState mScrollLockLedState; 1119 1120 // Immutable configuration parameters. 1121 struct Parameters { 1122 bool hasAssociatedDisplay; 1123 bool orientationAware; 1124 bool handlesKeyRepeat; 1125 } mParameters; 1126 1127 void configureParameters(); 1128 void dumpParameters(String8& dump); 1129 1130 bool isKeyboardOrGamepadKey(int32_t scanCode); 1131 bool isMediaKey(int32_t keyCode); 1132 1133 void processKey(nsecs_t when, bool down, int32_t scanCode, int32_t usageCode); 1134 1135 bool updateMetaStateIfNeeded(int32_t keyCode, bool down); 1136 1137 ssize_t findKeyDown(int32_t scanCode); 1138 1139 void resetLedState(); 1140 void initializeLedState(LedState& ledState, int32_t led); 1141 void updateLedState(bool reset); 1142 void updateLedStateForModifier(LedState& ledState, int32_t led, 1143 int32_t modifier, bool reset); 1144 }; 1145 1146 1147 class CursorInputMapper : public InputMapper { 1148 public: 1149 explicit CursorInputMapper(InputDevice* device); 1150 virtual ~CursorInputMapper(); 1151 1152 virtual uint32_t getSources(); 1153 virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo); 1154 virtual void dump(String8& dump); 1155 virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes); 1156 virtual void reset(nsecs_t when); 1157 virtual void process(const RawEvent* rawEvent); 1158 1159 virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode); 1160 1161 virtual void fadePointer(); 1162 1163 private: 1164 // Amount that trackball needs to move in order to generate a key event. 1165 static const int32_t TRACKBALL_MOVEMENT_THRESHOLD = 6; 1166 1167 // Immutable configuration parameters. 1168 struct Parameters { 1169 enum Mode { 1170 MODE_POINTER, 1171 MODE_POINTER_RELATIVE, 1172 MODE_NAVIGATION, 1173 }; 1174 1175 Mode mode; 1176 bool hasAssociatedDisplay; 1177 bool orientationAware; 1178 } mParameters; 1179 1180 CursorButtonAccumulator mCursorButtonAccumulator; 1181 CursorMotionAccumulator mCursorMotionAccumulator; 1182 CursorScrollAccumulator mCursorScrollAccumulator; 1183 1184 int32_t mSource; 1185 float mXScale; 1186 float mYScale; 1187 float mXPrecision; 1188 float mYPrecision; 1189 1190 float mVWheelScale; 1191 float mHWheelScale; 1192 1193 // Velocity controls for mouse pointer and wheel movements. 1194 // The controls for X and Y wheel movements are separate to keep them decoupled. 1195 VelocityControl mPointerVelocityControl; 1196 VelocityControl mWheelXVelocityControl; 1197 VelocityControl mWheelYVelocityControl; 1198 1199 int32_t mOrientation; 1200 1201 sp<PointerControllerInterface> mPointerController; 1202 1203 int32_t mButtonState; 1204 nsecs_t mDownTime; 1205 1206 void configureParameters(); 1207 void dumpParameters(String8& dump); 1208 1209 void sync(nsecs_t when); 1210 }; 1211 1212 1213 class RotaryEncoderInputMapper : public InputMapper { 1214 public: 1215 explicit RotaryEncoderInputMapper(InputDevice* device); 1216 virtual ~RotaryEncoderInputMapper(); 1217 1218 virtual uint32_t getSources(); 1219 virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo); 1220 virtual void dump(String8& dump); 1221 virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes); 1222 virtual void reset(nsecs_t when); 1223 virtual void process(const RawEvent* rawEvent); 1224 1225 private: 1226 CursorScrollAccumulator mRotaryEncoderScrollAccumulator; 1227 1228 int32_t mSource; 1229 float mScalingFactor; 1230 int32_t mOrientation; 1231 1232 void sync(nsecs_t when); 1233 }; 1234 1235 class TouchInputMapper : public InputMapper { 1236 public: 1237 explicit TouchInputMapper(InputDevice* device); 1238 virtual ~TouchInputMapper(); 1239 1240 virtual uint32_t getSources(); 1241 virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo); 1242 virtual void dump(String8& dump); 1243 virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes); 1244 virtual void reset(nsecs_t when); 1245 virtual void process(const RawEvent* rawEvent); 1246 1247 virtual int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode); 1248 virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode); 1249 virtual bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes, 1250 const int32_t* keyCodes, uint8_t* outFlags); 1251 1252 virtual void fadePointer(); 1253 virtual void cancelTouch(nsecs_t when); 1254 virtual void timeoutExpired(nsecs_t when); 1255 virtual void updateExternalStylusState(const StylusState& state); 1256 1257 protected: 1258 CursorButtonAccumulator mCursorButtonAccumulator; 1259 CursorScrollAccumulator mCursorScrollAccumulator; 1260 TouchButtonAccumulator mTouchButtonAccumulator; 1261 1262 struct VirtualKey { 1263 int32_t keyCode; 1264 int32_t scanCode; 1265 uint32_t flags; 1266 1267 // computed hit box, specified in touch screen coords based on known display size 1268 int32_t hitLeft; 1269 int32_t hitTop; 1270 int32_t hitRight; 1271 int32_t hitBottom; 1272 isHitVirtualKey1273 inline bool isHit(int32_t x, int32_t y) const { 1274 return x >= hitLeft && x <= hitRight && y >= hitTop && y <= hitBottom; 1275 } 1276 }; 1277 1278 // Input sources and device mode. 1279 uint32_t mSource; 1280 1281 enum DeviceMode { 1282 DEVICE_MODE_DISABLED, // input is disabled 1283 DEVICE_MODE_DIRECT, // direct mapping (touchscreen) 1284 DEVICE_MODE_UNSCALED, // unscaled mapping (touchpad) 1285 DEVICE_MODE_NAVIGATION, // unscaled mapping with assist gesture (touch navigation) 1286 DEVICE_MODE_POINTER, // pointer mapping (pointer) 1287 }; 1288 DeviceMode mDeviceMode; 1289 1290 // The reader's configuration. 1291 InputReaderConfiguration mConfig; 1292 1293 // Immutable configuration parameters. 1294 struct Parameters { 1295 enum DeviceType { 1296 DEVICE_TYPE_TOUCH_SCREEN, 1297 DEVICE_TYPE_TOUCH_PAD, 1298 DEVICE_TYPE_TOUCH_NAVIGATION, 1299 DEVICE_TYPE_POINTER, 1300 }; 1301 1302 DeviceType deviceType; 1303 bool hasAssociatedDisplay; 1304 bool associatedDisplayIsExternal; 1305 bool orientationAware; 1306 bool hasButtonUnderPad; 1307 String8 uniqueDisplayId; 1308 1309 enum GestureMode { 1310 GESTURE_MODE_SINGLE_TOUCH, 1311 GESTURE_MODE_MULTI_TOUCH, 1312 }; 1313 GestureMode gestureMode; 1314 1315 bool wake; 1316 } mParameters; 1317 1318 // Immutable calibration parameters in parsed form. 1319 struct Calibration { 1320 // Size 1321 enum SizeCalibration { 1322 SIZE_CALIBRATION_DEFAULT, 1323 SIZE_CALIBRATION_NONE, 1324 SIZE_CALIBRATION_GEOMETRIC, 1325 SIZE_CALIBRATION_DIAMETER, 1326 SIZE_CALIBRATION_BOX, 1327 SIZE_CALIBRATION_AREA, 1328 }; 1329 1330 SizeCalibration sizeCalibration; 1331 1332 bool haveSizeScale; 1333 float sizeScale; 1334 bool haveSizeBias; 1335 float sizeBias; 1336 bool haveSizeIsSummed; 1337 bool sizeIsSummed; 1338 1339 // Pressure 1340 enum PressureCalibration { 1341 PRESSURE_CALIBRATION_DEFAULT, 1342 PRESSURE_CALIBRATION_NONE, 1343 PRESSURE_CALIBRATION_PHYSICAL, 1344 PRESSURE_CALIBRATION_AMPLITUDE, 1345 }; 1346 1347 PressureCalibration pressureCalibration; 1348 bool havePressureScale; 1349 float pressureScale; 1350 1351 // Orientation 1352 enum OrientationCalibration { 1353 ORIENTATION_CALIBRATION_DEFAULT, 1354 ORIENTATION_CALIBRATION_NONE, 1355 ORIENTATION_CALIBRATION_INTERPOLATED, 1356 ORIENTATION_CALIBRATION_VECTOR, 1357 }; 1358 1359 OrientationCalibration orientationCalibration; 1360 1361 // Distance 1362 enum DistanceCalibration { 1363 DISTANCE_CALIBRATION_DEFAULT, 1364 DISTANCE_CALIBRATION_NONE, 1365 DISTANCE_CALIBRATION_SCALED, 1366 }; 1367 1368 DistanceCalibration distanceCalibration; 1369 bool haveDistanceScale; 1370 float distanceScale; 1371 1372 enum CoverageCalibration { 1373 COVERAGE_CALIBRATION_DEFAULT, 1374 COVERAGE_CALIBRATION_NONE, 1375 COVERAGE_CALIBRATION_BOX, 1376 }; 1377 1378 CoverageCalibration coverageCalibration; 1379 applySizeScaleAndBiasCalibration1380 inline void applySizeScaleAndBias(float* outSize) const { 1381 if (haveSizeScale) { 1382 *outSize *= sizeScale; 1383 } 1384 if (haveSizeBias) { 1385 *outSize += sizeBias; 1386 } 1387 if (*outSize < 0) { 1388 *outSize = 0; 1389 } 1390 } 1391 } mCalibration; 1392 1393 // Affine location transformation/calibration 1394 struct TouchAffineTransformation mAffineTransform; 1395 1396 RawPointerAxes mRawPointerAxes; 1397 1398 struct RawState { 1399 nsecs_t when; 1400 1401 // Raw pointer sample data. 1402 RawPointerData rawPointerData; 1403 1404 int32_t buttonState; 1405 1406 // Scroll state. 1407 int32_t rawVScroll; 1408 int32_t rawHScroll; 1409 copyFromRawState1410 void copyFrom(const RawState& other) { 1411 when = other.when; 1412 rawPointerData.copyFrom(other.rawPointerData); 1413 buttonState = other.buttonState; 1414 rawVScroll = other.rawVScroll; 1415 rawHScroll = other.rawHScroll; 1416 } 1417 clearRawState1418 void clear() { 1419 when = 0; 1420 rawPointerData.clear(); 1421 buttonState = 0; 1422 rawVScroll = 0; 1423 rawHScroll = 0; 1424 } 1425 }; 1426 1427 struct CookedState { 1428 // Cooked pointer sample data. 1429 CookedPointerData cookedPointerData; 1430 1431 // Id bits used to differentiate fingers, stylus and mouse tools. 1432 BitSet32 fingerIdBits; 1433 BitSet32 stylusIdBits; 1434 BitSet32 mouseIdBits; 1435 1436 int32_t buttonState; 1437 copyFromCookedState1438 void copyFrom(const CookedState& other) { 1439 cookedPointerData.copyFrom(other.cookedPointerData); 1440 fingerIdBits = other.fingerIdBits; 1441 stylusIdBits = other.stylusIdBits; 1442 mouseIdBits = other.mouseIdBits; 1443 buttonState = other.buttonState; 1444 } 1445 clearCookedState1446 void clear() { 1447 cookedPointerData.clear(); 1448 fingerIdBits.clear(); 1449 stylusIdBits.clear(); 1450 mouseIdBits.clear(); 1451 buttonState = 0; 1452 } 1453 }; 1454 1455 Vector<RawState> mRawStatesPending; 1456 RawState mCurrentRawState; 1457 CookedState mCurrentCookedState; 1458 RawState mLastRawState; 1459 CookedState mLastCookedState; 1460 1461 // State provided by an external stylus 1462 StylusState mExternalStylusState; 1463 int64_t mExternalStylusId; 1464 nsecs_t mExternalStylusFusionTimeout; 1465 bool mExternalStylusDataPending; 1466 1467 // True if we sent a HOVER_ENTER event. 1468 bool mSentHoverEnter; 1469 1470 // Have we assigned pointer IDs for this stream 1471 bool mHavePointerIds; 1472 1473 // Is the current stream of direct touch events aborted 1474 bool mCurrentMotionAborted; 1475 1476 // The time the primary pointer last went down. 1477 nsecs_t mDownTime; 1478 1479 // The pointer controller, or null if the device is not a pointer. 1480 sp<PointerControllerInterface> mPointerController; 1481 1482 Vector<VirtualKey> mVirtualKeys; 1483 1484 virtual void configureParameters(); 1485 virtual void dumpParameters(String8& dump); 1486 virtual void configureRawPointerAxes(); 1487 virtual void dumpRawPointerAxes(String8& dump); 1488 virtual void configureSurface(nsecs_t when, bool* outResetNeeded); 1489 virtual void dumpSurface(String8& dump); 1490 virtual void configureVirtualKeys(); 1491 virtual void dumpVirtualKeys(String8& dump); 1492 virtual void parseCalibration(); 1493 virtual void resolveCalibration(); 1494 virtual void dumpCalibration(String8& dump); 1495 virtual void updateAffineTransformation(); 1496 virtual void dumpAffineTransformation(String8& dump); 1497 virtual void resolveExternalStylusPresence(); 1498 virtual bool hasStylus() const = 0; 1499 virtual bool hasExternalStylus() const; 1500 1501 virtual void syncTouch(nsecs_t when, RawState* outState) = 0; 1502 1503 private: 1504 // The current viewport. 1505 // The components of the viewport are specified in the display's rotated orientation. 1506 DisplayViewport mViewport; 1507 1508 // The surface orientation, width and height set by configureSurface(). 1509 // The width and height are derived from the viewport but are specified 1510 // in the natural orientation. 1511 // The surface origin specifies how the surface coordinates should be translated 1512 // to align with the logical display coordinate space. 1513 // The orientation may be different from the viewport orientation as it specifies 1514 // the rotation of the surface coordinates required to produce the viewport's 1515 // requested orientation, so it will depend on whether the device is orientation aware. 1516 int32_t mSurfaceWidth; 1517 int32_t mSurfaceHeight; 1518 int32_t mSurfaceLeft; 1519 int32_t mSurfaceTop; 1520 int32_t mSurfaceOrientation; 1521 1522 // Translation and scaling factors, orientation-independent. 1523 float mXTranslate; 1524 float mXScale; 1525 float mXPrecision; 1526 1527 float mYTranslate; 1528 float mYScale; 1529 float mYPrecision; 1530 1531 float mGeometricScale; 1532 1533 float mPressureScale; 1534 1535 float mSizeScale; 1536 1537 float mOrientationScale; 1538 1539 float mDistanceScale; 1540 1541 bool mHaveTilt; 1542 float mTiltXCenter; 1543 float mTiltXScale; 1544 float mTiltYCenter; 1545 float mTiltYScale; 1546 1547 bool mExternalStylusConnected; 1548 1549 // Oriented motion ranges for input device info. 1550 struct OrientedRanges { 1551 InputDeviceInfo::MotionRange x; 1552 InputDeviceInfo::MotionRange y; 1553 InputDeviceInfo::MotionRange pressure; 1554 1555 bool haveSize; 1556 InputDeviceInfo::MotionRange size; 1557 1558 bool haveTouchSize; 1559 InputDeviceInfo::MotionRange touchMajor; 1560 InputDeviceInfo::MotionRange touchMinor; 1561 1562 bool haveToolSize; 1563 InputDeviceInfo::MotionRange toolMajor; 1564 InputDeviceInfo::MotionRange toolMinor; 1565 1566 bool haveOrientation; 1567 InputDeviceInfo::MotionRange orientation; 1568 1569 bool haveDistance; 1570 InputDeviceInfo::MotionRange distance; 1571 1572 bool haveTilt; 1573 InputDeviceInfo::MotionRange tilt; 1574 OrientedRangesOrientedRanges1575 OrientedRanges() { 1576 clear(); 1577 } 1578 clearOrientedRanges1579 void clear() { 1580 haveSize = false; 1581 haveTouchSize = false; 1582 haveToolSize = false; 1583 haveOrientation = false; 1584 haveDistance = false; 1585 haveTilt = false; 1586 } 1587 } mOrientedRanges; 1588 1589 // Oriented dimensions and precision. 1590 float mOrientedXPrecision; 1591 float mOrientedYPrecision; 1592 1593 struct CurrentVirtualKeyState { 1594 bool down; 1595 bool ignored; 1596 nsecs_t downTime; 1597 int32_t keyCode; 1598 int32_t scanCode; 1599 } mCurrentVirtualKey; 1600 1601 // Scale factor for gesture or mouse based pointer movements. 1602 float mPointerXMovementScale; 1603 float mPointerYMovementScale; 1604 1605 // Scale factor for gesture based zooming and other freeform motions. 1606 float mPointerXZoomScale; 1607 float mPointerYZoomScale; 1608 1609 // The maximum swipe width. 1610 float mPointerGestureMaxSwipeWidth; 1611 1612 struct PointerDistanceHeapElement { 1613 uint32_t currentPointerIndex : 8; 1614 uint32_t lastPointerIndex : 8; 1615 uint64_t distance : 48; // squared distance 1616 }; 1617 1618 enum PointerUsage { 1619 POINTER_USAGE_NONE, 1620 POINTER_USAGE_GESTURES, 1621 POINTER_USAGE_STYLUS, 1622 POINTER_USAGE_MOUSE, 1623 }; 1624 PointerUsage mPointerUsage; 1625 1626 struct PointerGesture { 1627 enum Mode { 1628 // No fingers, button is not pressed. 1629 // Nothing happening. 1630 NEUTRAL, 1631 1632 // No fingers, button is not pressed. 1633 // Tap detected. 1634 // Emits DOWN and UP events at the pointer location. 1635 TAP, 1636 1637 // Exactly one finger dragging following a tap. 1638 // Pointer follows the active finger. 1639 // Emits DOWN, MOVE and UP events at the pointer location. 1640 // 1641 // Detect double-taps when the finger goes up while in TAP_DRAG mode. 1642 TAP_DRAG, 1643 1644 // Button is pressed. 1645 // Pointer follows the active finger if there is one. Other fingers are ignored. 1646 // Emits DOWN, MOVE and UP events at the pointer location. 1647 BUTTON_CLICK_OR_DRAG, 1648 1649 // Exactly one finger, button is not pressed. 1650 // Pointer follows the active finger. 1651 // Emits HOVER_MOVE events at the pointer location. 1652 // 1653 // Detect taps when the finger goes up while in HOVER mode. 1654 HOVER, 1655 1656 // Exactly two fingers but neither have moved enough to clearly indicate 1657 // whether a swipe or freeform gesture was intended. We consider the 1658 // pointer to be pressed so this enables clicking or long-pressing on buttons. 1659 // Pointer does not move. 1660 // Emits DOWN, MOVE and UP events with a single stationary pointer coordinate. 1661 PRESS, 1662 1663 // Exactly two fingers moving in the same direction, button is not pressed. 1664 // Pointer does not move. 1665 // Emits DOWN, MOVE and UP events with a single pointer coordinate that 1666 // follows the midpoint between both fingers. 1667 SWIPE, 1668 1669 // Two or more fingers moving in arbitrary directions, button is not pressed. 1670 // Pointer does not move. 1671 // Emits DOWN, POINTER_DOWN, MOVE, POINTER_UP and UP events that follow 1672 // each finger individually relative to the initial centroid of the finger. 1673 FREEFORM, 1674 1675 // Waiting for quiet time to end before starting the next gesture. 1676 QUIET, 1677 }; 1678 1679 // Time the first finger went down. 1680 nsecs_t firstTouchTime; 1681 1682 // The active pointer id from the raw touch data. 1683 int32_t activeTouchId; // -1 if none 1684 1685 // The active pointer id from the gesture last delivered to the application. 1686 int32_t activeGestureId; // -1 if none 1687 1688 // Pointer coords and ids for the current and previous pointer gesture. 1689 Mode currentGestureMode; 1690 BitSet32 currentGestureIdBits; 1691 uint32_t currentGestureIdToIndex[MAX_POINTER_ID + 1]; 1692 PointerProperties currentGestureProperties[MAX_POINTERS]; 1693 PointerCoords currentGestureCoords[MAX_POINTERS]; 1694 1695 Mode lastGestureMode; 1696 BitSet32 lastGestureIdBits; 1697 uint32_t lastGestureIdToIndex[MAX_POINTER_ID + 1]; 1698 PointerProperties lastGestureProperties[MAX_POINTERS]; 1699 PointerCoords lastGestureCoords[MAX_POINTERS]; 1700 1701 // Time the pointer gesture last went down. 1702 nsecs_t downTime; 1703 1704 // Time when the pointer went down for a TAP. 1705 nsecs_t tapDownTime; 1706 1707 // Time when the pointer went up for a TAP. 1708 nsecs_t tapUpTime; 1709 1710 // Location of initial tap. 1711 float tapX, tapY; 1712 1713 // Time we started waiting for quiescence. 1714 nsecs_t quietTime; 1715 1716 // Reference points for multitouch gestures. 1717 float referenceTouchX; // reference touch X/Y coordinates in surface units 1718 float referenceTouchY; 1719 float referenceGestureX; // reference gesture X/Y coordinates in pixels 1720 float referenceGestureY; 1721 1722 // Distance that each pointer has traveled which has not yet been 1723 // subsumed into the reference gesture position. 1724 BitSet32 referenceIdBits; 1725 struct Delta { 1726 float dx, dy; 1727 }; 1728 Delta referenceDeltas[MAX_POINTER_ID + 1]; 1729 1730 // Describes how touch ids are mapped to gesture ids for freeform gestures. 1731 uint32_t freeformTouchToGestureIdMap[MAX_POINTER_ID + 1]; 1732 1733 // A velocity tracker for determining whether to switch active pointers during drags. 1734 VelocityTracker velocityTracker; 1735 resetPointerGesture1736 void reset() { 1737 firstTouchTime = LLONG_MIN; 1738 activeTouchId = -1; 1739 activeGestureId = -1; 1740 currentGestureMode = NEUTRAL; 1741 currentGestureIdBits.clear(); 1742 lastGestureMode = NEUTRAL; 1743 lastGestureIdBits.clear(); 1744 downTime = 0; 1745 velocityTracker.clear(); 1746 resetTap(); 1747 resetQuietTime(); 1748 } 1749 resetTapPointerGesture1750 void resetTap() { 1751 tapDownTime = LLONG_MIN; 1752 tapUpTime = LLONG_MIN; 1753 } 1754 resetQuietTimePointerGesture1755 void resetQuietTime() { 1756 quietTime = LLONG_MIN; 1757 } 1758 } mPointerGesture; 1759 1760 struct PointerSimple { 1761 PointerCoords currentCoords; 1762 PointerProperties currentProperties; 1763 PointerCoords lastCoords; 1764 PointerProperties lastProperties; 1765 1766 // True if the pointer is down. 1767 bool down; 1768 1769 // True if the pointer is hovering. 1770 bool hovering; 1771 1772 // Time the pointer last went down. 1773 nsecs_t downTime; 1774 resetPointerSimple1775 void reset() { 1776 currentCoords.clear(); 1777 currentProperties.clear(); 1778 lastCoords.clear(); 1779 lastProperties.clear(); 1780 down = false; 1781 hovering = false; 1782 downTime = 0; 1783 } 1784 } mPointerSimple; 1785 1786 // The pointer and scroll velocity controls. 1787 VelocityControl mPointerVelocityControl; 1788 VelocityControl mWheelXVelocityControl; 1789 VelocityControl mWheelYVelocityControl; 1790 1791 void resetExternalStylus(); 1792 void clearStylusDataPendingFlags(); 1793 1794 void sync(nsecs_t when); 1795 1796 bool consumeRawTouches(nsecs_t when, uint32_t policyFlags); 1797 void processRawTouches(bool timeout); 1798 void cookAndDispatch(nsecs_t when); 1799 void dispatchVirtualKey(nsecs_t when, uint32_t policyFlags, 1800 int32_t keyEventAction, int32_t keyEventFlags); 1801 1802 void dispatchTouches(nsecs_t when, uint32_t policyFlags); 1803 void dispatchHoverExit(nsecs_t when, uint32_t policyFlags); 1804 void dispatchHoverEnterAndMove(nsecs_t when, uint32_t policyFlags); 1805 void dispatchButtonRelease(nsecs_t when, uint32_t policyFlags); 1806 void dispatchButtonPress(nsecs_t when, uint32_t policyFlags); 1807 const BitSet32& findActiveIdBits(const CookedPointerData& cookedPointerData); 1808 void cookPointerData(); 1809 void abortTouches(nsecs_t when, uint32_t policyFlags); 1810 1811 void dispatchPointerUsage(nsecs_t when, uint32_t policyFlags, PointerUsage pointerUsage); 1812 void abortPointerUsage(nsecs_t when, uint32_t policyFlags); 1813 1814 void dispatchPointerGestures(nsecs_t when, uint32_t policyFlags, bool isTimeout); 1815 void abortPointerGestures(nsecs_t when, uint32_t policyFlags); 1816 bool preparePointerGestures(nsecs_t when, 1817 bool* outCancelPreviousGesture, bool* outFinishPreviousGesture, 1818 bool isTimeout); 1819 1820 void dispatchPointerStylus(nsecs_t when, uint32_t policyFlags); 1821 void abortPointerStylus(nsecs_t when, uint32_t policyFlags); 1822 1823 void dispatchPointerMouse(nsecs_t when, uint32_t policyFlags); 1824 void abortPointerMouse(nsecs_t when, uint32_t policyFlags); 1825 1826 void dispatchPointerSimple(nsecs_t when, uint32_t policyFlags, 1827 bool down, bool hovering); 1828 void abortPointerSimple(nsecs_t when, uint32_t policyFlags); 1829 1830 bool assignExternalStylusId(const RawState& state, bool timeout); 1831 void applyExternalStylusButtonState(nsecs_t when); 1832 void applyExternalStylusTouchState(nsecs_t when); 1833 1834 // Dispatches a motion event. 1835 // If the changedId is >= 0 and the action is POINTER_DOWN or POINTER_UP, the 1836 // method will take care of setting the index and transmuting the action to DOWN or UP 1837 // it is the first / last pointer to go down / up. 1838 void dispatchMotion(nsecs_t when, uint32_t policyFlags, uint32_t source, 1839 int32_t action, int32_t actionButton, 1840 int32_t flags, int32_t metaState, int32_t buttonState, int32_t edgeFlags, 1841 const PointerProperties* properties, const PointerCoords* coords, 1842 const uint32_t* idToIndex, BitSet32 idBits, 1843 int32_t changedId, float xPrecision, float yPrecision, nsecs_t downTime); 1844 1845 // Updates pointer coords and properties for pointers with specified ids that have moved. 1846 // Returns true if any of them changed. 1847 bool updateMovedPointers(const PointerProperties* inProperties, 1848 const PointerCoords* inCoords, const uint32_t* inIdToIndex, 1849 PointerProperties* outProperties, PointerCoords* outCoords, 1850 const uint32_t* outIdToIndex, BitSet32 idBits) const; 1851 1852 bool isPointInsideSurface(int32_t x, int32_t y); 1853 const VirtualKey* findVirtualKeyHit(int32_t x, int32_t y); 1854 1855 static void assignPointerIds(const RawState* last, RawState* current); 1856 1857 const char* modeToString(DeviceMode deviceMode); 1858 }; 1859 1860 1861 class SingleTouchInputMapper : public TouchInputMapper { 1862 public: 1863 explicit SingleTouchInputMapper(InputDevice* device); 1864 virtual ~SingleTouchInputMapper(); 1865 1866 virtual void reset(nsecs_t when); 1867 virtual void process(const RawEvent* rawEvent); 1868 1869 protected: 1870 virtual void syncTouch(nsecs_t when, RawState* outState); 1871 virtual void configureRawPointerAxes(); 1872 virtual bool hasStylus() const; 1873 1874 private: 1875 SingleTouchMotionAccumulator mSingleTouchMotionAccumulator; 1876 }; 1877 1878 1879 class MultiTouchInputMapper : public TouchInputMapper { 1880 public: 1881 explicit MultiTouchInputMapper(InputDevice* device); 1882 virtual ~MultiTouchInputMapper(); 1883 1884 virtual void reset(nsecs_t when); 1885 virtual void process(const RawEvent* rawEvent); 1886 1887 protected: 1888 virtual void syncTouch(nsecs_t when, RawState* outState); 1889 virtual void configureRawPointerAxes(); 1890 virtual bool hasStylus() const; 1891 1892 private: 1893 MultiTouchMotionAccumulator mMultiTouchMotionAccumulator; 1894 1895 // Specifies the pointer id bits that are in use, and their associated tracking id. 1896 BitSet32 mPointerIdBits; 1897 int32_t mPointerTrackingIdMap[MAX_POINTER_ID + 1]; 1898 }; 1899 1900 class ExternalStylusInputMapper : public InputMapper { 1901 public: 1902 explicit ExternalStylusInputMapper(InputDevice* device); 1903 virtual ~ExternalStylusInputMapper() = default; 1904 1905 virtual uint32_t getSources(); 1906 virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo); 1907 virtual void dump(String8& dump); 1908 virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes); 1909 virtual void reset(nsecs_t when); 1910 virtual void process(const RawEvent* rawEvent); 1911 virtual void sync(nsecs_t when); 1912 1913 private: 1914 SingleTouchMotionAccumulator mSingleTouchMotionAccumulator; 1915 RawAbsoluteAxisInfo mRawPressureAxis; 1916 TouchButtonAccumulator mTouchButtonAccumulator; 1917 1918 StylusState mStylusState; 1919 }; 1920 1921 1922 class JoystickInputMapper : public InputMapper { 1923 public: 1924 explicit JoystickInputMapper(InputDevice* device); 1925 virtual ~JoystickInputMapper(); 1926 1927 virtual uint32_t getSources(); 1928 virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo); 1929 virtual void dump(String8& dump); 1930 virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes); 1931 virtual void reset(nsecs_t when); 1932 virtual void process(const RawEvent* rawEvent); 1933 1934 private: 1935 struct Axis { 1936 RawAbsoluteAxisInfo rawAxisInfo; 1937 AxisInfo axisInfo; 1938 1939 bool explicitlyMapped; // true if the axis was explicitly assigned an axis id 1940 1941 float scale; // scale factor from raw to normalized values 1942 float offset; // offset to add after scaling for normalization 1943 float highScale; // scale factor from raw to normalized values of high split 1944 float highOffset; // offset to add after scaling for normalization of high split 1945 1946 float min; // normalized inclusive minimum 1947 float max; // normalized inclusive maximum 1948 float flat; // normalized flat region size 1949 float fuzz; // normalized error tolerance 1950 float resolution; // normalized resolution in units/mm 1951 1952 float filter; // filter out small variations of this size 1953 float currentValue; // current value 1954 float newValue; // most recent value 1955 float highCurrentValue; // current value of high split 1956 float highNewValue; // most recent value of high split 1957 initializeAxis1958 void initialize(const RawAbsoluteAxisInfo& rawAxisInfo, const AxisInfo& axisInfo, 1959 bool explicitlyMapped, float scale, float offset, 1960 float highScale, float highOffset, 1961 float min, float max, float flat, float fuzz, float resolution) { 1962 this->rawAxisInfo = rawAxisInfo; 1963 this->axisInfo = axisInfo; 1964 this->explicitlyMapped = explicitlyMapped; 1965 this->scale = scale; 1966 this->offset = offset; 1967 this->highScale = highScale; 1968 this->highOffset = highOffset; 1969 this->min = min; 1970 this->max = max; 1971 this->flat = flat; 1972 this->fuzz = fuzz; 1973 this->resolution = resolution; 1974 this->filter = 0; 1975 resetValue(); 1976 } 1977 resetValueAxis1978 void resetValue() { 1979 this->currentValue = 0; 1980 this->newValue = 0; 1981 this->highCurrentValue = 0; 1982 this->highNewValue = 0; 1983 } 1984 }; 1985 1986 // Axes indexed by raw ABS_* axis index. 1987 KeyedVector<int32_t, Axis> mAxes; 1988 1989 void sync(nsecs_t when, bool force); 1990 1991 bool haveAxis(int32_t axisId); 1992 void pruneAxes(bool ignoreExplicitlyMappedAxes); 1993 bool filterAxes(bool force); 1994 1995 static bool hasValueChangedSignificantly(float filter, 1996 float newValue, float currentValue, float min, float max); 1997 static bool hasMovedNearerToValueWithinFilteredRange(float filter, 1998 float newValue, float currentValue, float thresholdValue); 1999 2000 static bool isCenteredAxis(int32_t axis); 2001 static int32_t getCompatAxis(int32_t axis); 2002 2003 static void addMotionRange(int32_t axisId, const Axis& axis, InputDeviceInfo* info); 2004 static void setPointerCoordsAxisValue(PointerCoords* pointerCoords, int32_t axis, 2005 float value); 2006 }; 2007 2008 } // namespace android 2009 2010 #endif // _UI_INPUT_READER_H 2011