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