Input.h revision fd23e3ed976b22b9a92ddb2cb3a46f9d2a0ce23f
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 _ANDROIDFW_INPUT_H 18#define _ANDROIDFW_INPUT_H 19 20/** 21 * Native input event structures. 22 */ 23 24#include <android/input.h> 25#include <utils/Vector.h> 26#include <utils/KeyedVector.h> 27#include <utils/Timers.h> 28#include <utils/RefBase.h> 29#include <utils/String8.h> 30#include <utils/BitSet.h> 31 32#ifdef HAVE_ANDROID_OS 33class SkMatrix; 34#endif 35 36/* 37 * Additional private constants not defined in ndk/ui/input.h. 38 */ 39enum { 40 /* Private control to determine when an app is tracking a key sequence. */ 41 AKEY_EVENT_FLAG_START_TRACKING = 0x40000000, 42 43 /* Key event is inconsistent with previously sent key events. */ 44 AKEY_EVENT_FLAG_TAINTED = 0x80000000, 45}; 46 47enum { 48 /* Motion event is inconsistent with previously sent motion events. */ 49 AMOTION_EVENT_FLAG_TAINTED = 0x80000000, 50}; 51 52enum { 53 /* 54 * Indicates that an input device has switches. 55 * This input source flag is hidden from the API because switches are only used by the system 56 * and applications have no way to interact with them. 57 */ 58 AINPUT_SOURCE_SWITCH = 0x80000000, 59}; 60 61/* 62 * SystemUiVisibility constants from View. 63 */ 64enum { 65 ASYSTEM_UI_VISIBILITY_STATUS_BAR_VISIBLE = 0, 66 ASYSTEM_UI_VISIBILITY_STATUS_BAR_HIDDEN = 0x00000001, 67}; 68 69/* 70 * Maximum number of pointers supported per motion event. 71 * Smallest number of pointers is 1. 72 * (We want at least 10 but some touch controllers obstensibly configured for 10 pointers 73 * will occasionally emit 11. There is not much harm making this constant bigger.) 74 */ 75#define MAX_POINTERS 16 76 77/* 78 * Maximum pointer id value supported in a motion event. 79 * Smallest pointer id is 0. 80 * (This is limited by our use of BitSet32 to track pointer assignments.) 81 */ 82#define MAX_POINTER_ID 31 83 84/* 85 * Declare a concrete type for the NDK's input event forward declaration. 86 */ 87struct AInputEvent { 88 virtual ~AInputEvent() { } 89}; 90 91/* 92 * Declare a concrete type for the NDK's input device forward declaration. 93 */ 94struct AInputDevice { 95 virtual ~AInputDevice() { } 96}; 97 98 99namespace android { 100 101#ifdef HAVE_ANDROID_OS 102class Parcel; 103#endif 104 105/* 106 * Flags that flow alongside events in the input dispatch system to help with certain 107 * policy decisions such as waking from device sleep. 108 * 109 * These flags are also defined in frameworks/base/core/java/android/view/WindowManagerPolicy.java. 110 */ 111enum { 112 /* These flags originate in RawEvents and are generally set in the key map. 113 * NOTE: If you edit these flags, also edit labels in KeycodeLabels.h. */ 114 115 POLICY_FLAG_WAKE = 0x00000001, 116 POLICY_FLAG_WAKE_DROPPED = 0x00000002, 117 POLICY_FLAG_SHIFT = 0x00000004, 118 POLICY_FLAG_CAPS_LOCK = 0x00000008, 119 POLICY_FLAG_ALT = 0x00000010, 120 POLICY_FLAG_ALT_GR = 0x00000020, 121 POLICY_FLAG_MENU = 0x00000040, 122 POLICY_FLAG_LAUNCHER = 0x00000080, 123 POLICY_FLAG_VIRTUAL = 0x00000100, 124 POLICY_FLAG_FUNCTION = 0x00000200, 125 126 POLICY_FLAG_RAW_MASK = 0x0000ffff, 127 128 /* These flags are set by the input dispatcher. */ 129 130 // Indicates that the input event was injected. 131 POLICY_FLAG_INJECTED = 0x01000000, 132 133 // Indicates that the input event is from a trusted source such as a directly attached 134 // input device or an application with system-wide event injection permission. 135 POLICY_FLAG_TRUSTED = 0x02000000, 136 137 // Indicates that the input event has passed through an input filter. 138 POLICY_FLAG_FILTERED = 0x04000000, 139 140 // Disables automatic key repeating behavior. 141 POLICY_FLAG_DISABLE_KEY_REPEAT = 0x08000000, 142 143 /* These flags are set by the input reader policy as it intercepts each event. */ 144 145 // Indicates that the screen was off when the event was received and the event 146 // should wake the device. 147 POLICY_FLAG_WOKE_HERE = 0x10000000, 148 149 // Indicates that the screen was dim when the event was received and the event 150 // should brighten the device. 151 POLICY_FLAG_BRIGHT_HERE = 0x20000000, 152 153 // Indicates that the event should be dispatched to applications. 154 // The input event should still be sent to the InputDispatcher so that it can see all 155 // input events received include those that it will not deliver. 156 POLICY_FLAG_PASS_TO_USER = 0x40000000, 157}; 158 159/* 160 * Pointer coordinate data. 161 */ 162struct PointerCoords { 163 enum { MAX_AXES = 14 }; // 14 so that sizeof(PointerCoords) == 64 164 165 // Bitfield of axes that are present in this structure. 166 uint64_t bits; 167 168 // Values of axes that are stored in this structure packed in order by axis id 169 // for each axis that is present in the structure according to 'bits'. 170 float values[MAX_AXES]; 171 172 inline void clear() { 173 bits = 0; 174 } 175 176 float getAxisValue(int32_t axis) const; 177 status_t setAxisValue(int32_t axis, float value); 178 179 void scale(float scale); 180 void lerp(const PointerCoords& a, const PointerCoords& b, float alpha); 181 182 inline float getX() const { 183 return getAxisValue(AMOTION_EVENT_AXIS_X); 184 } 185 186 inline float getY() const { 187 return getAxisValue(AMOTION_EVENT_AXIS_Y); 188 } 189 190#ifdef HAVE_ANDROID_OS 191 status_t readFromParcel(Parcel* parcel); 192 status_t writeToParcel(Parcel* parcel) const; 193#endif 194 195 bool operator==(const PointerCoords& other) const; 196 inline bool operator!=(const PointerCoords& other) const { 197 return !(*this == other); 198 } 199 200 void copyFrom(const PointerCoords& other); 201 202private: 203 void tooManyAxes(int axis); 204}; 205 206/* 207 * Pointer property data. 208 */ 209struct PointerProperties { 210 // The id of the pointer. 211 int32_t id; 212 213 // The pointer tool type. 214 int32_t toolType; 215 216 inline void clear() { 217 id = -1; 218 toolType = 0; 219 } 220 221 bool operator==(const PointerProperties& other) const; 222 inline bool operator!=(const PointerProperties& other) const { 223 return !(*this == other); 224 } 225 226 void copyFrom(const PointerProperties& other); 227}; 228 229/* 230 * Input events. 231 */ 232class InputEvent : public AInputEvent { 233public: 234 virtual ~InputEvent() { } 235 236 virtual int32_t getType() const = 0; 237 238 inline int32_t getDeviceId() const { return mDeviceId; } 239 240 inline int32_t getSource() const { return mSource; } 241 242 inline void setSource(int32_t source) { mSource = source; } 243 244protected: 245 void initialize(int32_t deviceId, int32_t source); 246 void initialize(const InputEvent& from); 247 248 int32_t mDeviceId; 249 int32_t mSource; 250}; 251 252/* 253 * Key events. 254 */ 255class KeyEvent : public InputEvent { 256public: 257 virtual ~KeyEvent() { } 258 259 virtual int32_t getType() const { return AINPUT_EVENT_TYPE_KEY; } 260 261 inline int32_t getAction() const { return mAction; } 262 263 inline int32_t getFlags() const { return mFlags; } 264 265 inline void setFlags(int32_t flags) { mFlags = flags; } 266 267 inline int32_t getKeyCode() const { return mKeyCode; } 268 269 inline int32_t getScanCode() const { return mScanCode; } 270 271 inline int32_t getMetaState() const { return mMetaState; } 272 273 inline int32_t getRepeatCount() const { return mRepeatCount; } 274 275 inline nsecs_t getDownTime() const { return mDownTime; } 276 277 inline nsecs_t getEventTime() const { return mEventTime; } 278 279 // Return true if this event may have a default action implementation. 280 static bool hasDefaultAction(int32_t keyCode); 281 bool hasDefaultAction() const; 282 283 // Return true if this event represents a system key. 284 static bool isSystemKey(int32_t keyCode); 285 bool isSystemKey() const; 286 287 void initialize( 288 int32_t deviceId, 289 int32_t source, 290 int32_t action, 291 int32_t flags, 292 int32_t keyCode, 293 int32_t scanCode, 294 int32_t metaState, 295 int32_t repeatCount, 296 nsecs_t downTime, 297 nsecs_t eventTime); 298 void initialize(const KeyEvent& from); 299 300protected: 301 int32_t mAction; 302 int32_t mFlags; 303 int32_t mKeyCode; 304 int32_t mScanCode; 305 int32_t mMetaState; 306 int32_t mRepeatCount; 307 nsecs_t mDownTime; 308 nsecs_t mEventTime; 309}; 310 311/* 312 * Motion events. 313 */ 314class MotionEvent : public InputEvent { 315public: 316 virtual ~MotionEvent() { } 317 318 virtual int32_t getType() const { return AINPUT_EVENT_TYPE_MOTION; } 319 320 inline int32_t getAction() const { return mAction; } 321 322 inline int32_t getActionMasked() const { return mAction & AMOTION_EVENT_ACTION_MASK; } 323 324 inline int32_t getActionIndex() const { 325 return (mAction & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) 326 >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT; 327 } 328 329 inline void setAction(int32_t action) { mAction = action; } 330 331 inline int32_t getFlags() const { return mFlags; } 332 333 inline void setFlags(int32_t flags) { mFlags = flags; } 334 335 inline int32_t getEdgeFlags() const { return mEdgeFlags; } 336 337 inline void setEdgeFlags(int32_t edgeFlags) { mEdgeFlags = edgeFlags; } 338 339 inline int32_t getMetaState() const { return mMetaState; } 340 341 inline void setMetaState(int32_t metaState) { mMetaState = metaState; } 342 343 inline int32_t getButtonState() const { return mButtonState; } 344 345 inline float getXOffset() const { return mXOffset; } 346 347 inline float getYOffset() const { return mYOffset; } 348 349 inline float getXPrecision() const { return mXPrecision; } 350 351 inline float getYPrecision() const { return mYPrecision; } 352 353 inline nsecs_t getDownTime() const { return mDownTime; } 354 355 inline void setDownTime(nsecs_t downTime) { mDownTime = downTime; } 356 357 inline size_t getPointerCount() const { return mPointerProperties.size(); } 358 359 inline const PointerProperties* getPointerProperties(size_t pointerIndex) const { 360 return &mPointerProperties[pointerIndex]; 361 } 362 363 inline int32_t getPointerId(size_t pointerIndex) const { 364 return mPointerProperties[pointerIndex].id; 365 } 366 367 inline int32_t getToolType(size_t pointerIndex) const { 368 return mPointerProperties[pointerIndex].toolType; 369 } 370 371 inline nsecs_t getEventTime() const { return mSampleEventTimes[getHistorySize()]; } 372 373 const PointerCoords* getRawPointerCoords(size_t pointerIndex) const; 374 375 float getRawAxisValue(int32_t axis, size_t pointerIndex) const; 376 377 inline float getRawX(size_t pointerIndex) const { 378 return getRawAxisValue(AMOTION_EVENT_AXIS_X, pointerIndex); 379 } 380 381 inline float getRawY(size_t pointerIndex) const { 382 return getRawAxisValue(AMOTION_EVENT_AXIS_Y, pointerIndex); 383 } 384 385 float getAxisValue(int32_t axis, size_t pointerIndex) const; 386 387 inline float getX(size_t pointerIndex) const { 388 return getAxisValue(AMOTION_EVENT_AXIS_X, pointerIndex); 389 } 390 391 inline float getY(size_t pointerIndex) const { 392 return getAxisValue(AMOTION_EVENT_AXIS_Y, pointerIndex); 393 } 394 395 inline float getPressure(size_t pointerIndex) const { 396 return getAxisValue(AMOTION_EVENT_AXIS_PRESSURE, pointerIndex); 397 } 398 399 inline float getSize(size_t pointerIndex) const { 400 return getAxisValue(AMOTION_EVENT_AXIS_SIZE, pointerIndex); 401 } 402 403 inline float getTouchMajor(size_t pointerIndex) const { 404 return getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, pointerIndex); 405 } 406 407 inline float getTouchMinor(size_t pointerIndex) const { 408 return getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, pointerIndex); 409 } 410 411 inline float getToolMajor(size_t pointerIndex) const { 412 return getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, pointerIndex); 413 } 414 415 inline float getToolMinor(size_t pointerIndex) const { 416 return getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, pointerIndex); 417 } 418 419 inline float getOrientation(size_t pointerIndex) const { 420 return getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, pointerIndex); 421 } 422 423 inline size_t getHistorySize() const { return mSampleEventTimes.size() - 1; } 424 425 inline nsecs_t getHistoricalEventTime(size_t historicalIndex) const { 426 return mSampleEventTimes[historicalIndex]; 427 } 428 429 const PointerCoords* getHistoricalRawPointerCoords( 430 size_t pointerIndex, size_t historicalIndex) const; 431 432 float getHistoricalRawAxisValue(int32_t axis, size_t pointerIndex, 433 size_t historicalIndex) const; 434 435 inline float getHistoricalRawX(size_t pointerIndex, size_t historicalIndex) const { 436 return getHistoricalRawAxisValue( 437 AMOTION_EVENT_AXIS_X, pointerIndex, historicalIndex); 438 } 439 440 inline float getHistoricalRawY(size_t pointerIndex, size_t historicalIndex) const { 441 return getHistoricalRawAxisValue( 442 AMOTION_EVENT_AXIS_Y, pointerIndex, historicalIndex); 443 } 444 445 float getHistoricalAxisValue(int32_t axis, size_t pointerIndex, size_t historicalIndex) const; 446 447 inline float getHistoricalX(size_t pointerIndex, size_t historicalIndex) const { 448 return getHistoricalAxisValue( 449 AMOTION_EVENT_AXIS_X, pointerIndex, historicalIndex); 450 } 451 452 inline float getHistoricalY(size_t pointerIndex, size_t historicalIndex) const { 453 return getHistoricalAxisValue( 454 AMOTION_EVENT_AXIS_Y, pointerIndex, historicalIndex); 455 } 456 457 inline float getHistoricalPressure(size_t pointerIndex, size_t historicalIndex) const { 458 return getHistoricalAxisValue( 459 AMOTION_EVENT_AXIS_PRESSURE, pointerIndex, historicalIndex); 460 } 461 462 inline float getHistoricalSize(size_t pointerIndex, size_t historicalIndex) const { 463 return getHistoricalAxisValue( 464 AMOTION_EVENT_AXIS_SIZE, pointerIndex, historicalIndex); 465 } 466 467 inline float getHistoricalTouchMajor(size_t pointerIndex, size_t historicalIndex) const { 468 return getHistoricalAxisValue( 469 AMOTION_EVENT_AXIS_TOUCH_MAJOR, pointerIndex, historicalIndex); 470 } 471 472 inline float getHistoricalTouchMinor(size_t pointerIndex, size_t historicalIndex) const { 473 return getHistoricalAxisValue( 474 AMOTION_EVENT_AXIS_TOUCH_MINOR, pointerIndex, historicalIndex); 475 } 476 477 inline float getHistoricalToolMajor(size_t pointerIndex, size_t historicalIndex) const { 478 return getHistoricalAxisValue( 479 AMOTION_EVENT_AXIS_TOOL_MAJOR, pointerIndex, historicalIndex); 480 } 481 482 inline float getHistoricalToolMinor(size_t pointerIndex, size_t historicalIndex) const { 483 return getHistoricalAxisValue( 484 AMOTION_EVENT_AXIS_TOOL_MINOR, pointerIndex, historicalIndex); 485 } 486 487 inline float getHistoricalOrientation(size_t pointerIndex, size_t historicalIndex) const { 488 return getHistoricalAxisValue( 489 AMOTION_EVENT_AXIS_ORIENTATION, pointerIndex, historicalIndex); 490 } 491 492 ssize_t findPointerIndex(int32_t pointerId) const; 493 494 void initialize( 495 int32_t deviceId, 496 int32_t source, 497 int32_t action, 498 int32_t flags, 499 int32_t edgeFlags, 500 int32_t metaState, 501 int32_t buttonState, 502 float xOffset, 503 float yOffset, 504 float xPrecision, 505 float yPrecision, 506 nsecs_t downTime, 507 nsecs_t eventTime, 508 size_t pointerCount, 509 const PointerProperties* pointerProperties, 510 const PointerCoords* pointerCoords); 511 512 void copyFrom(const MotionEvent* other, bool keepHistory); 513 514 void addSample( 515 nsecs_t eventTime, 516 const PointerCoords* pointerCoords); 517 518 void offsetLocation(float xOffset, float yOffset); 519 520 void scale(float scaleFactor); 521 522#ifdef HAVE_ANDROID_OS 523 void transform(const SkMatrix* matrix); 524 525 status_t readFromParcel(Parcel* parcel); 526 status_t writeToParcel(Parcel* parcel) const; 527#endif 528 529 static bool isTouchEvent(int32_t source, int32_t action); 530 inline bool isTouchEvent() const { 531 return isTouchEvent(mSource, mAction); 532 } 533 534 // Low-level accessors. 535 inline const PointerProperties* getPointerProperties() const { 536 return mPointerProperties.array(); 537 } 538 inline const nsecs_t* getSampleEventTimes() const { return mSampleEventTimes.array(); } 539 inline const PointerCoords* getSamplePointerCoords() const { 540 return mSamplePointerCoords.array(); 541 } 542 543protected: 544 int32_t mAction; 545 int32_t mFlags; 546 int32_t mEdgeFlags; 547 int32_t mMetaState; 548 int32_t mButtonState; 549 float mXOffset; 550 float mYOffset; 551 float mXPrecision; 552 float mYPrecision; 553 nsecs_t mDownTime; 554 Vector<PointerProperties> mPointerProperties; 555 Vector<nsecs_t> mSampleEventTimes; 556 Vector<PointerCoords> mSamplePointerCoords; 557}; 558 559/* 560 * Input event factory. 561 */ 562class InputEventFactoryInterface { 563protected: 564 virtual ~InputEventFactoryInterface() { } 565 566public: 567 InputEventFactoryInterface() { } 568 569 virtual KeyEvent* createKeyEvent() = 0; 570 virtual MotionEvent* createMotionEvent() = 0; 571}; 572 573/* 574 * A simple input event factory implementation that uses a single preallocated instance 575 * of each type of input event that are reused for each request. 576 */ 577class PreallocatedInputEventFactory : public InputEventFactoryInterface { 578public: 579 PreallocatedInputEventFactory() { } 580 virtual ~PreallocatedInputEventFactory() { } 581 582 virtual KeyEvent* createKeyEvent() { return & mKeyEvent; } 583 virtual MotionEvent* createMotionEvent() { return & mMotionEvent; } 584 585private: 586 KeyEvent mKeyEvent; 587 MotionEvent mMotionEvent; 588}; 589 590/* 591 * An input event factory implementation that maintains a pool of input events. 592 */ 593class PooledInputEventFactory : public InputEventFactoryInterface { 594public: 595 PooledInputEventFactory(size_t maxPoolSize = 20); 596 virtual ~PooledInputEventFactory(); 597 598 virtual KeyEvent* createKeyEvent(); 599 virtual MotionEvent* createMotionEvent(); 600 601 void recycle(InputEvent* event); 602 603private: 604 const size_t mMaxPoolSize; 605 606 Vector<KeyEvent*> mKeyEventPool; 607 Vector<MotionEvent*> mMotionEventPool; 608}; 609 610/* 611 * Calculates the velocity of pointer movements over time. 612 */ 613class VelocityTracker { 614public: 615 // Default polynomial degree. (used by getVelocity) 616 static const uint32_t DEFAULT_DEGREE = 2; 617 618 // Default sample horizon. (used by getVelocity) 619 // We don't use too much history by default since we want to react to quick 620 // changes in direction. 621 static const nsecs_t DEFAULT_HORIZON = 100 * 1000000; // 100 ms 622 623 struct Position { 624 float x, y; 625 }; 626 627 struct Estimator { 628 static const size_t MAX_DEGREE = 2; 629 630 // Polynomial coefficients describing motion in X and Y. 631 float xCoeff[MAX_DEGREE + 1], yCoeff[MAX_DEGREE + 1]; 632 633 // Polynomial degree (number of coefficients), or zero if no information is 634 // available. 635 uint32_t degree; 636 637 // Confidence (coefficient of determination), between 0 (no fit) and 1 (perfect fit). 638 float confidence; 639 640 inline void clear() { 641 degree = 0; 642 confidence = 0; 643 for (size_t i = 0; i <= MAX_DEGREE; i++) { 644 xCoeff[i] = 0; 645 yCoeff[i] = 0; 646 } 647 } 648 }; 649 650 VelocityTracker(); 651 652 // Resets the velocity tracker state. 653 void clear(); 654 655 // Resets the velocity tracker state for specific pointers. 656 // Call this method when some pointers have changed and may be reusing 657 // an id that was assigned to a different pointer earlier. 658 void clearPointers(BitSet32 idBits); 659 660 // Adds movement information for a set of pointers. 661 // The idBits bitfield specifies the pointer ids of the pointers whose positions 662 // are included in the movement. 663 // The positions array contains position information for each pointer in order by 664 // increasing id. Its size should be equal to the number of one bits in idBits. 665 void addMovement(nsecs_t eventTime, BitSet32 idBits, const Position* positions); 666 667 // Adds movement information for all pointers in a MotionEvent, including historical samples. 668 void addMovement(const MotionEvent* event); 669 670 // Gets the velocity of the specified pointer id in position units per second. 671 // Returns false and sets the velocity components to zero if there is 672 // insufficient movement information for the pointer. 673 bool getVelocity(uint32_t id, float* outVx, float* outVy) const; 674 675 // Gets a quadratic estimator for the movements of the specified pointer id. 676 // Returns false and clears the estimator if there is no information available 677 // about the pointer. 678 bool getEstimator(uint32_t id, uint32_t degree, nsecs_t horizon, 679 Estimator* outEstimator) const; 680 681 // Gets the active pointer id, or -1 if none. 682 inline int32_t getActivePointerId() const { return mActivePointerId; } 683 684 // Gets a bitset containing all pointer ids from the most recent movement. 685 inline BitSet32 getCurrentPointerIdBits() const { return mMovements[mIndex].idBits; } 686 687private: 688 // Number of samples to keep. 689 static const uint32_t HISTORY_SIZE = 20; 690 691 struct Movement { 692 nsecs_t eventTime; 693 BitSet32 idBits; 694 Position positions[MAX_POINTERS]; 695 696 inline const Position& getPosition(uint32_t id) const { 697 return positions[idBits.getIndexOfBit(id)]; 698 } 699 }; 700 701 uint32_t mIndex; 702 Movement mMovements[HISTORY_SIZE]; 703 int32_t mActivePointerId; 704}; 705 706 707/* 708 * Specifies parameters that govern pointer or wheel acceleration. 709 */ 710struct VelocityControlParameters { 711 // A scale factor that is multiplied with the raw velocity deltas 712 // prior to applying any other velocity control factors. The scale 713 // factor should be used to adapt the input device resolution 714 // (eg. counts per inch) to the output device resolution (eg. pixels per inch). 715 // 716 // Must be a positive value. 717 // Default is 1.0 (no scaling). 718 float scale; 719 720 // The scaled speed at which acceleration begins to be applied. 721 // This value establishes the upper bound of a low speed regime for 722 // small precise motions that are performed without any acceleration. 723 // 724 // Must be a non-negative value. 725 // Default is 0.0 (no low threshold). 726 float lowThreshold; 727 728 // The scaled speed at which maximum acceleration is applied. 729 // The difference between highThreshold and lowThreshold controls 730 // the range of speeds over which the acceleration factor is interpolated. 731 // The wider the range, the smoother the acceleration. 732 // 733 // Must be a non-negative value greater than or equal to lowThreshold. 734 // Default is 0.0 (no high threshold). 735 float highThreshold; 736 737 // The acceleration factor. 738 // When the speed is above the low speed threshold, the velocity will scaled 739 // by an interpolated value between 1.0 and this amount. 740 // 741 // Must be a positive greater than or equal to 1.0. 742 // Default is 1.0 (no acceleration). 743 float acceleration; 744 745 VelocityControlParameters() : 746 scale(1.0f), lowThreshold(0.0f), highThreshold(0.0f), acceleration(1.0f) { 747 } 748 749 VelocityControlParameters(float scale, float lowThreshold, 750 float highThreshold, float acceleration) : 751 scale(scale), lowThreshold(lowThreshold), 752 highThreshold(highThreshold), acceleration(acceleration) { 753 } 754}; 755 756/* 757 * Implements mouse pointer and wheel speed control and acceleration. 758 */ 759class VelocityControl { 760public: 761 VelocityControl(); 762 763 /* Sets the various parameters. */ 764 void setParameters(const VelocityControlParameters& parameters); 765 766 /* Resets the current movement counters to zero. 767 * This has the effect of nullifying any acceleration. */ 768 void reset(); 769 770 /* Translates a raw movement delta into an appropriately 771 * scaled / accelerated delta based on the current velocity. */ 772 void move(nsecs_t eventTime, float* deltaX, float* deltaY); 773 774private: 775 // If no movements are received within this amount of time, 776 // we assume the movement has stopped and reset the movement counters. 777 static const nsecs_t STOP_TIME = 500 * 1000000; // 500 ms 778 779 VelocityControlParameters mParameters; 780 781 nsecs_t mLastMovementTime; 782 VelocityTracker::Position mRawPosition; 783 VelocityTracker mVelocityTracker; 784}; 785 786} // namespace android 787 788#endif // _ANDROIDFW_INPUT_H 789