InputReader_test.cpp revision 89de57a8d252a25ef2412a11a66089a9ff6ffe29
1// 2// Copyright 2010 The Android Open Source Project 3// 4 5#include "../InputReader.h" 6 7#include <utils/List.h> 8#include <gtest/gtest.h> 9#include <math.h> 10 11namespace android { 12 13// An arbitrary time value. 14static const nsecs_t ARBITRARY_TIME = 1234; 15 16// Arbitrary display properties. 17static const int32_t DISPLAY_ID = 0; 18static const int32_t DISPLAY_WIDTH = 480; 19static const int32_t DISPLAY_HEIGHT = 800; 20 21// Error tolerance for floating point assertions. 22static const float EPSILON = 0.001f; 23 24template<typename T> 25static inline T min(T a, T b) { 26 return a < b ? a : b; 27} 28 29static inline float avg(float x, float y) { 30 return (x + y) / 2; 31} 32 33 34// --- FakePointerController --- 35 36class FakePointerController : public PointerControllerInterface { 37 bool mHaveBounds; 38 float mMinX, mMinY, mMaxX, mMaxY; 39 40protected: 41 virtual ~FakePointerController() { } 42 43public: 44 FakePointerController() : 45 mHaveBounds(false), mMinX(0), mMinY(0), mMaxX(0), mMaxY(0) { 46 } 47 48 void setBounds(float minX, float minY, float maxX, float maxY) { 49 mHaveBounds = true; 50 mMinX = minX; 51 mMinY = minY; 52 mMaxX = maxX; 53 mMaxY = maxY; 54 } 55 56private: 57 virtual bool getBounds(float* outMinX, float* outMinY, float* outMaxX, float* outMaxY) const { 58 *outMinX = mMinX; 59 *outMinY = mMinY; 60 *outMaxX = mMaxX; 61 *outMaxY = mMaxY; 62 return mHaveBounds; 63 } 64 65 virtual void move(float deltaX, float deltaY) { 66 } 67 68 virtual void setButtonState(uint32_t buttonState) { 69 } 70 71 virtual uint32_t getButtonState() const { 72 return 0; 73 } 74 75 virtual void setPosition(float x, float y) { 76 } 77 78 virtual void getPosition(float* outX, float* outY) const { 79 *outX = 0; 80 *outY = 0; 81 } 82}; 83 84 85// --- FakeInputReaderPolicy --- 86 87class FakeInputReaderPolicy : public InputReaderPolicyInterface { 88 struct DisplayInfo { 89 int32_t width; 90 int32_t height; 91 int32_t orientation; 92 }; 93 94 KeyedVector<int32_t, DisplayInfo> mDisplayInfos; 95 bool mFilterTouchEvents; 96 bool mFilterJumpyTouchEvents; 97 Vector<String8> mExcludedDeviceNames; 98 KeyedVector<int32_t, sp<FakePointerController> > mPointerControllers; 99 100protected: 101 virtual ~FakeInputReaderPolicy() { } 102 103public: 104 FakeInputReaderPolicy() : 105 mFilterTouchEvents(false), mFilterJumpyTouchEvents(false) { 106 } 107 108 void removeDisplayInfo(int32_t displayId) { 109 mDisplayInfos.removeItem(displayId); 110 } 111 112 void setDisplayInfo(int32_t displayId, int32_t width, int32_t height, int32_t orientation) { 113 removeDisplayInfo(displayId); 114 115 DisplayInfo info; 116 info.width = width; 117 info.height = height; 118 info.orientation = orientation; 119 mDisplayInfos.add(displayId, info); 120 } 121 122 void setFilterTouchEvents(bool enabled) { 123 mFilterTouchEvents = enabled; 124 } 125 126 void setFilterJumpyTouchEvents(bool enabled) { 127 mFilterJumpyTouchEvents = enabled; 128 } 129 130 virtual nsecs_t getVirtualKeyQuietTime() { 131 return 0; 132 } 133 134 void addExcludedDeviceName(const String8& deviceName) { 135 mExcludedDeviceNames.push(deviceName); 136 } 137 138 void setPointerController(int32_t deviceId, const sp<FakePointerController>& controller) { 139 mPointerControllers.add(deviceId, controller); 140 } 141 142private: 143 virtual bool getDisplayInfo(int32_t displayId, 144 int32_t* width, int32_t* height, int32_t* orientation) { 145 ssize_t index = mDisplayInfos.indexOfKey(displayId); 146 if (index >= 0) { 147 const DisplayInfo& info = mDisplayInfos.valueAt(index); 148 if (width) { 149 *width = info.width; 150 } 151 if (height) { 152 *height = info.height; 153 } 154 if (orientation) { 155 *orientation = info.orientation; 156 } 157 return true; 158 } 159 return false; 160 } 161 162 virtual bool filterTouchEvents() { 163 return mFilterTouchEvents; 164 } 165 166 virtual bool filterJumpyTouchEvents() { 167 return mFilterJumpyTouchEvents; 168 } 169 170 virtual void getExcludedDeviceNames(Vector<String8>& outExcludedDeviceNames) { 171 outExcludedDeviceNames.appendVector(mExcludedDeviceNames); 172 } 173 174 virtual sp<PointerControllerInterface> obtainPointerController(int32_t deviceId) { 175 return mPointerControllers.valueFor(deviceId); 176 } 177}; 178 179 180// --- FakeInputDispatcher --- 181 182class FakeInputDispatcher : public InputDispatcherInterface { 183public: 184 struct NotifyConfigurationChangedArgs { 185 nsecs_t eventTime; 186 }; 187 188 struct NotifyKeyArgs { 189 nsecs_t eventTime; 190 int32_t deviceId; 191 int32_t source; 192 uint32_t policyFlags; 193 int32_t action; 194 int32_t flags; 195 int32_t keyCode; 196 int32_t scanCode; 197 int32_t metaState; 198 nsecs_t downTime; 199 }; 200 201 struct NotifyMotionArgs { 202 nsecs_t eventTime; 203 int32_t deviceId; 204 int32_t source; 205 uint32_t policyFlags; 206 int32_t action; 207 int32_t flags; 208 int32_t metaState; 209 int32_t edgeFlags; 210 uint32_t pointerCount; 211 Vector<int32_t> pointerIds; 212 Vector<PointerCoords> pointerCoords; 213 float xPrecision; 214 float yPrecision; 215 nsecs_t downTime; 216 }; 217 218 struct NotifySwitchArgs { 219 nsecs_t when; 220 int32_t switchCode; 221 int32_t switchValue; 222 uint32_t policyFlags; 223 }; 224 225private: 226 List<NotifyConfigurationChangedArgs> mNotifyConfigurationChangedArgs; 227 List<NotifyKeyArgs> mNotifyKeyArgs; 228 List<NotifyMotionArgs> mNotifyMotionArgs; 229 List<NotifySwitchArgs> mNotifySwitchArgs; 230 231protected: 232 virtual ~FakeInputDispatcher() { } 233 234public: 235 FakeInputDispatcher() { 236 } 237 238 void assertNotifyConfigurationChangedWasCalled(NotifyConfigurationChangedArgs* outArgs = NULL) { 239 ASSERT_FALSE(mNotifyConfigurationChangedArgs.empty()) 240 << "Expected notifyConfigurationChanged() to have been called."; 241 if (outArgs) { 242 *outArgs = *mNotifyConfigurationChangedArgs.begin(); 243 } 244 mNotifyConfigurationChangedArgs.erase(mNotifyConfigurationChangedArgs.begin()); 245 } 246 247 void assertNotifyKeyWasCalled(NotifyKeyArgs* outArgs = NULL) { 248 ASSERT_FALSE(mNotifyKeyArgs.empty()) 249 << "Expected notifyKey() to have been called."; 250 if (outArgs) { 251 *outArgs = *mNotifyKeyArgs.begin(); 252 } 253 mNotifyKeyArgs.erase(mNotifyKeyArgs.begin()); 254 } 255 256 void assertNotifyKeyWasNotCalled() { 257 ASSERT_TRUE(mNotifyKeyArgs.empty()) 258 << "Expected notifyKey() to not have been called."; 259 } 260 261 void assertNotifyMotionWasCalled(NotifyMotionArgs* outArgs = NULL) { 262 ASSERT_FALSE(mNotifyMotionArgs.empty()) 263 << "Expected notifyMotion() to have been called."; 264 if (outArgs) { 265 *outArgs = *mNotifyMotionArgs.begin(); 266 } 267 mNotifyMotionArgs.erase(mNotifyMotionArgs.begin()); 268 } 269 270 void assertNotifyMotionWasNotCalled() { 271 ASSERT_TRUE(mNotifyMotionArgs.empty()) 272 << "Expected notifyMotion() to not have been called."; 273 } 274 275 void assertNotifySwitchWasCalled(NotifySwitchArgs* outArgs = NULL) { 276 ASSERT_FALSE(mNotifySwitchArgs.empty()) 277 << "Expected notifySwitch() to have been called."; 278 if (outArgs) { 279 *outArgs = *mNotifySwitchArgs.begin(); 280 } 281 mNotifySwitchArgs.erase(mNotifySwitchArgs.begin()); 282 } 283 284private: 285 virtual void notifyConfigurationChanged(nsecs_t eventTime) { 286 NotifyConfigurationChangedArgs args; 287 args.eventTime = eventTime; 288 mNotifyConfigurationChangedArgs.push_back(args); 289 } 290 291 virtual void notifyKey(nsecs_t eventTime, int32_t deviceId, int32_t source, 292 uint32_t policyFlags, int32_t action, int32_t flags, int32_t keyCode, 293 int32_t scanCode, int32_t metaState, nsecs_t downTime) { 294 NotifyKeyArgs args; 295 args.eventTime = eventTime; 296 args.deviceId = deviceId; 297 args.source = source; 298 args.policyFlags = policyFlags; 299 args.action = action; 300 args.flags = flags; 301 args.keyCode = keyCode; 302 args.scanCode = scanCode; 303 args.metaState = metaState; 304 args.downTime = downTime; 305 mNotifyKeyArgs.push_back(args); 306 } 307 308 virtual void notifyMotion(nsecs_t eventTime, int32_t deviceId, int32_t source, 309 uint32_t policyFlags, int32_t action, int32_t flags, 310 int32_t metaState, int32_t edgeFlags, 311 uint32_t pointerCount, const int32_t* pointerIds, const PointerCoords* pointerCoords, 312 float xPrecision, float yPrecision, nsecs_t downTime) { 313 NotifyMotionArgs args; 314 args.eventTime = eventTime; 315 args.deviceId = deviceId; 316 args.source = source; 317 args.policyFlags = policyFlags; 318 args.action = action; 319 args.flags = flags; 320 args.metaState = metaState; 321 args.edgeFlags = edgeFlags; 322 args.pointerCount = pointerCount; 323 args.pointerIds.clear(); 324 args.pointerIds.appendArray(pointerIds, pointerCount); 325 args.pointerCoords.clear(); 326 args.pointerCoords.appendArray(pointerCoords, pointerCount); 327 args.xPrecision = xPrecision; 328 args.yPrecision = yPrecision; 329 args.downTime = downTime; 330 mNotifyMotionArgs.push_back(args); 331 } 332 333 virtual void notifySwitch(nsecs_t when, 334 int32_t switchCode, int32_t switchValue, uint32_t policyFlags) { 335 NotifySwitchArgs args; 336 args.when = when; 337 args.switchCode = switchCode; 338 args.switchValue = switchValue; 339 args.policyFlags = policyFlags; 340 mNotifySwitchArgs.push_back(args); 341 } 342 343 virtual void dump(String8& dump) { 344 ADD_FAILURE() << "Should never be called by input reader."; 345 } 346 347 virtual void dispatchOnce() { 348 ADD_FAILURE() << "Should never be called by input reader."; 349 } 350 351 virtual int32_t injectInputEvent(const InputEvent* event, 352 int32_t injectorPid, int32_t injectorUid, int32_t syncMode, int32_t timeoutMillis) { 353 ADD_FAILURE() << "Should never be called by input reader."; 354 return INPUT_EVENT_INJECTION_FAILED; 355 } 356 357 virtual void setInputWindows(const Vector<InputWindow>& inputWindows) { 358 ADD_FAILURE() << "Should never be called by input reader."; 359 } 360 361 virtual void setFocusedApplication(const InputApplication* inputApplication) { 362 ADD_FAILURE() << "Should never be called by input reader."; 363 } 364 365 virtual void setInputDispatchMode(bool enabled, bool frozen) { 366 ADD_FAILURE() << "Should never be called by input reader."; 367 } 368 369 virtual bool transferTouchFocus(const sp<InputChannel>& fromChannel, 370 const sp<InputChannel>& toChannel) { 371 ADD_FAILURE() << "Should never be called by input reader."; 372 return 0; 373 } 374 375 virtual status_t registerInputChannel(const sp<InputChannel>& inputChannel, 376 const sp<InputWindowHandle>& inputWindowHandle, bool monitor) { 377 ADD_FAILURE() << "Should never be called by input reader."; 378 return 0; 379 } 380 381 virtual status_t unregisterInputChannel(const sp<InputChannel>& inputChannel) { 382 ADD_FAILURE() << "Should never be called by input reader."; 383 return 0; 384 } 385}; 386 387 388// --- FakeEventHub --- 389 390class FakeEventHub : public EventHubInterface { 391 struct KeyInfo { 392 int32_t keyCode; 393 uint32_t flags; 394 }; 395 396 struct Device { 397 String8 name; 398 uint32_t classes; 399 PropertyMap configuration; 400 KeyedVector<int, RawAbsoluteAxisInfo> axes; 401 KeyedVector<int32_t, int32_t> keyCodeStates; 402 KeyedVector<int32_t, int32_t> scanCodeStates; 403 KeyedVector<int32_t, int32_t> switchStates; 404 KeyedVector<int32_t, KeyInfo> keys; 405 KeyedVector<int32_t, bool> leds; 406 Vector<VirtualKeyDefinition> virtualKeys; 407 408 Device(const String8& name, uint32_t classes) : 409 name(name), classes(classes) { 410 } 411 }; 412 413 KeyedVector<int32_t, Device*> mDevices; 414 Vector<String8> mExcludedDevices; 415 List<RawEvent> mEvents; 416 417protected: 418 virtual ~FakeEventHub() { 419 for (size_t i = 0; i < mDevices.size(); i++) { 420 delete mDevices.valueAt(i); 421 } 422 } 423 424public: 425 FakeEventHub() { } 426 427 void addDevice(int32_t deviceId, const String8& name, uint32_t classes) { 428 Device* device = new Device(name, classes); 429 mDevices.add(deviceId, device); 430 431 enqueueEvent(ARBITRARY_TIME, deviceId, EventHubInterface::DEVICE_ADDED, 0, 0, 0, 0); 432 } 433 434 void removeDevice(int32_t deviceId) { 435 delete mDevices.valueFor(deviceId); 436 mDevices.removeItem(deviceId); 437 438 enqueueEvent(ARBITRARY_TIME, deviceId, EventHubInterface::DEVICE_REMOVED, 0, 0, 0, 0); 439 } 440 441 void finishDeviceScan() { 442 enqueueEvent(ARBITRARY_TIME, 0, EventHubInterface::FINISHED_DEVICE_SCAN, 0, 0, 0, 0); 443 } 444 445 void addConfigurationProperty(int32_t deviceId, const String8& key, const String8& value) { 446 Device* device = getDevice(deviceId); 447 device->configuration.addProperty(key, value); 448 } 449 450 void addConfigurationMap(int32_t deviceId, const PropertyMap* configuration) { 451 Device* device = getDevice(deviceId); 452 device->configuration.addAll(configuration); 453 } 454 455 void addAxis(int32_t deviceId, int axis, 456 int32_t minValue, int32_t maxValue, int flat, int fuzz) { 457 Device* device = getDevice(deviceId); 458 459 RawAbsoluteAxisInfo info; 460 info.valid = true; 461 info.minValue = minValue; 462 info.maxValue = maxValue; 463 info.flat = flat; 464 info.fuzz = fuzz; 465 device->axes.add(axis, info); 466 } 467 468 void setKeyCodeState(int32_t deviceId, int32_t keyCode, int32_t state) { 469 Device* device = getDevice(deviceId); 470 device->keyCodeStates.replaceValueFor(keyCode, state); 471 } 472 473 void setScanCodeState(int32_t deviceId, int32_t scanCode, int32_t state) { 474 Device* device = getDevice(deviceId); 475 device->scanCodeStates.replaceValueFor(scanCode, state); 476 } 477 478 void setSwitchState(int32_t deviceId, int32_t switchCode, int32_t state) { 479 Device* device = getDevice(deviceId); 480 device->switchStates.replaceValueFor(switchCode, state); 481 } 482 483 void addKey(int32_t deviceId, int32_t scanCode, int32_t keyCode, uint32_t flags) { 484 Device* device = getDevice(deviceId); 485 KeyInfo info; 486 info.keyCode = keyCode; 487 info.flags = flags; 488 device->keys.add(scanCode, info); 489 } 490 491 void addLed(int32_t deviceId, int32_t led, bool initialState) { 492 Device* device = getDevice(deviceId); 493 device->leds.add(led, initialState); 494 } 495 496 bool getLedState(int32_t deviceId, int32_t led) { 497 Device* device = getDevice(deviceId); 498 return device->leds.valueFor(led); 499 } 500 501 Vector<String8>& getExcludedDevices() { 502 return mExcludedDevices; 503 } 504 505 void addVirtualKeyDefinition(int32_t deviceId, const VirtualKeyDefinition& definition) { 506 Device* device = getDevice(deviceId); 507 device->virtualKeys.push(definition); 508 } 509 510 void enqueueEvent(nsecs_t when, int32_t deviceId, int32_t type, 511 int32_t scanCode, int32_t keyCode, int32_t value, uint32_t flags) { 512 RawEvent event; 513 event.when = when; 514 event.deviceId = deviceId; 515 event.type = type; 516 event.scanCode = scanCode; 517 event.keyCode = keyCode; 518 event.value = value; 519 event.flags = flags; 520 mEvents.push_back(event); 521 } 522 523 void assertQueueIsEmpty() { 524 ASSERT_EQ(size_t(0), mEvents.size()) 525 << "Expected the event queue to be empty (fully consumed)."; 526 } 527 528private: 529 Device* getDevice(int32_t deviceId) const { 530 ssize_t index = mDevices.indexOfKey(deviceId); 531 return index >= 0 ? mDevices.valueAt(index) : NULL; 532 } 533 534 virtual uint32_t getDeviceClasses(int32_t deviceId) const { 535 Device* device = getDevice(deviceId); 536 return device ? device->classes : 0; 537 } 538 539 virtual String8 getDeviceName(int32_t deviceId) const { 540 Device* device = getDevice(deviceId); 541 return device ? device->name : String8("unknown"); 542 } 543 544 virtual void getConfiguration(int32_t deviceId, PropertyMap* outConfiguration) const { 545 Device* device = getDevice(deviceId); 546 if (device) { 547 *outConfiguration = device->configuration; 548 } 549 } 550 551 virtual status_t getAbsoluteAxisInfo(int32_t deviceId, int axis, 552 RawAbsoluteAxisInfo* outAxisInfo) const { 553 Device* device = getDevice(deviceId); 554 if (device) { 555 ssize_t index = device->axes.indexOfKey(axis); 556 if (index >= 0) { 557 *outAxisInfo = device->axes.valueAt(index); 558 return OK; 559 } 560 } 561 return -1; 562 } 563 564 virtual status_t scancodeToKeycode(int32_t deviceId, int scancode, 565 int32_t* outKeycode, uint32_t* outFlags) const { 566 Device* device = getDevice(deviceId); 567 if (device) { 568 ssize_t index = device->keys.indexOfKey(scancode); 569 if (index >= 0) { 570 if (outKeycode) { 571 *outKeycode = device->keys.valueAt(index).keyCode; 572 } 573 if (outFlags) { 574 *outFlags = device->keys.valueAt(index).flags; 575 } 576 return OK; 577 } 578 } 579 return NAME_NOT_FOUND; 580 } 581 582 virtual void addExcludedDevice(const char* deviceName) { 583 mExcludedDevices.add(String8(deviceName)); 584 } 585 586 virtual bool getEvent(RawEvent* outEvent) { 587 if (mEvents.empty()) { 588 return false; 589 } 590 591 *outEvent = *mEvents.begin(); 592 mEvents.erase(mEvents.begin()); 593 return true; 594 } 595 596 virtual int32_t getScanCodeState(int32_t deviceId, int32_t scanCode) const { 597 Device* device = getDevice(deviceId); 598 if (device) { 599 ssize_t index = device->scanCodeStates.indexOfKey(scanCode); 600 if (index >= 0) { 601 return device->scanCodeStates.valueAt(index); 602 } 603 } 604 return AKEY_STATE_UNKNOWN; 605 } 606 607 virtual int32_t getKeyCodeState(int32_t deviceId, int32_t keyCode) const { 608 Device* device = getDevice(deviceId); 609 if (device) { 610 ssize_t index = device->keyCodeStates.indexOfKey(keyCode); 611 if (index >= 0) { 612 return device->keyCodeStates.valueAt(index); 613 } 614 } 615 return AKEY_STATE_UNKNOWN; 616 } 617 618 virtual int32_t getSwitchState(int32_t deviceId, int32_t sw) const { 619 Device* device = getDevice(deviceId); 620 if (device) { 621 ssize_t index = device->switchStates.indexOfKey(sw); 622 if (index >= 0) { 623 return device->switchStates.valueAt(index); 624 } 625 } 626 return AKEY_STATE_UNKNOWN; 627 } 628 629 virtual bool markSupportedKeyCodes(int32_t deviceId, size_t numCodes, const int32_t* keyCodes, 630 uint8_t* outFlags) const { 631 bool result = false; 632 Device* device = getDevice(deviceId); 633 if (device) { 634 for (size_t i = 0; i < numCodes; i++) { 635 for (size_t j = 0; j < device->keys.size(); j++) { 636 if (keyCodes[i] == device->keys.valueAt(j).keyCode) { 637 outFlags[i] = 1; 638 result = true; 639 } 640 } 641 } 642 } 643 return result; 644 } 645 646 virtual bool hasLed(int32_t deviceId, int32_t led) const { 647 Device* device = getDevice(deviceId); 648 return device && device->leds.indexOfKey(led) >= 0; 649 } 650 651 virtual void setLedState(int32_t deviceId, int32_t led, bool on) { 652 Device* device = getDevice(deviceId); 653 if (device) { 654 ssize_t index = device->leds.indexOfKey(led); 655 if (index >= 0) { 656 device->leds.replaceValueAt(led, on); 657 } else { 658 ADD_FAILURE() 659 << "Attempted to set the state of an LED that the EventHub declared " 660 "was not present. led=" << led; 661 } 662 } 663 } 664 665 virtual void getVirtualKeyDefinitions(int32_t deviceId, 666 Vector<VirtualKeyDefinition>& outVirtualKeys) const { 667 outVirtualKeys.clear(); 668 669 Device* device = getDevice(deviceId); 670 if (device) { 671 outVirtualKeys.appendVector(device->virtualKeys); 672 } 673 } 674 675 virtual void dump(String8& dump) { 676 } 677}; 678 679 680// --- FakeInputReaderContext --- 681 682class FakeInputReaderContext : public InputReaderContext { 683 sp<EventHubInterface> mEventHub; 684 sp<InputReaderPolicyInterface> mPolicy; 685 sp<InputDispatcherInterface> mDispatcher; 686 int32_t mGlobalMetaState; 687 bool mUpdateGlobalMetaStateWasCalled; 688 689public: 690 FakeInputReaderContext(const sp<EventHubInterface>& eventHub, 691 const sp<InputReaderPolicyInterface>& policy, 692 const sp<InputDispatcherInterface>& dispatcher) : 693 mEventHub(eventHub), mPolicy(policy), mDispatcher(dispatcher), 694 mGlobalMetaState(0) { 695 } 696 697 virtual ~FakeInputReaderContext() { } 698 699 void assertUpdateGlobalMetaStateWasCalled() { 700 ASSERT_TRUE(mUpdateGlobalMetaStateWasCalled) 701 << "Expected updateGlobalMetaState() to have been called."; 702 mUpdateGlobalMetaStateWasCalled = false; 703 } 704 705 void setGlobalMetaState(int32_t state) { 706 mGlobalMetaState = state; 707 } 708 709private: 710 virtual void updateGlobalMetaState() { 711 mUpdateGlobalMetaStateWasCalled = true; 712 } 713 714 virtual int32_t getGlobalMetaState() { 715 return mGlobalMetaState; 716 } 717 718 virtual EventHubInterface* getEventHub() { 719 return mEventHub.get(); 720 } 721 722 virtual InputReaderPolicyInterface* getPolicy() { 723 return mPolicy.get(); 724 } 725 726 virtual InputDispatcherInterface* getDispatcher() { 727 return mDispatcher.get(); 728 } 729 730 virtual void disableVirtualKeysUntil(nsecs_t time) { 731 } 732 733 virtual bool shouldDropVirtualKey(nsecs_t now, 734 InputDevice* device, int32_t keyCode, int32_t scanCode) { 735 return false; 736 } 737}; 738 739 740// --- FakeInputMapper --- 741 742class FakeInputMapper : public InputMapper { 743 uint32_t mSources; 744 int32_t mKeyboardType; 745 int32_t mMetaState; 746 KeyedVector<int32_t, int32_t> mKeyCodeStates; 747 KeyedVector<int32_t, int32_t> mScanCodeStates; 748 KeyedVector<int32_t, int32_t> mSwitchStates; 749 Vector<int32_t> mSupportedKeyCodes; 750 RawEvent mLastEvent; 751 752 bool mConfigureWasCalled; 753 bool mResetWasCalled; 754 bool mProcessWasCalled; 755 756public: 757 FakeInputMapper(InputDevice* device, uint32_t sources) : 758 InputMapper(device), 759 mSources(sources), mKeyboardType(AINPUT_KEYBOARD_TYPE_NONE), 760 mMetaState(0), 761 mConfigureWasCalled(false), mResetWasCalled(false), mProcessWasCalled(false) { 762 } 763 764 virtual ~FakeInputMapper() { } 765 766 void setKeyboardType(int32_t keyboardType) { 767 mKeyboardType = keyboardType; 768 } 769 770 void setMetaState(int32_t metaState) { 771 mMetaState = metaState; 772 } 773 774 void assertConfigureWasCalled() { 775 ASSERT_TRUE(mConfigureWasCalled) 776 << "Expected configure() to have been called."; 777 mConfigureWasCalled = false; 778 } 779 780 void assertResetWasCalled() { 781 ASSERT_TRUE(mResetWasCalled) 782 << "Expected reset() to have been called."; 783 mResetWasCalled = false; 784 } 785 786 void assertProcessWasCalled(RawEvent* outLastEvent = NULL) { 787 ASSERT_TRUE(mProcessWasCalled) 788 << "Expected process() to have been called."; 789 if (outLastEvent) { 790 *outLastEvent = mLastEvent; 791 } 792 mProcessWasCalled = false; 793 } 794 795 void setKeyCodeState(int32_t keyCode, int32_t state) { 796 mKeyCodeStates.replaceValueFor(keyCode, state); 797 } 798 799 void setScanCodeState(int32_t scanCode, int32_t state) { 800 mScanCodeStates.replaceValueFor(scanCode, state); 801 } 802 803 void setSwitchState(int32_t switchCode, int32_t state) { 804 mSwitchStates.replaceValueFor(switchCode, state); 805 } 806 807 void addSupportedKeyCode(int32_t keyCode) { 808 mSupportedKeyCodes.add(keyCode); 809 } 810 811private: 812 virtual uint32_t getSources() { 813 return mSources; 814 } 815 816 virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo) { 817 InputMapper::populateDeviceInfo(deviceInfo); 818 819 if (mKeyboardType != AINPUT_KEYBOARD_TYPE_NONE) { 820 deviceInfo->setKeyboardType(mKeyboardType); 821 } 822 } 823 824 virtual void configure() { 825 mConfigureWasCalled = true; 826 } 827 828 virtual void reset() { 829 mResetWasCalled = true; 830 } 831 832 virtual void process(const RawEvent* rawEvent) { 833 mLastEvent = *rawEvent; 834 mProcessWasCalled = true; 835 } 836 837 virtual int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode) { 838 ssize_t index = mKeyCodeStates.indexOfKey(keyCode); 839 return index >= 0 ? mKeyCodeStates.valueAt(index) : AKEY_STATE_UNKNOWN; 840 } 841 842 virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode) { 843 ssize_t index = mScanCodeStates.indexOfKey(scanCode); 844 return index >= 0 ? mScanCodeStates.valueAt(index) : AKEY_STATE_UNKNOWN; 845 } 846 847 virtual int32_t getSwitchState(uint32_t sourceMask, int32_t switchCode) { 848 ssize_t index = mSwitchStates.indexOfKey(switchCode); 849 return index >= 0 ? mSwitchStates.valueAt(index) : AKEY_STATE_UNKNOWN; 850 } 851 852 virtual bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes, 853 const int32_t* keyCodes, uint8_t* outFlags) { 854 bool result = false; 855 for (size_t i = 0; i < numCodes; i++) { 856 for (size_t j = 0; j < mSupportedKeyCodes.size(); j++) { 857 if (keyCodes[i] == mSupportedKeyCodes[j]) { 858 outFlags[i] = 1; 859 result = true; 860 } 861 } 862 } 863 return result; 864 } 865 866 virtual int32_t getMetaState() { 867 return mMetaState; 868 } 869}; 870 871 872// --- InstrumentedInputReader --- 873 874class InstrumentedInputReader : public InputReader { 875 InputDevice* mNextDevice; 876 877public: 878 InstrumentedInputReader(const sp<EventHubInterface>& eventHub, 879 const sp<InputReaderPolicyInterface>& policy, 880 const sp<InputDispatcherInterface>& dispatcher) : 881 InputReader(eventHub, policy, dispatcher) { 882 } 883 884 virtual ~InstrumentedInputReader() { 885 if (mNextDevice) { 886 delete mNextDevice; 887 } 888 } 889 890 void setNextDevice(InputDevice* device) { 891 mNextDevice = device; 892 } 893 894protected: 895 virtual InputDevice* createDevice(int32_t deviceId, const String8& name, uint32_t classes) { 896 if (mNextDevice) { 897 InputDevice* device = mNextDevice; 898 mNextDevice = NULL; 899 return device; 900 } 901 return InputReader::createDevice(deviceId, name, classes); 902 } 903 904 friend class InputReaderTest; 905}; 906 907 908// --- InputReaderTest --- 909 910class InputReaderTest : public testing::Test { 911protected: 912 sp<FakeInputDispatcher> mFakeDispatcher; 913 sp<FakeInputReaderPolicy> mFakePolicy; 914 sp<FakeEventHub> mFakeEventHub; 915 sp<InstrumentedInputReader> mReader; 916 917 virtual void SetUp() { 918 mFakeEventHub = new FakeEventHub(); 919 mFakePolicy = new FakeInputReaderPolicy(); 920 mFakeDispatcher = new FakeInputDispatcher(); 921 922 mReader = new InstrumentedInputReader(mFakeEventHub, mFakePolicy, mFakeDispatcher); 923 } 924 925 virtual void TearDown() { 926 mReader.clear(); 927 928 mFakeDispatcher.clear(); 929 mFakePolicy.clear(); 930 mFakeEventHub.clear(); 931 } 932 933 void addDevice(int32_t deviceId, const String8& name, uint32_t classes, 934 const PropertyMap* configuration) { 935 mFakeEventHub->addDevice(deviceId, name, classes); 936 if (configuration) { 937 mFakeEventHub->addConfigurationMap(deviceId, configuration); 938 } 939 mFakeEventHub->finishDeviceScan(); 940 mReader->loopOnce(); 941 mReader->loopOnce(); 942 mFakeEventHub->assertQueueIsEmpty(); 943 } 944 945 FakeInputMapper* addDeviceWithFakeInputMapper(int32_t deviceId, 946 const String8& name, uint32_t classes, uint32_t sources, 947 const PropertyMap* configuration) { 948 InputDevice* device = new InputDevice(mReader.get(), deviceId, name); 949 FakeInputMapper* mapper = new FakeInputMapper(device, sources); 950 device->addMapper(mapper); 951 mReader->setNextDevice(device); 952 addDevice(deviceId, name, classes, configuration); 953 return mapper; 954 } 955}; 956 957TEST_F(InputReaderTest, GetInputConfiguration_WhenNoDevices_ReturnsDefaults) { 958 InputConfiguration config; 959 mReader->getInputConfiguration(&config); 960 961 ASSERT_EQ(InputConfiguration::KEYBOARD_NOKEYS, config.keyboard); 962 ASSERT_EQ(InputConfiguration::NAVIGATION_NONAV, config.navigation); 963 ASSERT_EQ(InputConfiguration::TOUCHSCREEN_NOTOUCH, config.touchScreen); 964} 965 966TEST_F(InputReaderTest, GetInputConfiguration_WhenAlphabeticKeyboardPresent_ReturnsQwertyKeyboard) { 967 ASSERT_NO_FATAL_FAILURE(addDevice(0, String8("keyboard"), 968 INPUT_DEVICE_CLASS_KEYBOARD | INPUT_DEVICE_CLASS_ALPHAKEY, NULL)); 969 970 InputConfiguration config; 971 mReader->getInputConfiguration(&config); 972 973 ASSERT_EQ(InputConfiguration::KEYBOARD_QWERTY, config.keyboard); 974 ASSERT_EQ(InputConfiguration::NAVIGATION_NONAV, config.navigation); 975 ASSERT_EQ(InputConfiguration::TOUCHSCREEN_NOTOUCH, config.touchScreen); 976} 977 978TEST_F(InputReaderTest, GetInputConfiguration_WhenTouchScreenPresent_ReturnsFingerTouchScreen) { 979 ASSERT_NO_FATAL_FAILURE(addDevice(0, String8("touchscreen"), 980 INPUT_DEVICE_CLASS_TOUCHSCREEN, NULL)); 981 982 InputConfiguration config; 983 mReader->getInputConfiguration(&config); 984 985 ASSERT_EQ(InputConfiguration::KEYBOARD_NOKEYS, config.keyboard); 986 ASSERT_EQ(InputConfiguration::NAVIGATION_NONAV, config.navigation); 987 ASSERT_EQ(InputConfiguration::TOUCHSCREEN_FINGER, config.touchScreen); 988} 989 990TEST_F(InputReaderTest, GetInputConfiguration_WhenMousePresent_ReturnsNoNavigation) { 991 sp<FakePointerController> controller = new FakePointerController(); 992 mFakePolicy->setPointerController(0, controller); 993 994 PropertyMap configuration; 995 configuration.addProperty(String8("cursor.mode"), String8("pointer")); 996 ASSERT_NO_FATAL_FAILURE(addDevice(0, String8("mouse"), 997 INPUT_DEVICE_CLASS_CURSOR, &configuration)); 998 999 InputConfiguration config; 1000 mReader->getInputConfiguration(&config); 1001 1002 ASSERT_EQ(InputConfiguration::KEYBOARD_NOKEYS, config.keyboard); 1003 ASSERT_EQ(InputConfiguration::NAVIGATION_NONAV, config.navigation); 1004 ASSERT_EQ(InputConfiguration::TOUCHSCREEN_NOTOUCH, config.touchScreen); 1005} 1006 1007TEST_F(InputReaderTest, GetInputConfiguration_WhenTrackballPresent_ReturnsTrackballNavigation) { 1008 PropertyMap configuration; 1009 configuration.addProperty(String8("cursor.mode"), String8("navigation")); 1010 ASSERT_NO_FATAL_FAILURE(addDevice(0, String8("trackball"), 1011 INPUT_DEVICE_CLASS_CURSOR, &configuration)); 1012 1013 InputConfiguration config; 1014 mReader->getInputConfiguration(&config); 1015 1016 ASSERT_EQ(InputConfiguration::KEYBOARD_NOKEYS, config.keyboard); 1017 ASSERT_EQ(InputConfiguration::NAVIGATION_TRACKBALL, config.navigation); 1018 ASSERT_EQ(InputConfiguration::TOUCHSCREEN_NOTOUCH, config.touchScreen); 1019} 1020 1021TEST_F(InputReaderTest, GetInputConfiguration_WhenDPadPresent_ReturnsDPadNavigation) { 1022 ASSERT_NO_FATAL_FAILURE(addDevice(0, String8("dpad"), 1023 INPUT_DEVICE_CLASS_DPAD, NULL)); 1024 1025 InputConfiguration config; 1026 mReader->getInputConfiguration(&config); 1027 1028 ASSERT_EQ(InputConfiguration::KEYBOARD_NOKEYS, config.keyboard); 1029 ASSERT_EQ(InputConfiguration::NAVIGATION_DPAD, config.navigation); 1030 ASSERT_EQ(InputConfiguration::TOUCHSCREEN_NOTOUCH, config.touchScreen); 1031} 1032 1033TEST_F(InputReaderTest, GetInputDeviceInfo_WhenDeviceIdIsValid) { 1034 ASSERT_NO_FATAL_FAILURE(addDevice(1, String8("keyboard"), 1035 INPUT_DEVICE_CLASS_KEYBOARD, NULL)); 1036 1037 InputDeviceInfo info; 1038 status_t result = mReader->getInputDeviceInfo(1, &info); 1039 1040 ASSERT_EQ(OK, result); 1041 ASSERT_EQ(1, info.getId()); 1042 ASSERT_STREQ("keyboard", info.getName().string()); 1043 ASSERT_EQ(AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC, info.getKeyboardType()); 1044 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, info.getSources()); 1045 ASSERT_EQ(size_t(0), info.getMotionRanges().size()); 1046} 1047 1048TEST_F(InputReaderTest, GetInputDeviceInfo_WhenDeviceIdIsInvalid) { 1049 InputDeviceInfo info; 1050 status_t result = mReader->getInputDeviceInfo(-1, &info); 1051 1052 ASSERT_EQ(NAME_NOT_FOUND, result); 1053} 1054 1055TEST_F(InputReaderTest, GetInputDeviceInfo_WhenDeviceIdIsIgnored) { 1056 addDevice(1, String8("ignored"), 0, NULL); // no classes so device will be ignored 1057 1058 InputDeviceInfo info; 1059 status_t result = mReader->getInputDeviceInfo(1, &info); 1060 1061 ASSERT_EQ(NAME_NOT_FOUND, result); 1062} 1063 1064TEST_F(InputReaderTest, GetInputDeviceIds) { 1065 sp<FakePointerController> controller = new FakePointerController(); 1066 mFakePolicy->setPointerController(2, controller); 1067 1068 ASSERT_NO_FATAL_FAILURE(addDevice(1, String8("keyboard"), 1069 INPUT_DEVICE_CLASS_KEYBOARD | INPUT_DEVICE_CLASS_ALPHAKEY, NULL)); 1070 ASSERT_NO_FATAL_FAILURE(addDevice(2, String8("mouse"), 1071 INPUT_DEVICE_CLASS_CURSOR, NULL)); 1072 1073 Vector<int32_t> ids; 1074 mReader->getInputDeviceIds(ids); 1075 1076 ASSERT_EQ(size_t(2), ids.size()); 1077 ASSERT_EQ(1, ids[0]); 1078 ASSERT_EQ(2, ids[1]); 1079} 1080 1081TEST_F(InputReaderTest, GetKeyCodeState_ForwardsRequestsToMappers) { 1082 FakeInputMapper* mapper = NULL; 1083 ASSERT_NO_FATAL_FAILURE(mapper = addDeviceWithFakeInputMapper(1, String8("fake"), 1084 INPUT_DEVICE_CLASS_KEYBOARD, AINPUT_SOURCE_KEYBOARD, NULL)); 1085 mapper->setKeyCodeState(AKEYCODE_A, AKEY_STATE_DOWN); 1086 1087 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getKeyCodeState(0, 1088 AINPUT_SOURCE_ANY, AKEYCODE_A)) 1089 << "Should return unknown when the device id is >= 0 but unknown."; 1090 1091 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getKeyCodeState(1, 1092 AINPUT_SOURCE_TRACKBALL, AKEYCODE_A)) 1093 << "Should return unknown when the device id is valid but the sources are not supported by the device."; 1094 1095 ASSERT_EQ(AKEY_STATE_DOWN, mReader->getKeyCodeState(1, 1096 AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, AKEYCODE_A)) 1097 << "Should return value provided by mapper when device id is valid and the device supports some of the sources."; 1098 1099 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getKeyCodeState(-1, 1100 AINPUT_SOURCE_TRACKBALL, AKEYCODE_A)) 1101 << "Should return unknown when the device id is < 0 but the sources are not supported by any device."; 1102 1103 ASSERT_EQ(AKEY_STATE_DOWN, mReader->getKeyCodeState(-1, 1104 AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, AKEYCODE_A)) 1105 << "Should return value provided by mapper when device id is < 0 and one of the devices supports some of the sources."; 1106} 1107 1108TEST_F(InputReaderTest, GetScanCodeState_ForwardsRequestsToMappers) { 1109 FakeInputMapper* mapper = NULL; 1110 ASSERT_NO_FATAL_FAILURE(mapper = addDeviceWithFakeInputMapper(1, String8("fake"), 1111 INPUT_DEVICE_CLASS_KEYBOARD, AINPUT_SOURCE_KEYBOARD, NULL)); 1112 mapper->setScanCodeState(KEY_A, AKEY_STATE_DOWN); 1113 1114 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getScanCodeState(0, 1115 AINPUT_SOURCE_ANY, KEY_A)) 1116 << "Should return unknown when the device id is >= 0 but unknown."; 1117 1118 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getScanCodeState(1, 1119 AINPUT_SOURCE_TRACKBALL, KEY_A)) 1120 << "Should return unknown when the device id is valid but the sources are not supported by the device."; 1121 1122 ASSERT_EQ(AKEY_STATE_DOWN, mReader->getScanCodeState(1, 1123 AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, KEY_A)) 1124 << "Should return value provided by mapper when device id is valid and the device supports some of the sources."; 1125 1126 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getScanCodeState(-1, 1127 AINPUT_SOURCE_TRACKBALL, KEY_A)) 1128 << "Should return unknown when the device id is < 0 but the sources are not supported by any device."; 1129 1130 ASSERT_EQ(AKEY_STATE_DOWN, mReader->getScanCodeState(-1, 1131 AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, KEY_A)) 1132 << "Should return value provided by mapper when device id is < 0 and one of the devices supports some of the sources."; 1133} 1134 1135TEST_F(InputReaderTest, GetSwitchState_ForwardsRequestsToMappers) { 1136 FakeInputMapper* mapper = NULL; 1137 ASSERT_NO_FATAL_FAILURE(mapper = addDeviceWithFakeInputMapper(1, String8("fake"), 1138 INPUT_DEVICE_CLASS_KEYBOARD, AINPUT_SOURCE_KEYBOARD, NULL)); 1139 mapper->setSwitchState(SW_LID, AKEY_STATE_DOWN); 1140 1141 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getSwitchState(0, 1142 AINPUT_SOURCE_ANY, SW_LID)) 1143 << "Should return unknown when the device id is >= 0 but unknown."; 1144 1145 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getSwitchState(1, 1146 AINPUT_SOURCE_TRACKBALL, SW_LID)) 1147 << "Should return unknown when the device id is valid but the sources are not supported by the device."; 1148 1149 ASSERT_EQ(AKEY_STATE_DOWN, mReader->getSwitchState(1, 1150 AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, SW_LID)) 1151 << "Should return value provided by mapper when device id is valid and the device supports some of the sources."; 1152 1153 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getSwitchState(-1, 1154 AINPUT_SOURCE_TRACKBALL, SW_LID)) 1155 << "Should return unknown when the device id is < 0 but the sources are not supported by any device."; 1156 1157 ASSERT_EQ(AKEY_STATE_DOWN, mReader->getSwitchState(-1, 1158 AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, SW_LID)) 1159 << "Should return value provided by mapper when device id is < 0 and one of the devices supports some of the sources."; 1160} 1161 1162TEST_F(InputReaderTest, MarkSupportedKeyCodes_ForwardsRequestsToMappers) { 1163 FakeInputMapper* mapper = NULL; 1164 ASSERT_NO_FATAL_FAILURE(mapper = addDeviceWithFakeInputMapper(1, String8("fake"), 1165 INPUT_DEVICE_CLASS_KEYBOARD, AINPUT_SOURCE_KEYBOARD, NULL)); 1166 mapper->addSupportedKeyCode(AKEYCODE_A); 1167 mapper->addSupportedKeyCode(AKEYCODE_B); 1168 1169 const int32_t keyCodes[4] = { AKEYCODE_A, AKEYCODE_B, AKEYCODE_1, AKEYCODE_2 }; 1170 uint8_t flags[4] = { 0, 0, 0, 1 }; 1171 1172 ASSERT_FALSE(mReader->hasKeys(0, AINPUT_SOURCE_ANY, 4, keyCodes, flags)) 1173 << "Should return false when device id is >= 0 but unknown."; 1174 ASSERT_TRUE(!flags[0] && !flags[1] && !flags[2] && !flags[3]); 1175 1176 flags[3] = 1; 1177 ASSERT_FALSE(mReader->hasKeys(1, AINPUT_SOURCE_TRACKBALL, 4, keyCodes, flags)) 1178 << "Should return false when device id is valid but the sources are not supported by the device."; 1179 ASSERT_TRUE(!flags[0] && !flags[1] && !flags[2] && !flags[3]); 1180 1181 flags[3] = 1; 1182 ASSERT_TRUE(mReader->hasKeys(1, AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, 4, keyCodes, flags)) 1183 << "Should return value provided by mapper when device id is valid and the device supports some of the sources."; 1184 ASSERT_TRUE(flags[0] && flags[1] && !flags[2] && !flags[3]); 1185 1186 flags[3] = 1; 1187 ASSERT_FALSE(mReader->hasKeys(-1, AINPUT_SOURCE_TRACKBALL, 4, keyCodes, flags)) 1188 << "Should return false when the device id is < 0 but the sources are not supported by any device."; 1189 ASSERT_TRUE(!flags[0] && !flags[1] && !flags[2] && !flags[3]); 1190 1191 flags[3] = 1; 1192 ASSERT_TRUE(mReader->hasKeys(-1, AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, 4, keyCodes, flags)) 1193 << "Should return value provided by mapper when device id is < 0 and one of the devices supports some of the sources."; 1194 ASSERT_TRUE(flags[0] && flags[1] && !flags[2] && !flags[3]); 1195} 1196 1197TEST_F(InputReaderTest, LoopOnce_WhenDeviceScanFinished_SendsConfigurationChanged) { 1198 addDevice(1, String8("ignored"), INPUT_DEVICE_CLASS_KEYBOARD, NULL); 1199 1200 FakeInputDispatcher::NotifyConfigurationChangedArgs args; 1201 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyConfigurationChangedWasCalled(&args)); 1202 ASSERT_EQ(ARBITRARY_TIME, args.eventTime); 1203} 1204 1205TEST_F(InputReaderTest, LoopOnce_ForwardsRawEventsToMappers) { 1206 FakeInputMapper* mapper = NULL; 1207 ASSERT_NO_FATAL_FAILURE(mapper = addDeviceWithFakeInputMapper(1, String8("fake"), 1208 INPUT_DEVICE_CLASS_KEYBOARD, AINPUT_SOURCE_KEYBOARD, NULL)); 1209 1210 mFakeEventHub->enqueueEvent(0, 1, EV_KEY, KEY_A, AKEYCODE_A, 1, POLICY_FLAG_WAKE); 1211 mReader->loopOnce(); 1212 ASSERT_NO_FATAL_FAILURE(mFakeEventHub->assertQueueIsEmpty()); 1213 1214 RawEvent event; 1215 ASSERT_NO_FATAL_FAILURE(mapper->assertProcessWasCalled(&event)); 1216 ASSERT_EQ(0, event.when); 1217 ASSERT_EQ(1, event.deviceId); 1218 ASSERT_EQ(EV_KEY, event.type); 1219 ASSERT_EQ(KEY_A, event.scanCode); 1220 ASSERT_EQ(AKEYCODE_A, event.keyCode); 1221 ASSERT_EQ(1, event.value); 1222 ASSERT_EQ(POLICY_FLAG_WAKE, event.flags); 1223} 1224 1225 1226// --- InputDeviceTest --- 1227 1228class InputDeviceTest : public testing::Test { 1229protected: 1230 static const char* DEVICE_NAME; 1231 static const int32_t DEVICE_ID; 1232 1233 sp<FakeEventHub> mFakeEventHub; 1234 sp<FakeInputReaderPolicy> mFakePolicy; 1235 sp<FakeInputDispatcher> mFakeDispatcher; 1236 FakeInputReaderContext* mFakeContext; 1237 1238 InputDevice* mDevice; 1239 1240 virtual void SetUp() { 1241 mFakeEventHub = new FakeEventHub(); 1242 mFakePolicy = new FakeInputReaderPolicy(); 1243 mFakeDispatcher = new FakeInputDispatcher(); 1244 mFakeContext = new FakeInputReaderContext(mFakeEventHub, mFakePolicy, mFakeDispatcher); 1245 1246 mFakeEventHub->addDevice(DEVICE_ID, String8(DEVICE_NAME), 0); 1247 mDevice = new InputDevice(mFakeContext, DEVICE_ID, String8(DEVICE_NAME)); 1248 } 1249 1250 virtual void TearDown() { 1251 delete mDevice; 1252 1253 delete mFakeContext; 1254 mFakeDispatcher.clear(); 1255 mFakePolicy.clear(); 1256 mFakeEventHub.clear(); 1257 } 1258}; 1259 1260const char* InputDeviceTest::DEVICE_NAME = "device"; 1261const int32_t InputDeviceTest::DEVICE_ID = 1; 1262 1263TEST_F(InputDeviceTest, ImmutableProperties) { 1264 ASSERT_EQ(DEVICE_ID, mDevice->getId()); 1265 ASSERT_STREQ(DEVICE_NAME, mDevice->getName()); 1266} 1267 1268TEST_F(InputDeviceTest, WhenNoMappersAreRegistered_DeviceIsIgnored) { 1269 // Configuration. 1270 mDevice->configure(); 1271 1272 // Metadata. 1273 ASSERT_TRUE(mDevice->isIgnored()); 1274 ASSERT_EQ(AINPUT_SOURCE_UNKNOWN, mDevice->getSources()); 1275 1276 InputDeviceInfo info; 1277 mDevice->getDeviceInfo(&info); 1278 ASSERT_EQ(DEVICE_ID, info.getId()); 1279 ASSERT_STREQ(DEVICE_NAME, info.getName().string()); 1280 ASSERT_EQ(AINPUT_KEYBOARD_TYPE_NONE, info.getKeyboardType()); 1281 ASSERT_EQ(AINPUT_SOURCE_UNKNOWN, info.getSources()); 1282 1283 // State queries. 1284 ASSERT_EQ(0, mDevice->getMetaState()); 1285 1286 ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getKeyCodeState(AINPUT_SOURCE_KEYBOARD, 0)) 1287 << "Ignored device should return unknown key code state."; 1288 ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getScanCodeState(AINPUT_SOURCE_KEYBOARD, 0)) 1289 << "Ignored device should return unknown scan code state."; 1290 ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getSwitchState(AINPUT_SOURCE_KEYBOARD, 0)) 1291 << "Ignored device should return unknown switch state."; 1292 1293 const int32_t keyCodes[2] = { AKEYCODE_A, AKEYCODE_B }; 1294 uint8_t flags[2] = { 0, 1 }; 1295 ASSERT_FALSE(mDevice->markSupportedKeyCodes(AINPUT_SOURCE_KEYBOARD, 2, keyCodes, flags)) 1296 << "Ignored device should never mark any key codes."; 1297 ASSERT_EQ(0, flags[0]) << "Flag for unsupported key should be unchanged."; 1298 ASSERT_EQ(1, flags[1]) << "Flag for unsupported key should be unchanged."; 1299 1300 // Reset. 1301 mDevice->reset(); 1302} 1303 1304TEST_F(InputDeviceTest, WhenMappersAreRegistered_DeviceIsNotIgnoredAndForwardsRequestsToMappers) { 1305 // Configuration. 1306 mFakeEventHub->addConfigurationProperty(DEVICE_ID, String8("key"), String8("value")); 1307 1308 FakeInputMapper* mapper1 = new FakeInputMapper(mDevice, AINPUT_SOURCE_KEYBOARD); 1309 mapper1->setKeyboardType(AINPUT_KEYBOARD_TYPE_ALPHABETIC); 1310 mapper1->setMetaState(AMETA_ALT_ON); 1311 mapper1->addSupportedKeyCode(AKEYCODE_A); 1312 mapper1->addSupportedKeyCode(AKEYCODE_B); 1313 mapper1->setKeyCodeState(AKEYCODE_A, AKEY_STATE_DOWN); 1314 mapper1->setKeyCodeState(AKEYCODE_B, AKEY_STATE_UP); 1315 mapper1->setScanCodeState(2, AKEY_STATE_DOWN); 1316 mapper1->setScanCodeState(3, AKEY_STATE_UP); 1317 mapper1->setSwitchState(4, AKEY_STATE_DOWN); 1318 mDevice->addMapper(mapper1); 1319 1320 FakeInputMapper* mapper2 = new FakeInputMapper(mDevice, AINPUT_SOURCE_TOUCHSCREEN); 1321 mapper2->setMetaState(AMETA_SHIFT_ON); 1322 mDevice->addMapper(mapper2); 1323 1324 mDevice->configure(); 1325 1326 String8 propertyValue; 1327 ASSERT_TRUE(mDevice->getConfiguration().tryGetProperty(String8("key"), propertyValue)) 1328 << "Device should have read configuration during configuration phase."; 1329 ASSERT_STREQ("value", propertyValue.string()); 1330 1331 ASSERT_NO_FATAL_FAILURE(mapper1->assertConfigureWasCalled()); 1332 ASSERT_NO_FATAL_FAILURE(mapper2->assertConfigureWasCalled()); 1333 1334 // Metadata. 1335 ASSERT_FALSE(mDevice->isIgnored()); 1336 ASSERT_EQ(uint32_t(AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TOUCHSCREEN), mDevice->getSources()); 1337 1338 InputDeviceInfo info; 1339 mDevice->getDeviceInfo(&info); 1340 ASSERT_EQ(DEVICE_ID, info.getId()); 1341 ASSERT_STREQ(DEVICE_NAME, info.getName().string()); 1342 ASSERT_EQ(AINPUT_KEYBOARD_TYPE_ALPHABETIC, info.getKeyboardType()); 1343 ASSERT_EQ(uint32_t(AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TOUCHSCREEN), info.getSources()); 1344 1345 // State queries. 1346 ASSERT_EQ(AMETA_ALT_ON | AMETA_SHIFT_ON, mDevice->getMetaState()) 1347 << "Should query mappers and combine meta states."; 1348 1349 ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getKeyCodeState(AINPUT_SOURCE_TRACKBALL, AKEYCODE_A)) 1350 << "Should return unknown key code state when source not supported."; 1351 ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getScanCodeState(AINPUT_SOURCE_TRACKBALL, AKEYCODE_A)) 1352 << "Should return unknown scan code state when source not supported."; 1353 ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getSwitchState(AINPUT_SOURCE_TRACKBALL, AKEYCODE_A)) 1354 << "Should return unknown switch state when source not supported."; 1355 1356 ASSERT_EQ(AKEY_STATE_DOWN, mDevice->getKeyCodeState(AINPUT_SOURCE_KEYBOARD, AKEYCODE_A)) 1357 << "Should query mapper when source is supported."; 1358 ASSERT_EQ(AKEY_STATE_UP, mDevice->getScanCodeState(AINPUT_SOURCE_KEYBOARD, 3)) 1359 << "Should query mapper when source is supported."; 1360 ASSERT_EQ(AKEY_STATE_DOWN, mDevice->getSwitchState(AINPUT_SOURCE_KEYBOARD, 4)) 1361 << "Should query mapper when source is supported."; 1362 1363 const int32_t keyCodes[4] = { AKEYCODE_A, AKEYCODE_B, AKEYCODE_1, AKEYCODE_2 }; 1364 uint8_t flags[4] = { 0, 0, 0, 1 }; 1365 ASSERT_FALSE(mDevice->markSupportedKeyCodes(AINPUT_SOURCE_TRACKBALL, 4, keyCodes, flags)) 1366 << "Should do nothing when source is unsupported."; 1367 ASSERT_EQ(0, flags[0]) << "Flag should be unchanged when source is unsupported."; 1368 ASSERT_EQ(0, flags[1]) << "Flag should be unchanged when source is unsupported."; 1369 ASSERT_EQ(0, flags[2]) << "Flag should be unchanged when source is unsupported."; 1370 ASSERT_EQ(1, flags[3]) << "Flag should be unchanged when source is unsupported."; 1371 1372 ASSERT_TRUE(mDevice->markSupportedKeyCodes(AINPUT_SOURCE_KEYBOARD, 4, keyCodes, flags)) 1373 << "Should query mapper when source is supported."; 1374 ASSERT_EQ(1, flags[0]) << "Flag for supported key should be set."; 1375 ASSERT_EQ(1, flags[1]) << "Flag for supported key should be set."; 1376 ASSERT_EQ(0, flags[2]) << "Flag for unsupported key should be unchanged."; 1377 ASSERT_EQ(1, flags[3]) << "Flag for unsupported key should be unchanged."; 1378 1379 // Event handling. 1380 RawEvent event; 1381 mDevice->process(&event); 1382 1383 ASSERT_NO_FATAL_FAILURE(mapper1->assertProcessWasCalled()); 1384 ASSERT_NO_FATAL_FAILURE(mapper2->assertProcessWasCalled()); 1385 1386 // Reset. 1387 mDevice->reset(); 1388 1389 ASSERT_NO_FATAL_FAILURE(mapper1->assertResetWasCalled()); 1390 ASSERT_NO_FATAL_FAILURE(mapper2->assertResetWasCalled()); 1391} 1392 1393 1394// --- InputMapperTest --- 1395 1396class InputMapperTest : public testing::Test { 1397protected: 1398 static const char* DEVICE_NAME; 1399 static const int32_t DEVICE_ID; 1400 1401 sp<FakeEventHub> mFakeEventHub; 1402 sp<FakeInputReaderPolicy> mFakePolicy; 1403 sp<FakeInputDispatcher> mFakeDispatcher; 1404 FakeInputReaderContext* mFakeContext; 1405 InputDevice* mDevice; 1406 1407 virtual void SetUp() { 1408 mFakeEventHub = new FakeEventHub(); 1409 mFakePolicy = new FakeInputReaderPolicy(); 1410 mFakeDispatcher = new FakeInputDispatcher(); 1411 mFakeContext = new FakeInputReaderContext(mFakeEventHub, mFakePolicy, mFakeDispatcher); 1412 mDevice = new InputDevice(mFakeContext, DEVICE_ID, String8(DEVICE_NAME)); 1413 1414 mFakeEventHub->addDevice(DEVICE_ID, String8(DEVICE_NAME), 0); 1415 } 1416 1417 virtual void TearDown() { 1418 delete mDevice; 1419 delete mFakeContext; 1420 mFakeDispatcher.clear(); 1421 mFakePolicy.clear(); 1422 mFakeEventHub.clear(); 1423 } 1424 1425 void addConfigurationProperty(const char* key, const char* value) { 1426 mFakeEventHub->addConfigurationProperty(DEVICE_ID, String8(key), String8(value)); 1427 } 1428 1429 void addMapperAndConfigure(InputMapper* mapper) { 1430 mDevice->addMapper(mapper); 1431 mDevice->configure(); 1432 } 1433 1434 static void process(InputMapper* mapper, nsecs_t when, int32_t deviceId, int32_t type, 1435 int32_t scanCode, int32_t keyCode, int32_t value, uint32_t flags) { 1436 RawEvent event; 1437 event.when = when; 1438 event.deviceId = deviceId; 1439 event.type = type; 1440 event.scanCode = scanCode; 1441 event.keyCode = keyCode; 1442 event.value = value; 1443 event.flags = flags; 1444 mapper->process(&event); 1445 } 1446 1447 static void assertMotionRange(const InputDeviceInfo& info, 1448 int32_t rangeType, float min, float max, float flat, float fuzz) { 1449 const InputDeviceInfo::MotionRange* range = info.getMotionRange(rangeType); 1450 ASSERT_TRUE(range != NULL) << "Range: " << rangeType; 1451 ASSERT_NEAR(min, range->min, EPSILON) << "Range: " << rangeType; 1452 ASSERT_NEAR(max, range->max, EPSILON) << "Range: " << rangeType; 1453 ASSERT_NEAR(flat, range->flat, EPSILON) << "Range: " << rangeType; 1454 ASSERT_NEAR(fuzz, range->fuzz, EPSILON) << "Range: " << rangeType; 1455 } 1456 1457 static void assertPointerCoords(const PointerCoords& coords, 1458 float x, float y, float pressure, float size, 1459 float touchMajor, float touchMinor, float toolMajor, float toolMinor, 1460 float orientation) { 1461 ASSERT_NEAR(x, coords.x, 1); 1462 ASSERT_NEAR(y, coords.y, 1); 1463 ASSERT_NEAR(pressure, coords.pressure, EPSILON); 1464 ASSERT_NEAR(size, coords.size, EPSILON); 1465 ASSERT_NEAR(touchMajor, coords.touchMajor, 1); 1466 ASSERT_NEAR(touchMinor, coords.touchMinor, 1); 1467 ASSERT_NEAR(toolMajor, coords.toolMajor, 1); 1468 ASSERT_NEAR(toolMinor, coords.toolMinor, 1); 1469 ASSERT_NEAR(orientation, coords.orientation, EPSILON); 1470 } 1471}; 1472 1473const char* InputMapperTest::DEVICE_NAME = "device"; 1474const int32_t InputMapperTest::DEVICE_ID = 1; 1475 1476 1477// --- SwitchInputMapperTest --- 1478 1479class SwitchInputMapperTest : public InputMapperTest { 1480protected: 1481}; 1482 1483TEST_F(SwitchInputMapperTest, GetSources) { 1484 SwitchInputMapper* mapper = new SwitchInputMapper(mDevice); 1485 addMapperAndConfigure(mapper); 1486 1487 ASSERT_EQ(uint32_t(AINPUT_SOURCE_SWITCH), mapper->getSources()); 1488} 1489 1490TEST_F(SwitchInputMapperTest, GetSwitchState) { 1491 SwitchInputMapper* mapper = new SwitchInputMapper(mDevice); 1492 addMapperAndConfigure(mapper); 1493 1494 mFakeEventHub->setSwitchState(DEVICE_ID, SW_LID, 1); 1495 ASSERT_EQ(1, mapper->getSwitchState(AINPUT_SOURCE_ANY, SW_LID)); 1496 1497 mFakeEventHub->setSwitchState(DEVICE_ID, SW_LID, 0); 1498 ASSERT_EQ(0, mapper->getSwitchState(AINPUT_SOURCE_ANY, SW_LID)); 1499} 1500 1501TEST_F(SwitchInputMapperTest, Process) { 1502 SwitchInputMapper* mapper = new SwitchInputMapper(mDevice); 1503 addMapperAndConfigure(mapper); 1504 1505 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SW, SW_LID, 0, 1, 0); 1506 1507 FakeInputDispatcher::NotifySwitchArgs args; 1508 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifySwitchWasCalled(&args)); 1509 ASSERT_EQ(ARBITRARY_TIME, args.when); 1510 ASSERT_EQ(SW_LID, args.switchCode); 1511 ASSERT_EQ(1, args.switchValue); 1512 ASSERT_EQ(uint32_t(0), args.policyFlags); 1513} 1514 1515 1516// --- KeyboardInputMapperTest --- 1517 1518class KeyboardInputMapperTest : public InputMapperTest { 1519protected: 1520 void testDPadKeyRotation(KeyboardInputMapper* mapper, 1521 int32_t originalScanCode, int32_t originalKeyCode, int32_t rotatedKeyCode); 1522}; 1523 1524void KeyboardInputMapperTest::testDPadKeyRotation(KeyboardInputMapper* mapper, 1525 int32_t originalScanCode, int32_t originalKeyCode, int32_t rotatedKeyCode) { 1526 FakeInputDispatcher::NotifyKeyArgs args; 1527 1528 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, originalScanCode, originalKeyCode, 1, 0); 1529 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args)); 1530 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, args.action); 1531 ASSERT_EQ(originalScanCode, args.scanCode); 1532 ASSERT_EQ(rotatedKeyCode, args.keyCode); 1533 1534 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, originalScanCode, originalKeyCode, 0, 0); 1535 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args)); 1536 ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action); 1537 ASSERT_EQ(originalScanCode, args.scanCode); 1538 ASSERT_EQ(rotatedKeyCode, args.keyCode); 1539} 1540 1541 1542TEST_F(KeyboardInputMapperTest, GetSources) { 1543 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, 1544 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC); 1545 addMapperAndConfigure(mapper); 1546 1547 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, mapper->getSources()); 1548} 1549 1550TEST_F(KeyboardInputMapperTest, Process_SimpleKeyPress) { 1551 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, 1552 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC); 1553 addMapperAndConfigure(mapper); 1554 1555 // Key down. 1556 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1557 EV_KEY, KEY_HOME, AKEYCODE_HOME, 1, POLICY_FLAG_WAKE); 1558 FakeInputDispatcher::NotifyKeyArgs args; 1559 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args)); 1560 ASSERT_EQ(DEVICE_ID, args.deviceId); 1561 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source); 1562 ASSERT_EQ(ARBITRARY_TIME, args.eventTime); 1563 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, args.action); 1564 ASSERT_EQ(AKEYCODE_HOME, args.keyCode); 1565 ASSERT_EQ(KEY_HOME, args.scanCode); 1566 ASSERT_EQ(AMETA_NONE, args.metaState); 1567 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, args.flags); 1568 ASSERT_EQ(POLICY_FLAG_WAKE, args.policyFlags); 1569 ASSERT_EQ(ARBITRARY_TIME, args.downTime); 1570 1571 // Key up. 1572 process(mapper, ARBITRARY_TIME + 1, DEVICE_ID, 1573 EV_KEY, KEY_HOME, AKEYCODE_HOME, 0, POLICY_FLAG_WAKE); 1574 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args)); 1575 ASSERT_EQ(DEVICE_ID, args.deviceId); 1576 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source); 1577 ASSERT_EQ(ARBITRARY_TIME + 1, args.eventTime); 1578 ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action); 1579 ASSERT_EQ(AKEYCODE_HOME, args.keyCode); 1580 ASSERT_EQ(KEY_HOME, args.scanCode); 1581 ASSERT_EQ(AMETA_NONE, args.metaState); 1582 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, args.flags); 1583 ASSERT_EQ(POLICY_FLAG_WAKE, args.policyFlags); 1584 ASSERT_EQ(ARBITRARY_TIME, args.downTime); 1585} 1586 1587TEST_F(KeyboardInputMapperTest, Reset_WhenKeysAreNotDown_DoesNotSynthesizeKeyUp) { 1588 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, 1589 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC); 1590 addMapperAndConfigure(mapper); 1591 1592 // Key down. 1593 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1594 EV_KEY, KEY_HOME, AKEYCODE_HOME, 1, POLICY_FLAG_WAKE); 1595 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled()); 1596 1597 // Key up. 1598 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1599 EV_KEY, KEY_HOME, AKEYCODE_HOME, 0, POLICY_FLAG_WAKE); 1600 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled()); 1601 1602 // Reset. Since no keys still down, should not synthesize any key ups. 1603 mapper->reset(); 1604 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled()); 1605} 1606 1607TEST_F(KeyboardInputMapperTest, Reset_WhenKeysAreDown_SynthesizesKeyUps) { 1608 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, 1609 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC); 1610 addMapperAndConfigure(mapper); 1611 1612 // Metakey down. 1613 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1614 EV_KEY, KEY_LEFTSHIFT, AKEYCODE_SHIFT_LEFT, 1, 0); 1615 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled()); 1616 1617 // Key down. 1618 process(mapper, ARBITRARY_TIME + 1, DEVICE_ID, 1619 EV_KEY, KEY_A, AKEYCODE_A, 1, 0); 1620 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled()); 1621 1622 // Reset. Since two keys are still down, should synthesize two key ups in reverse order. 1623 mapper->reset(); 1624 1625 FakeInputDispatcher::NotifyKeyArgs args; 1626 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args)); 1627 ASSERT_EQ(DEVICE_ID, args.deviceId); 1628 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source); 1629 ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action); 1630 ASSERT_EQ(AKEYCODE_A, args.keyCode); 1631 ASSERT_EQ(KEY_A, args.scanCode); 1632 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState); 1633 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, args.flags); 1634 ASSERT_EQ(uint32_t(0), args.policyFlags); 1635 ASSERT_EQ(ARBITRARY_TIME + 1, args.downTime); 1636 1637 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args)); 1638 ASSERT_EQ(DEVICE_ID, args.deviceId); 1639 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source); 1640 ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action); 1641 ASSERT_EQ(AKEYCODE_SHIFT_LEFT, args.keyCode); 1642 ASSERT_EQ(KEY_LEFTSHIFT, args.scanCode); 1643 ASSERT_EQ(AMETA_NONE, args.metaState); 1644 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, args.flags); 1645 ASSERT_EQ(uint32_t(0), args.policyFlags); 1646 ASSERT_EQ(ARBITRARY_TIME + 1, args.downTime); 1647 1648 // And that's it. 1649 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled()); 1650} 1651 1652TEST_F(KeyboardInputMapperTest, Process_ShouldUpdateMetaState) { 1653 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, 1654 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC); 1655 addMapperAndConfigure(mapper); 1656 1657 // Initial metastate. 1658 ASSERT_EQ(AMETA_NONE, mapper->getMetaState()); 1659 1660 // Metakey down. 1661 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1662 EV_KEY, KEY_LEFTSHIFT, AKEYCODE_SHIFT_LEFT, 1, 0); 1663 FakeInputDispatcher::NotifyKeyArgs args; 1664 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args)); 1665 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState); 1666 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, mapper->getMetaState()); 1667 ASSERT_NO_FATAL_FAILURE(mFakeContext->assertUpdateGlobalMetaStateWasCalled()); 1668 1669 // Key down. 1670 process(mapper, ARBITRARY_TIME + 1, DEVICE_ID, 1671 EV_KEY, KEY_A, AKEYCODE_A, 1, 0); 1672 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args)); 1673 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState); 1674 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, mapper->getMetaState()); 1675 1676 // Key up. 1677 process(mapper, ARBITRARY_TIME + 2, DEVICE_ID, 1678 EV_KEY, KEY_A, AKEYCODE_A, 0, 0); 1679 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args)); 1680 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState); 1681 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, mapper->getMetaState()); 1682 1683 // Metakey up. 1684 process(mapper, ARBITRARY_TIME + 3, DEVICE_ID, 1685 EV_KEY, KEY_LEFTSHIFT, AKEYCODE_SHIFT_LEFT, 0, 0); 1686 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args)); 1687 ASSERT_EQ(AMETA_NONE, args.metaState); 1688 ASSERT_EQ(AMETA_NONE, mapper->getMetaState()); 1689 ASSERT_NO_FATAL_FAILURE(mFakeContext->assertUpdateGlobalMetaStateWasCalled()); 1690} 1691 1692TEST_F(KeyboardInputMapperTest, Process_WhenNotOrientationAware_ShouldNotRotateDPad) { 1693 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, 1694 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC); 1695 addMapperAndConfigure(mapper); 1696 1697 mFakePolicy->setDisplayInfo(DISPLAY_ID, 1698 DISPLAY_WIDTH, DISPLAY_HEIGHT, 1699 DISPLAY_ORIENTATION_90); 1700 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1701 KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_UP)); 1702 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1703 KEY_RIGHT, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_RIGHT)); 1704 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1705 KEY_DOWN, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_DOWN)); 1706 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1707 KEY_LEFT, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_LEFT)); 1708} 1709 1710TEST_F(KeyboardInputMapperTest, Process_WhenOrientationAware_ShouldRotateDPad) { 1711 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, 1712 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC); 1713 addConfigurationProperty("keyboard.orientationAware", "1"); 1714 addMapperAndConfigure(mapper); 1715 1716 mFakePolicy->setDisplayInfo(DISPLAY_ID, 1717 DISPLAY_WIDTH, DISPLAY_HEIGHT, 1718 DISPLAY_ORIENTATION_0); 1719 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1720 KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_UP)); 1721 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1722 KEY_RIGHT, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_RIGHT)); 1723 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1724 KEY_DOWN, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_DOWN)); 1725 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1726 KEY_LEFT, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_LEFT)); 1727 1728 mFakePolicy->setDisplayInfo(DISPLAY_ID, 1729 DISPLAY_WIDTH, DISPLAY_HEIGHT, 1730 DISPLAY_ORIENTATION_90); 1731 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1732 KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_LEFT)); 1733 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1734 KEY_RIGHT, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_UP)); 1735 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1736 KEY_DOWN, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_RIGHT)); 1737 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1738 KEY_LEFT, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_DOWN)); 1739 1740 mFakePolicy->setDisplayInfo(DISPLAY_ID, 1741 DISPLAY_WIDTH, DISPLAY_HEIGHT, 1742 DISPLAY_ORIENTATION_180); 1743 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1744 KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_DOWN)); 1745 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1746 KEY_RIGHT, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_LEFT)); 1747 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1748 KEY_DOWN, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_UP)); 1749 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1750 KEY_LEFT, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_RIGHT)); 1751 1752 mFakePolicy->setDisplayInfo(DISPLAY_ID, 1753 DISPLAY_WIDTH, DISPLAY_HEIGHT, 1754 DISPLAY_ORIENTATION_270); 1755 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1756 KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_RIGHT)); 1757 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1758 KEY_RIGHT, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_DOWN)); 1759 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1760 KEY_DOWN, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_LEFT)); 1761 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1762 KEY_LEFT, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_UP)); 1763 1764 // Special case: if orientation changes while key is down, we still emit the same keycode 1765 // in the key up as we did in the key down. 1766 FakeInputDispatcher::NotifyKeyArgs args; 1767 1768 mFakePolicy->setDisplayInfo(DISPLAY_ID, 1769 DISPLAY_WIDTH, DISPLAY_HEIGHT, 1770 DISPLAY_ORIENTATION_270); 1771 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, KEY_UP, AKEYCODE_DPAD_UP, 1, 0); 1772 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args)); 1773 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, args.action); 1774 ASSERT_EQ(KEY_UP, args.scanCode); 1775 ASSERT_EQ(AKEYCODE_DPAD_RIGHT, args.keyCode); 1776 1777 mFakePolicy->setDisplayInfo(DISPLAY_ID, 1778 DISPLAY_WIDTH, DISPLAY_HEIGHT, 1779 DISPLAY_ORIENTATION_180); 1780 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, KEY_UP, AKEYCODE_DPAD_UP, 0, 0); 1781 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args)); 1782 ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action); 1783 ASSERT_EQ(KEY_UP, args.scanCode); 1784 ASSERT_EQ(AKEYCODE_DPAD_RIGHT, args.keyCode); 1785} 1786 1787TEST_F(KeyboardInputMapperTest, GetKeyCodeState) { 1788 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, 1789 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC); 1790 addMapperAndConfigure(mapper); 1791 1792 mFakeEventHub->setKeyCodeState(DEVICE_ID, AKEYCODE_A, 1); 1793 ASSERT_EQ(1, mapper->getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_A)); 1794 1795 mFakeEventHub->setKeyCodeState(DEVICE_ID, AKEYCODE_A, 0); 1796 ASSERT_EQ(0, mapper->getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_A)); 1797} 1798 1799TEST_F(KeyboardInputMapperTest, GetScanCodeState) { 1800 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, 1801 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC); 1802 addMapperAndConfigure(mapper); 1803 1804 mFakeEventHub->setScanCodeState(DEVICE_ID, KEY_A, 1); 1805 ASSERT_EQ(1, mapper->getScanCodeState(AINPUT_SOURCE_ANY, KEY_A)); 1806 1807 mFakeEventHub->setScanCodeState(DEVICE_ID, KEY_A, 0); 1808 ASSERT_EQ(0, mapper->getScanCodeState(AINPUT_SOURCE_ANY, KEY_A)); 1809} 1810 1811TEST_F(KeyboardInputMapperTest, MarkSupportedKeyCodes) { 1812 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, 1813 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC); 1814 addMapperAndConfigure(mapper); 1815 1816 mFakeEventHub->addKey(DEVICE_ID, KEY_A, AKEYCODE_A, 0); 1817 1818 const int32_t keyCodes[2] = { AKEYCODE_A, AKEYCODE_B }; 1819 uint8_t flags[2] = { 0, 0 }; 1820 ASSERT_TRUE(mapper->markSupportedKeyCodes(AINPUT_SOURCE_ANY, 1, keyCodes, flags)); 1821 ASSERT_TRUE(flags[0]); 1822 ASSERT_FALSE(flags[1]); 1823} 1824 1825TEST_F(KeyboardInputMapperTest, Process_LockedKeysShouldToggleMetaStateAndLeds) { 1826 mFakeEventHub->addLed(DEVICE_ID, LED_CAPSL, true /*initially on*/); 1827 mFakeEventHub->addLed(DEVICE_ID, LED_NUML, false /*initially off*/); 1828 mFakeEventHub->addLed(DEVICE_ID, LED_SCROLLL, false /*initially off*/); 1829 1830 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, 1831 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC); 1832 addMapperAndConfigure(mapper); 1833 1834 // Initialization should have turned all of the lights off. 1835 ASSERT_FALSE(mFakeEventHub->getLedState(DEVICE_ID, LED_CAPSL)); 1836 ASSERT_FALSE(mFakeEventHub->getLedState(DEVICE_ID, LED_NUML)); 1837 ASSERT_FALSE(mFakeEventHub->getLedState(DEVICE_ID, LED_SCROLLL)); 1838 1839 // Toggle caps lock on. 1840 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1841 EV_KEY, KEY_CAPSLOCK, AKEYCODE_CAPS_LOCK, 1, 0); 1842 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1843 EV_KEY, KEY_CAPSLOCK, AKEYCODE_CAPS_LOCK, 0, 0); 1844 ASSERT_TRUE(mFakeEventHub->getLedState(DEVICE_ID, LED_CAPSL)); 1845 ASSERT_FALSE(mFakeEventHub->getLedState(DEVICE_ID, LED_NUML)); 1846 ASSERT_FALSE(mFakeEventHub->getLedState(DEVICE_ID, LED_SCROLLL)); 1847 ASSERT_EQ(AMETA_CAPS_LOCK_ON, mapper->getMetaState()); 1848 1849 // Toggle num lock on. 1850 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1851 EV_KEY, KEY_NUMLOCK, AKEYCODE_NUM_LOCK, 1, 0); 1852 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1853 EV_KEY, KEY_NUMLOCK, AKEYCODE_NUM_LOCK, 0, 0); 1854 ASSERT_TRUE(mFakeEventHub->getLedState(DEVICE_ID, LED_CAPSL)); 1855 ASSERT_TRUE(mFakeEventHub->getLedState(DEVICE_ID, LED_NUML)); 1856 ASSERT_FALSE(mFakeEventHub->getLedState(DEVICE_ID, LED_SCROLLL)); 1857 ASSERT_EQ(AMETA_CAPS_LOCK_ON | AMETA_NUM_LOCK_ON, mapper->getMetaState()); 1858 1859 // Toggle caps lock off. 1860 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1861 EV_KEY, KEY_CAPSLOCK, AKEYCODE_CAPS_LOCK, 1, 0); 1862 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1863 EV_KEY, KEY_CAPSLOCK, AKEYCODE_CAPS_LOCK, 0, 0); 1864 ASSERT_FALSE(mFakeEventHub->getLedState(DEVICE_ID, LED_CAPSL)); 1865 ASSERT_TRUE(mFakeEventHub->getLedState(DEVICE_ID, LED_NUML)); 1866 ASSERT_FALSE(mFakeEventHub->getLedState(DEVICE_ID, LED_SCROLLL)); 1867 ASSERT_EQ(AMETA_NUM_LOCK_ON, mapper->getMetaState()); 1868 1869 // Toggle scroll lock on. 1870 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1871 EV_KEY, KEY_SCROLLLOCK, AKEYCODE_SCROLL_LOCK, 1, 0); 1872 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1873 EV_KEY, KEY_SCROLLLOCK, AKEYCODE_SCROLL_LOCK, 0, 0); 1874 ASSERT_FALSE(mFakeEventHub->getLedState(DEVICE_ID, LED_CAPSL)); 1875 ASSERT_TRUE(mFakeEventHub->getLedState(DEVICE_ID, LED_NUML)); 1876 ASSERT_TRUE(mFakeEventHub->getLedState(DEVICE_ID, LED_SCROLLL)); 1877 ASSERT_EQ(AMETA_NUM_LOCK_ON | AMETA_SCROLL_LOCK_ON, mapper->getMetaState()); 1878 1879 // Toggle num lock off. 1880 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1881 EV_KEY, KEY_NUMLOCK, AKEYCODE_NUM_LOCK, 1, 0); 1882 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1883 EV_KEY, KEY_NUMLOCK, AKEYCODE_NUM_LOCK, 0, 0); 1884 ASSERT_FALSE(mFakeEventHub->getLedState(DEVICE_ID, LED_CAPSL)); 1885 ASSERT_FALSE(mFakeEventHub->getLedState(DEVICE_ID, LED_NUML)); 1886 ASSERT_TRUE(mFakeEventHub->getLedState(DEVICE_ID, LED_SCROLLL)); 1887 ASSERT_EQ(AMETA_SCROLL_LOCK_ON, mapper->getMetaState()); 1888 1889 // Toggle scroll lock off. 1890 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1891 EV_KEY, KEY_SCROLLLOCK, AKEYCODE_SCROLL_LOCK, 1, 0); 1892 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1893 EV_KEY, KEY_SCROLLLOCK, AKEYCODE_SCROLL_LOCK, 0, 0); 1894 ASSERT_FALSE(mFakeEventHub->getLedState(DEVICE_ID, LED_CAPSL)); 1895 ASSERT_FALSE(mFakeEventHub->getLedState(DEVICE_ID, LED_NUML)); 1896 ASSERT_FALSE(mFakeEventHub->getLedState(DEVICE_ID, LED_SCROLLL)); 1897 ASSERT_EQ(AMETA_NONE, mapper->getMetaState()); 1898} 1899 1900 1901// --- CursorInputMapperTest --- 1902 1903class CursorInputMapperTest : public InputMapperTest { 1904protected: 1905 static const int32_t TRACKBALL_MOVEMENT_THRESHOLD; 1906 1907 sp<FakePointerController> mFakePointerController; 1908 1909 virtual void SetUp() { 1910 InputMapperTest::SetUp(); 1911 1912 mFakePointerController = new FakePointerController(); 1913 mFakePolicy->setPointerController(DEVICE_ID, mFakePointerController); 1914 } 1915 1916 void testMotionRotation(CursorInputMapper* mapper, 1917 int32_t originalX, int32_t originalY, int32_t rotatedX, int32_t rotatedY); 1918}; 1919 1920const int32_t CursorInputMapperTest::TRACKBALL_MOVEMENT_THRESHOLD = 6; 1921 1922void CursorInputMapperTest::testMotionRotation(CursorInputMapper* mapper, 1923 int32_t originalX, int32_t originalY, int32_t rotatedX, int32_t rotatedY) { 1924 FakeInputDispatcher::NotifyMotionArgs args; 1925 1926 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_X, 0, originalX, 0); 1927 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_Y, 0, originalY, 0); 1928 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0, 0, 0); 1929 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args)); 1930 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action); 1931 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 1932 float(rotatedX) / TRACKBALL_MOVEMENT_THRESHOLD, 1933 float(rotatedY) / TRACKBALL_MOVEMENT_THRESHOLD, 1934 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 1935} 1936 1937TEST_F(CursorInputMapperTest, WhenModeIsPointer_GetSources_ReturnsMouse) { 1938 CursorInputMapper* mapper = new CursorInputMapper(mDevice); 1939 addConfigurationProperty("cursor.mode", "pointer"); 1940 addMapperAndConfigure(mapper); 1941 1942 ASSERT_EQ(AINPUT_SOURCE_MOUSE, mapper->getSources()); 1943} 1944 1945TEST_F(CursorInputMapperTest, WhenModeIsNavigation_GetSources_ReturnsTrackball) { 1946 CursorInputMapper* mapper = new CursorInputMapper(mDevice); 1947 addConfigurationProperty("cursor.mode", "navigation"); 1948 addMapperAndConfigure(mapper); 1949 1950 ASSERT_EQ(AINPUT_SOURCE_TRACKBALL, mapper->getSources()); 1951} 1952 1953TEST_F(CursorInputMapperTest, WhenModeIsPointer_PopulateDeviceInfo_ReturnsRangeFromPointerController) { 1954 CursorInputMapper* mapper = new CursorInputMapper(mDevice); 1955 addConfigurationProperty("cursor.mode", "pointer"); 1956 addMapperAndConfigure(mapper); 1957 1958 InputDeviceInfo info; 1959 mapper->populateDeviceInfo(&info); 1960 1961 // Initially there may not be a valid motion range. 1962 ASSERT_EQ(NULL, info.getMotionRange(AINPUT_MOTION_RANGE_X)); 1963 ASSERT_EQ(NULL, info.getMotionRange(AINPUT_MOTION_RANGE_Y)); 1964 ASSERT_NO_FATAL_FAILURE(assertMotionRange(info, AINPUT_MOTION_RANGE_PRESSURE, 1965 0.0f, 1.0f, 0.0f, 0.0f)); 1966 1967 // When the bounds are set, then there should be a valid motion range. 1968 mFakePointerController->setBounds(1, 2, 800, 480); 1969 1970 InputDeviceInfo info2; 1971 mapper->populateDeviceInfo(&info2); 1972 1973 ASSERT_NO_FATAL_FAILURE(assertMotionRange(info2, AINPUT_MOTION_RANGE_X, 1974 1, 800, 0.0f, 0.0f)); 1975 ASSERT_NO_FATAL_FAILURE(assertMotionRange(info2, AINPUT_MOTION_RANGE_Y, 1976 2, 480, 0.0f, 0.0f)); 1977 ASSERT_NO_FATAL_FAILURE(assertMotionRange(info2, AINPUT_MOTION_RANGE_PRESSURE, 1978 0.0f, 1.0f, 0.0f, 0.0f)); 1979} 1980 1981TEST_F(CursorInputMapperTest, WhenModeIsNavigation_PopulateDeviceInfo_ReturnsScaledRange) { 1982 CursorInputMapper* mapper = new CursorInputMapper(mDevice); 1983 addConfigurationProperty("cursor.mode", "navigation"); 1984 addMapperAndConfigure(mapper); 1985 1986 InputDeviceInfo info; 1987 mapper->populateDeviceInfo(&info); 1988 1989 ASSERT_NO_FATAL_FAILURE(assertMotionRange(info, AINPUT_MOTION_RANGE_X, 1990 -1.0f, 1.0f, 0.0f, 1.0f / TRACKBALL_MOVEMENT_THRESHOLD)); 1991 ASSERT_NO_FATAL_FAILURE(assertMotionRange(info, AINPUT_MOTION_RANGE_Y, 1992 -1.0f, 1.0f, 0.0f, 1.0f / TRACKBALL_MOVEMENT_THRESHOLD)); 1993 ASSERT_NO_FATAL_FAILURE(assertMotionRange(info, AINPUT_MOTION_RANGE_PRESSURE, 1994 0.0f, 1.0f, 0.0f, 0.0f)); 1995} 1996 1997TEST_F(CursorInputMapperTest, Process_ShouldSetAllFieldsAndIncludeGlobalMetaState) { 1998 CursorInputMapper* mapper = new CursorInputMapper(mDevice); 1999 addConfigurationProperty("cursor.mode", "navigation"); 2000 addMapperAndConfigure(mapper); 2001 2002 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON); 2003 2004 FakeInputDispatcher::NotifyMotionArgs args; 2005 2006 // Button press. 2007 // Mostly testing non x/y behavior here so we don't need to check again elsewhere. 2008 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 1, 0); 2009 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args)); 2010 ASSERT_EQ(ARBITRARY_TIME, args.eventTime); 2011 ASSERT_EQ(DEVICE_ID, args.deviceId); 2012 ASSERT_EQ(AINPUT_SOURCE_TRACKBALL, args.source); 2013 ASSERT_EQ(uint32_t(0), args.policyFlags); 2014 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action); 2015 ASSERT_EQ(0, args.flags); 2016 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState); 2017 ASSERT_EQ(0, args.edgeFlags); 2018 ASSERT_EQ(uint32_t(1), args.pointerCount); 2019 ASSERT_EQ(0, args.pointerIds[0]); 2020 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 2021 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2022 ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.xPrecision); 2023 ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.yPrecision); 2024 ASSERT_EQ(ARBITRARY_TIME, args.downTime); 2025 2026 // Button release. Should have same down time. 2027 process(mapper, ARBITRARY_TIME + 1, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 0, 0); 2028 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args)); 2029 ASSERT_EQ(ARBITRARY_TIME + 1, args.eventTime); 2030 ASSERT_EQ(DEVICE_ID, args.deviceId); 2031 ASSERT_EQ(AINPUT_SOURCE_TRACKBALL, args.source); 2032 ASSERT_EQ(uint32_t(0), args.policyFlags); 2033 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, args.action); 2034 ASSERT_EQ(0, args.flags); 2035 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState); 2036 ASSERT_EQ(0, args.edgeFlags); 2037 ASSERT_EQ(uint32_t(1), args.pointerCount); 2038 ASSERT_EQ(0, args.pointerIds[0]); 2039 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 2040 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2041 ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.xPrecision); 2042 ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.yPrecision); 2043 ASSERT_EQ(ARBITRARY_TIME, args.downTime); 2044} 2045 2046TEST_F(CursorInputMapperTest, Process_ShouldHandleIndependentXYUpdates) { 2047 CursorInputMapper* mapper = new CursorInputMapper(mDevice); 2048 addConfigurationProperty("cursor.mode", "navigation"); 2049 addMapperAndConfigure(mapper); 2050 2051 FakeInputDispatcher::NotifyMotionArgs args; 2052 2053 // Motion in X but not Y. 2054 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_X, 0, 1, 0); 2055 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0, 0, 0); 2056 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args)); 2057 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action); 2058 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 2059 1.0f / TRACKBALL_MOVEMENT_THRESHOLD, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2060 2061 // Motion in Y but not X. 2062 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_Y, 0, -2, 0); 2063 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0, 0, 0); 2064 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args)); 2065 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action); 2066 ASSERT_NEAR(0.0f, args.pointerCoords[0].x, EPSILON); 2067 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 2068 0.0f, -2.0f / TRACKBALL_MOVEMENT_THRESHOLD, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2069} 2070 2071TEST_F(CursorInputMapperTest, Process_ShouldHandleIndependentButtonUpdates) { 2072 CursorInputMapper* mapper = new CursorInputMapper(mDevice); 2073 addConfigurationProperty("cursor.mode", "navigation"); 2074 addMapperAndConfigure(mapper); 2075 2076 FakeInputDispatcher::NotifyMotionArgs args; 2077 2078 // Button press without following sync. 2079 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 1, 0); 2080 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args)); 2081 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action); 2082 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 2083 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2084 2085 // Button release without following sync. 2086 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 0, 0); 2087 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args)); 2088 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, args.action); 2089 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 2090 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2091} 2092 2093TEST_F(CursorInputMapperTest, Process_ShouldHandleCombinedXYAndButtonUpdates) { 2094 CursorInputMapper* mapper = new CursorInputMapper(mDevice); 2095 addConfigurationProperty("cursor.mode", "navigation"); 2096 addMapperAndConfigure(mapper); 2097 2098 FakeInputDispatcher::NotifyMotionArgs args; 2099 2100 // Combined X, Y and Button. 2101 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_X, 0, 1, 0); 2102 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_Y, 0, -2, 0); 2103 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 1, 0); 2104 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0, 0, 0); 2105 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args)); 2106 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action); 2107 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 2108 1.0f / TRACKBALL_MOVEMENT_THRESHOLD, -2.0f / TRACKBALL_MOVEMENT_THRESHOLD, 2109 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2110 2111 // Move X, Y a bit while pressed. 2112 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_X, 0, 2, 0); 2113 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_Y, 0, 1, 0); 2114 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0, 0, 0); 2115 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args)); 2116 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action); 2117 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 2118 2.0f / TRACKBALL_MOVEMENT_THRESHOLD, 1.0f / TRACKBALL_MOVEMENT_THRESHOLD, 2119 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2120 2121 // Release Button. 2122 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 0, 0); 2123 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args)); 2124 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, args.action); 2125 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 2126 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2127} 2128 2129TEST_F(CursorInputMapperTest, Reset_WhenButtonIsNotDown_ShouldNotSynthesizeButtonUp) { 2130 CursorInputMapper* mapper = new CursorInputMapper(mDevice); 2131 addConfigurationProperty("cursor.mode", "navigation"); 2132 addMapperAndConfigure(mapper); 2133 2134 FakeInputDispatcher::NotifyMotionArgs args; 2135 2136 // Button press. 2137 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 1, 0); 2138 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args)); 2139 2140 // Button release. 2141 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 0, 0); 2142 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args)); 2143 2144 // Reset. Should not synthesize button up since button is not pressed. 2145 mapper->reset(); 2146 2147 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled()); 2148} 2149 2150TEST_F(CursorInputMapperTest, Reset_WhenButtonIsDown_ShouldSynthesizeButtonUp) { 2151 CursorInputMapper* mapper = new CursorInputMapper(mDevice); 2152 addConfigurationProperty("cursor.mode", "navigation"); 2153 addMapperAndConfigure(mapper); 2154 2155 FakeInputDispatcher::NotifyMotionArgs args; 2156 2157 // Button press. 2158 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 1, 0); 2159 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args)); 2160 2161 // Reset. Should synthesize button up. 2162 mapper->reset(); 2163 2164 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args)); 2165 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, args.action); 2166 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 2167 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2168} 2169 2170TEST_F(CursorInputMapperTest, Process_WhenNotOrientationAware_ShouldNotRotateMotions) { 2171 CursorInputMapper* mapper = new CursorInputMapper(mDevice); 2172 addConfigurationProperty("cursor.mode", "navigation"); 2173 addMapperAndConfigure(mapper); 2174 2175 mFakePolicy->setDisplayInfo(DISPLAY_ID, 2176 DISPLAY_WIDTH, DISPLAY_HEIGHT, 2177 DISPLAY_ORIENTATION_90); 2178 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, 1, 0, 1)); 2179 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 1, 1, 1)); 2180 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 0, 1, 0)); 2181 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, -1, 1, -1)); 2182 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, -1, 0, -1)); 2183 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1, -1, -1)); 2184 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 0, -1, 0)); 2185 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 1, -1, 1)); 2186} 2187 2188TEST_F(CursorInputMapperTest, Process_WhenOrientationAware_ShouldRotateMotions) { 2189 CursorInputMapper* mapper = new CursorInputMapper(mDevice); 2190 addConfigurationProperty("cursor.mode", "navigation"); 2191 addConfigurationProperty("cursor.orientationAware", "1"); 2192 addMapperAndConfigure(mapper); 2193 2194 mFakePolicy->setDisplayInfo(DISPLAY_ID, 2195 DISPLAY_WIDTH, DISPLAY_HEIGHT, DISPLAY_ORIENTATION_0); 2196 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, 1, 0, 1)); 2197 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 1, 1, 1)); 2198 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 0, 1, 0)); 2199 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, -1, 1, -1)); 2200 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, -1, 0, -1)); 2201 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1, -1, -1)); 2202 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 0, -1, 0)); 2203 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 1, -1, 1)); 2204 2205 mFakePolicy->setDisplayInfo(DISPLAY_ID, 2206 DISPLAY_WIDTH, DISPLAY_HEIGHT, DISPLAY_ORIENTATION_90); 2207 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, 1, 1, 0)); 2208 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 1, 1, -1)); 2209 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 0, 0, -1)); 2210 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, -1, -1, -1)); 2211 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, -1, -1, 0)); 2212 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1, -1, 1)); 2213 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 0, 0, 1)); 2214 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 1, 1, 1)); 2215 2216 mFakePolicy->setDisplayInfo(DISPLAY_ID, 2217 DISPLAY_WIDTH, DISPLAY_HEIGHT, DISPLAY_ORIENTATION_180); 2218 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, 1, 0, -1)); 2219 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 1, -1, -1)); 2220 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 0, -1, 0)); 2221 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, -1, -1, 1)); 2222 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, -1, 0, 1)); 2223 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1, 1, 1)); 2224 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 0, 1, 0)); 2225 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 1, 1, -1)); 2226 2227 mFakePolicy->setDisplayInfo(DISPLAY_ID, 2228 DISPLAY_WIDTH, DISPLAY_HEIGHT, DISPLAY_ORIENTATION_270); 2229 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, 1, -1, 0)); 2230 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 1, -1, 1)); 2231 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 0, 0, 1)); 2232 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, -1, 1, 1)); 2233 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, -1, 1, 0)); 2234 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1, 1, -1)); 2235 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 0, 0, -1)); 2236 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 1, -1, -1)); 2237} 2238 2239 2240// --- TouchInputMapperTest --- 2241 2242class TouchInputMapperTest : public InputMapperTest { 2243protected: 2244 static const int32_t RAW_X_MIN; 2245 static const int32_t RAW_X_MAX; 2246 static const int32_t RAW_Y_MIN; 2247 static const int32_t RAW_Y_MAX; 2248 static const int32_t RAW_TOUCH_MIN; 2249 static const int32_t RAW_TOUCH_MAX; 2250 static const int32_t RAW_TOOL_MIN; 2251 static const int32_t RAW_TOOL_MAX; 2252 static const int32_t RAW_PRESSURE_MIN; 2253 static const int32_t RAW_PRESSURE_MAX; 2254 static const int32_t RAW_ORIENTATION_MIN; 2255 static const int32_t RAW_ORIENTATION_MAX; 2256 static const int32_t RAW_ID_MIN; 2257 static const int32_t RAW_ID_MAX; 2258 static const float X_PRECISION; 2259 static const float Y_PRECISION; 2260 2261 static const VirtualKeyDefinition VIRTUAL_KEYS[2]; 2262 2263 enum Axes { 2264 POSITION = 1 << 0, 2265 TOUCH = 1 << 1, 2266 TOOL = 1 << 2, 2267 PRESSURE = 1 << 3, 2268 ORIENTATION = 1 << 4, 2269 MINOR = 1 << 5, 2270 ID = 1 << 6, 2271 }; 2272 2273 void prepareDisplay(int32_t orientation); 2274 void prepareVirtualKeys(); 2275 int32_t toRawX(float displayX); 2276 int32_t toRawY(float displayY); 2277 float toDisplayX(int32_t rawX); 2278 float toDisplayY(int32_t rawY); 2279}; 2280 2281const int32_t TouchInputMapperTest::RAW_X_MIN = 25; 2282const int32_t TouchInputMapperTest::RAW_X_MAX = 1020; 2283const int32_t TouchInputMapperTest::RAW_Y_MIN = 30; 2284const int32_t TouchInputMapperTest::RAW_Y_MAX = 1010; 2285const int32_t TouchInputMapperTest::RAW_TOUCH_MIN = 0; 2286const int32_t TouchInputMapperTest::RAW_TOUCH_MAX = 31; 2287const int32_t TouchInputMapperTest::RAW_TOOL_MIN = 0; 2288const int32_t TouchInputMapperTest::RAW_TOOL_MAX = 15; 2289const int32_t TouchInputMapperTest::RAW_PRESSURE_MIN = RAW_TOUCH_MIN; 2290const int32_t TouchInputMapperTest::RAW_PRESSURE_MAX = RAW_TOUCH_MAX; 2291const int32_t TouchInputMapperTest::RAW_ORIENTATION_MIN = -7; 2292const int32_t TouchInputMapperTest::RAW_ORIENTATION_MAX = 7; 2293const int32_t TouchInputMapperTest::RAW_ID_MIN = 0; 2294const int32_t TouchInputMapperTest::RAW_ID_MAX = 9; 2295const float TouchInputMapperTest::X_PRECISION = float(RAW_X_MAX - RAW_X_MIN) / DISPLAY_WIDTH; 2296const float TouchInputMapperTest::Y_PRECISION = float(RAW_Y_MAX - RAW_Y_MIN) / DISPLAY_HEIGHT; 2297 2298const VirtualKeyDefinition TouchInputMapperTest::VIRTUAL_KEYS[2] = { 2299 { KEY_HOME, 60, DISPLAY_HEIGHT + 15, 20, 20 }, 2300 { KEY_MENU, DISPLAY_HEIGHT - 60, DISPLAY_WIDTH + 15, 20, 20 }, 2301}; 2302 2303void TouchInputMapperTest::prepareDisplay(int32_t orientation) { 2304 mFakePolicy->setDisplayInfo(DISPLAY_ID, DISPLAY_WIDTH, DISPLAY_HEIGHT, orientation); 2305} 2306 2307void TouchInputMapperTest::prepareVirtualKeys() { 2308 mFakeEventHub->addVirtualKeyDefinition(DEVICE_ID, VIRTUAL_KEYS[0]); 2309 mFakeEventHub->addVirtualKeyDefinition(DEVICE_ID, VIRTUAL_KEYS[1]); 2310 mFakeEventHub->addKey(DEVICE_ID, KEY_HOME, AKEYCODE_HOME, POLICY_FLAG_WAKE); 2311 mFakeEventHub->addKey(DEVICE_ID, KEY_MENU, AKEYCODE_MENU, POLICY_FLAG_WAKE); 2312} 2313 2314int32_t TouchInputMapperTest::toRawX(float displayX) { 2315 return int32_t(displayX * (RAW_X_MAX - RAW_X_MIN) / DISPLAY_WIDTH + RAW_X_MIN); 2316} 2317 2318int32_t TouchInputMapperTest::toRawY(float displayY) { 2319 return int32_t(displayY * (RAW_Y_MAX - RAW_Y_MIN) / DISPLAY_HEIGHT + RAW_Y_MIN); 2320} 2321 2322float TouchInputMapperTest::toDisplayX(int32_t rawX) { 2323 return float(rawX - RAW_X_MIN) * DISPLAY_WIDTH / (RAW_X_MAX - RAW_X_MIN); 2324} 2325 2326float TouchInputMapperTest::toDisplayY(int32_t rawY) { 2327 return float(rawY - RAW_Y_MIN) * DISPLAY_HEIGHT / (RAW_Y_MAX - RAW_Y_MIN); 2328} 2329 2330 2331// --- SingleTouchInputMapperTest --- 2332 2333class SingleTouchInputMapperTest : public TouchInputMapperTest { 2334protected: 2335 void prepareAxes(int axes); 2336 2337 void processDown(SingleTouchInputMapper* mapper, int32_t x, int32_t y); 2338 void processMove(SingleTouchInputMapper* mapper, int32_t x, int32_t y); 2339 void processUp(SingleTouchInputMapper* mappery); 2340 void processPressure(SingleTouchInputMapper* mapper, int32_t pressure); 2341 void processToolMajor(SingleTouchInputMapper* mapper, int32_t toolMajor); 2342 void processSync(SingleTouchInputMapper* mapper); 2343}; 2344 2345void SingleTouchInputMapperTest::prepareAxes(int axes) { 2346 if (axes & POSITION) { 2347 mFakeEventHub->addAxis(DEVICE_ID, ABS_X, RAW_X_MIN, RAW_X_MAX, 0, 0); 2348 mFakeEventHub->addAxis(DEVICE_ID, ABS_Y, RAW_Y_MIN, RAW_Y_MAX, 0, 0); 2349 } 2350 if (axes & PRESSURE) { 2351 mFakeEventHub->addAxis(DEVICE_ID, ABS_PRESSURE, RAW_PRESSURE_MIN, RAW_PRESSURE_MAX, 0, 0); 2352 } 2353 if (axes & TOOL) { 2354 mFakeEventHub->addAxis(DEVICE_ID, ABS_TOOL_WIDTH, RAW_TOOL_MIN, RAW_TOOL_MAX, 0, 0); 2355 } 2356} 2357 2358void SingleTouchInputMapperTest::processDown(SingleTouchInputMapper* mapper, int32_t x, int32_t y) { 2359 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_TOUCH, 0, 1, 0); 2360 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_X, 0, x, 0); 2361 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_Y, 0, y, 0); 2362} 2363 2364void SingleTouchInputMapperTest::processMove(SingleTouchInputMapper* mapper, int32_t x, int32_t y) { 2365 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_X, 0, x, 0); 2366 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_Y, 0, y, 0); 2367} 2368 2369void SingleTouchInputMapperTest::processUp(SingleTouchInputMapper* mapper) { 2370 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_TOUCH, 0, 0, 0); 2371} 2372 2373void SingleTouchInputMapperTest::processPressure( 2374 SingleTouchInputMapper* mapper, int32_t pressure) { 2375 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_PRESSURE, 0, pressure, 0); 2376} 2377 2378void SingleTouchInputMapperTest::processToolMajor( 2379 SingleTouchInputMapper* mapper, int32_t toolMajor) { 2380 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_TOOL_WIDTH, 0, toolMajor, 0); 2381} 2382 2383void SingleTouchInputMapperTest::processSync(SingleTouchInputMapper* mapper) { 2384 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0, 0, 0); 2385} 2386 2387 2388TEST_F(SingleTouchInputMapperTest, GetSources_WhenDeviceTypeIsTouchPad_ReturnsTouchPad) { 2389 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 2390 prepareAxes(POSITION); 2391 addConfigurationProperty("touch.deviceType", "touchPad"); 2392 addMapperAndConfigure(mapper); 2393 2394 ASSERT_EQ(AINPUT_SOURCE_TOUCHPAD, mapper->getSources()); 2395} 2396 2397TEST_F(SingleTouchInputMapperTest, GetSources_WhenDeviceTypeIsTouchScreen_ReturnsTouchScreen) { 2398 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 2399 prepareAxes(POSITION); 2400 addConfigurationProperty("touch.deviceType", "touchScreen"); 2401 addMapperAndConfigure(mapper); 2402 2403 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, mapper->getSources()); 2404} 2405 2406TEST_F(SingleTouchInputMapperTest, GetKeyCodeState) { 2407 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 2408 prepareDisplay(DISPLAY_ORIENTATION_0); 2409 prepareAxes(POSITION); 2410 prepareVirtualKeys(); 2411 addMapperAndConfigure(mapper); 2412 2413 // Unknown key. 2414 ASSERT_EQ(AKEY_STATE_UNKNOWN, mapper->getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_A)); 2415 2416 // Virtual key is down. 2417 int32_t x = toRawX(VIRTUAL_KEYS[0].centerX); 2418 int32_t y = toRawY(VIRTUAL_KEYS[0].centerY); 2419 processDown(mapper, x, y); 2420 processSync(mapper); 2421 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled()); 2422 2423 ASSERT_EQ(AKEY_STATE_VIRTUAL, mapper->getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_HOME)); 2424 2425 // Virtual key is up. 2426 processUp(mapper); 2427 processSync(mapper); 2428 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled()); 2429 2430 ASSERT_EQ(AKEY_STATE_UP, mapper->getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_HOME)); 2431} 2432 2433TEST_F(SingleTouchInputMapperTest, GetScanCodeState) { 2434 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 2435 prepareDisplay(DISPLAY_ORIENTATION_0); 2436 prepareAxes(POSITION); 2437 prepareVirtualKeys(); 2438 addMapperAndConfigure(mapper); 2439 2440 // Unknown key. 2441 ASSERT_EQ(AKEY_STATE_UNKNOWN, mapper->getScanCodeState(AINPUT_SOURCE_ANY, KEY_A)); 2442 2443 // Virtual key is down. 2444 int32_t x = toRawX(VIRTUAL_KEYS[0].centerX); 2445 int32_t y = toRawY(VIRTUAL_KEYS[0].centerY); 2446 processDown(mapper, x, y); 2447 processSync(mapper); 2448 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled()); 2449 2450 ASSERT_EQ(AKEY_STATE_VIRTUAL, mapper->getScanCodeState(AINPUT_SOURCE_ANY, KEY_HOME)); 2451 2452 // Virtual key is up. 2453 processUp(mapper); 2454 processSync(mapper); 2455 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled()); 2456 2457 ASSERT_EQ(AKEY_STATE_UP, mapper->getScanCodeState(AINPUT_SOURCE_ANY, KEY_HOME)); 2458} 2459 2460TEST_F(SingleTouchInputMapperTest, MarkSupportedKeyCodes) { 2461 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 2462 prepareDisplay(DISPLAY_ORIENTATION_0); 2463 prepareAxes(POSITION); 2464 prepareVirtualKeys(); 2465 addMapperAndConfigure(mapper); 2466 2467 const int32_t keys[2] = { AKEYCODE_HOME, AKEYCODE_A }; 2468 uint8_t flags[2] = { 0, 0 }; 2469 ASSERT_TRUE(mapper->markSupportedKeyCodes(AINPUT_SOURCE_ANY, 2, keys, flags)); 2470 ASSERT_TRUE(flags[0]); 2471 ASSERT_FALSE(flags[1]); 2472} 2473 2474TEST_F(SingleTouchInputMapperTest, Reset_WhenVirtualKeysAreDown_SendsUp) { 2475 // Note: Ideally we should send cancels but the implementation is more straightforward 2476 // with up and this will only happen if a device is forcibly removed. 2477 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 2478 prepareDisplay(DISPLAY_ORIENTATION_0); 2479 prepareAxes(POSITION); 2480 prepareVirtualKeys(); 2481 addMapperAndConfigure(mapper); 2482 2483 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON); 2484 2485 // Press virtual key. 2486 int32_t x = toRawX(VIRTUAL_KEYS[0].centerX); 2487 int32_t y = toRawY(VIRTUAL_KEYS[0].centerY); 2488 processDown(mapper, x, y); 2489 processSync(mapper); 2490 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled()); 2491 2492 // Reset. Since key is down, synthesize key up. 2493 mapper->reset(); 2494 2495 FakeInputDispatcher::NotifyKeyArgs args; 2496 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args)); 2497 //ASSERT_EQ(ARBITRARY_TIME, args.eventTime); 2498 ASSERT_EQ(DEVICE_ID, args.deviceId); 2499 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source); 2500 ASSERT_EQ(POLICY_FLAG_VIRTUAL, args.policyFlags); 2501 ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action); 2502 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY, args.flags); 2503 ASSERT_EQ(AKEYCODE_HOME, args.keyCode); 2504 ASSERT_EQ(KEY_HOME, args.scanCode); 2505 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState); 2506 ASSERT_EQ(ARBITRARY_TIME, args.downTime); 2507} 2508 2509TEST_F(SingleTouchInputMapperTest, Reset_WhenNothingIsPressed_NothingMuchHappens) { 2510 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 2511 prepareDisplay(DISPLAY_ORIENTATION_0); 2512 prepareAxes(POSITION); 2513 prepareVirtualKeys(); 2514 addMapperAndConfigure(mapper); 2515 2516 // Press virtual key. 2517 int32_t x = toRawX(VIRTUAL_KEYS[0].centerX); 2518 int32_t y = toRawY(VIRTUAL_KEYS[0].centerY); 2519 processDown(mapper, x, y); 2520 processSync(mapper); 2521 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled()); 2522 2523 // Release virtual key. 2524 processUp(mapper); 2525 processSync(mapper); 2526 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled()); 2527 2528 // Reset. Since no key is down, nothing happens. 2529 mapper->reset(); 2530 2531 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled()); 2532 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled()); 2533} 2534 2535TEST_F(SingleTouchInputMapperTest, Process_WhenVirtualKeyIsPressedAndReleasedNormally_SendsKeyDownAndKeyUp) { 2536 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 2537 prepareDisplay(DISPLAY_ORIENTATION_0); 2538 prepareAxes(POSITION); 2539 prepareVirtualKeys(); 2540 addMapperAndConfigure(mapper); 2541 2542 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON); 2543 2544 FakeInputDispatcher::NotifyKeyArgs args; 2545 2546 // Press virtual key. 2547 int32_t x = toRawX(VIRTUAL_KEYS[0].centerX); 2548 int32_t y = toRawY(VIRTUAL_KEYS[0].centerY); 2549 processDown(mapper, x, y); 2550 processSync(mapper); 2551 2552 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args)); 2553 ASSERT_EQ(ARBITRARY_TIME, args.eventTime); 2554 ASSERT_EQ(DEVICE_ID, args.deviceId); 2555 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source); 2556 ASSERT_EQ(POLICY_FLAG_VIRTUAL, args.policyFlags); 2557 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, args.action); 2558 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY, args.flags); 2559 ASSERT_EQ(AKEYCODE_HOME, args.keyCode); 2560 ASSERT_EQ(KEY_HOME, args.scanCode); 2561 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState); 2562 ASSERT_EQ(ARBITRARY_TIME, args.downTime); 2563 2564 // Release virtual key. 2565 processUp(mapper); 2566 processSync(mapper); 2567 2568 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args)); 2569 ASSERT_EQ(ARBITRARY_TIME, args.eventTime); 2570 ASSERT_EQ(DEVICE_ID, args.deviceId); 2571 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source); 2572 ASSERT_EQ(POLICY_FLAG_VIRTUAL, args.policyFlags); 2573 ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action); 2574 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY, args.flags); 2575 ASSERT_EQ(AKEYCODE_HOME, args.keyCode); 2576 ASSERT_EQ(KEY_HOME, args.scanCode); 2577 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState); 2578 ASSERT_EQ(ARBITRARY_TIME, args.downTime); 2579 2580 // Should not have sent any motions. 2581 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled()); 2582} 2583 2584TEST_F(SingleTouchInputMapperTest, Process_WhenVirtualKeyIsPressedAndMovedOutOfBounds_SendsKeyDownAndKeyCancel) { 2585 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 2586 prepareDisplay(DISPLAY_ORIENTATION_0); 2587 prepareAxes(POSITION); 2588 prepareVirtualKeys(); 2589 addMapperAndConfigure(mapper); 2590 2591 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON); 2592 2593 FakeInputDispatcher::NotifyKeyArgs keyArgs; 2594 2595 // Press virtual key. 2596 int32_t x = toRawX(VIRTUAL_KEYS[0].centerX); 2597 int32_t y = toRawY(VIRTUAL_KEYS[0].centerY); 2598 processDown(mapper, x, y); 2599 processSync(mapper); 2600 2601 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&keyArgs)); 2602 ASSERT_EQ(ARBITRARY_TIME, keyArgs.eventTime); 2603 ASSERT_EQ(DEVICE_ID, keyArgs.deviceId); 2604 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, keyArgs.source); 2605 ASSERT_EQ(POLICY_FLAG_VIRTUAL, keyArgs.policyFlags); 2606 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action); 2607 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY, keyArgs.flags); 2608 ASSERT_EQ(AKEYCODE_HOME, keyArgs.keyCode); 2609 ASSERT_EQ(KEY_HOME, keyArgs.scanCode); 2610 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, keyArgs.metaState); 2611 ASSERT_EQ(ARBITRARY_TIME, keyArgs.downTime); 2612 2613 // Move out of bounds. This should generate a cancel and a pointer down since we moved 2614 // into the display area. 2615 y -= 100; 2616 processMove(mapper, x, y); 2617 processSync(mapper); 2618 2619 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&keyArgs)); 2620 ASSERT_EQ(ARBITRARY_TIME, keyArgs.eventTime); 2621 ASSERT_EQ(DEVICE_ID, keyArgs.deviceId); 2622 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, keyArgs.source); 2623 ASSERT_EQ(POLICY_FLAG_VIRTUAL, keyArgs.policyFlags); 2624 ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action); 2625 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY 2626 | AKEY_EVENT_FLAG_CANCELED, keyArgs.flags); 2627 ASSERT_EQ(AKEYCODE_HOME, keyArgs.keyCode); 2628 ASSERT_EQ(KEY_HOME, keyArgs.scanCode); 2629 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, keyArgs.metaState); 2630 ASSERT_EQ(ARBITRARY_TIME, keyArgs.downTime); 2631 2632 FakeInputDispatcher::NotifyMotionArgs motionArgs; 2633 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs)); 2634 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 2635 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 2636 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 2637 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 2638 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action); 2639 ASSERT_EQ(0, motionArgs.flags); 2640 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 2641 ASSERT_EQ(0, motionArgs.edgeFlags); 2642 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 2643 ASSERT_EQ(0, motionArgs.pointerIds[0]); 2644 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 2645 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0)); 2646 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 2647 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 2648 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 2649 2650 // Keep moving out of bounds. Should generate a pointer move. 2651 y -= 50; 2652 processMove(mapper, x, y); 2653 processSync(mapper); 2654 2655 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs)); 2656 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 2657 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 2658 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 2659 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 2660 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 2661 ASSERT_EQ(0, motionArgs.flags); 2662 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 2663 ASSERT_EQ(0, motionArgs.edgeFlags); 2664 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 2665 ASSERT_EQ(0, motionArgs.pointerIds[0]); 2666 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 2667 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0)); 2668 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 2669 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 2670 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 2671 2672 // Release out of bounds. Should generate a pointer up. 2673 processUp(mapper); 2674 processSync(mapper); 2675 2676 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs)); 2677 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 2678 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 2679 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 2680 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 2681 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action); 2682 ASSERT_EQ(0, motionArgs.flags); 2683 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 2684 ASSERT_EQ(0, motionArgs.edgeFlags); 2685 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 2686 ASSERT_EQ(0, motionArgs.pointerIds[0]); 2687 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 2688 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0)); 2689 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 2690 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 2691 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 2692 2693 // Should not have sent any more keys or motions. 2694 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled()); 2695 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled()); 2696} 2697 2698TEST_F(SingleTouchInputMapperTest, Process_WhenTouchStartsOutsideDisplayAndMovesIn_SendsDownAsTouchEntersDisplay) { 2699 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 2700 prepareDisplay(DISPLAY_ORIENTATION_0); 2701 prepareAxes(POSITION); 2702 prepareVirtualKeys(); 2703 addMapperAndConfigure(mapper); 2704 2705 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON); 2706 2707 FakeInputDispatcher::NotifyMotionArgs motionArgs; 2708 2709 // Initially go down out of bounds. 2710 int32_t x = -10; 2711 int32_t y = -10; 2712 processDown(mapper, x, y); 2713 processSync(mapper); 2714 2715 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled()); 2716 2717 // Move into the display area. Should generate a pointer down. 2718 x = 50; 2719 y = 75; 2720 processMove(mapper, x, y); 2721 processSync(mapper); 2722 2723 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs)); 2724 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 2725 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 2726 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 2727 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 2728 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action); 2729 ASSERT_EQ(0, motionArgs.flags); 2730 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 2731 ASSERT_EQ(0, motionArgs.edgeFlags); 2732 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 2733 ASSERT_EQ(0, motionArgs.pointerIds[0]); 2734 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 2735 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0)); 2736 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 2737 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 2738 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 2739 2740 // Release. Should generate a pointer up. 2741 processUp(mapper); 2742 processSync(mapper); 2743 2744 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs)); 2745 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 2746 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 2747 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 2748 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 2749 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action); 2750 ASSERT_EQ(0, motionArgs.flags); 2751 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 2752 ASSERT_EQ(0, motionArgs.edgeFlags); 2753 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 2754 ASSERT_EQ(0, motionArgs.pointerIds[0]); 2755 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 2756 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0)); 2757 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 2758 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 2759 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 2760 2761 // Should not have sent any more keys or motions. 2762 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled()); 2763 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled()); 2764} 2765 2766TEST_F(SingleTouchInputMapperTest, Process_NormalSingleTouchGesture) { 2767 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 2768 prepareDisplay(DISPLAY_ORIENTATION_0); 2769 prepareAxes(POSITION); 2770 prepareVirtualKeys(); 2771 addMapperAndConfigure(mapper); 2772 2773 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON); 2774 2775 FakeInputDispatcher::NotifyMotionArgs motionArgs; 2776 2777 // Down. 2778 int32_t x = 100; 2779 int32_t y = 125; 2780 processDown(mapper, x, y); 2781 processSync(mapper); 2782 2783 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs)); 2784 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 2785 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 2786 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 2787 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 2788 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action); 2789 ASSERT_EQ(0, motionArgs.flags); 2790 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 2791 ASSERT_EQ(0, motionArgs.edgeFlags); 2792 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 2793 ASSERT_EQ(0, motionArgs.pointerIds[0]); 2794 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 2795 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0)); 2796 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 2797 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 2798 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 2799 2800 // Move. 2801 x += 50; 2802 y += 75; 2803 processMove(mapper, x, y); 2804 processSync(mapper); 2805 2806 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs)); 2807 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 2808 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 2809 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 2810 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 2811 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 2812 ASSERT_EQ(0, motionArgs.flags); 2813 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 2814 ASSERT_EQ(0, motionArgs.edgeFlags); 2815 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 2816 ASSERT_EQ(0, motionArgs.pointerIds[0]); 2817 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 2818 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0)); 2819 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 2820 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 2821 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 2822 2823 // Up. 2824 processUp(mapper); 2825 processSync(mapper); 2826 2827 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs)); 2828 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 2829 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 2830 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 2831 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 2832 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action); 2833 ASSERT_EQ(0, motionArgs.flags); 2834 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 2835 ASSERT_EQ(0, motionArgs.edgeFlags); 2836 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 2837 ASSERT_EQ(0, motionArgs.pointerIds[0]); 2838 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 2839 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0)); 2840 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 2841 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 2842 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 2843 2844 // Should not have sent any more keys or motions. 2845 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled()); 2846 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled()); 2847} 2848 2849TEST_F(SingleTouchInputMapperTest, Process_WhenNotOrientationAware_DoesNotRotateMotions) { 2850 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 2851 prepareAxes(POSITION); 2852 addConfigurationProperty("touch.orientationAware", "0"); 2853 addMapperAndConfigure(mapper); 2854 2855 FakeInputDispatcher::NotifyMotionArgs args; 2856 2857 // Rotation 90. 2858 prepareDisplay(DISPLAY_ORIENTATION_90); 2859 processDown(mapper, toRawX(50), toRawY(75)); 2860 processSync(mapper); 2861 2862 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args)); 2863 ASSERT_NEAR(50, args.pointerCoords[0].x, 1); 2864 ASSERT_NEAR(75, args.pointerCoords[0].y, 1); 2865 2866 processUp(mapper); 2867 processSync(mapper); 2868 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled()); 2869} 2870 2871TEST_F(SingleTouchInputMapperTest, Process_WhenOrientationAware_RotatesMotions) { 2872 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 2873 prepareAxes(POSITION); 2874 addMapperAndConfigure(mapper); 2875 2876 FakeInputDispatcher::NotifyMotionArgs args; 2877 2878 // Rotation 0. 2879 prepareDisplay(DISPLAY_ORIENTATION_0); 2880 processDown(mapper, toRawX(50), toRawY(75)); 2881 processSync(mapper); 2882 2883 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args)); 2884 ASSERT_NEAR(50, args.pointerCoords[0].x, 1); 2885 ASSERT_NEAR(75, args.pointerCoords[0].y, 1); 2886 2887 processUp(mapper); 2888 processSync(mapper); 2889 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled()); 2890 2891 // Rotation 90. 2892 prepareDisplay(DISPLAY_ORIENTATION_90); 2893 processDown(mapper, toRawX(50), toRawY(75)); 2894 processSync(mapper); 2895 2896 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args)); 2897 ASSERT_NEAR(75, args.pointerCoords[0].x, 1); 2898 ASSERT_NEAR(DISPLAY_WIDTH - 50, args.pointerCoords[0].y, 1); 2899 2900 processUp(mapper); 2901 processSync(mapper); 2902 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled()); 2903 2904 // Rotation 180. 2905 prepareDisplay(DISPLAY_ORIENTATION_180); 2906 processDown(mapper, toRawX(50), toRawY(75)); 2907 processSync(mapper); 2908 2909 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args)); 2910 ASSERT_NEAR(DISPLAY_WIDTH - 50, args.pointerCoords[0].x, 1); 2911 ASSERT_NEAR(DISPLAY_HEIGHT - 75, args.pointerCoords[0].y, 1); 2912 2913 processUp(mapper); 2914 processSync(mapper); 2915 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled()); 2916 2917 // Rotation 270. 2918 prepareDisplay(DISPLAY_ORIENTATION_270); 2919 processDown(mapper, toRawX(50), toRawY(75)); 2920 processSync(mapper); 2921 2922 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args)); 2923 ASSERT_NEAR(DISPLAY_HEIGHT - 75, args.pointerCoords[0].x, 1); 2924 ASSERT_NEAR(50, args.pointerCoords[0].y, 1); 2925 2926 processUp(mapper); 2927 processSync(mapper); 2928 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled()); 2929} 2930 2931TEST_F(SingleTouchInputMapperTest, Process_AllAxes_DefaultCalibration) { 2932 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 2933 prepareDisplay(DISPLAY_ORIENTATION_0); 2934 prepareAxes(POSITION | PRESSURE | TOOL); 2935 addMapperAndConfigure(mapper); 2936 2937 // These calculations are based on the input device calibration documentation. 2938 int32_t rawX = 100; 2939 int32_t rawY = 200; 2940 int32_t rawPressure = 10; 2941 int32_t rawToolMajor = 12; 2942 2943 float x = toDisplayX(rawX); 2944 float y = toDisplayY(rawY); 2945 float pressure = float(rawPressure) / RAW_PRESSURE_MAX; 2946 float size = float(rawToolMajor) / RAW_TOOL_MAX; 2947 float tool = min(DISPLAY_WIDTH, DISPLAY_HEIGHT) * size; 2948 float touch = min(tool * pressure, tool); 2949 2950 processDown(mapper, rawX, rawY); 2951 processPressure(mapper, rawPressure); 2952 processToolMajor(mapper, rawToolMajor); 2953 processSync(mapper); 2954 2955 FakeInputDispatcher::NotifyMotionArgs args; 2956 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args)); 2957 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 2958 x, y, pressure, size, touch, touch, tool, tool, 0)); 2959} 2960 2961 2962// --- MultiTouchInputMapperTest --- 2963 2964class MultiTouchInputMapperTest : public TouchInputMapperTest { 2965protected: 2966 void prepareAxes(int axes); 2967 2968 void processPosition(MultiTouchInputMapper* mapper, int32_t x, int32_t y); 2969 void processTouchMajor(MultiTouchInputMapper* mapper, int32_t touchMajor); 2970 void processTouchMinor(MultiTouchInputMapper* mapper, int32_t touchMinor); 2971 void processToolMajor(MultiTouchInputMapper* mapper, int32_t toolMajor); 2972 void processToolMinor(MultiTouchInputMapper* mapper, int32_t toolMinor); 2973 void processOrientation(MultiTouchInputMapper* mapper, int32_t orientation); 2974 void processPressure(MultiTouchInputMapper* mapper, int32_t pressure); 2975 void processId(MultiTouchInputMapper* mapper, int32_t id); 2976 void processMTSync(MultiTouchInputMapper* mapper); 2977 void processSync(MultiTouchInputMapper* mapper); 2978}; 2979 2980void MultiTouchInputMapperTest::prepareAxes(int axes) { 2981 if (axes & POSITION) { 2982 mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_POSITION_X, RAW_X_MIN, RAW_X_MAX, 0, 0); 2983 mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_POSITION_Y, RAW_Y_MIN, RAW_Y_MAX, 0, 0); 2984 } 2985 if (axes & TOUCH) { 2986 mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_TOUCH_MAJOR, RAW_TOUCH_MIN, RAW_TOUCH_MAX, 0, 0); 2987 if (axes & MINOR) { 2988 mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_TOUCH_MINOR, 2989 RAW_TOUCH_MIN, RAW_TOUCH_MAX, 0, 0); 2990 } 2991 } 2992 if (axes & TOOL) { 2993 mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_WIDTH_MAJOR, RAW_TOOL_MIN, RAW_TOOL_MAX, 0, 0); 2994 if (axes & MINOR) { 2995 mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_WIDTH_MINOR, 2996 RAW_TOOL_MAX, RAW_TOOL_MAX, 0, 0); 2997 } 2998 } 2999 if (axes & ORIENTATION) { 3000 mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_ORIENTATION, 3001 RAW_ORIENTATION_MIN, RAW_ORIENTATION_MAX, 0, 0); 3002 } 3003 if (axes & PRESSURE) { 3004 mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_PRESSURE, 3005 RAW_PRESSURE_MIN, RAW_PRESSURE_MAX, 0, 0); 3006 } 3007 if (axes & ID) { 3008 mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_TRACKING_ID, 3009 RAW_ID_MIN, RAW_ID_MAX, 0, 0); 3010 } 3011} 3012 3013void MultiTouchInputMapperTest::processPosition( 3014 MultiTouchInputMapper* mapper, int32_t x, int32_t y) { 3015 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_POSITION_X, 0, x, 0); 3016 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_POSITION_Y, 0, y, 0); 3017} 3018 3019void MultiTouchInputMapperTest::processTouchMajor( 3020 MultiTouchInputMapper* mapper, int32_t touchMajor) { 3021 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_TOUCH_MAJOR, 0, touchMajor, 0); 3022} 3023 3024void MultiTouchInputMapperTest::processTouchMinor( 3025 MultiTouchInputMapper* mapper, int32_t touchMinor) { 3026 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_TOUCH_MINOR, 0, touchMinor, 0); 3027} 3028 3029void MultiTouchInputMapperTest::processToolMajor( 3030 MultiTouchInputMapper* mapper, int32_t toolMajor) { 3031 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_WIDTH_MAJOR, 0, toolMajor, 0); 3032} 3033 3034void MultiTouchInputMapperTest::processToolMinor( 3035 MultiTouchInputMapper* mapper, int32_t toolMinor) { 3036 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_WIDTH_MINOR, 0, toolMinor, 0); 3037} 3038 3039void MultiTouchInputMapperTest::processOrientation( 3040 MultiTouchInputMapper* mapper, int32_t orientation) { 3041 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_ORIENTATION, 0, orientation, 0); 3042} 3043 3044void MultiTouchInputMapperTest::processPressure( 3045 MultiTouchInputMapper* mapper, int32_t pressure) { 3046 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_PRESSURE, 0, pressure, 0); 3047} 3048 3049void MultiTouchInputMapperTest::processId( 3050 MultiTouchInputMapper* mapper, int32_t id) { 3051 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_TRACKING_ID, 0, id, 0); 3052} 3053 3054void MultiTouchInputMapperTest::processMTSync(MultiTouchInputMapper* mapper) { 3055 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_MT_REPORT, 0, 0, 0); 3056} 3057 3058void MultiTouchInputMapperTest::processSync(MultiTouchInputMapper* mapper) { 3059 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0, 0, 0); 3060} 3061 3062 3063TEST_F(MultiTouchInputMapperTest, Process_NormalMultiTouchGesture_WithoutTrackingIds) { 3064 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice); 3065 prepareDisplay(DISPLAY_ORIENTATION_0); 3066 prepareAxes(POSITION); 3067 prepareVirtualKeys(); 3068 addMapperAndConfigure(mapper); 3069 3070 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON); 3071 3072 FakeInputDispatcher::NotifyMotionArgs motionArgs; 3073 3074 // Two fingers down at once. 3075 int32_t x1 = 100, y1 = 125, x2 = 300, y2 = 500; 3076 processPosition(mapper, x1, y1); 3077 processMTSync(mapper); 3078 processPosition(mapper, x2, y2); 3079 processMTSync(mapper); 3080 processSync(mapper); 3081 3082 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs)); 3083 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 3084 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 3085 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 3086 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 3087 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action); 3088 ASSERT_EQ(0, motionArgs.flags); 3089 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 3090 ASSERT_EQ(0, motionArgs.edgeFlags); 3091 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 3092 ASSERT_EQ(0, motionArgs.pointerIds[0]); 3093 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3094 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0)); 3095 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 3096 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 3097 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 3098 3099 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs)); 3100 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 3101 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 3102 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 3103 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 3104 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_DOWN | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT), 3105 motionArgs.action); 3106 ASSERT_EQ(0, motionArgs.flags); 3107 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 3108 ASSERT_EQ(0, motionArgs.edgeFlags); 3109 ASSERT_EQ(size_t(2), motionArgs.pointerCount); 3110 ASSERT_EQ(0, motionArgs.pointerIds[0]); 3111 ASSERT_EQ(1, motionArgs.pointerIds[1]); 3112 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3113 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0)); 3114 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1], 3115 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0)); 3116 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 3117 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 3118 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 3119 3120 // Move. 3121 x1 += 10; y1 += 15; x2 += 5; y2 -= 10; 3122 processPosition(mapper, x1, y1); 3123 processMTSync(mapper); 3124 processPosition(mapper, x2, y2); 3125 processMTSync(mapper); 3126 processSync(mapper); 3127 3128 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs)); 3129 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 3130 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 3131 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 3132 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 3133 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3134 ASSERT_EQ(0, motionArgs.flags); 3135 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 3136 ASSERT_EQ(0, motionArgs.edgeFlags); 3137 ASSERT_EQ(size_t(2), motionArgs.pointerCount); 3138 ASSERT_EQ(0, motionArgs.pointerIds[0]); 3139 ASSERT_EQ(1, motionArgs.pointerIds[1]); 3140 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3141 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0)); 3142 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1], 3143 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0)); 3144 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 3145 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 3146 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 3147 3148 // First finger up. 3149 x2 += 15; y2 -= 20; 3150 processPosition(mapper, x2, y2); 3151 processMTSync(mapper); 3152 processSync(mapper); 3153 3154 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs)); 3155 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 3156 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 3157 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 3158 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 3159 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_UP | (0 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT), 3160 motionArgs.action); 3161 ASSERT_EQ(0, motionArgs.flags); 3162 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 3163 ASSERT_EQ(0, motionArgs.edgeFlags); 3164 ASSERT_EQ(size_t(2), motionArgs.pointerCount); 3165 ASSERT_EQ(0, motionArgs.pointerIds[0]); 3166 ASSERT_EQ(1, motionArgs.pointerIds[1]); 3167 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3168 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0)); 3169 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1], 3170 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0)); 3171 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 3172 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 3173 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 3174 3175 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs)); 3176 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 3177 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 3178 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 3179 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 3180 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3181 ASSERT_EQ(0, motionArgs.flags); 3182 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 3183 ASSERT_EQ(0, motionArgs.edgeFlags); 3184 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 3185 ASSERT_EQ(1, motionArgs.pointerIds[0]); 3186 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3187 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0)); 3188 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 3189 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 3190 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 3191 3192 // Move. 3193 x2 += 20; y2 -= 25; 3194 processPosition(mapper, x2, y2); 3195 processMTSync(mapper); 3196 processSync(mapper); 3197 3198 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs)); 3199 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 3200 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 3201 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 3202 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 3203 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3204 ASSERT_EQ(0, motionArgs.flags); 3205 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 3206 ASSERT_EQ(0, motionArgs.edgeFlags); 3207 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 3208 ASSERT_EQ(1, motionArgs.pointerIds[0]); 3209 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3210 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0)); 3211 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 3212 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 3213 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 3214 3215 // New finger down. 3216 int32_t x3 = 700, y3 = 300; 3217 processPosition(mapper, x2, y2); 3218 processMTSync(mapper); 3219 processPosition(mapper, x3, y3); 3220 processMTSync(mapper); 3221 processSync(mapper); 3222 3223 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs)); 3224 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 3225 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 3226 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 3227 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 3228 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_DOWN | (0 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT), 3229 motionArgs.action); 3230 ASSERT_EQ(0, motionArgs.flags); 3231 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 3232 ASSERT_EQ(0, motionArgs.edgeFlags); 3233 ASSERT_EQ(size_t(2), motionArgs.pointerCount); 3234 ASSERT_EQ(0, motionArgs.pointerIds[0]); 3235 ASSERT_EQ(1, motionArgs.pointerIds[1]); 3236 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3237 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0)); 3238 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1], 3239 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0)); 3240 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 3241 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 3242 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 3243 3244 // Second finger up. 3245 x3 += 30; y3 -= 20; 3246 processPosition(mapper, x3, y3); 3247 processMTSync(mapper); 3248 processSync(mapper); 3249 3250 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs)); 3251 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 3252 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 3253 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 3254 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 3255 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_UP | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT), 3256 motionArgs.action); 3257 ASSERT_EQ(0, motionArgs.flags); 3258 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 3259 ASSERT_EQ(0, motionArgs.edgeFlags); 3260 ASSERT_EQ(size_t(2), motionArgs.pointerCount); 3261 ASSERT_EQ(0, motionArgs.pointerIds[0]); 3262 ASSERT_EQ(1, motionArgs.pointerIds[1]); 3263 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3264 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0)); 3265 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1], 3266 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0)); 3267 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 3268 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 3269 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 3270 3271 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs)); 3272 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 3273 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 3274 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 3275 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 3276 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3277 ASSERT_EQ(0, motionArgs.flags); 3278 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 3279 ASSERT_EQ(0, motionArgs.edgeFlags); 3280 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 3281 ASSERT_EQ(0, motionArgs.pointerIds[0]); 3282 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3283 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0)); 3284 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 3285 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 3286 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 3287 3288 // Last finger up. 3289 processMTSync(mapper); 3290 processSync(mapper); 3291 3292 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs)); 3293 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 3294 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 3295 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 3296 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 3297 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action); 3298 ASSERT_EQ(0, motionArgs.flags); 3299 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 3300 ASSERT_EQ(0, motionArgs.edgeFlags); 3301 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 3302 ASSERT_EQ(0, motionArgs.pointerIds[0]); 3303 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3304 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0)); 3305 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 3306 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 3307 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 3308 3309 // Should not have sent any more keys or motions. 3310 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled()); 3311 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled()); 3312} 3313 3314TEST_F(MultiTouchInputMapperTest, Process_NormalMultiTouchGesture_WithTrackingIds) { 3315 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice); 3316 prepareDisplay(DISPLAY_ORIENTATION_0); 3317 prepareAxes(POSITION | ID); 3318 prepareVirtualKeys(); 3319 addMapperAndConfigure(mapper); 3320 3321 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON); 3322 3323 FakeInputDispatcher::NotifyMotionArgs motionArgs; 3324 3325 // Two fingers down at once. 3326 int32_t x1 = 100, y1 = 125, x2 = 300, y2 = 500; 3327 processPosition(mapper, x1, y1); 3328 processId(mapper, 1); 3329 processMTSync(mapper); 3330 processPosition(mapper, x2, y2); 3331 processId(mapper, 2); 3332 processMTSync(mapper); 3333 processSync(mapper); 3334 3335 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs)); 3336 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action); 3337 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 3338 ASSERT_EQ(1, motionArgs.pointerIds[0]); 3339 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3340 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0)); 3341 3342 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs)); 3343 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_DOWN | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT), 3344 motionArgs.action); 3345 ASSERT_EQ(size_t(2), motionArgs.pointerCount); 3346 ASSERT_EQ(1, motionArgs.pointerIds[0]); 3347 ASSERT_EQ(2, motionArgs.pointerIds[1]); 3348 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3349 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0)); 3350 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1], 3351 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0)); 3352 3353 // Move. 3354 x1 += 10; y1 += 15; x2 += 5; y2 -= 10; 3355 processPosition(mapper, x1, y1); 3356 processId(mapper, 1); 3357 processMTSync(mapper); 3358 processPosition(mapper, x2, y2); 3359 processId(mapper, 2); 3360 processMTSync(mapper); 3361 processSync(mapper); 3362 3363 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs)); 3364 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3365 ASSERT_EQ(size_t(2), motionArgs.pointerCount); 3366 ASSERT_EQ(1, motionArgs.pointerIds[0]); 3367 ASSERT_EQ(2, motionArgs.pointerIds[1]); 3368 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3369 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0)); 3370 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1], 3371 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0)); 3372 3373 // First finger up. 3374 x2 += 15; y2 -= 20; 3375 processPosition(mapper, x2, y2); 3376 processId(mapper, 2); 3377 processMTSync(mapper); 3378 processSync(mapper); 3379 3380 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs)); 3381 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_UP | (0 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT), 3382 motionArgs.action); 3383 ASSERT_EQ(size_t(2), motionArgs.pointerCount); 3384 ASSERT_EQ(1, motionArgs.pointerIds[0]); 3385 ASSERT_EQ(2, motionArgs.pointerIds[1]); 3386 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3387 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0)); 3388 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1], 3389 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0)); 3390 3391 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs)); 3392 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3393 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 3394 ASSERT_EQ(2, motionArgs.pointerIds[0]); 3395 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3396 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0)); 3397 3398 // Move. 3399 x2 += 20; y2 -= 25; 3400 processPosition(mapper, x2, y2); 3401 processId(mapper, 2); 3402 processMTSync(mapper); 3403 processSync(mapper); 3404 3405 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs)); 3406 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3407 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 3408 ASSERT_EQ(2, motionArgs.pointerIds[0]); 3409 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3410 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0)); 3411 3412 // New finger down. 3413 int32_t x3 = 700, y3 = 300; 3414 processPosition(mapper, x2, y2); 3415 processId(mapper, 2); 3416 processMTSync(mapper); 3417 processPosition(mapper, x3, y3); 3418 processId(mapper, 3); 3419 processMTSync(mapper); 3420 processSync(mapper); 3421 3422 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs)); 3423 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_DOWN | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT), 3424 motionArgs.action); 3425 ASSERT_EQ(size_t(2), motionArgs.pointerCount); 3426 ASSERT_EQ(2, motionArgs.pointerIds[0]); 3427 ASSERT_EQ(3, motionArgs.pointerIds[1]); 3428 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3429 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0)); 3430 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1], 3431 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0)); 3432 3433 // Second finger up. 3434 x3 += 30; y3 -= 20; 3435 processPosition(mapper, x3, y3); 3436 processId(mapper, 3); 3437 processMTSync(mapper); 3438 processSync(mapper); 3439 3440 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs)); 3441 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_UP | (0 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT), 3442 motionArgs.action); 3443 ASSERT_EQ(size_t(2), motionArgs.pointerCount); 3444 ASSERT_EQ(2, motionArgs.pointerIds[0]); 3445 ASSERT_EQ(3, motionArgs.pointerIds[1]); 3446 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3447 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0)); 3448 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1], 3449 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0)); 3450 3451 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs)); 3452 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3453 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 3454 ASSERT_EQ(3, motionArgs.pointerIds[0]); 3455 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3456 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0)); 3457 3458 // Last finger up. 3459 processMTSync(mapper); 3460 processSync(mapper); 3461 3462 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs)); 3463 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action); 3464 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 3465 ASSERT_EQ(3, motionArgs.pointerIds[0]); 3466 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3467 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0)); 3468 3469 // Should not have sent any more keys or motions. 3470 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled()); 3471 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled()); 3472} 3473 3474TEST_F(MultiTouchInputMapperTest, Process_AllAxes_WithDefaultCalibration) { 3475 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice); 3476 prepareDisplay(DISPLAY_ORIENTATION_0); 3477 prepareAxes(POSITION | TOUCH | TOOL | PRESSURE | ORIENTATION | ID | MINOR); 3478 addMapperAndConfigure(mapper); 3479 3480 // These calculations are based on the input device calibration documentation. 3481 int32_t rawX = 100; 3482 int32_t rawY = 200; 3483 int32_t rawTouchMajor = 7; 3484 int32_t rawTouchMinor = 6; 3485 int32_t rawToolMajor = 9; 3486 int32_t rawToolMinor = 8; 3487 int32_t rawPressure = 11; 3488 int32_t rawOrientation = 3; 3489 int32_t id = 5; 3490 3491 float x = toDisplayX(rawX); 3492 float y = toDisplayY(rawY); 3493 float pressure = float(rawPressure) / RAW_PRESSURE_MAX; 3494 float size = avg(rawToolMajor, rawToolMinor) / RAW_TOOL_MAX; 3495 float toolMajor = float(min(DISPLAY_WIDTH, DISPLAY_HEIGHT)) * rawToolMajor / RAW_TOOL_MAX; 3496 float toolMinor = float(min(DISPLAY_WIDTH, DISPLAY_HEIGHT)) * rawToolMinor / RAW_TOOL_MAX; 3497 float touchMajor = min(toolMajor * pressure, toolMajor); 3498 float touchMinor = min(toolMinor * pressure, toolMinor); 3499 float orientation = float(rawOrientation) / RAW_ORIENTATION_MAX * M_PI_2; 3500 3501 processPosition(mapper, rawX, rawY); 3502 processTouchMajor(mapper, rawTouchMajor); 3503 processTouchMinor(mapper, rawTouchMinor); 3504 processToolMajor(mapper, rawToolMajor); 3505 processToolMinor(mapper, rawToolMinor); 3506 processPressure(mapper, rawPressure); 3507 processOrientation(mapper, rawOrientation); 3508 processId(mapper, id); 3509 processMTSync(mapper); 3510 processSync(mapper); 3511 3512 FakeInputDispatcher::NotifyMotionArgs args; 3513 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args)); 3514 ASSERT_EQ(id, args.pointerIds[0]); 3515 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 3516 x, y, pressure, size, touchMajor, touchMinor, toolMajor, toolMinor, orientation)); 3517} 3518 3519TEST_F(MultiTouchInputMapperTest, Process_TouchAndToolAxes_GeometricCalibration) { 3520 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice); 3521 prepareDisplay(DISPLAY_ORIENTATION_0); 3522 prepareAxes(POSITION | TOUCH | TOOL | MINOR); 3523 addConfigurationProperty("touch.touchSize.calibration", "geometric"); 3524 addConfigurationProperty("touch.toolSize.calibration", "geometric"); 3525 addMapperAndConfigure(mapper); 3526 3527 // These calculations are based on the input device calibration documentation. 3528 int32_t rawX = 100; 3529 int32_t rawY = 200; 3530 int32_t rawTouchMajor = 140; 3531 int32_t rawTouchMinor = 120; 3532 int32_t rawToolMajor = 180; 3533 int32_t rawToolMinor = 160; 3534 3535 float x = toDisplayX(rawX); 3536 float y = toDisplayY(rawY); 3537 float pressure = float(rawTouchMajor) / RAW_TOUCH_MAX; 3538 float size = avg(rawToolMajor, rawToolMinor) / RAW_TOOL_MAX; 3539 float scale = avg(float(DISPLAY_WIDTH) / (RAW_X_MAX - RAW_X_MIN), 3540 float(DISPLAY_HEIGHT) / (RAW_Y_MAX - RAW_Y_MIN)); 3541 float toolMajor = float(rawToolMajor) * scale; 3542 float toolMinor = float(rawToolMinor) * scale; 3543 float touchMajor = min(float(rawTouchMajor) * scale, toolMajor); 3544 float touchMinor = min(float(rawTouchMinor) * scale, toolMinor); 3545 3546 processPosition(mapper, rawX, rawY); 3547 processTouchMajor(mapper, rawTouchMajor); 3548 processTouchMinor(mapper, rawTouchMinor); 3549 processToolMajor(mapper, rawToolMajor); 3550 processToolMinor(mapper, rawToolMinor); 3551 processMTSync(mapper); 3552 processSync(mapper); 3553 3554 FakeInputDispatcher::NotifyMotionArgs args; 3555 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args)); 3556 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 3557 x, y, pressure, size, touchMajor, touchMinor, toolMajor, toolMinor, 0)); 3558} 3559 3560TEST_F(MultiTouchInputMapperTest, Process_TouchToolPressureSizeAxes_SummedLinearCalibration) { 3561 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice); 3562 prepareDisplay(DISPLAY_ORIENTATION_0); 3563 prepareAxes(POSITION | TOUCH | TOOL); 3564 addConfigurationProperty("touch.touchSize.calibration", "pressure"); 3565 addConfigurationProperty("touch.toolSize.calibration", "linear"); 3566 addConfigurationProperty("touch.toolSize.linearScale", "10"); 3567 addConfigurationProperty("touch.toolSize.linearBias", "160"); 3568 addConfigurationProperty("touch.toolSize.isSummed", "1"); 3569 addConfigurationProperty("touch.pressure.calibration", "amplitude"); 3570 addConfigurationProperty("touch.pressure.source", "touch"); 3571 addConfigurationProperty("touch.pressure.scale", "0.01"); 3572 addMapperAndConfigure(mapper); 3573 3574 // These calculations are based on the input device calibration documentation. 3575 // Note: We only provide a single common touch/tool value because the device is assumed 3576 // not to emit separate values for each pointer (isSummed = 1). 3577 int32_t rawX = 100; 3578 int32_t rawY = 200; 3579 int32_t rawX2 = 150; 3580 int32_t rawY2 = 250; 3581 int32_t rawTouchMajor = 60; 3582 int32_t rawToolMajor = 5; 3583 3584 float x = toDisplayX(rawX); 3585 float y = toDisplayY(rawY); 3586 float x2 = toDisplayX(rawX2); 3587 float y2 = toDisplayY(rawY2); 3588 float pressure = float(rawTouchMajor) * 0.01f; 3589 float size = float(rawToolMajor) / RAW_TOOL_MAX; 3590 float tool = (float(rawToolMajor) * 10.0f + 160.0f) / 2; 3591 float touch = min(tool * pressure, tool); 3592 3593 processPosition(mapper, rawX, rawY); 3594 processTouchMajor(mapper, rawTouchMajor); 3595 processToolMajor(mapper, rawToolMajor); 3596 processMTSync(mapper); 3597 processPosition(mapper, rawX2, rawY2); 3598 processTouchMajor(mapper, rawTouchMajor); 3599 processToolMajor(mapper, rawToolMajor); 3600 processMTSync(mapper); 3601 processSync(mapper); 3602 3603 FakeInputDispatcher::NotifyMotionArgs args; 3604 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args)); 3605 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action); 3606 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args)); 3607 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_DOWN | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT), 3608 args.action); 3609 ASSERT_EQ(size_t(2), args.pointerCount); 3610 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 3611 x, y, pressure, size, touch, touch, tool, tool, 0)); 3612 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[1], 3613 x2, y2, pressure, size, touch, touch, tool, tool, 0)); 3614} 3615 3616TEST_F(MultiTouchInputMapperTest, Process_TouchToolPressureSizeAxes_AreaCalibration) { 3617 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice); 3618 prepareDisplay(DISPLAY_ORIENTATION_0); 3619 prepareAxes(POSITION | TOUCH | TOOL); 3620 addConfigurationProperty("touch.touchSize.calibration", "pressure"); 3621 addConfigurationProperty("touch.toolSize.calibration", "area"); 3622 addConfigurationProperty("touch.toolSize.areaScale", "22"); 3623 addConfigurationProperty("touch.toolSize.areaBias", "1"); 3624 addConfigurationProperty("touch.toolSize.linearScale", "9.2"); 3625 addConfigurationProperty("touch.toolSize.linearBias", "3"); 3626 addConfigurationProperty("touch.pressure.calibration", "amplitude"); 3627 addConfigurationProperty("touch.pressure.source", "touch"); 3628 addConfigurationProperty("touch.pressure.scale", "0.01"); 3629 addMapperAndConfigure(mapper); 3630 3631 // These calculations are based on the input device calibration documentation. 3632 int32_t rawX = 100; 3633 int32_t rawY = 200; 3634 int32_t rawTouchMajor = 60; 3635 int32_t rawToolMajor = 5; 3636 3637 float x = toDisplayX(rawX); 3638 float y = toDisplayY(rawY); 3639 float pressure = float(rawTouchMajor) * 0.01f; 3640 float size = float(rawToolMajor) / RAW_TOOL_MAX; 3641 float tool = sqrtf(float(rawToolMajor) * 22.0f + 1.0f) * 9.2f + 3.0f; 3642 float touch = min(tool * pressure, tool); 3643 3644 processPosition(mapper, rawX, rawY); 3645 processTouchMajor(mapper, rawTouchMajor); 3646 processToolMajor(mapper, rawToolMajor); 3647 processMTSync(mapper); 3648 processSync(mapper); 3649 3650 FakeInputDispatcher::NotifyMotionArgs args; 3651 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args)); 3652 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 3653 x, y, pressure, size, touch, touch, tool, tool, 0)); 3654} 3655 3656} // namespace android 3657