1 /* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include "../InputReader.h" 18 19 #include <utils/List.h> 20 #include <gtest/gtest.h> 21 #include <math.h> 22 23 namespace android { 24 25 // An arbitrary time value. 26 static const nsecs_t ARBITRARY_TIME = 1234; 27 28 // Arbitrary display properties. 29 static const int32_t DISPLAY_ID = 0; 30 static const int32_t DISPLAY_WIDTH = 480; 31 static const int32_t DISPLAY_HEIGHT = 800; 32 33 // Error tolerance for floating point assertions. 34 static const float EPSILON = 0.001f; 35 36 template<typename T> 37 static inline T min(T a, T b) { 38 return a < b ? a : b; 39 } 40 41 static inline float avg(float x, float y) { 42 return (x + y) / 2; 43 } 44 45 46 // --- FakePointerController --- 47 48 class FakePointerController : public PointerControllerInterface { 49 bool mHaveBounds; 50 float mMinX, mMinY, mMaxX, mMaxY; 51 float mX, mY; 52 int32_t mButtonState; 53 54 protected: 55 virtual ~FakePointerController() { } 56 57 public: 58 FakePointerController() : 59 mHaveBounds(false), mMinX(0), mMinY(0), mMaxX(0), mMaxY(0), mX(0), mY(0), 60 mButtonState(0) { 61 } 62 63 void setBounds(float minX, float minY, float maxX, float maxY) { 64 mHaveBounds = true; 65 mMinX = minX; 66 mMinY = minY; 67 mMaxX = maxX; 68 mMaxY = maxY; 69 } 70 71 virtual void setPosition(float x, float y) { 72 mX = x; 73 mY = y; 74 } 75 76 virtual void setButtonState(int32_t buttonState) { 77 mButtonState = buttonState; 78 } 79 80 virtual int32_t getButtonState() const { 81 return mButtonState; 82 } 83 84 virtual void getPosition(float* outX, float* outY) const { 85 *outX = mX; 86 *outY = mY; 87 } 88 89 private: 90 virtual bool getBounds(float* outMinX, float* outMinY, float* outMaxX, float* outMaxY) const { 91 *outMinX = mMinX; 92 *outMinY = mMinY; 93 *outMaxX = mMaxX; 94 *outMaxY = mMaxY; 95 return mHaveBounds; 96 } 97 98 virtual void move(float deltaX, float deltaY) { 99 mX += deltaX; 100 if (mX < mMinX) mX = mMinX; 101 if (mX > mMaxX) mX = mMaxX; 102 mY += deltaY; 103 if (mY < mMinY) mY = mMinY; 104 if (mY > mMaxY) mY = mMaxY; 105 } 106 107 virtual void fade(Transition transition) { 108 } 109 110 virtual void unfade(Transition transition) { 111 } 112 113 virtual void setPresentation(Presentation presentation) { 114 } 115 116 virtual void setSpots(const PointerCoords* spotCoords, 117 const uint32_t* spotIdToIndex, BitSet32 spotIdBits) { 118 } 119 120 virtual void clearSpots() { 121 } 122 }; 123 124 125 // --- FakeInputReaderPolicy --- 126 127 class FakeInputReaderPolicy : public InputReaderPolicyInterface { 128 InputReaderConfiguration mConfig; 129 KeyedVector<int32_t, sp<FakePointerController> > mPointerControllers; 130 Vector<InputDeviceInfo> mInputDevices; 131 132 protected: 133 virtual ~FakeInputReaderPolicy() { } 134 135 public: 136 FakeInputReaderPolicy() { 137 } 138 139 void setDisplayInfo(int32_t displayId, int32_t width, int32_t height, int32_t orientation) { 140 // Set the size of both the internal and external display at the same time. 141 mConfig.setDisplayInfo(displayId, false /*external*/, width, height, orientation); 142 mConfig.setDisplayInfo(displayId, true /*external*/, width, height, orientation); 143 } 144 145 void addExcludedDeviceName(const String8& deviceName) { 146 mConfig.excludedDeviceNames.push(deviceName); 147 } 148 149 void setPointerController(int32_t deviceId, const sp<FakePointerController>& controller) { 150 mPointerControllers.add(deviceId, controller); 151 } 152 153 const InputReaderConfiguration* getReaderConfiguration() const { 154 return &mConfig; 155 } 156 157 const Vector<InputDeviceInfo>& getInputDevices() const { 158 return mInputDevices; 159 } 160 161 private: 162 virtual void getReaderConfiguration(InputReaderConfiguration* outConfig) { 163 *outConfig = mConfig; 164 } 165 166 virtual sp<PointerControllerInterface> obtainPointerController(int32_t deviceId) { 167 return mPointerControllers.valueFor(deviceId); 168 } 169 170 virtual void notifyInputDevicesChanged(const Vector<InputDeviceInfo>& inputDevices) { 171 mInputDevices = inputDevices; 172 } 173 174 virtual sp<KeyCharacterMap> getKeyboardLayoutOverlay(const String8& inputDeviceDescriptor) { 175 return NULL; 176 } 177 178 virtual String8 getDeviceAlias(const InputDeviceIdentifier& identifier) { 179 return String8::empty(); 180 } 181 }; 182 183 184 // --- FakeInputListener --- 185 186 class FakeInputListener : public InputListenerInterface { 187 private: 188 List<NotifyConfigurationChangedArgs> mNotifyConfigurationChangedArgsQueue; 189 List<NotifyDeviceResetArgs> mNotifyDeviceResetArgsQueue; 190 List<NotifyKeyArgs> mNotifyKeyArgsQueue; 191 List<NotifyMotionArgs> mNotifyMotionArgsQueue; 192 List<NotifySwitchArgs> mNotifySwitchArgsQueue; 193 194 protected: 195 virtual ~FakeInputListener() { } 196 197 public: 198 FakeInputListener() { 199 } 200 201 void assertNotifyConfigurationChangedWasCalled( 202 NotifyConfigurationChangedArgs* outEventArgs = NULL) { 203 ASSERT_FALSE(mNotifyConfigurationChangedArgsQueue.empty()) 204 << "Expected notifyConfigurationChanged() to have been called."; 205 if (outEventArgs) { 206 *outEventArgs = *mNotifyConfigurationChangedArgsQueue.begin(); 207 } 208 mNotifyConfigurationChangedArgsQueue.erase(mNotifyConfigurationChangedArgsQueue.begin()); 209 } 210 211 void assertNotifyDeviceResetWasCalled( 212 NotifyDeviceResetArgs* outEventArgs = NULL) { 213 ASSERT_FALSE(mNotifyDeviceResetArgsQueue.empty()) 214 << "Expected notifyDeviceReset() to have been called."; 215 if (outEventArgs) { 216 *outEventArgs = *mNotifyDeviceResetArgsQueue.begin(); 217 } 218 mNotifyDeviceResetArgsQueue.erase(mNotifyDeviceResetArgsQueue.begin()); 219 } 220 221 void assertNotifyKeyWasCalled(NotifyKeyArgs* outEventArgs = NULL) { 222 ASSERT_FALSE(mNotifyKeyArgsQueue.empty()) 223 << "Expected notifyKey() to have been called."; 224 if (outEventArgs) { 225 *outEventArgs = *mNotifyKeyArgsQueue.begin(); 226 } 227 mNotifyKeyArgsQueue.erase(mNotifyKeyArgsQueue.begin()); 228 } 229 230 void assertNotifyKeyWasNotCalled() { 231 ASSERT_TRUE(mNotifyKeyArgsQueue.empty()) 232 << "Expected notifyKey() to not have been called."; 233 } 234 235 void assertNotifyMotionWasCalled(NotifyMotionArgs* outEventArgs = NULL) { 236 ASSERT_FALSE(mNotifyMotionArgsQueue.empty()) 237 << "Expected notifyMotion() to have been called."; 238 if (outEventArgs) { 239 *outEventArgs = *mNotifyMotionArgsQueue.begin(); 240 } 241 mNotifyMotionArgsQueue.erase(mNotifyMotionArgsQueue.begin()); 242 } 243 244 void assertNotifyMotionWasNotCalled() { 245 ASSERT_TRUE(mNotifyMotionArgsQueue.empty()) 246 << "Expected notifyMotion() to not have been called."; 247 } 248 249 void assertNotifySwitchWasCalled(NotifySwitchArgs* outEventArgs = NULL) { 250 ASSERT_FALSE(mNotifySwitchArgsQueue.empty()) 251 << "Expected notifySwitch() to have been called."; 252 if (outEventArgs) { 253 *outEventArgs = *mNotifySwitchArgsQueue.begin(); 254 } 255 mNotifySwitchArgsQueue.erase(mNotifySwitchArgsQueue.begin()); 256 } 257 258 private: 259 virtual void notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args) { 260 mNotifyConfigurationChangedArgsQueue.push_back(*args); 261 } 262 263 virtual void notifyDeviceReset(const NotifyDeviceResetArgs* args) { 264 mNotifyDeviceResetArgsQueue.push_back(*args); 265 } 266 267 virtual void notifyKey(const NotifyKeyArgs* args) { 268 mNotifyKeyArgsQueue.push_back(*args); 269 } 270 271 virtual void notifyMotion(const NotifyMotionArgs* args) { 272 mNotifyMotionArgsQueue.push_back(*args); 273 } 274 275 virtual void notifySwitch(const NotifySwitchArgs* args) { 276 mNotifySwitchArgsQueue.push_back(*args); 277 } 278 }; 279 280 281 // --- FakeEventHub --- 282 283 class FakeEventHub : public EventHubInterface { 284 struct KeyInfo { 285 int32_t keyCode; 286 uint32_t flags; 287 }; 288 289 struct Device { 290 InputDeviceIdentifier identifier; 291 uint32_t classes; 292 PropertyMap configuration; 293 KeyedVector<int, RawAbsoluteAxisInfo> absoluteAxes; 294 KeyedVector<int, bool> relativeAxes; 295 KeyedVector<int32_t, int32_t> keyCodeStates; 296 KeyedVector<int32_t, int32_t> scanCodeStates; 297 KeyedVector<int32_t, int32_t> switchStates; 298 KeyedVector<int32_t, int32_t> absoluteAxisValue; 299 KeyedVector<int32_t, KeyInfo> keysByScanCode; 300 KeyedVector<int32_t, KeyInfo> keysByUsageCode; 301 KeyedVector<int32_t, bool> leds; 302 Vector<VirtualKeyDefinition> virtualKeys; 303 304 Device(uint32_t classes) : 305 classes(classes) { 306 } 307 }; 308 309 KeyedVector<int32_t, Device*> mDevices; 310 Vector<String8> mExcludedDevices; 311 List<RawEvent> mEvents; 312 313 protected: 314 virtual ~FakeEventHub() { 315 for (size_t i = 0; i < mDevices.size(); i++) { 316 delete mDevices.valueAt(i); 317 } 318 } 319 320 public: 321 FakeEventHub() { } 322 323 void addDevice(int32_t deviceId, const String8& name, uint32_t classes) { 324 Device* device = new Device(classes); 325 device->identifier.name = name; 326 mDevices.add(deviceId, device); 327 328 enqueueEvent(ARBITRARY_TIME, deviceId, EventHubInterface::DEVICE_ADDED, 0, 0); 329 } 330 331 void removeDevice(int32_t deviceId) { 332 delete mDevices.valueFor(deviceId); 333 mDevices.removeItem(deviceId); 334 335 enqueueEvent(ARBITRARY_TIME, deviceId, EventHubInterface::DEVICE_REMOVED, 0, 0); 336 } 337 338 void finishDeviceScan() { 339 enqueueEvent(ARBITRARY_TIME, 0, EventHubInterface::FINISHED_DEVICE_SCAN, 0, 0); 340 } 341 342 void addConfigurationProperty(int32_t deviceId, const String8& key, const String8& value) { 343 Device* device = getDevice(deviceId); 344 device->configuration.addProperty(key, value); 345 } 346 347 void addConfigurationMap(int32_t deviceId, const PropertyMap* configuration) { 348 Device* device = getDevice(deviceId); 349 device->configuration.addAll(configuration); 350 } 351 352 void addAbsoluteAxis(int32_t deviceId, int axis, 353 int32_t minValue, int32_t maxValue, int flat, int fuzz, int resolution = 0) { 354 Device* device = getDevice(deviceId); 355 356 RawAbsoluteAxisInfo info; 357 info.valid = true; 358 info.minValue = minValue; 359 info.maxValue = maxValue; 360 info.flat = flat; 361 info.fuzz = fuzz; 362 info.resolution = resolution; 363 device->absoluteAxes.add(axis, info); 364 } 365 366 void addRelativeAxis(int32_t deviceId, int32_t axis) { 367 Device* device = getDevice(deviceId); 368 device->relativeAxes.add(axis, true); 369 } 370 371 void setKeyCodeState(int32_t deviceId, int32_t keyCode, int32_t state) { 372 Device* device = getDevice(deviceId); 373 device->keyCodeStates.replaceValueFor(keyCode, state); 374 } 375 376 void setScanCodeState(int32_t deviceId, int32_t scanCode, int32_t state) { 377 Device* device = getDevice(deviceId); 378 device->scanCodeStates.replaceValueFor(scanCode, state); 379 } 380 381 void setSwitchState(int32_t deviceId, int32_t switchCode, int32_t state) { 382 Device* device = getDevice(deviceId); 383 device->switchStates.replaceValueFor(switchCode, state); 384 } 385 386 void setAbsoluteAxisValue(int32_t deviceId, int32_t axis, int32_t value) { 387 Device* device = getDevice(deviceId); 388 device->absoluteAxisValue.replaceValueFor(axis, value); 389 } 390 391 void addKey(int32_t deviceId, int32_t scanCode, int32_t usageCode, 392 int32_t keyCode, uint32_t flags) { 393 Device* device = getDevice(deviceId); 394 KeyInfo info; 395 info.keyCode = keyCode; 396 info.flags = flags; 397 if (scanCode) { 398 device->keysByScanCode.add(scanCode, info); 399 } 400 if (usageCode) { 401 device->keysByUsageCode.add(usageCode, info); 402 } 403 } 404 405 void addLed(int32_t deviceId, int32_t led, bool initialState) { 406 Device* device = getDevice(deviceId); 407 device->leds.add(led, initialState); 408 } 409 410 bool getLedState(int32_t deviceId, int32_t led) { 411 Device* device = getDevice(deviceId); 412 return device->leds.valueFor(led); 413 } 414 415 Vector<String8>& getExcludedDevices() { 416 return mExcludedDevices; 417 } 418 419 void addVirtualKeyDefinition(int32_t deviceId, const VirtualKeyDefinition& definition) { 420 Device* device = getDevice(deviceId); 421 device->virtualKeys.push(definition); 422 } 423 424 void enqueueEvent(nsecs_t when, int32_t deviceId, int32_t type, 425 int32_t code, int32_t value) { 426 RawEvent event; 427 event.when = when; 428 event.deviceId = deviceId; 429 event.type = type; 430 event.code = code; 431 event.value = value; 432 mEvents.push_back(event); 433 434 if (type == EV_ABS) { 435 setAbsoluteAxisValue(deviceId, code, value); 436 } 437 } 438 439 void assertQueueIsEmpty() { 440 ASSERT_EQ(size_t(0), mEvents.size()) 441 << "Expected the event queue to be empty (fully consumed)."; 442 } 443 444 private: 445 Device* getDevice(int32_t deviceId) const { 446 ssize_t index = mDevices.indexOfKey(deviceId); 447 return index >= 0 ? mDevices.valueAt(index) : NULL; 448 } 449 450 virtual uint32_t getDeviceClasses(int32_t deviceId) const { 451 Device* device = getDevice(deviceId); 452 return device ? device->classes : 0; 453 } 454 455 virtual InputDeviceIdentifier getDeviceIdentifier(int32_t deviceId) const { 456 Device* device = getDevice(deviceId); 457 return device ? device->identifier : InputDeviceIdentifier(); 458 } 459 460 virtual void getConfiguration(int32_t deviceId, PropertyMap* outConfiguration) const { 461 Device* device = getDevice(deviceId); 462 if (device) { 463 *outConfiguration = device->configuration; 464 } 465 } 466 467 virtual status_t getAbsoluteAxisInfo(int32_t deviceId, int axis, 468 RawAbsoluteAxisInfo* outAxisInfo) const { 469 Device* device = getDevice(deviceId); 470 if (device) { 471 ssize_t index = device->absoluteAxes.indexOfKey(axis); 472 if (index >= 0) { 473 *outAxisInfo = device->absoluteAxes.valueAt(index); 474 return OK; 475 } 476 } 477 return -1; 478 } 479 480 virtual bool hasRelativeAxis(int32_t deviceId, int axis) const { 481 Device* device = getDevice(deviceId); 482 if (device) { 483 return device->relativeAxes.indexOfKey(axis) >= 0; 484 } 485 return false; 486 } 487 488 virtual bool hasInputProperty(int32_t deviceId, int property) const { 489 return false; 490 } 491 492 virtual status_t mapKey(int32_t deviceId, int32_t scanCode, int32_t usageCode, 493 int32_t* outKeycode, uint32_t* outFlags) const { 494 Device* device = getDevice(deviceId); 495 if (device) { 496 const KeyInfo* key = getKey(device, scanCode, usageCode); 497 if (key) { 498 if (outKeycode) { 499 *outKeycode = key->keyCode; 500 } 501 if (outFlags) { 502 *outFlags = key->flags; 503 } 504 return OK; 505 } 506 } 507 return NAME_NOT_FOUND; 508 } 509 510 const KeyInfo* getKey(Device* device, int32_t scanCode, int32_t usageCode) const { 511 if (usageCode) { 512 ssize_t index = device->keysByUsageCode.indexOfKey(usageCode); 513 if (index >= 0) { 514 return &device->keysByUsageCode.valueAt(index); 515 } 516 } 517 if (scanCode) { 518 ssize_t index = device->keysByScanCode.indexOfKey(scanCode); 519 if (index >= 0) { 520 return &device->keysByScanCode.valueAt(index); 521 } 522 } 523 return NULL; 524 } 525 526 virtual status_t mapAxis(int32_t deviceId, int32_t scanCode, 527 AxisInfo* outAxisInfo) const { 528 return NAME_NOT_FOUND; 529 } 530 531 virtual void setExcludedDevices(const Vector<String8>& devices) { 532 mExcludedDevices = devices; 533 } 534 535 virtual size_t getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize) { 536 if (mEvents.empty()) { 537 return 0; 538 } 539 540 *buffer = *mEvents.begin(); 541 mEvents.erase(mEvents.begin()); 542 return 1; 543 } 544 545 virtual int32_t getScanCodeState(int32_t deviceId, int32_t scanCode) const { 546 Device* device = getDevice(deviceId); 547 if (device) { 548 ssize_t index = device->scanCodeStates.indexOfKey(scanCode); 549 if (index >= 0) { 550 return device->scanCodeStates.valueAt(index); 551 } 552 } 553 return AKEY_STATE_UNKNOWN; 554 } 555 556 virtual int32_t getKeyCodeState(int32_t deviceId, int32_t keyCode) const { 557 Device* device = getDevice(deviceId); 558 if (device) { 559 ssize_t index = device->keyCodeStates.indexOfKey(keyCode); 560 if (index >= 0) { 561 return device->keyCodeStates.valueAt(index); 562 } 563 } 564 return AKEY_STATE_UNKNOWN; 565 } 566 567 virtual int32_t getSwitchState(int32_t deviceId, int32_t sw) const { 568 Device* device = getDevice(deviceId); 569 if (device) { 570 ssize_t index = device->switchStates.indexOfKey(sw); 571 if (index >= 0) { 572 return device->switchStates.valueAt(index); 573 } 574 } 575 return AKEY_STATE_UNKNOWN; 576 } 577 578 virtual status_t getAbsoluteAxisValue(int32_t deviceId, int32_t axis, 579 int32_t* outValue) const { 580 Device* device = getDevice(deviceId); 581 if (device) { 582 ssize_t index = device->absoluteAxisValue.indexOfKey(axis); 583 if (index >= 0) { 584 *outValue = device->absoluteAxisValue.valueAt(index); 585 return OK; 586 } 587 } 588 *outValue = 0; 589 return -1; 590 } 591 592 virtual bool markSupportedKeyCodes(int32_t deviceId, size_t numCodes, const int32_t* keyCodes, 593 uint8_t* outFlags) const { 594 bool result = false; 595 Device* device = getDevice(deviceId); 596 if (device) { 597 for (size_t i = 0; i < numCodes; i++) { 598 for (size_t j = 0; j < device->keysByScanCode.size(); j++) { 599 if (keyCodes[i] == device->keysByScanCode.valueAt(j).keyCode) { 600 outFlags[i] = 1; 601 result = true; 602 } 603 } 604 for (size_t j = 0; j < device->keysByUsageCode.size(); j++) { 605 if (keyCodes[i] == device->keysByUsageCode.valueAt(j).keyCode) { 606 outFlags[i] = 1; 607 result = true; 608 } 609 } 610 } 611 } 612 return result; 613 } 614 615 virtual bool hasScanCode(int32_t deviceId, int32_t scanCode) const { 616 Device* device = getDevice(deviceId); 617 if (device) { 618 ssize_t index = device->keysByScanCode.indexOfKey(scanCode); 619 return index >= 0; 620 } 621 return false; 622 } 623 624 virtual bool hasLed(int32_t deviceId, int32_t led) const { 625 Device* device = getDevice(deviceId); 626 return device && device->leds.indexOfKey(led) >= 0; 627 } 628 629 virtual void setLedState(int32_t deviceId, int32_t led, bool on) { 630 Device* device = getDevice(deviceId); 631 if (device) { 632 ssize_t index = device->leds.indexOfKey(led); 633 if (index >= 0) { 634 device->leds.replaceValueAt(led, on); 635 } else { 636 ADD_FAILURE() 637 << "Attempted to set the state of an LED that the EventHub declared " 638 "was not present. led=" << led; 639 } 640 } 641 } 642 643 virtual void getVirtualKeyDefinitions(int32_t deviceId, 644 Vector<VirtualKeyDefinition>& outVirtualKeys) const { 645 outVirtualKeys.clear(); 646 647 Device* device = getDevice(deviceId); 648 if (device) { 649 outVirtualKeys.appendVector(device->virtualKeys); 650 } 651 } 652 653 virtual sp<KeyCharacterMap> getKeyCharacterMap(int32_t deviceId) const { 654 return NULL; 655 } 656 657 virtual bool setKeyboardLayoutOverlay(int32_t deviceId, const sp<KeyCharacterMap>& map) { 658 return false; 659 } 660 661 virtual void vibrate(int32_t deviceId, nsecs_t duration) { 662 } 663 664 virtual void cancelVibrate(int32_t deviceId) { 665 } 666 667 virtual bool isExternal(int32_t deviceId) const { 668 return false; 669 } 670 671 virtual void dump(String8& dump) { 672 } 673 674 virtual void monitor() { 675 } 676 677 virtual void requestReopenDevices() { 678 } 679 680 virtual void wake() { 681 } 682 }; 683 684 685 // --- FakeInputReaderContext --- 686 687 class FakeInputReaderContext : public InputReaderContext { 688 sp<EventHubInterface> mEventHub; 689 sp<InputReaderPolicyInterface> mPolicy; 690 sp<InputListenerInterface> mListener; 691 int32_t mGlobalMetaState; 692 bool mUpdateGlobalMetaStateWasCalled; 693 int32_t mGeneration; 694 695 public: 696 FakeInputReaderContext(const sp<EventHubInterface>& eventHub, 697 const sp<InputReaderPolicyInterface>& policy, 698 const sp<InputListenerInterface>& listener) : 699 mEventHub(eventHub), mPolicy(policy), mListener(listener), 700 mGlobalMetaState(0) { 701 } 702 703 virtual ~FakeInputReaderContext() { } 704 705 void assertUpdateGlobalMetaStateWasCalled() { 706 ASSERT_TRUE(mUpdateGlobalMetaStateWasCalled) 707 << "Expected updateGlobalMetaState() to have been called."; 708 mUpdateGlobalMetaStateWasCalled = false; 709 } 710 711 void setGlobalMetaState(int32_t state) { 712 mGlobalMetaState = state; 713 } 714 715 private: 716 virtual void updateGlobalMetaState() { 717 mUpdateGlobalMetaStateWasCalled = true; 718 } 719 720 virtual int32_t getGlobalMetaState() { 721 return mGlobalMetaState; 722 } 723 724 virtual EventHubInterface* getEventHub() { 725 return mEventHub.get(); 726 } 727 728 virtual InputReaderPolicyInterface* getPolicy() { 729 return mPolicy.get(); 730 } 731 732 virtual InputListenerInterface* getListener() { 733 return mListener.get(); 734 } 735 736 virtual void disableVirtualKeysUntil(nsecs_t time) { 737 } 738 739 virtual bool shouldDropVirtualKey(nsecs_t now, 740 InputDevice* device, int32_t keyCode, int32_t scanCode) { 741 return false; 742 } 743 744 virtual void fadePointer() { 745 } 746 747 virtual void requestTimeoutAtTime(nsecs_t when) { 748 } 749 750 virtual int32_t bumpGeneration() { 751 return ++mGeneration; 752 } 753 }; 754 755 756 // --- FakeInputMapper --- 757 758 class FakeInputMapper : public InputMapper { 759 uint32_t mSources; 760 int32_t mKeyboardType; 761 int32_t mMetaState; 762 KeyedVector<int32_t, int32_t> mKeyCodeStates; 763 KeyedVector<int32_t, int32_t> mScanCodeStates; 764 KeyedVector<int32_t, int32_t> mSwitchStates; 765 Vector<int32_t> mSupportedKeyCodes; 766 RawEvent mLastEvent; 767 768 bool mConfigureWasCalled; 769 bool mResetWasCalled; 770 bool mProcessWasCalled; 771 772 public: 773 FakeInputMapper(InputDevice* device, uint32_t sources) : 774 InputMapper(device), 775 mSources(sources), mKeyboardType(AINPUT_KEYBOARD_TYPE_NONE), 776 mMetaState(0), 777 mConfigureWasCalled(false), mResetWasCalled(false), mProcessWasCalled(false) { 778 } 779 780 virtual ~FakeInputMapper() { } 781 782 void setKeyboardType(int32_t keyboardType) { 783 mKeyboardType = keyboardType; 784 } 785 786 void setMetaState(int32_t metaState) { 787 mMetaState = metaState; 788 } 789 790 void assertConfigureWasCalled() { 791 ASSERT_TRUE(mConfigureWasCalled) 792 << "Expected configure() to have been called."; 793 mConfigureWasCalled = false; 794 } 795 796 void assertResetWasCalled() { 797 ASSERT_TRUE(mResetWasCalled) 798 << "Expected reset() to have been called."; 799 mResetWasCalled = false; 800 } 801 802 void assertProcessWasCalled(RawEvent* outLastEvent = NULL) { 803 ASSERT_TRUE(mProcessWasCalled) 804 << "Expected process() to have been called."; 805 if (outLastEvent) { 806 *outLastEvent = mLastEvent; 807 } 808 mProcessWasCalled = false; 809 } 810 811 void setKeyCodeState(int32_t keyCode, int32_t state) { 812 mKeyCodeStates.replaceValueFor(keyCode, state); 813 } 814 815 void setScanCodeState(int32_t scanCode, int32_t state) { 816 mScanCodeStates.replaceValueFor(scanCode, state); 817 } 818 819 void setSwitchState(int32_t switchCode, int32_t state) { 820 mSwitchStates.replaceValueFor(switchCode, state); 821 } 822 823 void addSupportedKeyCode(int32_t keyCode) { 824 mSupportedKeyCodes.add(keyCode); 825 } 826 827 private: 828 virtual uint32_t getSources() { 829 return mSources; 830 } 831 832 virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo) { 833 InputMapper::populateDeviceInfo(deviceInfo); 834 835 if (mKeyboardType != AINPUT_KEYBOARD_TYPE_NONE) { 836 deviceInfo->setKeyboardType(mKeyboardType); 837 } 838 } 839 840 virtual void configure(nsecs_t when, 841 const InputReaderConfiguration* config, uint32_t changes) { 842 mConfigureWasCalled = true; 843 } 844 845 virtual void reset(nsecs_t when) { 846 mResetWasCalled = true; 847 } 848 849 virtual void process(const RawEvent* rawEvent) { 850 mLastEvent = *rawEvent; 851 mProcessWasCalled = true; 852 } 853 854 virtual int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode) { 855 ssize_t index = mKeyCodeStates.indexOfKey(keyCode); 856 return index >= 0 ? mKeyCodeStates.valueAt(index) : AKEY_STATE_UNKNOWN; 857 } 858 859 virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode) { 860 ssize_t index = mScanCodeStates.indexOfKey(scanCode); 861 return index >= 0 ? mScanCodeStates.valueAt(index) : AKEY_STATE_UNKNOWN; 862 } 863 864 virtual int32_t getSwitchState(uint32_t sourceMask, int32_t switchCode) { 865 ssize_t index = mSwitchStates.indexOfKey(switchCode); 866 return index >= 0 ? mSwitchStates.valueAt(index) : AKEY_STATE_UNKNOWN; 867 } 868 869 virtual bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes, 870 const int32_t* keyCodes, uint8_t* outFlags) { 871 bool result = false; 872 for (size_t i = 0; i < numCodes; i++) { 873 for (size_t j = 0; j < mSupportedKeyCodes.size(); j++) { 874 if (keyCodes[i] == mSupportedKeyCodes[j]) { 875 outFlags[i] = 1; 876 result = true; 877 } 878 } 879 } 880 return result; 881 } 882 883 virtual int32_t getMetaState() { 884 return mMetaState; 885 } 886 887 virtual void fadePointer() { 888 } 889 }; 890 891 892 // --- InstrumentedInputReader --- 893 894 class InstrumentedInputReader : public InputReader { 895 InputDevice* mNextDevice; 896 897 public: 898 InstrumentedInputReader(const sp<EventHubInterface>& eventHub, 899 const sp<InputReaderPolicyInterface>& policy, 900 const sp<InputListenerInterface>& listener) : 901 InputReader(eventHub, policy, listener), 902 mNextDevice(NULL) { 903 } 904 905 virtual ~InstrumentedInputReader() { 906 if (mNextDevice) { 907 delete mNextDevice; 908 } 909 } 910 911 void setNextDevice(InputDevice* device) { 912 mNextDevice = device; 913 } 914 915 InputDevice* newDevice(int32_t deviceId, const String8& name, uint32_t classes) { 916 InputDeviceIdentifier identifier; 917 identifier.name = name; 918 int32_t generation = deviceId + 1; 919 return new InputDevice(&mContext, deviceId, generation, identifier, classes); 920 } 921 922 protected: 923 virtual InputDevice* createDeviceLocked(int32_t deviceId, 924 const InputDeviceIdentifier& identifier, uint32_t classes) { 925 if (mNextDevice) { 926 InputDevice* device = mNextDevice; 927 mNextDevice = NULL; 928 return device; 929 } 930 return InputReader::createDeviceLocked(deviceId, identifier, classes); 931 } 932 933 friend class InputReaderTest; 934 }; 935 936 937 // --- InputReaderTest --- 938 939 class InputReaderTest : public testing::Test { 940 protected: 941 sp<FakeInputListener> mFakeListener; 942 sp<FakeInputReaderPolicy> mFakePolicy; 943 sp<FakeEventHub> mFakeEventHub; 944 sp<InstrumentedInputReader> mReader; 945 946 virtual void SetUp() { 947 mFakeEventHub = new FakeEventHub(); 948 mFakePolicy = new FakeInputReaderPolicy(); 949 mFakeListener = new FakeInputListener(); 950 951 mReader = new InstrumentedInputReader(mFakeEventHub, mFakePolicy, mFakeListener); 952 } 953 954 virtual void TearDown() { 955 mReader.clear(); 956 957 mFakeListener.clear(); 958 mFakePolicy.clear(); 959 mFakeEventHub.clear(); 960 } 961 962 void addDevice(int32_t deviceId, const String8& name, uint32_t classes, 963 const PropertyMap* configuration) { 964 mFakeEventHub->addDevice(deviceId, name, classes); 965 966 if (configuration) { 967 mFakeEventHub->addConfigurationMap(deviceId, configuration); 968 } 969 mFakeEventHub->finishDeviceScan(); 970 mReader->loopOnce(); 971 mReader->loopOnce(); 972 mFakeEventHub->assertQueueIsEmpty(); 973 } 974 975 FakeInputMapper* addDeviceWithFakeInputMapper(int32_t deviceId, 976 const String8& name, uint32_t classes, uint32_t sources, 977 const PropertyMap* configuration) { 978 InputDevice* device = mReader->newDevice(deviceId, name, classes); 979 FakeInputMapper* mapper = new FakeInputMapper(device, sources); 980 device->addMapper(mapper); 981 mReader->setNextDevice(device); 982 addDevice(deviceId, name, classes, configuration); 983 return mapper; 984 } 985 }; 986 987 TEST_F(InputReaderTest, GetInputDevices) { 988 ASSERT_NO_FATAL_FAILURE(addDevice(1, String8("keyboard"), 989 INPUT_DEVICE_CLASS_KEYBOARD, NULL)); 990 ASSERT_NO_FATAL_FAILURE(addDevice(2, String8("ignored"), 991 0, NULL)); // no classes so device will be ignored 992 993 Vector<InputDeviceInfo> inputDevices; 994 mReader->getInputDevices(inputDevices); 995 996 ASSERT_EQ(1U, inputDevices.size()); 997 ASSERT_EQ(1, inputDevices[0].getId()); 998 ASSERT_STREQ("keyboard", inputDevices[0].getIdentifier().name.string()); 999 ASSERT_EQ(AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC, inputDevices[0].getKeyboardType()); 1000 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, inputDevices[0].getSources()); 1001 ASSERT_EQ(size_t(0), inputDevices[0].getMotionRanges().size()); 1002 1003 // Should also have received a notification describing the new input devices. 1004 inputDevices = mFakePolicy->getInputDevices(); 1005 ASSERT_EQ(1U, inputDevices.size()); 1006 ASSERT_EQ(1, inputDevices[0].getId()); 1007 ASSERT_STREQ("keyboard", inputDevices[0].getIdentifier().name.string()); 1008 ASSERT_EQ(AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC, inputDevices[0].getKeyboardType()); 1009 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, inputDevices[0].getSources()); 1010 ASSERT_EQ(size_t(0), inputDevices[0].getMotionRanges().size()); 1011 } 1012 1013 TEST_F(InputReaderTest, GetKeyCodeState_ForwardsRequestsToMappers) { 1014 FakeInputMapper* mapper = NULL; 1015 ASSERT_NO_FATAL_FAILURE(mapper = addDeviceWithFakeInputMapper(1, String8("fake"), 1016 INPUT_DEVICE_CLASS_KEYBOARD, AINPUT_SOURCE_KEYBOARD, NULL)); 1017 mapper->setKeyCodeState(AKEYCODE_A, AKEY_STATE_DOWN); 1018 1019 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getKeyCodeState(0, 1020 AINPUT_SOURCE_ANY, AKEYCODE_A)) 1021 << "Should return unknown when the device id is >= 0 but unknown."; 1022 1023 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getKeyCodeState(1, 1024 AINPUT_SOURCE_TRACKBALL, AKEYCODE_A)) 1025 << "Should return unknown when the device id is valid but the sources are not supported by the device."; 1026 1027 ASSERT_EQ(AKEY_STATE_DOWN, mReader->getKeyCodeState(1, 1028 AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, AKEYCODE_A)) 1029 << "Should return value provided by mapper when device id is valid and the device supports some of the sources."; 1030 1031 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getKeyCodeState(-1, 1032 AINPUT_SOURCE_TRACKBALL, AKEYCODE_A)) 1033 << "Should return unknown when the device id is < 0 but the sources are not supported by any device."; 1034 1035 ASSERT_EQ(AKEY_STATE_DOWN, mReader->getKeyCodeState(-1, 1036 AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, AKEYCODE_A)) 1037 << "Should return value provided by mapper when device id is < 0 and one of the devices supports some of the sources."; 1038 } 1039 1040 TEST_F(InputReaderTest, GetScanCodeState_ForwardsRequestsToMappers) { 1041 FakeInputMapper* mapper = NULL; 1042 ASSERT_NO_FATAL_FAILURE(mapper = addDeviceWithFakeInputMapper(1, String8("fake"), 1043 INPUT_DEVICE_CLASS_KEYBOARD, AINPUT_SOURCE_KEYBOARD, NULL)); 1044 mapper->setScanCodeState(KEY_A, AKEY_STATE_DOWN); 1045 1046 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getScanCodeState(0, 1047 AINPUT_SOURCE_ANY, KEY_A)) 1048 << "Should return unknown when the device id is >= 0 but unknown."; 1049 1050 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getScanCodeState(1, 1051 AINPUT_SOURCE_TRACKBALL, KEY_A)) 1052 << "Should return unknown when the device id is valid but the sources are not supported by the device."; 1053 1054 ASSERT_EQ(AKEY_STATE_DOWN, mReader->getScanCodeState(1, 1055 AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, KEY_A)) 1056 << "Should return value provided by mapper when device id is valid and the device supports some of the sources."; 1057 1058 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getScanCodeState(-1, 1059 AINPUT_SOURCE_TRACKBALL, KEY_A)) 1060 << "Should return unknown when the device id is < 0 but the sources are not supported by any device."; 1061 1062 ASSERT_EQ(AKEY_STATE_DOWN, mReader->getScanCodeState(-1, 1063 AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, KEY_A)) 1064 << "Should return value provided by mapper when device id is < 0 and one of the devices supports some of the sources."; 1065 } 1066 1067 TEST_F(InputReaderTest, GetSwitchState_ForwardsRequestsToMappers) { 1068 FakeInputMapper* mapper = NULL; 1069 ASSERT_NO_FATAL_FAILURE(mapper = addDeviceWithFakeInputMapper(1, String8("fake"), 1070 INPUT_DEVICE_CLASS_KEYBOARD, AINPUT_SOURCE_KEYBOARD, NULL)); 1071 mapper->setSwitchState(SW_LID, AKEY_STATE_DOWN); 1072 1073 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getSwitchState(0, 1074 AINPUT_SOURCE_ANY, SW_LID)) 1075 << "Should return unknown when the device id is >= 0 but unknown."; 1076 1077 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getSwitchState(1, 1078 AINPUT_SOURCE_TRACKBALL, SW_LID)) 1079 << "Should return unknown when the device id is valid but the sources are not supported by the device."; 1080 1081 ASSERT_EQ(AKEY_STATE_DOWN, mReader->getSwitchState(1, 1082 AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, SW_LID)) 1083 << "Should return value provided by mapper when device id is valid and the device supports some of the sources."; 1084 1085 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getSwitchState(-1, 1086 AINPUT_SOURCE_TRACKBALL, SW_LID)) 1087 << "Should return unknown when the device id is < 0 but the sources are not supported by any device."; 1088 1089 ASSERT_EQ(AKEY_STATE_DOWN, mReader->getSwitchState(-1, 1090 AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, SW_LID)) 1091 << "Should return value provided by mapper when device id is < 0 and one of the devices supports some of the sources."; 1092 } 1093 1094 TEST_F(InputReaderTest, MarkSupportedKeyCodes_ForwardsRequestsToMappers) { 1095 FakeInputMapper* mapper = NULL; 1096 ASSERT_NO_FATAL_FAILURE(mapper = addDeviceWithFakeInputMapper(1, String8("fake"), 1097 INPUT_DEVICE_CLASS_KEYBOARD, AINPUT_SOURCE_KEYBOARD, NULL)); 1098 mapper->addSupportedKeyCode(AKEYCODE_A); 1099 mapper->addSupportedKeyCode(AKEYCODE_B); 1100 1101 const int32_t keyCodes[4] = { AKEYCODE_A, AKEYCODE_B, AKEYCODE_1, AKEYCODE_2 }; 1102 uint8_t flags[4] = { 0, 0, 0, 1 }; 1103 1104 ASSERT_FALSE(mReader->hasKeys(0, AINPUT_SOURCE_ANY, 4, keyCodes, flags)) 1105 << "Should return false when device id is >= 0 but unknown."; 1106 ASSERT_TRUE(!flags[0] && !flags[1] && !flags[2] && !flags[3]); 1107 1108 flags[3] = 1; 1109 ASSERT_FALSE(mReader->hasKeys(1, AINPUT_SOURCE_TRACKBALL, 4, keyCodes, flags)) 1110 << "Should return false when device id is valid but the sources are not supported by the device."; 1111 ASSERT_TRUE(!flags[0] && !flags[1] && !flags[2] && !flags[3]); 1112 1113 flags[3] = 1; 1114 ASSERT_TRUE(mReader->hasKeys(1, AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, 4, keyCodes, flags)) 1115 << "Should return value provided by mapper when device id is valid and the device supports some of the sources."; 1116 ASSERT_TRUE(flags[0] && flags[1] && !flags[2] && !flags[3]); 1117 1118 flags[3] = 1; 1119 ASSERT_FALSE(mReader->hasKeys(-1, AINPUT_SOURCE_TRACKBALL, 4, keyCodes, flags)) 1120 << "Should return false when the device id is < 0 but the sources are not supported by any device."; 1121 ASSERT_TRUE(!flags[0] && !flags[1] && !flags[2] && !flags[3]); 1122 1123 flags[3] = 1; 1124 ASSERT_TRUE(mReader->hasKeys(-1, AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, 4, keyCodes, flags)) 1125 << "Should return value provided by mapper when device id is < 0 and one of the devices supports some of the sources."; 1126 ASSERT_TRUE(flags[0] && flags[1] && !flags[2] && !flags[3]); 1127 } 1128 1129 TEST_F(InputReaderTest, LoopOnce_WhenDeviceScanFinished_SendsConfigurationChanged) { 1130 addDevice(1, String8("ignored"), INPUT_DEVICE_CLASS_KEYBOARD, NULL); 1131 1132 NotifyConfigurationChangedArgs args; 1133 1134 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyConfigurationChangedWasCalled(&args)); 1135 ASSERT_EQ(ARBITRARY_TIME, args.eventTime); 1136 } 1137 1138 TEST_F(InputReaderTest, LoopOnce_ForwardsRawEventsToMappers) { 1139 FakeInputMapper* mapper = NULL; 1140 ASSERT_NO_FATAL_FAILURE(mapper = addDeviceWithFakeInputMapper(1, String8("fake"), 1141 INPUT_DEVICE_CLASS_KEYBOARD, AINPUT_SOURCE_KEYBOARD, NULL)); 1142 1143 mFakeEventHub->enqueueEvent(0, 1, EV_KEY, KEY_A, 1); 1144 mReader->loopOnce(); 1145 ASSERT_NO_FATAL_FAILURE(mFakeEventHub->assertQueueIsEmpty()); 1146 1147 RawEvent event; 1148 ASSERT_NO_FATAL_FAILURE(mapper->assertProcessWasCalled(&event)); 1149 ASSERT_EQ(0, event.when); 1150 ASSERT_EQ(1, event.deviceId); 1151 ASSERT_EQ(EV_KEY, event.type); 1152 ASSERT_EQ(KEY_A, event.code); 1153 ASSERT_EQ(1, event.value); 1154 } 1155 1156 1157 // --- InputDeviceTest --- 1158 1159 class InputDeviceTest : public testing::Test { 1160 protected: 1161 static const char* DEVICE_NAME; 1162 static const int32_t DEVICE_ID; 1163 static const int32_t DEVICE_GENERATION; 1164 static const uint32_t DEVICE_CLASSES; 1165 1166 sp<FakeEventHub> mFakeEventHub; 1167 sp<FakeInputReaderPolicy> mFakePolicy; 1168 sp<FakeInputListener> mFakeListener; 1169 FakeInputReaderContext* mFakeContext; 1170 1171 InputDevice* mDevice; 1172 1173 virtual void SetUp() { 1174 mFakeEventHub = new FakeEventHub(); 1175 mFakePolicy = new FakeInputReaderPolicy(); 1176 mFakeListener = new FakeInputListener(); 1177 mFakeContext = new FakeInputReaderContext(mFakeEventHub, mFakePolicy, mFakeListener); 1178 1179 mFakeEventHub->addDevice(DEVICE_ID, String8(DEVICE_NAME), 0); 1180 InputDeviceIdentifier identifier; 1181 identifier.name = DEVICE_NAME; 1182 mDevice = new InputDevice(mFakeContext, DEVICE_ID, DEVICE_GENERATION, 1183 identifier, DEVICE_CLASSES); 1184 } 1185 1186 virtual void TearDown() { 1187 delete mDevice; 1188 1189 delete mFakeContext; 1190 mFakeListener.clear(); 1191 mFakePolicy.clear(); 1192 mFakeEventHub.clear(); 1193 } 1194 }; 1195 1196 const char* InputDeviceTest::DEVICE_NAME = "device"; 1197 const int32_t InputDeviceTest::DEVICE_ID = 1; 1198 const int32_t InputDeviceTest::DEVICE_GENERATION = 2; 1199 const uint32_t InputDeviceTest::DEVICE_CLASSES = INPUT_DEVICE_CLASS_KEYBOARD 1200 | INPUT_DEVICE_CLASS_TOUCH | INPUT_DEVICE_CLASS_JOYSTICK; 1201 1202 TEST_F(InputDeviceTest, ImmutableProperties) { 1203 ASSERT_EQ(DEVICE_ID, mDevice->getId()); 1204 ASSERT_STREQ(DEVICE_NAME, mDevice->getName()); 1205 ASSERT_EQ(DEVICE_CLASSES, mDevice->getClasses()); 1206 } 1207 1208 TEST_F(InputDeviceTest, WhenNoMappersAreRegistered_DeviceIsIgnored) { 1209 // Configuration. 1210 InputReaderConfiguration config; 1211 mDevice->configure(ARBITRARY_TIME, &config, 0); 1212 1213 // Reset. 1214 mDevice->reset(ARBITRARY_TIME); 1215 1216 NotifyDeviceResetArgs resetArgs; 1217 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled(&resetArgs)); 1218 ASSERT_EQ(ARBITRARY_TIME, resetArgs.eventTime); 1219 ASSERT_EQ(DEVICE_ID, resetArgs.deviceId); 1220 1221 // Metadata. 1222 ASSERT_TRUE(mDevice->isIgnored()); 1223 ASSERT_EQ(AINPUT_SOURCE_UNKNOWN, mDevice->getSources()); 1224 1225 InputDeviceInfo info; 1226 mDevice->getDeviceInfo(&info); 1227 ASSERT_EQ(DEVICE_ID, info.getId()); 1228 ASSERT_STREQ(DEVICE_NAME, info.getIdentifier().name.string()); 1229 ASSERT_EQ(AINPUT_KEYBOARD_TYPE_NONE, info.getKeyboardType()); 1230 ASSERT_EQ(AINPUT_SOURCE_UNKNOWN, info.getSources()); 1231 1232 // State queries. 1233 ASSERT_EQ(0, mDevice->getMetaState()); 1234 1235 ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getKeyCodeState(AINPUT_SOURCE_KEYBOARD, 0)) 1236 << "Ignored device should return unknown key code state."; 1237 ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getScanCodeState(AINPUT_SOURCE_KEYBOARD, 0)) 1238 << "Ignored device should return unknown scan code state."; 1239 ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getSwitchState(AINPUT_SOURCE_KEYBOARD, 0)) 1240 << "Ignored device should return unknown switch state."; 1241 1242 const int32_t keyCodes[2] = { AKEYCODE_A, AKEYCODE_B }; 1243 uint8_t flags[2] = { 0, 1 }; 1244 ASSERT_FALSE(mDevice->markSupportedKeyCodes(AINPUT_SOURCE_KEYBOARD, 2, keyCodes, flags)) 1245 << "Ignored device should never mark any key codes."; 1246 ASSERT_EQ(0, flags[0]) << "Flag for unsupported key should be unchanged."; 1247 ASSERT_EQ(1, flags[1]) << "Flag for unsupported key should be unchanged."; 1248 } 1249 1250 TEST_F(InputDeviceTest, WhenMappersAreRegistered_DeviceIsNotIgnoredAndForwardsRequestsToMappers) { 1251 // Configuration. 1252 mFakeEventHub->addConfigurationProperty(DEVICE_ID, String8("key"), String8("value")); 1253 1254 FakeInputMapper* mapper1 = new FakeInputMapper(mDevice, AINPUT_SOURCE_KEYBOARD); 1255 mapper1->setKeyboardType(AINPUT_KEYBOARD_TYPE_ALPHABETIC); 1256 mapper1->setMetaState(AMETA_ALT_ON); 1257 mapper1->addSupportedKeyCode(AKEYCODE_A); 1258 mapper1->addSupportedKeyCode(AKEYCODE_B); 1259 mapper1->setKeyCodeState(AKEYCODE_A, AKEY_STATE_DOWN); 1260 mapper1->setKeyCodeState(AKEYCODE_B, AKEY_STATE_UP); 1261 mapper1->setScanCodeState(2, AKEY_STATE_DOWN); 1262 mapper1->setScanCodeState(3, AKEY_STATE_UP); 1263 mapper1->setSwitchState(4, AKEY_STATE_DOWN); 1264 mDevice->addMapper(mapper1); 1265 1266 FakeInputMapper* mapper2 = new FakeInputMapper(mDevice, AINPUT_SOURCE_TOUCHSCREEN); 1267 mapper2->setMetaState(AMETA_SHIFT_ON); 1268 mDevice->addMapper(mapper2); 1269 1270 InputReaderConfiguration config; 1271 mDevice->configure(ARBITRARY_TIME, &config, 0); 1272 1273 String8 propertyValue; 1274 ASSERT_TRUE(mDevice->getConfiguration().tryGetProperty(String8("key"), propertyValue)) 1275 << "Device should have read configuration during configuration phase."; 1276 ASSERT_STREQ("value", propertyValue.string()); 1277 1278 ASSERT_NO_FATAL_FAILURE(mapper1->assertConfigureWasCalled()); 1279 ASSERT_NO_FATAL_FAILURE(mapper2->assertConfigureWasCalled()); 1280 1281 // Reset 1282 mDevice->reset(ARBITRARY_TIME); 1283 ASSERT_NO_FATAL_FAILURE(mapper1->assertResetWasCalled()); 1284 ASSERT_NO_FATAL_FAILURE(mapper2->assertResetWasCalled()); 1285 1286 NotifyDeviceResetArgs resetArgs; 1287 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled(&resetArgs)); 1288 ASSERT_EQ(ARBITRARY_TIME, resetArgs.eventTime); 1289 ASSERT_EQ(DEVICE_ID, resetArgs.deviceId); 1290 1291 // Metadata. 1292 ASSERT_FALSE(mDevice->isIgnored()); 1293 ASSERT_EQ(uint32_t(AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TOUCHSCREEN), mDevice->getSources()); 1294 1295 InputDeviceInfo info; 1296 mDevice->getDeviceInfo(&info); 1297 ASSERT_EQ(DEVICE_ID, info.getId()); 1298 ASSERT_STREQ(DEVICE_NAME, info.getIdentifier().name.string()); 1299 ASSERT_EQ(AINPUT_KEYBOARD_TYPE_ALPHABETIC, info.getKeyboardType()); 1300 ASSERT_EQ(uint32_t(AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TOUCHSCREEN), info.getSources()); 1301 1302 // State queries. 1303 ASSERT_EQ(AMETA_ALT_ON | AMETA_SHIFT_ON, mDevice->getMetaState()) 1304 << "Should query mappers and combine meta states."; 1305 1306 ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getKeyCodeState(AINPUT_SOURCE_TRACKBALL, AKEYCODE_A)) 1307 << "Should return unknown key code state when source not supported."; 1308 ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getScanCodeState(AINPUT_SOURCE_TRACKBALL, AKEYCODE_A)) 1309 << "Should return unknown scan code state when source not supported."; 1310 ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getSwitchState(AINPUT_SOURCE_TRACKBALL, AKEYCODE_A)) 1311 << "Should return unknown switch state when source not supported."; 1312 1313 ASSERT_EQ(AKEY_STATE_DOWN, mDevice->getKeyCodeState(AINPUT_SOURCE_KEYBOARD, AKEYCODE_A)) 1314 << "Should query mapper when source is supported."; 1315 ASSERT_EQ(AKEY_STATE_UP, mDevice->getScanCodeState(AINPUT_SOURCE_KEYBOARD, 3)) 1316 << "Should query mapper when source is supported."; 1317 ASSERT_EQ(AKEY_STATE_DOWN, mDevice->getSwitchState(AINPUT_SOURCE_KEYBOARD, 4)) 1318 << "Should query mapper when source is supported."; 1319 1320 const int32_t keyCodes[4] = { AKEYCODE_A, AKEYCODE_B, AKEYCODE_1, AKEYCODE_2 }; 1321 uint8_t flags[4] = { 0, 0, 0, 1 }; 1322 ASSERT_FALSE(mDevice->markSupportedKeyCodes(AINPUT_SOURCE_TRACKBALL, 4, keyCodes, flags)) 1323 << "Should do nothing when source is unsupported."; 1324 ASSERT_EQ(0, flags[0]) << "Flag should be unchanged when source is unsupported."; 1325 ASSERT_EQ(0, flags[1]) << "Flag should be unchanged when source is unsupported."; 1326 ASSERT_EQ(0, flags[2]) << "Flag should be unchanged when source is unsupported."; 1327 ASSERT_EQ(1, flags[3]) << "Flag should be unchanged when source is unsupported."; 1328 1329 ASSERT_TRUE(mDevice->markSupportedKeyCodes(AINPUT_SOURCE_KEYBOARD, 4, keyCodes, flags)) 1330 << "Should query mapper when source is supported."; 1331 ASSERT_EQ(1, flags[0]) << "Flag for supported key should be set."; 1332 ASSERT_EQ(1, flags[1]) << "Flag for supported key should be set."; 1333 ASSERT_EQ(0, flags[2]) << "Flag for unsupported key should be unchanged."; 1334 ASSERT_EQ(1, flags[3]) << "Flag for unsupported key should be unchanged."; 1335 1336 // Event handling. 1337 RawEvent event; 1338 mDevice->process(&event, 1); 1339 1340 ASSERT_NO_FATAL_FAILURE(mapper1->assertProcessWasCalled()); 1341 ASSERT_NO_FATAL_FAILURE(mapper2->assertProcessWasCalled()); 1342 } 1343 1344 1345 // --- InputMapperTest --- 1346 1347 class InputMapperTest : public testing::Test { 1348 protected: 1349 static const char* DEVICE_NAME; 1350 static const int32_t DEVICE_ID; 1351 static const int32_t DEVICE_GENERATION; 1352 static const uint32_t DEVICE_CLASSES; 1353 1354 sp<FakeEventHub> mFakeEventHub; 1355 sp<FakeInputReaderPolicy> mFakePolicy; 1356 sp<FakeInputListener> mFakeListener; 1357 FakeInputReaderContext* mFakeContext; 1358 InputDevice* mDevice; 1359 1360 virtual void SetUp() { 1361 mFakeEventHub = new FakeEventHub(); 1362 mFakePolicy = new FakeInputReaderPolicy(); 1363 mFakeListener = new FakeInputListener(); 1364 mFakeContext = new FakeInputReaderContext(mFakeEventHub, mFakePolicy, mFakeListener); 1365 InputDeviceIdentifier identifier; 1366 identifier.name = DEVICE_NAME; 1367 mDevice = new InputDevice(mFakeContext, DEVICE_ID, DEVICE_GENERATION, 1368 identifier, DEVICE_CLASSES); 1369 1370 mFakeEventHub->addDevice(DEVICE_ID, String8(DEVICE_NAME), 0); 1371 } 1372 1373 virtual void TearDown() { 1374 delete mDevice; 1375 delete mFakeContext; 1376 mFakeListener.clear(); 1377 mFakePolicy.clear(); 1378 mFakeEventHub.clear(); 1379 } 1380 1381 void addConfigurationProperty(const char* key, const char* value) { 1382 mFakeEventHub->addConfigurationProperty(DEVICE_ID, String8(key), String8(value)); 1383 } 1384 1385 void addMapperAndConfigure(InputMapper* mapper) { 1386 mDevice->addMapper(mapper); 1387 mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), 0); 1388 mDevice->reset(ARBITRARY_TIME); 1389 } 1390 1391 void setDisplayInfoAndReconfigure(int32_t displayId, int32_t width, int32_t height, 1392 int32_t orientation) { 1393 mFakePolicy->setDisplayInfo(displayId, width, height, orientation); 1394 mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), 1395 InputReaderConfiguration::CHANGE_DISPLAY_INFO); 1396 } 1397 1398 static void process(InputMapper* mapper, nsecs_t when, int32_t deviceId, int32_t type, 1399 int32_t code, int32_t value) { 1400 RawEvent event; 1401 event.when = when; 1402 event.deviceId = deviceId; 1403 event.type = type; 1404 event.code = code; 1405 event.value = value; 1406 mapper->process(&event); 1407 } 1408 1409 static void assertMotionRange(const InputDeviceInfo& info, 1410 int32_t axis, uint32_t source, float min, float max, float flat, float fuzz) { 1411 const InputDeviceInfo::MotionRange* range = info.getMotionRange(axis, source); 1412 ASSERT_TRUE(range != NULL) << "Axis: " << axis << " Source: " << source; 1413 ASSERT_EQ(axis, range->axis) << "Axis: " << axis << " Source: " << source; 1414 ASSERT_EQ(source, range->source) << "Axis: " << axis << " Source: " << source; 1415 ASSERT_NEAR(min, range->min, EPSILON) << "Axis: " << axis << " Source: " << source; 1416 ASSERT_NEAR(max, range->max, EPSILON) << "Axis: " << axis << " Source: " << source; 1417 ASSERT_NEAR(flat, range->flat, EPSILON) << "Axis: " << axis << " Source: " << source; 1418 ASSERT_NEAR(fuzz, range->fuzz, EPSILON) << "Axis: " << axis << " Source: " << source; 1419 } 1420 1421 static void assertPointerCoords(const PointerCoords& coords, 1422 float x, float y, float pressure, float size, 1423 float touchMajor, float touchMinor, float toolMajor, float toolMinor, 1424 float orientation, float distance) { 1425 ASSERT_NEAR(x, coords.getAxisValue(AMOTION_EVENT_AXIS_X), 1); 1426 ASSERT_NEAR(y, coords.getAxisValue(AMOTION_EVENT_AXIS_Y), 1); 1427 ASSERT_NEAR(pressure, coords.getAxisValue(AMOTION_EVENT_AXIS_PRESSURE), EPSILON); 1428 ASSERT_NEAR(size, coords.getAxisValue(AMOTION_EVENT_AXIS_SIZE), EPSILON); 1429 ASSERT_NEAR(touchMajor, coords.getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR), 1); 1430 ASSERT_NEAR(touchMinor, coords.getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR), 1); 1431 ASSERT_NEAR(toolMajor, coords.getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR), 1); 1432 ASSERT_NEAR(toolMinor, coords.getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR), 1); 1433 ASSERT_NEAR(orientation, coords.getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION), EPSILON); 1434 ASSERT_NEAR(distance, coords.getAxisValue(AMOTION_EVENT_AXIS_DISTANCE), EPSILON); 1435 } 1436 1437 static void assertPosition(const sp<FakePointerController>& controller, float x, float y) { 1438 float actualX, actualY; 1439 controller->getPosition(&actualX, &actualY); 1440 ASSERT_NEAR(x, actualX, 1); 1441 ASSERT_NEAR(y, actualY, 1); 1442 } 1443 }; 1444 1445 const char* InputMapperTest::DEVICE_NAME = "device"; 1446 const int32_t InputMapperTest::DEVICE_ID = 1; 1447 const int32_t InputMapperTest::DEVICE_GENERATION = 2; 1448 const uint32_t InputMapperTest::DEVICE_CLASSES = 0; // not needed for current tests 1449 1450 1451 // --- SwitchInputMapperTest --- 1452 1453 class SwitchInputMapperTest : public InputMapperTest { 1454 protected: 1455 }; 1456 1457 TEST_F(SwitchInputMapperTest, GetSources) { 1458 SwitchInputMapper* mapper = new SwitchInputMapper(mDevice); 1459 addMapperAndConfigure(mapper); 1460 1461 ASSERT_EQ(uint32_t(AINPUT_SOURCE_SWITCH), mapper->getSources()); 1462 } 1463 1464 TEST_F(SwitchInputMapperTest, GetSwitchState) { 1465 SwitchInputMapper* mapper = new SwitchInputMapper(mDevice); 1466 addMapperAndConfigure(mapper); 1467 1468 mFakeEventHub->setSwitchState(DEVICE_ID, SW_LID, 1); 1469 ASSERT_EQ(1, mapper->getSwitchState(AINPUT_SOURCE_ANY, SW_LID)); 1470 1471 mFakeEventHub->setSwitchState(DEVICE_ID, SW_LID, 0); 1472 ASSERT_EQ(0, mapper->getSwitchState(AINPUT_SOURCE_ANY, SW_LID)); 1473 } 1474 1475 TEST_F(SwitchInputMapperTest, Process) { 1476 SwitchInputMapper* mapper = new SwitchInputMapper(mDevice); 1477 addMapperAndConfigure(mapper); 1478 1479 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SW, SW_LID, 1); 1480 1481 NotifySwitchArgs args; 1482 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifySwitchWasCalled(&args)); 1483 ASSERT_EQ(ARBITRARY_TIME, args.eventTime); 1484 ASSERT_EQ(SW_LID, args.switchCode); 1485 ASSERT_EQ(1, args.switchValue); 1486 ASSERT_EQ(uint32_t(0), args.policyFlags); 1487 } 1488 1489 1490 // --- KeyboardInputMapperTest --- 1491 1492 class KeyboardInputMapperTest : public InputMapperTest { 1493 protected: 1494 void testDPadKeyRotation(KeyboardInputMapper* mapper, 1495 int32_t originalScanCode, int32_t originalKeyCode, int32_t rotatedKeyCode); 1496 }; 1497 1498 void KeyboardInputMapperTest::testDPadKeyRotation(KeyboardInputMapper* mapper, 1499 int32_t originalScanCode, int32_t originalKeyCode, int32_t rotatedKeyCode) { 1500 NotifyKeyArgs args; 1501 1502 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, originalScanCode, 1); 1503 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args)); 1504 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, args.action); 1505 ASSERT_EQ(originalScanCode, args.scanCode); 1506 ASSERT_EQ(rotatedKeyCode, args.keyCode); 1507 1508 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, originalScanCode, 0); 1509 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args)); 1510 ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action); 1511 ASSERT_EQ(originalScanCode, args.scanCode); 1512 ASSERT_EQ(rotatedKeyCode, args.keyCode); 1513 } 1514 1515 1516 TEST_F(KeyboardInputMapperTest, GetSources) { 1517 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, 1518 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC); 1519 addMapperAndConfigure(mapper); 1520 1521 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, mapper->getSources()); 1522 } 1523 1524 TEST_F(KeyboardInputMapperTest, Process_SimpleKeyPress) { 1525 const int32_t USAGE_A = 0x070004; 1526 const int32_t USAGE_UNKNOWN = 0x07ffff; 1527 mFakeEventHub->addKey(DEVICE_ID, KEY_HOME, 0, AKEYCODE_HOME, POLICY_FLAG_WAKE); 1528 mFakeEventHub->addKey(DEVICE_ID, 0, USAGE_A, AKEYCODE_A, POLICY_FLAG_WAKE); 1529 1530 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, 1531 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC); 1532 addMapperAndConfigure(mapper); 1533 1534 // Key down by scan code. 1535 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1536 EV_KEY, KEY_HOME, 1); 1537 NotifyKeyArgs args; 1538 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args)); 1539 ASSERT_EQ(DEVICE_ID, args.deviceId); 1540 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source); 1541 ASSERT_EQ(ARBITRARY_TIME, args.eventTime); 1542 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, args.action); 1543 ASSERT_EQ(AKEYCODE_HOME, args.keyCode); 1544 ASSERT_EQ(KEY_HOME, args.scanCode); 1545 ASSERT_EQ(AMETA_NONE, args.metaState); 1546 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, args.flags); 1547 ASSERT_EQ(POLICY_FLAG_WAKE, args.policyFlags); 1548 ASSERT_EQ(ARBITRARY_TIME, args.downTime); 1549 1550 // Key up by scan code. 1551 process(mapper, ARBITRARY_TIME + 1, DEVICE_ID, 1552 EV_KEY, KEY_HOME, 0); 1553 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args)); 1554 ASSERT_EQ(DEVICE_ID, args.deviceId); 1555 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source); 1556 ASSERT_EQ(ARBITRARY_TIME + 1, args.eventTime); 1557 ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action); 1558 ASSERT_EQ(AKEYCODE_HOME, args.keyCode); 1559 ASSERT_EQ(KEY_HOME, args.scanCode); 1560 ASSERT_EQ(AMETA_NONE, args.metaState); 1561 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, args.flags); 1562 ASSERT_EQ(POLICY_FLAG_WAKE, args.policyFlags); 1563 ASSERT_EQ(ARBITRARY_TIME, args.downTime); 1564 1565 // Key down by usage code. 1566 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1567 EV_MSC, MSC_SCAN, USAGE_A); 1568 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1569 EV_KEY, 0, 1); 1570 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args)); 1571 ASSERT_EQ(DEVICE_ID, args.deviceId); 1572 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source); 1573 ASSERT_EQ(ARBITRARY_TIME, args.eventTime); 1574 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, args.action); 1575 ASSERT_EQ(AKEYCODE_A, args.keyCode); 1576 ASSERT_EQ(0, args.scanCode); 1577 ASSERT_EQ(AMETA_NONE, args.metaState); 1578 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, args.flags); 1579 ASSERT_EQ(POLICY_FLAG_WAKE, args.policyFlags); 1580 ASSERT_EQ(ARBITRARY_TIME, args.downTime); 1581 1582 // Key up by usage code. 1583 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1584 EV_MSC, MSC_SCAN, USAGE_A); 1585 process(mapper, ARBITRARY_TIME + 1, DEVICE_ID, 1586 EV_KEY, 0, 0); 1587 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args)); 1588 ASSERT_EQ(DEVICE_ID, args.deviceId); 1589 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source); 1590 ASSERT_EQ(ARBITRARY_TIME + 1, args.eventTime); 1591 ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action); 1592 ASSERT_EQ(AKEYCODE_A, args.keyCode); 1593 ASSERT_EQ(0, args.scanCode); 1594 ASSERT_EQ(AMETA_NONE, args.metaState); 1595 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, args.flags); 1596 ASSERT_EQ(POLICY_FLAG_WAKE, args.policyFlags); 1597 ASSERT_EQ(ARBITRARY_TIME, args.downTime); 1598 1599 // Key down with unknown scan code or usage code. 1600 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1601 EV_MSC, MSC_SCAN, USAGE_UNKNOWN); 1602 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1603 EV_KEY, KEY_UNKNOWN, 1); 1604 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args)); 1605 ASSERT_EQ(DEVICE_ID, args.deviceId); 1606 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source); 1607 ASSERT_EQ(ARBITRARY_TIME, args.eventTime); 1608 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, args.action); 1609 ASSERT_EQ(0, args.keyCode); 1610 ASSERT_EQ(KEY_UNKNOWN, args.scanCode); 1611 ASSERT_EQ(AMETA_NONE, args.metaState); 1612 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, args.flags); 1613 ASSERT_EQ(0U, args.policyFlags); 1614 ASSERT_EQ(ARBITRARY_TIME, args.downTime); 1615 1616 // Key up with unknown scan code or usage code. 1617 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1618 EV_MSC, MSC_SCAN, USAGE_UNKNOWN); 1619 process(mapper, ARBITRARY_TIME + 1, DEVICE_ID, 1620 EV_KEY, KEY_UNKNOWN, 0); 1621 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args)); 1622 ASSERT_EQ(DEVICE_ID, args.deviceId); 1623 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source); 1624 ASSERT_EQ(ARBITRARY_TIME + 1, args.eventTime); 1625 ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action); 1626 ASSERT_EQ(0, args.keyCode); 1627 ASSERT_EQ(KEY_UNKNOWN, args.scanCode); 1628 ASSERT_EQ(AMETA_NONE, args.metaState); 1629 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, args.flags); 1630 ASSERT_EQ(0U, args.policyFlags); 1631 ASSERT_EQ(ARBITRARY_TIME, args.downTime); 1632 } 1633 1634 TEST_F(KeyboardInputMapperTest, Process_ShouldUpdateMetaState) { 1635 mFakeEventHub->addKey(DEVICE_ID, KEY_LEFTSHIFT, 0, AKEYCODE_SHIFT_LEFT, 0); 1636 mFakeEventHub->addKey(DEVICE_ID, KEY_A, 0, AKEYCODE_A, 0); 1637 1638 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, 1639 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC); 1640 addMapperAndConfigure(mapper); 1641 1642 // Initial metastate. 1643 ASSERT_EQ(AMETA_NONE, mapper->getMetaState()); 1644 1645 // Metakey down. 1646 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1647 EV_KEY, KEY_LEFTSHIFT, 1); 1648 NotifyKeyArgs args; 1649 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args)); 1650 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState); 1651 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, mapper->getMetaState()); 1652 ASSERT_NO_FATAL_FAILURE(mFakeContext->assertUpdateGlobalMetaStateWasCalled()); 1653 1654 // Key down. 1655 process(mapper, ARBITRARY_TIME + 1, DEVICE_ID, 1656 EV_KEY, KEY_A, 1); 1657 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args)); 1658 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState); 1659 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, mapper->getMetaState()); 1660 1661 // Key up. 1662 process(mapper, ARBITRARY_TIME + 2, DEVICE_ID, 1663 EV_KEY, KEY_A, 0); 1664 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args)); 1665 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState); 1666 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, mapper->getMetaState()); 1667 1668 // Metakey up. 1669 process(mapper, ARBITRARY_TIME + 3, DEVICE_ID, 1670 EV_KEY, KEY_LEFTSHIFT, 0); 1671 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args)); 1672 ASSERT_EQ(AMETA_NONE, args.metaState); 1673 ASSERT_EQ(AMETA_NONE, mapper->getMetaState()); 1674 ASSERT_NO_FATAL_FAILURE(mFakeContext->assertUpdateGlobalMetaStateWasCalled()); 1675 } 1676 1677 TEST_F(KeyboardInputMapperTest, Process_WhenNotOrientationAware_ShouldNotRotateDPad) { 1678 mFakeEventHub->addKey(DEVICE_ID, KEY_UP, 0, AKEYCODE_DPAD_UP, 0); 1679 mFakeEventHub->addKey(DEVICE_ID, KEY_RIGHT, 0, AKEYCODE_DPAD_RIGHT, 0); 1680 mFakeEventHub->addKey(DEVICE_ID, KEY_DOWN, 0, AKEYCODE_DPAD_DOWN, 0); 1681 mFakeEventHub->addKey(DEVICE_ID, KEY_LEFT, 0, AKEYCODE_DPAD_LEFT, 0); 1682 1683 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, 1684 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC); 1685 addMapperAndConfigure(mapper); 1686 1687 setDisplayInfoAndReconfigure(DISPLAY_ID, 1688 DISPLAY_WIDTH, DISPLAY_HEIGHT, 1689 DISPLAY_ORIENTATION_90); 1690 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1691 KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_UP)); 1692 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1693 KEY_RIGHT, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_RIGHT)); 1694 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1695 KEY_DOWN, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_DOWN)); 1696 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1697 KEY_LEFT, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_LEFT)); 1698 } 1699 1700 TEST_F(KeyboardInputMapperTest, Process_WhenOrientationAware_ShouldRotateDPad) { 1701 mFakeEventHub->addKey(DEVICE_ID, KEY_UP, 0, AKEYCODE_DPAD_UP, 0); 1702 mFakeEventHub->addKey(DEVICE_ID, KEY_RIGHT, 0, AKEYCODE_DPAD_RIGHT, 0); 1703 mFakeEventHub->addKey(DEVICE_ID, KEY_DOWN, 0, AKEYCODE_DPAD_DOWN, 0); 1704 mFakeEventHub->addKey(DEVICE_ID, KEY_LEFT, 0, AKEYCODE_DPAD_LEFT, 0); 1705 1706 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, 1707 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC); 1708 addConfigurationProperty("keyboard.orientationAware", "1"); 1709 addMapperAndConfigure(mapper); 1710 1711 setDisplayInfoAndReconfigure(DISPLAY_ID, 1712 DISPLAY_WIDTH, DISPLAY_HEIGHT, 1713 DISPLAY_ORIENTATION_0); 1714 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1715 KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_UP)); 1716 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1717 KEY_RIGHT, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_RIGHT)); 1718 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1719 KEY_DOWN, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_DOWN)); 1720 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1721 KEY_LEFT, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_LEFT)); 1722 1723 setDisplayInfoAndReconfigure(DISPLAY_ID, 1724 DISPLAY_WIDTH, DISPLAY_HEIGHT, 1725 DISPLAY_ORIENTATION_90); 1726 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1727 KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_LEFT)); 1728 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1729 KEY_RIGHT, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_UP)); 1730 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1731 KEY_DOWN, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_RIGHT)); 1732 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1733 KEY_LEFT, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_DOWN)); 1734 1735 setDisplayInfoAndReconfigure(DISPLAY_ID, 1736 DISPLAY_WIDTH, DISPLAY_HEIGHT, 1737 DISPLAY_ORIENTATION_180); 1738 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1739 KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_DOWN)); 1740 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1741 KEY_RIGHT, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_LEFT)); 1742 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1743 KEY_DOWN, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_UP)); 1744 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1745 KEY_LEFT, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_RIGHT)); 1746 1747 setDisplayInfoAndReconfigure(DISPLAY_ID, 1748 DISPLAY_WIDTH, DISPLAY_HEIGHT, 1749 DISPLAY_ORIENTATION_270); 1750 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1751 KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_RIGHT)); 1752 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1753 KEY_RIGHT, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_DOWN)); 1754 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1755 KEY_DOWN, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_LEFT)); 1756 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, 1757 KEY_LEFT, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_UP)); 1758 1759 // Special case: if orientation changes while key is down, we still emit the same keycode 1760 // in the key up as we did in the key down. 1761 NotifyKeyArgs args; 1762 1763 setDisplayInfoAndReconfigure(DISPLAY_ID, 1764 DISPLAY_WIDTH, DISPLAY_HEIGHT, 1765 DISPLAY_ORIENTATION_270); 1766 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, KEY_UP, 1); 1767 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args)); 1768 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, args.action); 1769 ASSERT_EQ(KEY_UP, args.scanCode); 1770 ASSERT_EQ(AKEYCODE_DPAD_RIGHT, args.keyCode); 1771 1772 setDisplayInfoAndReconfigure(DISPLAY_ID, 1773 DISPLAY_WIDTH, DISPLAY_HEIGHT, 1774 DISPLAY_ORIENTATION_180); 1775 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, KEY_UP, 0); 1776 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args)); 1777 ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action); 1778 ASSERT_EQ(KEY_UP, args.scanCode); 1779 ASSERT_EQ(AKEYCODE_DPAD_RIGHT, args.keyCode); 1780 } 1781 1782 TEST_F(KeyboardInputMapperTest, GetKeyCodeState) { 1783 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, 1784 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC); 1785 addMapperAndConfigure(mapper); 1786 1787 mFakeEventHub->setKeyCodeState(DEVICE_ID, AKEYCODE_A, 1); 1788 ASSERT_EQ(1, mapper->getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_A)); 1789 1790 mFakeEventHub->setKeyCodeState(DEVICE_ID, AKEYCODE_A, 0); 1791 ASSERT_EQ(0, mapper->getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_A)); 1792 } 1793 1794 TEST_F(KeyboardInputMapperTest, GetScanCodeState) { 1795 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, 1796 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC); 1797 addMapperAndConfigure(mapper); 1798 1799 mFakeEventHub->setScanCodeState(DEVICE_ID, KEY_A, 1); 1800 ASSERT_EQ(1, mapper->getScanCodeState(AINPUT_SOURCE_ANY, KEY_A)); 1801 1802 mFakeEventHub->setScanCodeState(DEVICE_ID, KEY_A, 0); 1803 ASSERT_EQ(0, mapper->getScanCodeState(AINPUT_SOURCE_ANY, KEY_A)); 1804 } 1805 1806 TEST_F(KeyboardInputMapperTest, MarkSupportedKeyCodes) { 1807 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, 1808 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC); 1809 addMapperAndConfigure(mapper); 1810 1811 mFakeEventHub->addKey(DEVICE_ID, KEY_A, 0, AKEYCODE_A, 0); 1812 1813 const int32_t keyCodes[2] = { AKEYCODE_A, AKEYCODE_B }; 1814 uint8_t flags[2] = { 0, 0 }; 1815 ASSERT_TRUE(mapper->markSupportedKeyCodes(AINPUT_SOURCE_ANY, 1, keyCodes, flags)); 1816 ASSERT_TRUE(flags[0]); 1817 ASSERT_FALSE(flags[1]); 1818 } 1819 1820 TEST_F(KeyboardInputMapperTest, Process_LockedKeysShouldToggleMetaStateAndLeds) { 1821 mFakeEventHub->addLed(DEVICE_ID, LED_CAPSL, true /*initially on*/); 1822 mFakeEventHub->addLed(DEVICE_ID, LED_NUML, false /*initially off*/); 1823 mFakeEventHub->addLed(DEVICE_ID, LED_SCROLLL, false /*initially off*/); 1824 mFakeEventHub->addKey(DEVICE_ID, KEY_CAPSLOCK, 0, AKEYCODE_CAPS_LOCK, 0); 1825 mFakeEventHub->addKey(DEVICE_ID, KEY_NUMLOCK, 0, AKEYCODE_NUM_LOCK, 0); 1826 mFakeEventHub->addKey(DEVICE_ID, KEY_SCROLLLOCK, 0, AKEYCODE_SCROLL_LOCK, 0); 1827 1828 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, 1829 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC); 1830 addMapperAndConfigure(mapper); 1831 1832 // Initialization should have turned all of the lights off. 1833 ASSERT_FALSE(mFakeEventHub->getLedState(DEVICE_ID, LED_CAPSL)); 1834 ASSERT_FALSE(mFakeEventHub->getLedState(DEVICE_ID, LED_NUML)); 1835 ASSERT_FALSE(mFakeEventHub->getLedState(DEVICE_ID, LED_SCROLLL)); 1836 1837 // Toggle caps lock on. 1838 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1839 EV_KEY, KEY_CAPSLOCK, 1); 1840 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1841 EV_KEY, KEY_CAPSLOCK, 0); 1842 ASSERT_TRUE(mFakeEventHub->getLedState(DEVICE_ID, LED_CAPSL)); 1843 ASSERT_FALSE(mFakeEventHub->getLedState(DEVICE_ID, LED_NUML)); 1844 ASSERT_FALSE(mFakeEventHub->getLedState(DEVICE_ID, LED_SCROLLL)); 1845 ASSERT_EQ(AMETA_CAPS_LOCK_ON, mapper->getMetaState()); 1846 1847 // Toggle num lock on. 1848 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1849 EV_KEY, KEY_NUMLOCK, 1); 1850 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1851 EV_KEY, KEY_NUMLOCK, 0); 1852 ASSERT_TRUE(mFakeEventHub->getLedState(DEVICE_ID, LED_CAPSL)); 1853 ASSERT_TRUE(mFakeEventHub->getLedState(DEVICE_ID, LED_NUML)); 1854 ASSERT_FALSE(mFakeEventHub->getLedState(DEVICE_ID, LED_SCROLLL)); 1855 ASSERT_EQ(AMETA_CAPS_LOCK_ON | AMETA_NUM_LOCK_ON, mapper->getMetaState()); 1856 1857 // Toggle caps lock off. 1858 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1859 EV_KEY, KEY_CAPSLOCK, 1); 1860 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1861 EV_KEY, KEY_CAPSLOCK, 0); 1862 ASSERT_FALSE(mFakeEventHub->getLedState(DEVICE_ID, LED_CAPSL)); 1863 ASSERT_TRUE(mFakeEventHub->getLedState(DEVICE_ID, LED_NUML)); 1864 ASSERT_FALSE(mFakeEventHub->getLedState(DEVICE_ID, LED_SCROLLL)); 1865 ASSERT_EQ(AMETA_NUM_LOCK_ON, mapper->getMetaState()); 1866 1867 // Toggle scroll lock on. 1868 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1869 EV_KEY, KEY_SCROLLLOCK, 1); 1870 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1871 EV_KEY, KEY_SCROLLLOCK, 0); 1872 ASSERT_FALSE(mFakeEventHub->getLedState(DEVICE_ID, LED_CAPSL)); 1873 ASSERT_TRUE(mFakeEventHub->getLedState(DEVICE_ID, LED_NUML)); 1874 ASSERT_TRUE(mFakeEventHub->getLedState(DEVICE_ID, LED_SCROLLL)); 1875 ASSERT_EQ(AMETA_NUM_LOCK_ON | AMETA_SCROLL_LOCK_ON, mapper->getMetaState()); 1876 1877 // Toggle num lock off. 1878 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1879 EV_KEY, KEY_NUMLOCK, 1); 1880 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1881 EV_KEY, KEY_NUMLOCK, 0); 1882 ASSERT_FALSE(mFakeEventHub->getLedState(DEVICE_ID, LED_CAPSL)); 1883 ASSERT_FALSE(mFakeEventHub->getLedState(DEVICE_ID, LED_NUML)); 1884 ASSERT_TRUE(mFakeEventHub->getLedState(DEVICE_ID, LED_SCROLLL)); 1885 ASSERT_EQ(AMETA_SCROLL_LOCK_ON, mapper->getMetaState()); 1886 1887 // Toggle scroll lock off. 1888 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1889 EV_KEY, KEY_SCROLLLOCK, 1); 1890 process(mapper, ARBITRARY_TIME, DEVICE_ID, 1891 EV_KEY, KEY_SCROLLLOCK, 0); 1892 ASSERT_FALSE(mFakeEventHub->getLedState(DEVICE_ID, LED_CAPSL)); 1893 ASSERT_FALSE(mFakeEventHub->getLedState(DEVICE_ID, LED_NUML)); 1894 ASSERT_FALSE(mFakeEventHub->getLedState(DEVICE_ID, LED_SCROLLL)); 1895 ASSERT_EQ(AMETA_NONE, mapper->getMetaState()); 1896 } 1897 1898 1899 // --- CursorInputMapperTest --- 1900 1901 class CursorInputMapperTest : public InputMapperTest { 1902 protected: 1903 static const int32_t TRACKBALL_MOVEMENT_THRESHOLD; 1904 1905 sp<FakePointerController> mFakePointerController; 1906 1907 virtual void SetUp() { 1908 InputMapperTest::SetUp(); 1909 1910 mFakePointerController = new FakePointerController(); 1911 mFakePolicy->setPointerController(DEVICE_ID, mFakePointerController); 1912 } 1913 1914 void testMotionRotation(CursorInputMapper* mapper, 1915 int32_t originalX, int32_t originalY, int32_t rotatedX, int32_t rotatedY); 1916 }; 1917 1918 const int32_t CursorInputMapperTest::TRACKBALL_MOVEMENT_THRESHOLD = 6; 1919 1920 void CursorInputMapperTest::testMotionRotation(CursorInputMapper* mapper, 1921 int32_t originalX, int32_t originalY, int32_t rotatedX, int32_t rotatedY) { 1922 NotifyMotionArgs args; 1923 1924 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_X, originalX); 1925 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_Y, originalY); 1926 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0); 1927 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args)); 1928 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action); 1929 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 1930 float(rotatedX) / TRACKBALL_MOVEMENT_THRESHOLD, 1931 float(rotatedY) / TRACKBALL_MOVEMENT_THRESHOLD, 1932 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 1933 } 1934 1935 TEST_F(CursorInputMapperTest, WhenModeIsPointer_GetSources_ReturnsMouse) { 1936 CursorInputMapper* mapper = new CursorInputMapper(mDevice); 1937 addConfigurationProperty("cursor.mode", "pointer"); 1938 addMapperAndConfigure(mapper); 1939 1940 ASSERT_EQ(AINPUT_SOURCE_MOUSE, mapper->getSources()); 1941 } 1942 1943 TEST_F(CursorInputMapperTest, WhenModeIsNavigation_GetSources_ReturnsTrackball) { 1944 CursorInputMapper* mapper = new CursorInputMapper(mDevice); 1945 addConfigurationProperty("cursor.mode", "navigation"); 1946 addMapperAndConfigure(mapper); 1947 1948 ASSERT_EQ(AINPUT_SOURCE_TRACKBALL, mapper->getSources()); 1949 } 1950 1951 TEST_F(CursorInputMapperTest, WhenModeIsPointer_PopulateDeviceInfo_ReturnsRangeFromPointerController) { 1952 CursorInputMapper* mapper = new CursorInputMapper(mDevice); 1953 addConfigurationProperty("cursor.mode", "pointer"); 1954 addMapperAndConfigure(mapper); 1955 1956 InputDeviceInfo info; 1957 mapper->populateDeviceInfo(&info); 1958 1959 // Initially there may not be a valid motion range. 1960 ASSERT_EQ(NULL, info.getMotionRange(AINPUT_MOTION_RANGE_X, AINPUT_SOURCE_MOUSE)); 1961 ASSERT_EQ(NULL, info.getMotionRange(AINPUT_MOTION_RANGE_Y, AINPUT_SOURCE_MOUSE)); 1962 ASSERT_NO_FATAL_FAILURE(assertMotionRange(info, 1963 AINPUT_MOTION_RANGE_PRESSURE, AINPUT_SOURCE_MOUSE, 0.0f, 1.0f, 0.0f, 0.0f)); 1964 1965 // When the bounds are set, then there should be a valid motion range. 1966 mFakePointerController->setBounds(1, 2, 800 - 1, 480 - 1); 1967 1968 InputDeviceInfo info2; 1969 mapper->populateDeviceInfo(&info2); 1970 1971 ASSERT_NO_FATAL_FAILURE(assertMotionRange(info2, 1972 AINPUT_MOTION_RANGE_X, AINPUT_SOURCE_MOUSE, 1973 1, 800 - 1, 0.0f, 0.0f)); 1974 ASSERT_NO_FATAL_FAILURE(assertMotionRange(info2, 1975 AINPUT_MOTION_RANGE_Y, AINPUT_SOURCE_MOUSE, 1976 2, 480 - 1, 0.0f, 0.0f)); 1977 ASSERT_NO_FATAL_FAILURE(assertMotionRange(info2, 1978 AINPUT_MOTION_RANGE_PRESSURE, AINPUT_SOURCE_MOUSE, 1979 0.0f, 1.0f, 0.0f, 0.0f)); 1980 } 1981 1982 TEST_F(CursorInputMapperTest, WhenModeIsNavigation_PopulateDeviceInfo_ReturnsScaledRange) { 1983 CursorInputMapper* mapper = new CursorInputMapper(mDevice); 1984 addConfigurationProperty("cursor.mode", "navigation"); 1985 addMapperAndConfigure(mapper); 1986 1987 InputDeviceInfo info; 1988 mapper->populateDeviceInfo(&info); 1989 1990 ASSERT_NO_FATAL_FAILURE(assertMotionRange(info, 1991 AINPUT_MOTION_RANGE_X, AINPUT_SOURCE_TRACKBALL, 1992 -1.0f, 1.0f, 0.0f, 1.0f / TRACKBALL_MOVEMENT_THRESHOLD)); 1993 ASSERT_NO_FATAL_FAILURE(assertMotionRange(info, 1994 AINPUT_MOTION_RANGE_Y, AINPUT_SOURCE_TRACKBALL, 1995 -1.0f, 1.0f, 0.0f, 1.0f / TRACKBALL_MOVEMENT_THRESHOLD)); 1996 ASSERT_NO_FATAL_FAILURE(assertMotionRange(info, 1997 AINPUT_MOTION_RANGE_PRESSURE, AINPUT_SOURCE_TRACKBALL, 1998 0.0f, 1.0f, 0.0f, 0.0f)); 1999 } 2000 2001 TEST_F(CursorInputMapperTest, Process_ShouldSetAllFieldsAndIncludeGlobalMetaState) { 2002 CursorInputMapper* mapper = new CursorInputMapper(mDevice); 2003 addConfigurationProperty("cursor.mode", "navigation"); 2004 addMapperAndConfigure(mapper); 2005 2006 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON); 2007 2008 NotifyMotionArgs args; 2009 2010 // Button press. 2011 // Mostly testing non x/y behavior here so we don't need to check again elsewhere. 2012 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 1); 2013 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0); 2014 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args)); 2015 ASSERT_EQ(ARBITRARY_TIME, args.eventTime); 2016 ASSERT_EQ(DEVICE_ID, args.deviceId); 2017 ASSERT_EQ(AINPUT_SOURCE_TRACKBALL, args.source); 2018 ASSERT_EQ(uint32_t(0), args.policyFlags); 2019 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action); 2020 ASSERT_EQ(0, args.flags); 2021 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState); 2022 ASSERT_EQ(AMOTION_EVENT_BUTTON_PRIMARY, args.buttonState); 2023 ASSERT_EQ(0, args.edgeFlags); 2024 ASSERT_EQ(uint32_t(1), args.pointerCount); 2025 ASSERT_EQ(0, args.pointerProperties[0].id); 2026 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_MOUSE, args.pointerProperties[0].toolType); 2027 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 2028 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2029 ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.xPrecision); 2030 ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.yPrecision); 2031 ASSERT_EQ(ARBITRARY_TIME, args.downTime); 2032 2033 // Button release. Should have same down time. 2034 process(mapper, ARBITRARY_TIME + 1, DEVICE_ID, EV_KEY, BTN_MOUSE, 0); 2035 process(mapper, ARBITRARY_TIME + 1, DEVICE_ID, EV_SYN, SYN_REPORT, 0); 2036 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args)); 2037 ASSERT_EQ(ARBITRARY_TIME + 1, args.eventTime); 2038 ASSERT_EQ(DEVICE_ID, args.deviceId); 2039 ASSERT_EQ(AINPUT_SOURCE_TRACKBALL, args.source); 2040 ASSERT_EQ(uint32_t(0), args.policyFlags); 2041 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, args.action); 2042 ASSERT_EQ(0, args.flags); 2043 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState); 2044 ASSERT_EQ(0, args.buttonState); 2045 ASSERT_EQ(0, args.edgeFlags); 2046 ASSERT_EQ(uint32_t(1), args.pointerCount); 2047 ASSERT_EQ(0, args.pointerProperties[0].id); 2048 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_MOUSE, args.pointerProperties[0].toolType); 2049 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 2050 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2051 ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.xPrecision); 2052 ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.yPrecision); 2053 ASSERT_EQ(ARBITRARY_TIME, args.downTime); 2054 } 2055 2056 TEST_F(CursorInputMapperTest, Process_ShouldHandleIndependentXYUpdates) { 2057 CursorInputMapper* mapper = new CursorInputMapper(mDevice); 2058 addConfigurationProperty("cursor.mode", "navigation"); 2059 addMapperAndConfigure(mapper); 2060 2061 NotifyMotionArgs args; 2062 2063 // Motion in X but not Y. 2064 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_X, 1); 2065 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0); 2066 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args)); 2067 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action); 2068 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 2069 1.0f / TRACKBALL_MOVEMENT_THRESHOLD, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2070 2071 // Motion in Y but not X. 2072 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_Y, -2); 2073 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0); 2074 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args)); 2075 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action); 2076 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 2077 0.0f, -2.0f / TRACKBALL_MOVEMENT_THRESHOLD, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2078 } 2079 2080 TEST_F(CursorInputMapperTest, Process_ShouldHandleIndependentButtonUpdates) { 2081 CursorInputMapper* mapper = new CursorInputMapper(mDevice); 2082 addConfigurationProperty("cursor.mode", "navigation"); 2083 addMapperAndConfigure(mapper); 2084 2085 NotifyMotionArgs args; 2086 2087 // Button press. 2088 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 1); 2089 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0); 2090 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args)); 2091 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action); 2092 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 2093 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2094 2095 // Button release. 2096 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0); 2097 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0); 2098 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args)); 2099 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, args.action); 2100 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 2101 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2102 } 2103 2104 TEST_F(CursorInputMapperTest, Process_ShouldHandleCombinedXYAndButtonUpdates) { 2105 CursorInputMapper* mapper = new CursorInputMapper(mDevice); 2106 addConfigurationProperty("cursor.mode", "navigation"); 2107 addMapperAndConfigure(mapper); 2108 2109 NotifyMotionArgs args; 2110 2111 // Combined X, Y and Button. 2112 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_X, 1); 2113 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_Y, -2); 2114 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 1); 2115 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0); 2116 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args)); 2117 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action); 2118 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 2119 1.0f / TRACKBALL_MOVEMENT_THRESHOLD, -2.0f / TRACKBALL_MOVEMENT_THRESHOLD, 2120 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2121 2122 // Move X, Y a bit while pressed. 2123 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_X, 2); 2124 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_Y, 1); 2125 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0); 2126 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args)); 2127 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action); 2128 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 2129 2.0f / TRACKBALL_MOVEMENT_THRESHOLD, 1.0f / TRACKBALL_MOVEMENT_THRESHOLD, 2130 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2131 2132 // Release Button. 2133 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0); 2134 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0); 2135 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args)); 2136 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, args.action); 2137 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 2138 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2139 } 2140 2141 TEST_F(CursorInputMapperTest, Process_WhenNotOrientationAware_ShouldNotRotateMotions) { 2142 CursorInputMapper* mapper = new CursorInputMapper(mDevice); 2143 addConfigurationProperty("cursor.mode", "navigation"); 2144 addMapperAndConfigure(mapper); 2145 2146 setDisplayInfoAndReconfigure(DISPLAY_ID, 2147 DISPLAY_WIDTH, DISPLAY_HEIGHT, 2148 DISPLAY_ORIENTATION_90); 2149 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, 1, 0, 1)); 2150 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 1, 1, 1)); 2151 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 0, 1, 0)); 2152 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, -1, 1, -1)); 2153 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, -1, 0, -1)); 2154 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1, -1, -1)); 2155 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 0, -1, 0)); 2156 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 1, -1, 1)); 2157 } 2158 2159 TEST_F(CursorInputMapperTest, Process_WhenOrientationAware_ShouldRotateMotions) { 2160 CursorInputMapper* mapper = new CursorInputMapper(mDevice); 2161 addConfigurationProperty("cursor.mode", "navigation"); 2162 addConfigurationProperty("cursor.orientationAware", "1"); 2163 addMapperAndConfigure(mapper); 2164 2165 setDisplayInfoAndReconfigure(DISPLAY_ID, 2166 DISPLAY_WIDTH, DISPLAY_HEIGHT, DISPLAY_ORIENTATION_0); 2167 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, 1, 0, 1)); 2168 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 1, 1, 1)); 2169 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 0, 1, 0)); 2170 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, -1, 1, -1)); 2171 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, -1, 0, -1)); 2172 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1, -1, -1)); 2173 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 0, -1, 0)); 2174 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 1, -1, 1)); 2175 2176 setDisplayInfoAndReconfigure(DISPLAY_ID, 2177 DISPLAY_WIDTH, DISPLAY_HEIGHT, DISPLAY_ORIENTATION_90); 2178 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, 1, 1, 0)); 2179 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 1, 1, -1)); 2180 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 0, 0, -1)); 2181 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, -1, -1, -1)); 2182 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, -1, -1, 0)); 2183 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1, -1, 1)); 2184 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 0, 0, 1)); 2185 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 1, 1, 1)); 2186 2187 setDisplayInfoAndReconfigure(DISPLAY_ID, 2188 DISPLAY_WIDTH, DISPLAY_HEIGHT, DISPLAY_ORIENTATION_180); 2189 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, 1, 0, -1)); 2190 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 1, -1, -1)); 2191 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 0, -1, 0)); 2192 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, -1, -1, 1)); 2193 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, -1, 0, 1)); 2194 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1, 1, 1)); 2195 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 0, 1, 0)); 2196 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 1, 1, -1)); 2197 2198 setDisplayInfoAndReconfigure(DISPLAY_ID, 2199 DISPLAY_WIDTH, DISPLAY_HEIGHT, DISPLAY_ORIENTATION_270); 2200 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, 1, -1, 0)); 2201 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 1, -1, 1)); 2202 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 0, 0, 1)); 2203 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, -1, 1, 1)); 2204 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, -1, 1, 0)); 2205 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1, 1, -1)); 2206 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 0, 0, -1)); 2207 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 1, -1, -1)); 2208 } 2209 2210 TEST_F(CursorInputMapperTest, Process_ShouldHandleAllButtons) { 2211 CursorInputMapper* mapper = new CursorInputMapper(mDevice); 2212 addConfigurationProperty("cursor.mode", "pointer"); 2213 addMapperAndConfigure(mapper); 2214 2215 mFakePointerController->setBounds(0, 0, 800 - 1, 480 - 1); 2216 mFakePointerController->setPosition(100, 200); 2217 mFakePointerController->setButtonState(0); 2218 2219 NotifyMotionArgs motionArgs; 2220 NotifyKeyArgs keyArgs; 2221 2222 // press BTN_LEFT, release BTN_LEFT 2223 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_LEFT, 1); 2224 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0); 2225 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 2226 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action); 2227 ASSERT_EQ(AMOTION_EVENT_BUTTON_PRIMARY, motionArgs.buttonState); 2228 ASSERT_EQ(AMOTION_EVENT_BUTTON_PRIMARY, mFakePointerController->getButtonState()); 2229 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 2230 100.0f, 200.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2231 2232 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_LEFT, 0); 2233 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0); 2234 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 2235 ASSERT_EQ(0, motionArgs.buttonState); 2236 ASSERT_EQ(0, mFakePointerController->getButtonState()); 2237 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action); 2238 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 2239 100.0f, 200.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2240 2241 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 2242 ASSERT_EQ(0, motionArgs.buttonState); 2243 ASSERT_EQ(0, mFakePointerController->getButtonState()); 2244 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action); 2245 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 2246 100.0f, 200.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2247 2248 // press BTN_RIGHT + BTN_MIDDLE, release BTN_RIGHT, release BTN_MIDDLE 2249 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_RIGHT, 1); 2250 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MIDDLE, 1); 2251 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0); 2252 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 2253 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action); 2254 ASSERT_EQ(AMOTION_EVENT_BUTTON_SECONDARY | AMOTION_EVENT_BUTTON_TERTIARY, 2255 motionArgs.buttonState); 2256 ASSERT_EQ(AMOTION_EVENT_BUTTON_SECONDARY | AMOTION_EVENT_BUTTON_TERTIARY, 2257 mFakePointerController->getButtonState()); 2258 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 2259 100.0f, 200.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2260 2261 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_RIGHT, 0); 2262 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0); 2263 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 2264 ASSERT_EQ(AMOTION_EVENT_BUTTON_TERTIARY, motionArgs.buttonState); 2265 ASSERT_EQ(AMOTION_EVENT_BUTTON_TERTIARY, mFakePointerController->getButtonState()); 2266 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 2267 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 2268 100.0f, 200.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2269 2270 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MIDDLE, 0); 2271 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0); 2272 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 2273 ASSERT_EQ(0, motionArgs.buttonState); 2274 ASSERT_EQ(0, mFakePointerController->getButtonState()); 2275 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action); 2276 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 2277 100.0f, 200.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2278 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 2279 ASSERT_EQ(0, motionArgs.buttonState); 2280 ASSERT_EQ(0, mFakePointerController->getButtonState()); 2281 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action); 2282 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 2283 100.0f, 200.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2284 2285 // press BTN_BACK, release BTN_BACK 2286 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_BACK, 1); 2287 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0); 2288 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs)); 2289 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action); 2290 ASSERT_EQ(AKEYCODE_BACK, keyArgs.keyCode); 2291 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 2292 ASSERT_EQ(AMOTION_EVENT_BUTTON_BACK, motionArgs.buttonState); 2293 ASSERT_EQ(AMOTION_EVENT_BUTTON_BACK, mFakePointerController->getButtonState()); 2294 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action); 2295 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 2296 100.0f, 200.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2297 2298 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_BACK, 0); 2299 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0); 2300 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 2301 ASSERT_EQ(0, motionArgs.buttonState); 2302 ASSERT_EQ(0, mFakePointerController->getButtonState()); 2303 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action); 2304 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 2305 100.0f, 200.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2306 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs)); 2307 ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action); 2308 ASSERT_EQ(AKEYCODE_BACK, keyArgs.keyCode); 2309 2310 // press BTN_SIDE, release BTN_SIDE 2311 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_SIDE, 1); 2312 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0); 2313 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs)); 2314 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action); 2315 ASSERT_EQ(AKEYCODE_BACK, keyArgs.keyCode); 2316 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 2317 ASSERT_EQ(AMOTION_EVENT_BUTTON_BACK, motionArgs.buttonState); 2318 ASSERT_EQ(AMOTION_EVENT_BUTTON_BACK, mFakePointerController->getButtonState()); 2319 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action); 2320 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 2321 100.0f, 200.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2322 2323 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_SIDE, 0); 2324 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0); 2325 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 2326 ASSERT_EQ(0, motionArgs.buttonState); 2327 ASSERT_EQ(0, mFakePointerController->getButtonState()); 2328 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action); 2329 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 2330 100.0f, 200.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2331 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs)); 2332 ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action); 2333 ASSERT_EQ(AKEYCODE_BACK, keyArgs.keyCode); 2334 2335 // press BTN_FORWARD, release BTN_FORWARD 2336 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_FORWARD, 1); 2337 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0); 2338 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs)); 2339 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action); 2340 ASSERT_EQ(AKEYCODE_FORWARD, keyArgs.keyCode); 2341 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 2342 ASSERT_EQ(AMOTION_EVENT_BUTTON_FORWARD, motionArgs.buttonState); 2343 ASSERT_EQ(AMOTION_EVENT_BUTTON_FORWARD, mFakePointerController->getButtonState()); 2344 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action); 2345 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 2346 100.0f, 200.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2347 2348 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_FORWARD, 0); 2349 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0); 2350 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 2351 ASSERT_EQ(0, motionArgs.buttonState); 2352 ASSERT_EQ(0, mFakePointerController->getButtonState()); 2353 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action); 2354 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 2355 100.0f, 200.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2356 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs)); 2357 ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action); 2358 ASSERT_EQ(AKEYCODE_FORWARD, keyArgs.keyCode); 2359 2360 // press BTN_EXTRA, release BTN_EXTRA 2361 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_EXTRA, 1); 2362 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0); 2363 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs)); 2364 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action); 2365 ASSERT_EQ(AKEYCODE_FORWARD, keyArgs.keyCode); 2366 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 2367 ASSERT_EQ(AMOTION_EVENT_BUTTON_FORWARD, motionArgs.buttonState); 2368 ASSERT_EQ(AMOTION_EVENT_BUTTON_FORWARD, mFakePointerController->getButtonState()); 2369 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action); 2370 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 2371 100.0f, 200.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2372 2373 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_EXTRA, 0); 2374 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0); 2375 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 2376 ASSERT_EQ(0, motionArgs.buttonState); 2377 ASSERT_EQ(0, mFakePointerController->getButtonState()); 2378 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action); 2379 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 2380 100.0f, 200.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2381 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs)); 2382 ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action); 2383 ASSERT_EQ(AKEYCODE_FORWARD, keyArgs.keyCode); 2384 } 2385 2386 TEST_F(CursorInputMapperTest, Process_WhenModeIsPointer_ShouldMoveThePointerAround) { 2387 CursorInputMapper* mapper = new CursorInputMapper(mDevice); 2388 addConfigurationProperty("cursor.mode", "pointer"); 2389 addMapperAndConfigure(mapper); 2390 2391 mFakePointerController->setBounds(0, 0, 800 - 1, 480 - 1); 2392 mFakePointerController->setPosition(100, 200); 2393 mFakePointerController->setButtonState(0); 2394 2395 NotifyMotionArgs args; 2396 2397 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_X, 10); 2398 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_Y, 20); 2399 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0); 2400 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args)); 2401 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, args.action); 2402 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 2403 110.0f, 220.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); 2404 ASSERT_NO_FATAL_FAILURE(assertPosition(mFakePointerController, 110.0f, 220.0f)); 2405 } 2406 2407 2408 // --- TouchInputMapperTest --- 2409 2410 class TouchInputMapperTest : public InputMapperTest { 2411 protected: 2412 static const int32_t RAW_X_MIN; 2413 static const int32_t RAW_X_MAX; 2414 static const int32_t RAW_Y_MIN; 2415 static const int32_t RAW_Y_MAX; 2416 static const int32_t RAW_TOUCH_MIN; 2417 static const int32_t RAW_TOUCH_MAX; 2418 static const int32_t RAW_TOOL_MIN; 2419 static const int32_t RAW_TOOL_MAX; 2420 static const int32_t RAW_PRESSURE_MIN; 2421 static const int32_t RAW_PRESSURE_MAX; 2422 static const int32_t RAW_ORIENTATION_MIN; 2423 static const int32_t RAW_ORIENTATION_MAX; 2424 static const int32_t RAW_DISTANCE_MIN; 2425 static const int32_t RAW_DISTANCE_MAX; 2426 static const int32_t RAW_TILT_MIN; 2427 static const int32_t RAW_TILT_MAX; 2428 static const int32_t RAW_ID_MIN; 2429 static const int32_t RAW_ID_MAX; 2430 static const int32_t RAW_SLOT_MIN; 2431 static const int32_t RAW_SLOT_MAX; 2432 static const float X_PRECISION; 2433 static const float Y_PRECISION; 2434 2435 static const float GEOMETRIC_SCALE; 2436 2437 static const VirtualKeyDefinition VIRTUAL_KEYS[2]; 2438 2439 enum Axes { 2440 POSITION = 1 << 0, 2441 TOUCH = 1 << 1, 2442 TOOL = 1 << 2, 2443 PRESSURE = 1 << 3, 2444 ORIENTATION = 1 << 4, 2445 MINOR = 1 << 5, 2446 ID = 1 << 6, 2447 DISTANCE = 1 << 7, 2448 TILT = 1 << 8, 2449 SLOT = 1 << 9, 2450 TOOL_TYPE = 1 << 10, 2451 }; 2452 2453 void prepareDisplay(int32_t orientation); 2454 void prepareVirtualKeys(); 2455 int32_t toRawX(float displayX); 2456 int32_t toRawY(float displayY); 2457 float toDisplayX(int32_t rawX); 2458 float toDisplayY(int32_t rawY); 2459 }; 2460 2461 const int32_t TouchInputMapperTest::RAW_X_MIN = 25; 2462 const int32_t TouchInputMapperTest::RAW_X_MAX = 1019; 2463 const int32_t TouchInputMapperTest::RAW_Y_MIN = 30; 2464 const int32_t TouchInputMapperTest::RAW_Y_MAX = 1009; 2465 const int32_t TouchInputMapperTest::RAW_TOUCH_MIN = 0; 2466 const int32_t TouchInputMapperTest::RAW_TOUCH_MAX = 31; 2467 const int32_t TouchInputMapperTest::RAW_TOOL_MIN = 0; 2468 const int32_t TouchInputMapperTest::RAW_TOOL_MAX = 15; 2469 const int32_t TouchInputMapperTest::RAW_PRESSURE_MIN = RAW_TOUCH_MIN; 2470 const int32_t TouchInputMapperTest::RAW_PRESSURE_MAX = RAW_TOUCH_MAX; 2471 const int32_t TouchInputMapperTest::RAW_ORIENTATION_MIN = -7; 2472 const int32_t TouchInputMapperTest::RAW_ORIENTATION_MAX = 7; 2473 const int32_t TouchInputMapperTest::RAW_DISTANCE_MIN = 0; 2474 const int32_t TouchInputMapperTest::RAW_DISTANCE_MAX = 7; 2475 const int32_t TouchInputMapperTest::RAW_TILT_MIN = 0; 2476 const int32_t TouchInputMapperTest::RAW_TILT_MAX = 150; 2477 const int32_t TouchInputMapperTest::RAW_ID_MIN = 0; 2478 const int32_t TouchInputMapperTest::RAW_ID_MAX = 9; 2479 const int32_t TouchInputMapperTest::RAW_SLOT_MIN = 0; 2480 const int32_t TouchInputMapperTest::RAW_SLOT_MAX = 9; 2481 const float TouchInputMapperTest::X_PRECISION = float(RAW_X_MAX - RAW_X_MIN + 1) / DISPLAY_WIDTH; 2482 const float TouchInputMapperTest::Y_PRECISION = float(RAW_Y_MAX - RAW_Y_MIN + 1) / DISPLAY_HEIGHT; 2483 2484 const float TouchInputMapperTest::GEOMETRIC_SCALE = 2485 avg(float(DISPLAY_WIDTH) / (RAW_X_MAX - RAW_X_MIN + 1), 2486 float(DISPLAY_HEIGHT) / (RAW_Y_MAX - RAW_Y_MIN + 1)); 2487 2488 const VirtualKeyDefinition TouchInputMapperTest::VIRTUAL_KEYS[2] = { 2489 { KEY_HOME, 60, DISPLAY_HEIGHT + 15, 20, 20 }, 2490 { KEY_MENU, DISPLAY_HEIGHT - 60, DISPLAY_WIDTH + 15, 20, 20 }, 2491 }; 2492 2493 void TouchInputMapperTest::prepareDisplay(int32_t orientation) { 2494 setDisplayInfoAndReconfigure(DISPLAY_ID, DISPLAY_WIDTH, DISPLAY_HEIGHT, orientation); 2495 } 2496 2497 void TouchInputMapperTest::prepareVirtualKeys() { 2498 mFakeEventHub->addVirtualKeyDefinition(DEVICE_ID, VIRTUAL_KEYS[0]); 2499 mFakeEventHub->addVirtualKeyDefinition(DEVICE_ID, VIRTUAL_KEYS[1]); 2500 mFakeEventHub->addKey(DEVICE_ID, KEY_HOME, 0, AKEYCODE_HOME, POLICY_FLAG_WAKE); 2501 mFakeEventHub->addKey(DEVICE_ID, KEY_MENU, 0, AKEYCODE_MENU, POLICY_FLAG_WAKE); 2502 } 2503 2504 int32_t TouchInputMapperTest::toRawX(float displayX) { 2505 return int32_t(displayX * (RAW_X_MAX - RAW_X_MIN + 1) / DISPLAY_WIDTH + RAW_X_MIN); 2506 } 2507 2508 int32_t TouchInputMapperTest::toRawY(float displayY) { 2509 return int32_t(displayY * (RAW_Y_MAX - RAW_Y_MIN + 1) / DISPLAY_HEIGHT + RAW_Y_MIN); 2510 } 2511 2512 float TouchInputMapperTest::toDisplayX(int32_t rawX) { 2513 return float(rawX - RAW_X_MIN) * DISPLAY_WIDTH / (RAW_X_MAX - RAW_X_MIN + 1); 2514 } 2515 2516 float TouchInputMapperTest::toDisplayY(int32_t rawY) { 2517 return float(rawY - RAW_Y_MIN) * DISPLAY_HEIGHT / (RAW_Y_MAX - RAW_Y_MIN + 1); 2518 } 2519 2520 2521 // --- SingleTouchInputMapperTest --- 2522 2523 class SingleTouchInputMapperTest : public TouchInputMapperTest { 2524 protected: 2525 void prepareButtons(); 2526 void prepareAxes(int axes); 2527 2528 void processDown(SingleTouchInputMapper* mapper, int32_t x, int32_t y); 2529 void processMove(SingleTouchInputMapper* mapper, int32_t x, int32_t y); 2530 void processUp(SingleTouchInputMapper* mappery); 2531 void processPressure(SingleTouchInputMapper* mapper, int32_t pressure); 2532 void processToolMajor(SingleTouchInputMapper* mapper, int32_t toolMajor); 2533 void processDistance(SingleTouchInputMapper* mapper, int32_t distance); 2534 void processTilt(SingleTouchInputMapper* mapper, int32_t tiltX, int32_t tiltY); 2535 void processKey(SingleTouchInputMapper* mapper, int32_t code, int32_t value); 2536 void processSync(SingleTouchInputMapper* mapper); 2537 }; 2538 2539 void SingleTouchInputMapperTest::prepareButtons() { 2540 mFakeEventHub->addKey(DEVICE_ID, BTN_TOUCH, 0, AKEYCODE_UNKNOWN, 0); 2541 } 2542 2543 void SingleTouchInputMapperTest::prepareAxes(int axes) { 2544 if (axes & POSITION) { 2545 mFakeEventHub->addAbsoluteAxis(DEVICE_ID, ABS_X, 2546 RAW_X_MIN, RAW_X_MAX, 0, 0); 2547 mFakeEventHub->addAbsoluteAxis(DEVICE_ID, ABS_Y, 2548 RAW_Y_MIN, RAW_Y_MAX, 0, 0); 2549 } 2550 if (axes & PRESSURE) { 2551 mFakeEventHub->addAbsoluteAxis(DEVICE_ID, ABS_PRESSURE, 2552 RAW_PRESSURE_MIN, RAW_PRESSURE_MAX, 0, 0); 2553 } 2554 if (axes & TOOL) { 2555 mFakeEventHub->addAbsoluteAxis(DEVICE_ID, ABS_TOOL_WIDTH, 2556 RAW_TOOL_MIN, RAW_TOOL_MAX, 0, 0); 2557 } 2558 if (axes & DISTANCE) { 2559 mFakeEventHub->addAbsoluteAxis(DEVICE_ID, ABS_DISTANCE, 2560 RAW_DISTANCE_MIN, RAW_DISTANCE_MAX, 0, 0); 2561 } 2562 if (axes & TILT) { 2563 mFakeEventHub->addAbsoluteAxis(DEVICE_ID, ABS_TILT_X, 2564 RAW_TILT_MIN, RAW_TILT_MAX, 0, 0); 2565 mFakeEventHub->addAbsoluteAxis(DEVICE_ID, ABS_TILT_Y, 2566 RAW_TILT_MIN, RAW_TILT_MAX, 0, 0); 2567 } 2568 } 2569 2570 void SingleTouchInputMapperTest::processDown(SingleTouchInputMapper* mapper, int32_t x, int32_t y) { 2571 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_TOUCH, 1); 2572 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_X, x); 2573 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_Y, y); 2574 } 2575 2576 void SingleTouchInputMapperTest::processMove(SingleTouchInputMapper* mapper, int32_t x, int32_t y) { 2577 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_X, x); 2578 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_Y, y); 2579 } 2580 2581 void SingleTouchInputMapperTest::processUp(SingleTouchInputMapper* mapper) { 2582 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_TOUCH, 0); 2583 } 2584 2585 void SingleTouchInputMapperTest::processPressure( 2586 SingleTouchInputMapper* mapper, int32_t pressure) { 2587 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_PRESSURE, pressure); 2588 } 2589 2590 void SingleTouchInputMapperTest::processToolMajor( 2591 SingleTouchInputMapper* mapper, int32_t toolMajor) { 2592 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_TOOL_WIDTH, toolMajor); 2593 } 2594 2595 void SingleTouchInputMapperTest::processDistance( 2596 SingleTouchInputMapper* mapper, int32_t distance) { 2597 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_DISTANCE, distance); 2598 } 2599 2600 void SingleTouchInputMapperTest::processTilt( 2601 SingleTouchInputMapper* mapper, int32_t tiltX, int32_t tiltY) { 2602 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_TILT_X, tiltX); 2603 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_TILT_Y, tiltY); 2604 } 2605 2606 void SingleTouchInputMapperTest::processKey( 2607 SingleTouchInputMapper* mapper, int32_t code, int32_t value) { 2608 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, code, value); 2609 } 2610 2611 void SingleTouchInputMapperTest::processSync(SingleTouchInputMapper* mapper) { 2612 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0); 2613 } 2614 2615 2616 TEST_F(SingleTouchInputMapperTest, GetSources_WhenDeviceTypeIsNotSpecifiedAndNotACursor_ReturnsPointer) { 2617 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 2618 prepareButtons(); 2619 prepareAxes(POSITION); 2620 addMapperAndConfigure(mapper); 2621 2622 ASSERT_EQ(AINPUT_SOURCE_MOUSE, mapper->getSources()); 2623 } 2624 2625 TEST_F(SingleTouchInputMapperTest, GetSources_WhenDeviceTypeIsNotSpecifiedAndIsACursor_ReturnsTouchPad) { 2626 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 2627 mFakeEventHub->addRelativeAxis(DEVICE_ID, REL_X); 2628 mFakeEventHub->addRelativeAxis(DEVICE_ID, REL_Y); 2629 prepareButtons(); 2630 prepareAxes(POSITION); 2631 addMapperAndConfigure(mapper); 2632 2633 ASSERT_EQ(AINPUT_SOURCE_TOUCHPAD, mapper->getSources()); 2634 } 2635 2636 TEST_F(SingleTouchInputMapperTest, GetSources_WhenDeviceTypeIsTouchPad_ReturnsTouchPad) { 2637 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 2638 prepareButtons(); 2639 prepareAxes(POSITION); 2640 addConfigurationProperty("touch.deviceType", "touchPad"); 2641 addMapperAndConfigure(mapper); 2642 2643 ASSERT_EQ(AINPUT_SOURCE_TOUCHPAD, mapper->getSources()); 2644 } 2645 2646 TEST_F(SingleTouchInputMapperTest, GetSources_WhenDeviceTypeIsTouchScreen_ReturnsTouchScreen) { 2647 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 2648 prepareButtons(); 2649 prepareAxes(POSITION); 2650 addConfigurationProperty("touch.deviceType", "touchScreen"); 2651 addMapperAndConfigure(mapper); 2652 2653 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, mapper->getSources()); 2654 } 2655 2656 TEST_F(SingleTouchInputMapperTest, GetKeyCodeState) { 2657 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 2658 addConfigurationProperty("touch.deviceType", "touchScreen"); 2659 prepareDisplay(DISPLAY_ORIENTATION_0); 2660 prepareButtons(); 2661 prepareAxes(POSITION); 2662 prepareVirtualKeys(); 2663 addMapperAndConfigure(mapper); 2664 2665 // Unknown key. 2666 ASSERT_EQ(AKEY_STATE_UNKNOWN, mapper->getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_A)); 2667 2668 // Virtual key is down. 2669 int32_t x = toRawX(VIRTUAL_KEYS[0].centerX); 2670 int32_t y = toRawY(VIRTUAL_KEYS[0].centerY); 2671 processDown(mapper, x, y); 2672 processSync(mapper); 2673 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled()); 2674 2675 ASSERT_EQ(AKEY_STATE_VIRTUAL, mapper->getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_HOME)); 2676 2677 // Virtual key is up. 2678 processUp(mapper); 2679 processSync(mapper); 2680 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled()); 2681 2682 ASSERT_EQ(AKEY_STATE_UP, mapper->getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_HOME)); 2683 } 2684 2685 TEST_F(SingleTouchInputMapperTest, GetScanCodeState) { 2686 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 2687 addConfigurationProperty("touch.deviceType", "touchScreen"); 2688 prepareDisplay(DISPLAY_ORIENTATION_0); 2689 prepareButtons(); 2690 prepareAxes(POSITION); 2691 prepareVirtualKeys(); 2692 addMapperAndConfigure(mapper); 2693 2694 // Unknown key. 2695 ASSERT_EQ(AKEY_STATE_UNKNOWN, mapper->getScanCodeState(AINPUT_SOURCE_ANY, KEY_A)); 2696 2697 // Virtual key is down. 2698 int32_t x = toRawX(VIRTUAL_KEYS[0].centerX); 2699 int32_t y = toRawY(VIRTUAL_KEYS[0].centerY); 2700 processDown(mapper, x, y); 2701 processSync(mapper); 2702 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled()); 2703 2704 ASSERT_EQ(AKEY_STATE_VIRTUAL, mapper->getScanCodeState(AINPUT_SOURCE_ANY, KEY_HOME)); 2705 2706 // Virtual key is up. 2707 processUp(mapper); 2708 processSync(mapper); 2709 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled()); 2710 2711 ASSERT_EQ(AKEY_STATE_UP, mapper->getScanCodeState(AINPUT_SOURCE_ANY, KEY_HOME)); 2712 } 2713 2714 TEST_F(SingleTouchInputMapperTest, MarkSupportedKeyCodes) { 2715 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 2716 addConfigurationProperty("touch.deviceType", "touchScreen"); 2717 prepareDisplay(DISPLAY_ORIENTATION_0); 2718 prepareButtons(); 2719 prepareAxes(POSITION); 2720 prepareVirtualKeys(); 2721 addMapperAndConfigure(mapper); 2722 2723 const int32_t keys[2] = { AKEYCODE_HOME, AKEYCODE_A }; 2724 uint8_t flags[2] = { 0, 0 }; 2725 ASSERT_TRUE(mapper->markSupportedKeyCodes(AINPUT_SOURCE_ANY, 2, keys, flags)); 2726 ASSERT_TRUE(flags[0]); 2727 ASSERT_FALSE(flags[1]); 2728 } 2729 2730 TEST_F(SingleTouchInputMapperTest, Process_WhenVirtualKeyIsPressedAndReleasedNormally_SendsKeyDownAndKeyUp) { 2731 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 2732 addConfigurationProperty("touch.deviceType", "touchScreen"); 2733 prepareDisplay(DISPLAY_ORIENTATION_0); 2734 prepareButtons(); 2735 prepareAxes(POSITION); 2736 prepareVirtualKeys(); 2737 addMapperAndConfigure(mapper); 2738 2739 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON); 2740 2741 NotifyKeyArgs args; 2742 2743 // Press virtual key. 2744 int32_t x = toRawX(VIRTUAL_KEYS[0].centerX); 2745 int32_t y = toRawY(VIRTUAL_KEYS[0].centerY); 2746 processDown(mapper, x, y); 2747 processSync(mapper); 2748 2749 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args)); 2750 ASSERT_EQ(ARBITRARY_TIME, args.eventTime); 2751 ASSERT_EQ(DEVICE_ID, args.deviceId); 2752 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source); 2753 ASSERT_EQ(POLICY_FLAG_VIRTUAL, args.policyFlags); 2754 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, args.action); 2755 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY, args.flags); 2756 ASSERT_EQ(AKEYCODE_HOME, args.keyCode); 2757 ASSERT_EQ(KEY_HOME, args.scanCode); 2758 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState); 2759 ASSERT_EQ(ARBITRARY_TIME, args.downTime); 2760 2761 // Release virtual key. 2762 processUp(mapper); 2763 processSync(mapper); 2764 2765 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args)); 2766 ASSERT_EQ(ARBITRARY_TIME, args.eventTime); 2767 ASSERT_EQ(DEVICE_ID, args.deviceId); 2768 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source); 2769 ASSERT_EQ(POLICY_FLAG_VIRTUAL, args.policyFlags); 2770 ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action); 2771 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY, args.flags); 2772 ASSERT_EQ(AKEYCODE_HOME, args.keyCode); 2773 ASSERT_EQ(KEY_HOME, args.scanCode); 2774 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState); 2775 ASSERT_EQ(ARBITRARY_TIME, args.downTime); 2776 2777 // Should not have sent any motions. 2778 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasNotCalled()); 2779 } 2780 2781 TEST_F(SingleTouchInputMapperTest, Process_WhenVirtualKeyIsPressedAndMovedOutOfBounds_SendsKeyDownAndKeyCancel) { 2782 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 2783 addConfigurationProperty("touch.deviceType", "touchScreen"); 2784 prepareDisplay(DISPLAY_ORIENTATION_0); 2785 prepareButtons(); 2786 prepareAxes(POSITION); 2787 prepareVirtualKeys(); 2788 addMapperAndConfigure(mapper); 2789 2790 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON); 2791 2792 NotifyKeyArgs keyArgs; 2793 2794 // Press virtual key. 2795 int32_t x = toRawX(VIRTUAL_KEYS[0].centerX); 2796 int32_t y = toRawY(VIRTUAL_KEYS[0].centerY); 2797 processDown(mapper, x, y); 2798 processSync(mapper); 2799 2800 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs)); 2801 ASSERT_EQ(ARBITRARY_TIME, keyArgs.eventTime); 2802 ASSERT_EQ(DEVICE_ID, keyArgs.deviceId); 2803 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, keyArgs.source); 2804 ASSERT_EQ(POLICY_FLAG_VIRTUAL, keyArgs.policyFlags); 2805 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action); 2806 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY, keyArgs.flags); 2807 ASSERT_EQ(AKEYCODE_HOME, keyArgs.keyCode); 2808 ASSERT_EQ(KEY_HOME, keyArgs.scanCode); 2809 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, keyArgs.metaState); 2810 ASSERT_EQ(ARBITRARY_TIME, keyArgs.downTime); 2811 2812 // Move out of bounds. This should generate a cancel and a pointer down since we moved 2813 // into the display area. 2814 y -= 100; 2815 processMove(mapper, x, y); 2816 processSync(mapper); 2817 2818 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs)); 2819 ASSERT_EQ(ARBITRARY_TIME, keyArgs.eventTime); 2820 ASSERT_EQ(DEVICE_ID, keyArgs.deviceId); 2821 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, keyArgs.source); 2822 ASSERT_EQ(POLICY_FLAG_VIRTUAL, keyArgs.policyFlags); 2823 ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action); 2824 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY 2825 | AKEY_EVENT_FLAG_CANCELED, keyArgs.flags); 2826 ASSERT_EQ(AKEYCODE_HOME, keyArgs.keyCode); 2827 ASSERT_EQ(KEY_HOME, keyArgs.scanCode); 2828 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, keyArgs.metaState); 2829 ASSERT_EQ(ARBITRARY_TIME, keyArgs.downTime); 2830 2831 NotifyMotionArgs motionArgs; 2832 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 2833 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 2834 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 2835 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 2836 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 2837 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action); 2838 ASSERT_EQ(0, motionArgs.flags); 2839 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 2840 ASSERT_EQ(0, motionArgs.buttonState); 2841 ASSERT_EQ(0, motionArgs.edgeFlags); 2842 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 2843 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 2844 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 2845 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 2846 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0, 0)); 2847 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 2848 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 2849 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 2850 2851 // Keep moving out of bounds. Should generate a pointer move. 2852 y -= 50; 2853 processMove(mapper, x, y); 2854 processSync(mapper); 2855 2856 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 2857 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 2858 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 2859 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 2860 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 2861 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 2862 ASSERT_EQ(0, motionArgs.flags); 2863 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 2864 ASSERT_EQ(0, motionArgs.buttonState); 2865 ASSERT_EQ(0, motionArgs.edgeFlags); 2866 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 2867 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 2868 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 2869 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 2870 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0, 0)); 2871 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 2872 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 2873 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 2874 2875 // Release out of bounds. Should generate a pointer up. 2876 processUp(mapper); 2877 processSync(mapper); 2878 2879 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 2880 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 2881 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 2882 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 2883 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 2884 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action); 2885 ASSERT_EQ(0, motionArgs.flags); 2886 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 2887 ASSERT_EQ(0, motionArgs.buttonState); 2888 ASSERT_EQ(0, motionArgs.edgeFlags); 2889 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 2890 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 2891 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 2892 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 2893 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0, 0)); 2894 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 2895 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 2896 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 2897 2898 // Should not have sent any more keys or motions. 2899 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasNotCalled()); 2900 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled()); 2901 } 2902 2903 TEST_F(SingleTouchInputMapperTest, Process_WhenTouchStartsOutsideDisplayAndMovesIn_SendsDownAsTouchEntersDisplay) { 2904 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 2905 addConfigurationProperty("touch.deviceType", "touchScreen"); 2906 prepareDisplay(DISPLAY_ORIENTATION_0); 2907 prepareButtons(); 2908 prepareAxes(POSITION); 2909 prepareVirtualKeys(); 2910 addMapperAndConfigure(mapper); 2911 2912 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON); 2913 2914 NotifyMotionArgs motionArgs; 2915 2916 // Initially go down out of bounds. 2917 int32_t x = -10; 2918 int32_t y = -10; 2919 processDown(mapper, x, y); 2920 processSync(mapper); 2921 2922 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled()); 2923 2924 // Move into the display area. Should generate a pointer down. 2925 x = 50; 2926 y = 75; 2927 processMove(mapper, x, y); 2928 processSync(mapper); 2929 2930 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 2931 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 2932 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 2933 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 2934 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 2935 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action); 2936 ASSERT_EQ(0, motionArgs.flags); 2937 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 2938 ASSERT_EQ(0, motionArgs.buttonState); 2939 ASSERT_EQ(0, motionArgs.edgeFlags); 2940 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 2941 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 2942 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 2943 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 2944 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0, 0)); 2945 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 2946 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 2947 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 2948 2949 // Release. Should generate a pointer up. 2950 processUp(mapper); 2951 processSync(mapper); 2952 2953 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 2954 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 2955 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 2956 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 2957 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 2958 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action); 2959 ASSERT_EQ(0, motionArgs.flags); 2960 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 2961 ASSERT_EQ(0, motionArgs.buttonState); 2962 ASSERT_EQ(0, motionArgs.edgeFlags); 2963 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 2964 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 2965 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 2966 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 2967 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0, 0)); 2968 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 2969 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 2970 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 2971 2972 // Should not have sent any more keys or motions. 2973 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasNotCalled()); 2974 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled()); 2975 } 2976 2977 TEST_F(SingleTouchInputMapperTest, Process_NormalSingleTouchGesture) { 2978 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 2979 addConfigurationProperty("touch.deviceType", "touchScreen"); 2980 prepareDisplay(DISPLAY_ORIENTATION_0); 2981 prepareButtons(); 2982 prepareAxes(POSITION); 2983 prepareVirtualKeys(); 2984 addMapperAndConfigure(mapper); 2985 2986 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON); 2987 2988 NotifyMotionArgs motionArgs; 2989 2990 // Down. 2991 int32_t x = 100; 2992 int32_t y = 125; 2993 processDown(mapper, x, y); 2994 processSync(mapper); 2995 2996 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 2997 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 2998 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 2999 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 3000 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 3001 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action); 3002 ASSERT_EQ(0, motionArgs.flags); 3003 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 3004 ASSERT_EQ(0, motionArgs.buttonState); 3005 ASSERT_EQ(0, motionArgs.edgeFlags); 3006 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 3007 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 3008 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 3009 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3010 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0, 0)); 3011 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 3012 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 3013 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 3014 3015 // Move. 3016 x += 50; 3017 y += 75; 3018 processMove(mapper, x, y); 3019 processSync(mapper); 3020 3021 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3022 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 3023 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 3024 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 3025 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 3026 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3027 ASSERT_EQ(0, motionArgs.flags); 3028 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 3029 ASSERT_EQ(0, motionArgs.buttonState); 3030 ASSERT_EQ(0, motionArgs.edgeFlags); 3031 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 3032 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 3033 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 3034 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3035 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0, 0)); 3036 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 3037 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 3038 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 3039 3040 // Up. 3041 processUp(mapper); 3042 processSync(mapper); 3043 3044 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3045 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 3046 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 3047 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 3048 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 3049 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action); 3050 ASSERT_EQ(0, motionArgs.flags); 3051 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 3052 ASSERT_EQ(0, motionArgs.buttonState); 3053 ASSERT_EQ(0, motionArgs.edgeFlags); 3054 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 3055 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 3056 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 3057 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3058 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0, 0)); 3059 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 3060 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 3061 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 3062 3063 // Should not have sent any more keys or motions. 3064 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasNotCalled()); 3065 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled()); 3066 } 3067 3068 TEST_F(SingleTouchInputMapperTest, Process_WhenNotOrientationAware_DoesNotRotateMotions) { 3069 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 3070 addConfigurationProperty("touch.deviceType", "touchScreen"); 3071 prepareButtons(); 3072 prepareAxes(POSITION); 3073 addConfigurationProperty("touch.orientationAware", "0"); 3074 addMapperAndConfigure(mapper); 3075 3076 NotifyMotionArgs args; 3077 3078 // Rotation 90. 3079 prepareDisplay(DISPLAY_ORIENTATION_90); 3080 processDown(mapper, toRawX(50), toRawY(75)); 3081 processSync(mapper); 3082 3083 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args)); 3084 ASSERT_NEAR(50, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X), 1); 3085 ASSERT_NEAR(75, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y), 1); 3086 3087 processUp(mapper); 3088 processSync(mapper); 3089 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled()); 3090 } 3091 3092 TEST_F(SingleTouchInputMapperTest, Process_WhenOrientationAware_RotatesMotions) { 3093 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 3094 addConfigurationProperty("touch.deviceType", "touchScreen"); 3095 prepareButtons(); 3096 prepareAxes(POSITION); 3097 addMapperAndConfigure(mapper); 3098 3099 NotifyMotionArgs args; 3100 3101 // Rotation 0. 3102 prepareDisplay(DISPLAY_ORIENTATION_0); 3103 processDown(mapper, toRawX(50), toRawY(75)); 3104 processSync(mapper); 3105 3106 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args)); 3107 ASSERT_NEAR(50, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X), 1); 3108 ASSERT_NEAR(75, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y), 1); 3109 3110 processUp(mapper); 3111 processSync(mapper); 3112 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled()); 3113 3114 // Rotation 90. 3115 prepareDisplay(DISPLAY_ORIENTATION_90); 3116 processDown(mapper, RAW_X_MAX - toRawX(75) + RAW_X_MIN, toRawY(50)); 3117 processSync(mapper); 3118 3119 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args)); 3120 ASSERT_NEAR(50, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X), 1); 3121 ASSERT_NEAR(75, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y), 1); 3122 3123 processUp(mapper); 3124 processSync(mapper); 3125 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled()); 3126 3127 // Rotation 180. 3128 prepareDisplay(DISPLAY_ORIENTATION_180); 3129 processDown(mapper, RAW_X_MAX - toRawX(50) + RAW_X_MIN, RAW_Y_MAX - toRawY(75) + RAW_Y_MIN); 3130 processSync(mapper); 3131 3132 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args)); 3133 ASSERT_NEAR(50, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X), 1); 3134 ASSERT_NEAR(75, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y), 1); 3135 3136 processUp(mapper); 3137 processSync(mapper); 3138 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled()); 3139 3140 // Rotation 270. 3141 prepareDisplay(DISPLAY_ORIENTATION_270); 3142 processDown(mapper, toRawX(75), RAW_Y_MAX - toRawY(50) + RAW_Y_MIN); 3143 processSync(mapper); 3144 3145 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args)); 3146 ASSERT_NEAR(50, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X), 1); 3147 ASSERT_NEAR(75, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y), 1); 3148 3149 processUp(mapper); 3150 processSync(mapper); 3151 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled()); 3152 } 3153 3154 TEST_F(SingleTouchInputMapperTest, Process_AllAxes_DefaultCalibration) { 3155 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 3156 addConfigurationProperty("touch.deviceType", "touchScreen"); 3157 prepareDisplay(DISPLAY_ORIENTATION_0); 3158 prepareButtons(); 3159 prepareAxes(POSITION | PRESSURE | TOOL | DISTANCE | TILT); 3160 addMapperAndConfigure(mapper); 3161 3162 // These calculations are based on the input device calibration documentation. 3163 int32_t rawX = 100; 3164 int32_t rawY = 200; 3165 int32_t rawPressure = 10; 3166 int32_t rawToolMajor = 12; 3167 int32_t rawDistance = 2; 3168 int32_t rawTiltX = 30; 3169 int32_t rawTiltY = 110; 3170 3171 float x = toDisplayX(rawX); 3172 float y = toDisplayY(rawY); 3173 float pressure = float(rawPressure) / RAW_PRESSURE_MAX; 3174 float size = float(rawToolMajor) / RAW_TOOL_MAX; 3175 float tool = float(rawToolMajor) * GEOMETRIC_SCALE; 3176 float distance = float(rawDistance); 3177 3178 float tiltCenter = (RAW_TILT_MAX + RAW_TILT_MIN) * 0.5f; 3179 float tiltScale = M_PI / 180; 3180 float tiltXAngle = (rawTiltX - tiltCenter) * tiltScale; 3181 float tiltYAngle = (rawTiltY - tiltCenter) * tiltScale; 3182 float orientation = atan2f(-sinf(tiltXAngle), sinf(tiltYAngle)); 3183 float tilt = acosf(cosf(tiltXAngle) * cosf(tiltYAngle)); 3184 3185 processDown(mapper, rawX, rawY); 3186 processPressure(mapper, rawPressure); 3187 processToolMajor(mapper, rawToolMajor); 3188 processDistance(mapper, rawDistance); 3189 processTilt(mapper, rawTiltX, rawTiltY); 3190 processSync(mapper); 3191 3192 NotifyMotionArgs args; 3193 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args)); 3194 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 3195 x, y, pressure, size, tool, tool, tool, tool, orientation, distance)); 3196 ASSERT_EQ(tilt, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_TILT)); 3197 } 3198 3199 TEST_F(SingleTouchInputMapperTest, Process_ShouldHandleAllButtons) { 3200 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 3201 addConfigurationProperty("touch.deviceType", "touchScreen"); 3202 prepareDisplay(DISPLAY_ORIENTATION_0); 3203 prepareButtons(); 3204 prepareAxes(POSITION); 3205 addMapperAndConfigure(mapper); 3206 3207 NotifyMotionArgs motionArgs; 3208 NotifyKeyArgs keyArgs; 3209 3210 processDown(mapper, 100, 200); 3211 processSync(mapper); 3212 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3213 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action); 3214 ASSERT_EQ(0, motionArgs.buttonState); 3215 3216 // press BTN_LEFT, release BTN_LEFT 3217 processKey(mapper, BTN_LEFT, 1); 3218 processSync(mapper); 3219 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3220 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3221 ASSERT_EQ(AMOTION_EVENT_BUTTON_PRIMARY, motionArgs.buttonState); 3222 3223 processKey(mapper, BTN_LEFT, 0); 3224 processSync(mapper); 3225 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3226 ASSERT_EQ(0, motionArgs.buttonState); 3227 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3228 3229 // press BTN_RIGHT + BTN_MIDDLE, release BTN_RIGHT, release BTN_MIDDLE 3230 processKey(mapper, BTN_RIGHT, 1); 3231 processKey(mapper, BTN_MIDDLE, 1); 3232 processSync(mapper); 3233 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3234 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3235 ASSERT_EQ(AMOTION_EVENT_BUTTON_SECONDARY | AMOTION_EVENT_BUTTON_TERTIARY, 3236 motionArgs.buttonState); 3237 3238 processKey(mapper, BTN_RIGHT, 0); 3239 processSync(mapper); 3240 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3241 ASSERT_EQ(AMOTION_EVENT_BUTTON_TERTIARY, motionArgs.buttonState); 3242 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3243 3244 processKey(mapper, BTN_MIDDLE, 0); 3245 processSync(mapper); 3246 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3247 ASSERT_EQ(0, motionArgs.buttonState); 3248 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3249 3250 // press BTN_BACK, release BTN_BACK 3251 processKey(mapper, BTN_BACK, 1); 3252 processSync(mapper); 3253 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs)); 3254 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action); 3255 ASSERT_EQ(AKEYCODE_BACK, keyArgs.keyCode); 3256 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3257 ASSERT_EQ(AMOTION_EVENT_BUTTON_BACK, motionArgs.buttonState); 3258 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3259 3260 processKey(mapper, BTN_BACK, 0); 3261 processSync(mapper); 3262 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3263 ASSERT_EQ(0, motionArgs.buttonState); 3264 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3265 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs)); 3266 ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action); 3267 ASSERT_EQ(AKEYCODE_BACK, keyArgs.keyCode); 3268 3269 // press BTN_SIDE, release BTN_SIDE 3270 processKey(mapper, BTN_SIDE, 1); 3271 processSync(mapper); 3272 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs)); 3273 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action); 3274 ASSERT_EQ(AKEYCODE_BACK, keyArgs.keyCode); 3275 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3276 ASSERT_EQ(AMOTION_EVENT_BUTTON_BACK, motionArgs.buttonState); 3277 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3278 3279 processKey(mapper, BTN_SIDE, 0); 3280 processSync(mapper); 3281 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3282 ASSERT_EQ(0, motionArgs.buttonState); 3283 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3284 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs)); 3285 ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action); 3286 ASSERT_EQ(AKEYCODE_BACK, keyArgs.keyCode); 3287 3288 // press BTN_FORWARD, release BTN_FORWARD 3289 processKey(mapper, BTN_FORWARD, 1); 3290 processSync(mapper); 3291 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs)); 3292 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action); 3293 ASSERT_EQ(AKEYCODE_FORWARD, keyArgs.keyCode); 3294 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3295 ASSERT_EQ(AMOTION_EVENT_BUTTON_FORWARD, motionArgs.buttonState); 3296 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3297 3298 processKey(mapper, BTN_FORWARD, 0); 3299 processSync(mapper); 3300 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3301 ASSERT_EQ(0, motionArgs.buttonState); 3302 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3303 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs)); 3304 ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action); 3305 ASSERT_EQ(AKEYCODE_FORWARD, keyArgs.keyCode); 3306 3307 // press BTN_EXTRA, release BTN_EXTRA 3308 processKey(mapper, BTN_EXTRA, 1); 3309 processSync(mapper); 3310 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs)); 3311 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action); 3312 ASSERT_EQ(AKEYCODE_FORWARD, keyArgs.keyCode); 3313 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3314 ASSERT_EQ(AMOTION_EVENT_BUTTON_FORWARD, motionArgs.buttonState); 3315 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3316 3317 processKey(mapper, BTN_EXTRA, 0); 3318 processSync(mapper); 3319 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3320 ASSERT_EQ(0, motionArgs.buttonState); 3321 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3322 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs)); 3323 ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action); 3324 ASSERT_EQ(AKEYCODE_FORWARD, keyArgs.keyCode); 3325 3326 // press BTN_STYLUS, release BTN_STYLUS 3327 processKey(mapper, BTN_STYLUS, 1); 3328 processSync(mapper); 3329 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3330 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3331 ASSERT_EQ(AMOTION_EVENT_BUTTON_SECONDARY, motionArgs.buttonState); 3332 3333 processKey(mapper, BTN_STYLUS, 0); 3334 processSync(mapper); 3335 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3336 ASSERT_EQ(0, motionArgs.buttonState); 3337 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3338 3339 // press BTN_STYLUS2, release BTN_STYLUS2 3340 processKey(mapper, BTN_STYLUS2, 1); 3341 processSync(mapper); 3342 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3343 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3344 ASSERT_EQ(AMOTION_EVENT_BUTTON_TERTIARY, motionArgs.buttonState); 3345 3346 processKey(mapper, BTN_STYLUS2, 0); 3347 processSync(mapper); 3348 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3349 ASSERT_EQ(0, motionArgs.buttonState); 3350 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3351 3352 // release touch 3353 processUp(mapper); 3354 processSync(mapper); 3355 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3356 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action); 3357 ASSERT_EQ(0, motionArgs.buttonState); 3358 } 3359 3360 TEST_F(SingleTouchInputMapperTest, Process_ShouldHandleAllToolTypes) { 3361 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 3362 addConfigurationProperty("touch.deviceType", "touchScreen"); 3363 prepareDisplay(DISPLAY_ORIENTATION_0); 3364 prepareButtons(); 3365 prepareAxes(POSITION); 3366 addMapperAndConfigure(mapper); 3367 3368 NotifyMotionArgs motionArgs; 3369 3370 // default tool type is finger 3371 processDown(mapper, 100, 200); 3372 processSync(mapper); 3373 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3374 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action); 3375 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 3376 3377 // eraser 3378 processKey(mapper, BTN_TOOL_RUBBER, 1); 3379 processSync(mapper); 3380 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3381 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3382 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_ERASER, motionArgs.pointerProperties[0].toolType); 3383 3384 // stylus 3385 processKey(mapper, BTN_TOOL_RUBBER, 0); 3386 processKey(mapper, BTN_TOOL_PEN, 1); 3387 processSync(mapper); 3388 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3389 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3390 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_STYLUS, motionArgs.pointerProperties[0].toolType); 3391 3392 // brush 3393 processKey(mapper, BTN_TOOL_PEN, 0); 3394 processKey(mapper, BTN_TOOL_BRUSH, 1); 3395 processSync(mapper); 3396 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3397 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3398 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_STYLUS, motionArgs.pointerProperties[0].toolType); 3399 3400 // pencil 3401 processKey(mapper, BTN_TOOL_BRUSH, 0); 3402 processKey(mapper, BTN_TOOL_PENCIL, 1); 3403 processSync(mapper); 3404 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3405 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3406 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_STYLUS, motionArgs.pointerProperties[0].toolType); 3407 3408 // airbrush 3409 processKey(mapper, BTN_TOOL_PENCIL, 0); 3410 processKey(mapper, BTN_TOOL_AIRBRUSH, 1); 3411 processSync(mapper); 3412 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3413 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3414 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_STYLUS, motionArgs.pointerProperties[0].toolType); 3415 3416 // mouse 3417 processKey(mapper, BTN_TOOL_AIRBRUSH, 0); 3418 processKey(mapper, BTN_TOOL_MOUSE, 1); 3419 processSync(mapper); 3420 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3421 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3422 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_MOUSE, motionArgs.pointerProperties[0].toolType); 3423 3424 // lens 3425 processKey(mapper, BTN_TOOL_MOUSE, 0); 3426 processKey(mapper, BTN_TOOL_LENS, 1); 3427 processSync(mapper); 3428 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3429 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3430 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_MOUSE, motionArgs.pointerProperties[0].toolType); 3431 3432 // double-tap 3433 processKey(mapper, BTN_TOOL_LENS, 0); 3434 processKey(mapper, BTN_TOOL_DOUBLETAP, 1); 3435 processSync(mapper); 3436 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3437 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3438 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 3439 3440 // triple-tap 3441 processKey(mapper, BTN_TOOL_DOUBLETAP, 0); 3442 processKey(mapper, BTN_TOOL_TRIPLETAP, 1); 3443 processSync(mapper); 3444 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3445 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3446 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 3447 3448 // quad-tap 3449 processKey(mapper, BTN_TOOL_TRIPLETAP, 0); 3450 processKey(mapper, BTN_TOOL_QUADTAP, 1); 3451 processSync(mapper); 3452 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3453 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3454 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 3455 3456 // finger 3457 processKey(mapper, BTN_TOOL_QUADTAP, 0); 3458 processKey(mapper, BTN_TOOL_FINGER, 1); 3459 processSync(mapper); 3460 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3461 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3462 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 3463 3464 // stylus trumps finger 3465 processKey(mapper, BTN_TOOL_PEN, 1); 3466 processSync(mapper); 3467 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3468 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3469 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_STYLUS, motionArgs.pointerProperties[0].toolType); 3470 3471 // eraser trumps stylus 3472 processKey(mapper, BTN_TOOL_RUBBER, 1); 3473 processSync(mapper); 3474 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3475 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3476 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_ERASER, motionArgs.pointerProperties[0].toolType); 3477 3478 // mouse trumps eraser 3479 processKey(mapper, BTN_TOOL_MOUSE, 1); 3480 processSync(mapper); 3481 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3482 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3483 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_MOUSE, motionArgs.pointerProperties[0].toolType); 3484 3485 // back to default tool type 3486 processKey(mapper, BTN_TOOL_MOUSE, 0); 3487 processKey(mapper, BTN_TOOL_RUBBER, 0); 3488 processKey(mapper, BTN_TOOL_PEN, 0); 3489 processKey(mapper, BTN_TOOL_FINGER, 0); 3490 processSync(mapper); 3491 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3492 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3493 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 3494 } 3495 3496 TEST_F(SingleTouchInputMapperTest, Process_WhenBtnTouchPresent_HoversIfItsValueIsZero) { 3497 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 3498 addConfigurationProperty("touch.deviceType", "touchScreen"); 3499 prepareDisplay(DISPLAY_ORIENTATION_0); 3500 prepareButtons(); 3501 prepareAxes(POSITION); 3502 mFakeEventHub->addKey(DEVICE_ID, BTN_TOOL_FINGER, 0, AKEYCODE_UNKNOWN, 0); 3503 addMapperAndConfigure(mapper); 3504 3505 NotifyMotionArgs motionArgs; 3506 3507 // initially hovering because BTN_TOUCH not sent yet, pressure defaults to 0 3508 processKey(mapper, BTN_TOOL_FINGER, 1); 3509 processMove(mapper, 100, 200); 3510 processSync(mapper); 3511 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3512 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_ENTER, motionArgs.action); 3513 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3514 toDisplayX(100), toDisplayY(200), 0, 0, 0, 0, 0, 0, 0, 0)); 3515 3516 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3517 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action); 3518 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3519 toDisplayX(100), toDisplayY(200), 0, 0, 0, 0, 0, 0, 0, 0)); 3520 3521 // move a little 3522 processMove(mapper, 150, 250); 3523 processSync(mapper); 3524 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3525 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action); 3526 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3527 toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0)); 3528 3529 // down when BTN_TOUCH is pressed, pressure defaults to 1 3530 processKey(mapper, BTN_TOUCH, 1); 3531 processSync(mapper); 3532 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3533 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_EXIT, motionArgs.action); 3534 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3535 toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0)); 3536 3537 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3538 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action); 3539 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3540 toDisplayX(150), toDisplayY(250), 1, 0, 0, 0, 0, 0, 0, 0)); 3541 3542 // up when BTN_TOUCH is released, hover restored 3543 processKey(mapper, BTN_TOUCH, 0); 3544 processSync(mapper); 3545 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3546 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action); 3547 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3548 toDisplayX(150), toDisplayY(250), 1, 0, 0, 0, 0, 0, 0, 0)); 3549 3550 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3551 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_ENTER, motionArgs.action); 3552 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3553 toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0)); 3554 3555 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3556 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action); 3557 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3558 toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0)); 3559 3560 // exit hover when pointer goes away 3561 processKey(mapper, BTN_TOOL_FINGER, 0); 3562 processSync(mapper); 3563 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3564 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_EXIT, motionArgs.action); 3565 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3566 toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0)); 3567 } 3568 3569 TEST_F(SingleTouchInputMapperTest, Process_WhenAbsPressureIsPresent_HoversIfItsValueIsZero) { 3570 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice); 3571 addConfigurationProperty("touch.deviceType", "touchScreen"); 3572 prepareDisplay(DISPLAY_ORIENTATION_0); 3573 prepareButtons(); 3574 prepareAxes(POSITION | PRESSURE); 3575 addMapperAndConfigure(mapper); 3576 3577 NotifyMotionArgs motionArgs; 3578 3579 // initially hovering because pressure is 0 3580 processDown(mapper, 100, 200); 3581 processPressure(mapper, 0); 3582 processSync(mapper); 3583 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3584 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_ENTER, motionArgs.action); 3585 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3586 toDisplayX(100), toDisplayY(200), 0, 0, 0, 0, 0, 0, 0, 0)); 3587 3588 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3589 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action); 3590 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3591 toDisplayX(100), toDisplayY(200), 0, 0, 0, 0, 0, 0, 0, 0)); 3592 3593 // move a little 3594 processMove(mapper, 150, 250); 3595 processSync(mapper); 3596 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3597 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action); 3598 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3599 toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0)); 3600 3601 // down when pressure is non-zero 3602 processPressure(mapper, RAW_PRESSURE_MAX); 3603 processSync(mapper); 3604 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3605 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_EXIT, motionArgs.action); 3606 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3607 toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0)); 3608 3609 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3610 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action); 3611 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3612 toDisplayX(150), toDisplayY(250), 1, 0, 0, 0, 0, 0, 0, 0)); 3613 3614 // up when pressure becomes 0, hover restored 3615 processPressure(mapper, 0); 3616 processSync(mapper); 3617 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3618 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action); 3619 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3620 toDisplayX(150), toDisplayY(250), 1, 0, 0, 0, 0, 0, 0, 0)); 3621 3622 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3623 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_ENTER, motionArgs.action); 3624 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3625 toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0)); 3626 3627 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3628 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action); 3629 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3630 toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0)); 3631 3632 // exit hover when pointer goes away 3633 processUp(mapper); 3634 processSync(mapper); 3635 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3636 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_EXIT, motionArgs.action); 3637 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3638 toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0)); 3639 } 3640 3641 3642 // --- MultiTouchInputMapperTest --- 3643 3644 class MultiTouchInputMapperTest : public TouchInputMapperTest { 3645 protected: 3646 void prepareAxes(int axes); 3647 3648 void processPosition(MultiTouchInputMapper* mapper, int32_t x, int32_t y); 3649 void processTouchMajor(MultiTouchInputMapper* mapper, int32_t touchMajor); 3650 void processTouchMinor(MultiTouchInputMapper* mapper, int32_t touchMinor); 3651 void processToolMajor(MultiTouchInputMapper* mapper, int32_t toolMajor); 3652 void processToolMinor(MultiTouchInputMapper* mapper, int32_t toolMinor); 3653 void processOrientation(MultiTouchInputMapper* mapper, int32_t orientation); 3654 void processPressure(MultiTouchInputMapper* mapper, int32_t pressure); 3655 void processDistance(MultiTouchInputMapper* mapper, int32_t distance); 3656 void processId(MultiTouchInputMapper* mapper, int32_t id); 3657 void processSlot(MultiTouchInputMapper* mapper, int32_t slot); 3658 void processToolType(MultiTouchInputMapper* mapper, int32_t toolType); 3659 void processKey(MultiTouchInputMapper* mapper, int32_t code, int32_t value); 3660 void processMTSync(MultiTouchInputMapper* mapper); 3661 void processSync(MultiTouchInputMapper* mapper); 3662 }; 3663 3664 void MultiTouchInputMapperTest::prepareAxes(int axes) { 3665 if (axes & POSITION) { 3666 mFakeEventHub->addAbsoluteAxis(DEVICE_ID, ABS_MT_POSITION_X, 3667 RAW_X_MIN, RAW_X_MAX, 0, 0); 3668 mFakeEventHub->addAbsoluteAxis(DEVICE_ID, ABS_MT_POSITION_Y, 3669 RAW_Y_MIN, RAW_Y_MAX, 0, 0); 3670 } 3671 if (axes & TOUCH) { 3672 mFakeEventHub->addAbsoluteAxis(DEVICE_ID, ABS_MT_TOUCH_MAJOR, 3673 RAW_TOUCH_MIN, RAW_TOUCH_MAX, 0, 0); 3674 if (axes & MINOR) { 3675 mFakeEventHub->addAbsoluteAxis(DEVICE_ID, ABS_MT_TOUCH_MINOR, 3676 RAW_TOUCH_MIN, RAW_TOUCH_MAX, 0, 0); 3677 } 3678 } 3679 if (axes & TOOL) { 3680 mFakeEventHub->addAbsoluteAxis(DEVICE_ID, ABS_MT_WIDTH_MAJOR, 3681 RAW_TOOL_MIN, RAW_TOOL_MAX, 0, 0); 3682 if (axes & MINOR) { 3683 mFakeEventHub->addAbsoluteAxis(DEVICE_ID, ABS_MT_WIDTH_MINOR, 3684 RAW_TOOL_MAX, RAW_TOOL_MAX, 0, 0); 3685 } 3686 } 3687 if (axes & ORIENTATION) { 3688 mFakeEventHub->addAbsoluteAxis(DEVICE_ID, ABS_MT_ORIENTATION, 3689 RAW_ORIENTATION_MIN, RAW_ORIENTATION_MAX, 0, 0); 3690 } 3691 if (axes & PRESSURE) { 3692 mFakeEventHub->addAbsoluteAxis(DEVICE_ID, ABS_MT_PRESSURE, 3693 RAW_PRESSURE_MIN, RAW_PRESSURE_MAX, 0, 0); 3694 } 3695 if (axes & DISTANCE) { 3696 mFakeEventHub->addAbsoluteAxis(DEVICE_ID, ABS_MT_DISTANCE, 3697 RAW_DISTANCE_MIN, RAW_DISTANCE_MAX, 0, 0); 3698 } 3699 if (axes & ID) { 3700 mFakeEventHub->addAbsoluteAxis(DEVICE_ID, ABS_MT_TRACKING_ID, 3701 RAW_ID_MIN, RAW_ID_MAX, 0, 0); 3702 } 3703 if (axes & SLOT) { 3704 mFakeEventHub->addAbsoluteAxis(DEVICE_ID, ABS_MT_SLOT, 3705 RAW_SLOT_MIN, RAW_SLOT_MAX, 0, 0); 3706 mFakeEventHub->setAbsoluteAxisValue(DEVICE_ID, ABS_MT_SLOT, 0); 3707 } 3708 if (axes & TOOL_TYPE) { 3709 mFakeEventHub->addAbsoluteAxis(DEVICE_ID, ABS_MT_TOOL_TYPE, 3710 0, MT_TOOL_MAX, 0, 0); 3711 } 3712 } 3713 3714 void MultiTouchInputMapperTest::processPosition( 3715 MultiTouchInputMapper* mapper, int32_t x, int32_t y) { 3716 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_POSITION_X, x); 3717 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_POSITION_Y, y); 3718 } 3719 3720 void MultiTouchInputMapperTest::processTouchMajor( 3721 MultiTouchInputMapper* mapper, int32_t touchMajor) { 3722 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_TOUCH_MAJOR, touchMajor); 3723 } 3724 3725 void MultiTouchInputMapperTest::processTouchMinor( 3726 MultiTouchInputMapper* mapper, int32_t touchMinor) { 3727 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_TOUCH_MINOR, touchMinor); 3728 } 3729 3730 void MultiTouchInputMapperTest::processToolMajor( 3731 MultiTouchInputMapper* mapper, int32_t toolMajor) { 3732 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_WIDTH_MAJOR, toolMajor); 3733 } 3734 3735 void MultiTouchInputMapperTest::processToolMinor( 3736 MultiTouchInputMapper* mapper, int32_t toolMinor) { 3737 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_WIDTH_MINOR, toolMinor); 3738 } 3739 3740 void MultiTouchInputMapperTest::processOrientation( 3741 MultiTouchInputMapper* mapper, int32_t orientation) { 3742 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_ORIENTATION, orientation); 3743 } 3744 3745 void MultiTouchInputMapperTest::processPressure( 3746 MultiTouchInputMapper* mapper, int32_t pressure) { 3747 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_PRESSURE, pressure); 3748 } 3749 3750 void MultiTouchInputMapperTest::processDistance( 3751 MultiTouchInputMapper* mapper, int32_t distance) { 3752 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_DISTANCE, distance); 3753 } 3754 3755 void MultiTouchInputMapperTest::processId( 3756 MultiTouchInputMapper* mapper, int32_t id) { 3757 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_TRACKING_ID, id); 3758 } 3759 3760 void MultiTouchInputMapperTest::processSlot( 3761 MultiTouchInputMapper* mapper, int32_t slot) { 3762 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_SLOT, slot); 3763 } 3764 3765 void MultiTouchInputMapperTest::processToolType( 3766 MultiTouchInputMapper* mapper, int32_t toolType) { 3767 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_TOOL_TYPE, toolType); 3768 } 3769 3770 void MultiTouchInputMapperTest::processKey( 3771 MultiTouchInputMapper* mapper, int32_t code, int32_t value) { 3772 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, code, value); 3773 } 3774 3775 void MultiTouchInputMapperTest::processMTSync(MultiTouchInputMapper* mapper) { 3776 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_MT_REPORT, 0); 3777 } 3778 3779 void MultiTouchInputMapperTest::processSync(MultiTouchInputMapper* mapper) { 3780 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0); 3781 } 3782 3783 3784 TEST_F(MultiTouchInputMapperTest, Process_NormalMultiTouchGesture_WithoutTrackingIds) { 3785 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice); 3786 addConfigurationProperty("touch.deviceType", "touchScreen"); 3787 prepareDisplay(DISPLAY_ORIENTATION_0); 3788 prepareAxes(POSITION); 3789 prepareVirtualKeys(); 3790 addMapperAndConfigure(mapper); 3791 3792 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON); 3793 3794 NotifyMotionArgs motionArgs; 3795 3796 // Two fingers down at once. 3797 int32_t x1 = 100, y1 = 125, x2 = 300, y2 = 500; 3798 processPosition(mapper, x1, y1); 3799 processMTSync(mapper); 3800 processPosition(mapper, x2, y2); 3801 processMTSync(mapper); 3802 processSync(mapper); 3803 3804 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3805 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 3806 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 3807 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 3808 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 3809 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action); 3810 ASSERT_EQ(0, motionArgs.flags); 3811 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 3812 ASSERT_EQ(0, motionArgs.buttonState); 3813 ASSERT_EQ(0, motionArgs.edgeFlags); 3814 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 3815 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 3816 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 3817 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3818 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0, 0)); 3819 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 3820 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 3821 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 3822 3823 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3824 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 3825 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 3826 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 3827 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 3828 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_DOWN | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT), 3829 motionArgs.action); 3830 ASSERT_EQ(0, motionArgs.flags); 3831 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 3832 ASSERT_EQ(0, motionArgs.buttonState); 3833 ASSERT_EQ(0, motionArgs.edgeFlags); 3834 ASSERT_EQ(size_t(2), motionArgs.pointerCount); 3835 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 3836 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 3837 ASSERT_EQ(1, motionArgs.pointerProperties[1].id); 3838 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType); 3839 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3840 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0, 0)); 3841 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1], 3842 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0)); 3843 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 3844 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 3845 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 3846 3847 // Move. 3848 x1 += 10; y1 += 15; x2 += 5; y2 -= 10; 3849 processPosition(mapper, x1, y1); 3850 processMTSync(mapper); 3851 processPosition(mapper, x2, y2); 3852 processMTSync(mapper); 3853 processSync(mapper); 3854 3855 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3856 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 3857 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 3858 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 3859 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 3860 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3861 ASSERT_EQ(0, motionArgs.flags); 3862 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 3863 ASSERT_EQ(0, motionArgs.buttonState); 3864 ASSERT_EQ(0, motionArgs.edgeFlags); 3865 ASSERT_EQ(size_t(2), motionArgs.pointerCount); 3866 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 3867 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 3868 ASSERT_EQ(1, motionArgs.pointerProperties[1].id); 3869 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType); 3870 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3871 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0, 0)); 3872 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1], 3873 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0)); 3874 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 3875 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 3876 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 3877 3878 // First finger up. 3879 x2 += 15; y2 -= 20; 3880 processPosition(mapper, x2, y2); 3881 processMTSync(mapper); 3882 processSync(mapper); 3883 3884 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3885 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 3886 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 3887 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 3888 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 3889 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_UP | (0 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT), 3890 motionArgs.action); 3891 ASSERT_EQ(0, motionArgs.flags); 3892 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 3893 ASSERT_EQ(0, motionArgs.buttonState); 3894 ASSERT_EQ(0, motionArgs.edgeFlags); 3895 ASSERT_EQ(size_t(2), motionArgs.pointerCount); 3896 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 3897 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 3898 ASSERT_EQ(1, motionArgs.pointerProperties[1].id); 3899 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType); 3900 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3901 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0, 0)); 3902 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1], 3903 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0)); 3904 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 3905 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 3906 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 3907 3908 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3909 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 3910 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 3911 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 3912 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 3913 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3914 ASSERT_EQ(0, motionArgs.flags); 3915 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 3916 ASSERT_EQ(0, motionArgs.buttonState); 3917 ASSERT_EQ(0, motionArgs.edgeFlags); 3918 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 3919 ASSERT_EQ(1, motionArgs.pointerProperties[0].id); 3920 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 3921 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3922 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0)); 3923 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 3924 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 3925 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 3926 3927 // Move. 3928 x2 += 20; y2 -= 25; 3929 processPosition(mapper, x2, y2); 3930 processMTSync(mapper); 3931 processSync(mapper); 3932 3933 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3934 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 3935 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 3936 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 3937 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 3938 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 3939 ASSERT_EQ(0, motionArgs.flags); 3940 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 3941 ASSERT_EQ(0, motionArgs.buttonState); 3942 ASSERT_EQ(0, motionArgs.edgeFlags); 3943 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 3944 ASSERT_EQ(1, motionArgs.pointerProperties[0].id); 3945 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 3946 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3947 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0)); 3948 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 3949 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 3950 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 3951 3952 // New finger down. 3953 int32_t x3 = 700, y3 = 300; 3954 processPosition(mapper, x2, y2); 3955 processMTSync(mapper); 3956 processPosition(mapper, x3, y3); 3957 processMTSync(mapper); 3958 processSync(mapper); 3959 3960 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3961 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 3962 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 3963 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 3964 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 3965 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_DOWN | (0 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT), 3966 motionArgs.action); 3967 ASSERT_EQ(0, motionArgs.flags); 3968 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 3969 ASSERT_EQ(0, motionArgs.buttonState); 3970 ASSERT_EQ(0, motionArgs.edgeFlags); 3971 ASSERT_EQ(size_t(2), motionArgs.pointerCount); 3972 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 3973 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 3974 ASSERT_EQ(1, motionArgs.pointerProperties[1].id); 3975 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType); 3976 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 3977 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0, 0)); 3978 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1], 3979 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0)); 3980 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 3981 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 3982 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 3983 3984 // Second finger up. 3985 x3 += 30; y3 -= 20; 3986 processPosition(mapper, x3, y3); 3987 processMTSync(mapper); 3988 processSync(mapper); 3989 3990 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 3991 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 3992 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 3993 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 3994 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 3995 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_UP | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT), 3996 motionArgs.action); 3997 ASSERT_EQ(0, motionArgs.flags); 3998 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 3999 ASSERT_EQ(0, motionArgs.buttonState); 4000 ASSERT_EQ(0, motionArgs.edgeFlags); 4001 ASSERT_EQ(size_t(2), motionArgs.pointerCount); 4002 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 4003 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4004 ASSERT_EQ(1, motionArgs.pointerProperties[1].id); 4005 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType); 4006 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4007 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0, 0)); 4008 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1], 4009 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0)); 4010 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 4011 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 4012 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 4013 4014 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4015 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 4016 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 4017 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 4018 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 4019 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4020 ASSERT_EQ(0, motionArgs.flags); 4021 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 4022 ASSERT_EQ(0, motionArgs.buttonState); 4023 ASSERT_EQ(0, motionArgs.edgeFlags); 4024 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 4025 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 4026 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4027 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4028 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0, 0)); 4029 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 4030 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 4031 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 4032 4033 // Last finger up. 4034 processMTSync(mapper); 4035 processSync(mapper); 4036 4037 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4038 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime); 4039 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId); 4040 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source); 4041 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags); 4042 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action); 4043 ASSERT_EQ(0, motionArgs.flags); 4044 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState); 4045 ASSERT_EQ(0, motionArgs.buttonState); 4046 ASSERT_EQ(0, motionArgs.edgeFlags); 4047 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 4048 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 4049 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4050 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4051 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0, 0)); 4052 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON); 4053 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON); 4054 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime); 4055 4056 // Should not have sent any more keys or motions. 4057 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasNotCalled()); 4058 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled()); 4059 } 4060 4061 TEST_F(MultiTouchInputMapperTest, Process_NormalMultiTouchGesture_WithTrackingIds) { 4062 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice); 4063 addConfigurationProperty("touch.deviceType", "touchScreen"); 4064 prepareDisplay(DISPLAY_ORIENTATION_0); 4065 prepareAxes(POSITION | ID); 4066 prepareVirtualKeys(); 4067 addMapperAndConfigure(mapper); 4068 4069 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON); 4070 4071 NotifyMotionArgs motionArgs; 4072 4073 // Two fingers down at once. 4074 int32_t x1 = 100, y1 = 125, x2 = 300, y2 = 500; 4075 processPosition(mapper, x1, y1); 4076 processId(mapper, 1); 4077 processMTSync(mapper); 4078 processPosition(mapper, x2, y2); 4079 processId(mapper, 2); 4080 processMTSync(mapper); 4081 processSync(mapper); 4082 4083 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4084 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action); 4085 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 4086 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 4087 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4088 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4089 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0, 0)); 4090 4091 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4092 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_DOWN | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT), 4093 motionArgs.action); 4094 ASSERT_EQ(size_t(2), motionArgs.pointerCount); 4095 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 4096 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4097 ASSERT_EQ(1, motionArgs.pointerProperties[1].id); 4098 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType); 4099 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4100 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0, 0)); 4101 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1], 4102 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0)); 4103 4104 // Move. 4105 x1 += 10; y1 += 15; x2 += 5; y2 -= 10; 4106 processPosition(mapper, x1, y1); 4107 processId(mapper, 1); 4108 processMTSync(mapper); 4109 processPosition(mapper, x2, y2); 4110 processId(mapper, 2); 4111 processMTSync(mapper); 4112 processSync(mapper); 4113 4114 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4115 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4116 ASSERT_EQ(size_t(2), motionArgs.pointerCount); 4117 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 4118 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4119 ASSERT_EQ(1, motionArgs.pointerProperties[1].id); 4120 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType); 4121 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4122 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0, 0)); 4123 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1], 4124 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0)); 4125 4126 // First finger up. 4127 x2 += 15; y2 -= 20; 4128 processPosition(mapper, x2, y2); 4129 processId(mapper, 2); 4130 processMTSync(mapper); 4131 processSync(mapper); 4132 4133 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4134 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_UP | (0 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT), 4135 motionArgs.action); 4136 ASSERT_EQ(size_t(2), motionArgs.pointerCount); 4137 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 4138 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4139 ASSERT_EQ(1, motionArgs.pointerProperties[1].id); 4140 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType); 4141 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4142 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0, 0)); 4143 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1], 4144 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0)); 4145 4146 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4147 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4148 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 4149 ASSERT_EQ(1, motionArgs.pointerProperties[0].id); 4150 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4151 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4152 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0)); 4153 4154 // Move. 4155 x2 += 20; y2 -= 25; 4156 processPosition(mapper, x2, y2); 4157 processId(mapper, 2); 4158 processMTSync(mapper); 4159 processSync(mapper); 4160 4161 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4162 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4163 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 4164 ASSERT_EQ(1, motionArgs.pointerProperties[0].id); 4165 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4166 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4167 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0)); 4168 4169 // New finger down. 4170 int32_t x3 = 700, y3 = 300; 4171 processPosition(mapper, x2, y2); 4172 processId(mapper, 2); 4173 processMTSync(mapper); 4174 processPosition(mapper, x3, y3); 4175 processId(mapper, 3); 4176 processMTSync(mapper); 4177 processSync(mapper); 4178 4179 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4180 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_DOWN | (0 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT), 4181 motionArgs.action); 4182 ASSERT_EQ(size_t(2), motionArgs.pointerCount); 4183 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 4184 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4185 ASSERT_EQ(1, motionArgs.pointerProperties[1].id); 4186 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType); 4187 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4188 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0, 0)); 4189 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1], 4190 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0)); 4191 4192 // Second finger up. 4193 x3 += 30; y3 -= 20; 4194 processPosition(mapper, x3, y3); 4195 processId(mapper, 3); 4196 processMTSync(mapper); 4197 processSync(mapper); 4198 4199 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4200 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_UP | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT), 4201 motionArgs.action); 4202 ASSERT_EQ(size_t(2), motionArgs.pointerCount); 4203 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 4204 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4205 ASSERT_EQ(1, motionArgs.pointerProperties[1].id); 4206 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType); 4207 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4208 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0, 0)); 4209 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1], 4210 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0)); 4211 4212 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4213 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4214 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 4215 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 4216 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4217 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4218 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0, 0)); 4219 4220 // Last finger up. 4221 processMTSync(mapper); 4222 processSync(mapper); 4223 4224 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4225 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action); 4226 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 4227 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 4228 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4229 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4230 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0, 0)); 4231 4232 // Should not have sent any more keys or motions. 4233 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasNotCalled()); 4234 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled()); 4235 } 4236 4237 TEST_F(MultiTouchInputMapperTest, Process_NormalMultiTouchGesture_WithSlots) { 4238 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice); 4239 addConfigurationProperty("touch.deviceType", "touchScreen"); 4240 prepareDisplay(DISPLAY_ORIENTATION_0); 4241 prepareAxes(POSITION | ID | SLOT); 4242 prepareVirtualKeys(); 4243 addMapperAndConfigure(mapper); 4244 4245 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON); 4246 4247 NotifyMotionArgs motionArgs; 4248 4249 // Two fingers down at once. 4250 int32_t x1 = 100, y1 = 125, x2 = 300, y2 = 500; 4251 processPosition(mapper, x1, y1); 4252 processId(mapper, 1); 4253 processSlot(mapper, 1); 4254 processPosition(mapper, x2, y2); 4255 processId(mapper, 2); 4256 processSync(mapper); 4257 4258 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4259 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action); 4260 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 4261 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 4262 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4263 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4264 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0, 0)); 4265 4266 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4267 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_DOWN | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT), 4268 motionArgs.action); 4269 ASSERT_EQ(size_t(2), motionArgs.pointerCount); 4270 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 4271 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4272 ASSERT_EQ(1, motionArgs.pointerProperties[1].id); 4273 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType); 4274 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4275 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0, 0)); 4276 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1], 4277 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0)); 4278 4279 // Move. 4280 x1 += 10; y1 += 15; x2 += 5; y2 -= 10; 4281 processSlot(mapper, 0); 4282 processPosition(mapper, x1, y1); 4283 processSlot(mapper, 1); 4284 processPosition(mapper, x2, y2); 4285 processSync(mapper); 4286 4287 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4288 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4289 ASSERT_EQ(size_t(2), motionArgs.pointerCount); 4290 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 4291 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4292 ASSERT_EQ(1, motionArgs.pointerProperties[1].id); 4293 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType); 4294 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4295 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0, 0)); 4296 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1], 4297 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0)); 4298 4299 // First finger up. 4300 x2 += 15; y2 -= 20; 4301 processSlot(mapper, 0); 4302 processId(mapper, -1); 4303 processSlot(mapper, 1); 4304 processPosition(mapper, x2, y2); 4305 processSync(mapper); 4306 4307 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4308 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_UP | (0 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT), 4309 motionArgs.action); 4310 ASSERT_EQ(size_t(2), motionArgs.pointerCount); 4311 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 4312 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4313 ASSERT_EQ(1, motionArgs.pointerProperties[1].id); 4314 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType); 4315 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4316 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0, 0)); 4317 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1], 4318 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0)); 4319 4320 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4321 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4322 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 4323 ASSERT_EQ(1, motionArgs.pointerProperties[0].id); 4324 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4325 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4326 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0)); 4327 4328 // Move. 4329 x2 += 20; y2 -= 25; 4330 processPosition(mapper, x2, y2); 4331 processSync(mapper); 4332 4333 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4334 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4335 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 4336 ASSERT_EQ(1, motionArgs.pointerProperties[0].id); 4337 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4338 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4339 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0)); 4340 4341 // New finger down. 4342 int32_t x3 = 700, y3 = 300; 4343 processPosition(mapper, x2, y2); 4344 processSlot(mapper, 0); 4345 processId(mapper, 3); 4346 processPosition(mapper, x3, y3); 4347 processSync(mapper); 4348 4349 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4350 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_DOWN | (0 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT), 4351 motionArgs.action); 4352 ASSERT_EQ(size_t(2), motionArgs.pointerCount); 4353 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 4354 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4355 ASSERT_EQ(1, motionArgs.pointerProperties[1].id); 4356 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType); 4357 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4358 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0, 0)); 4359 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1], 4360 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0)); 4361 4362 // Second finger up. 4363 x3 += 30; y3 -= 20; 4364 processSlot(mapper, 1); 4365 processId(mapper, -1); 4366 processSlot(mapper, 0); 4367 processPosition(mapper, x3, y3); 4368 processSync(mapper); 4369 4370 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4371 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_UP | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT), 4372 motionArgs.action); 4373 ASSERT_EQ(size_t(2), motionArgs.pointerCount); 4374 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 4375 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4376 ASSERT_EQ(1, motionArgs.pointerProperties[1].id); 4377 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType); 4378 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4379 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0, 0)); 4380 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1], 4381 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0)); 4382 4383 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4384 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4385 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 4386 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 4387 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4388 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4389 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0, 0)); 4390 4391 // Last finger up. 4392 processId(mapper, -1); 4393 processSync(mapper); 4394 4395 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4396 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action); 4397 ASSERT_EQ(size_t(1), motionArgs.pointerCount); 4398 ASSERT_EQ(0, motionArgs.pointerProperties[0].id); 4399 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4400 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4401 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0, 0)); 4402 4403 // Should not have sent any more keys or motions. 4404 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasNotCalled()); 4405 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled()); 4406 } 4407 4408 TEST_F(MultiTouchInputMapperTest, Process_AllAxes_WithDefaultCalibration) { 4409 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice); 4410 addConfigurationProperty("touch.deviceType", "touchScreen"); 4411 prepareDisplay(DISPLAY_ORIENTATION_0); 4412 prepareAxes(POSITION | TOUCH | TOOL | PRESSURE | ORIENTATION | ID | MINOR | DISTANCE); 4413 addMapperAndConfigure(mapper); 4414 4415 // These calculations are based on the input device calibration documentation. 4416 int32_t rawX = 100; 4417 int32_t rawY = 200; 4418 int32_t rawTouchMajor = 7; 4419 int32_t rawTouchMinor = 6; 4420 int32_t rawToolMajor = 9; 4421 int32_t rawToolMinor = 8; 4422 int32_t rawPressure = 11; 4423 int32_t rawDistance = 0; 4424 int32_t rawOrientation = 3; 4425 int32_t id = 5; 4426 4427 float x = toDisplayX(rawX); 4428 float y = toDisplayY(rawY); 4429 float pressure = float(rawPressure) / RAW_PRESSURE_MAX; 4430 float size = avg(rawTouchMajor, rawTouchMinor) / RAW_TOUCH_MAX; 4431 float toolMajor = float(rawToolMajor) * GEOMETRIC_SCALE; 4432 float toolMinor = float(rawToolMinor) * GEOMETRIC_SCALE; 4433 float touchMajor = float(rawTouchMajor) * GEOMETRIC_SCALE; 4434 float touchMinor = float(rawTouchMinor) * GEOMETRIC_SCALE; 4435 float orientation = float(rawOrientation) / RAW_ORIENTATION_MAX * M_PI_2; 4436 float distance = float(rawDistance); 4437 4438 processPosition(mapper, rawX, rawY); 4439 processTouchMajor(mapper, rawTouchMajor); 4440 processTouchMinor(mapper, rawTouchMinor); 4441 processToolMajor(mapper, rawToolMajor); 4442 processToolMinor(mapper, rawToolMinor); 4443 processPressure(mapper, rawPressure); 4444 processOrientation(mapper, rawOrientation); 4445 processDistance(mapper, rawDistance); 4446 processId(mapper, id); 4447 processMTSync(mapper); 4448 processSync(mapper); 4449 4450 NotifyMotionArgs args; 4451 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args)); 4452 ASSERT_EQ(0, args.pointerProperties[0].id); 4453 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 4454 x, y, pressure, size, touchMajor, touchMinor, toolMajor, toolMinor, 4455 orientation, distance)); 4456 } 4457 4458 TEST_F(MultiTouchInputMapperTest, Process_TouchAndToolAxes_GeometricCalibration) { 4459 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice); 4460 addConfigurationProperty("touch.deviceType", "touchScreen"); 4461 prepareDisplay(DISPLAY_ORIENTATION_0); 4462 prepareAxes(POSITION | TOUCH | TOOL | MINOR); 4463 addConfigurationProperty("touch.size.calibration", "geometric"); 4464 addMapperAndConfigure(mapper); 4465 4466 // These calculations are based on the input device calibration documentation. 4467 int32_t rawX = 100; 4468 int32_t rawY = 200; 4469 int32_t rawTouchMajor = 140; 4470 int32_t rawTouchMinor = 120; 4471 int32_t rawToolMajor = 180; 4472 int32_t rawToolMinor = 160; 4473 4474 float x = toDisplayX(rawX); 4475 float y = toDisplayY(rawY); 4476 float size = avg(rawTouchMajor, rawTouchMinor) / RAW_TOUCH_MAX; 4477 float toolMajor = float(rawToolMajor) * GEOMETRIC_SCALE; 4478 float toolMinor = float(rawToolMinor) * GEOMETRIC_SCALE; 4479 float touchMajor = float(rawTouchMajor) * GEOMETRIC_SCALE; 4480 float touchMinor = float(rawTouchMinor) * GEOMETRIC_SCALE; 4481 4482 processPosition(mapper, rawX, rawY); 4483 processTouchMajor(mapper, rawTouchMajor); 4484 processTouchMinor(mapper, rawTouchMinor); 4485 processToolMajor(mapper, rawToolMajor); 4486 processToolMinor(mapper, rawToolMinor); 4487 processMTSync(mapper); 4488 processSync(mapper); 4489 4490 NotifyMotionArgs args; 4491 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args)); 4492 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 4493 x, y, 1.0f, size, touchMajor, touchMinor, toolMajor, toolMinor, 0, 0)); 4494 } 4495 4496 TEST_F(MultiTouchInputMapperTest, Process_TouchAndToolAxes_SummedLinearCalibration) { 4497 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice); 4498 addConfigurationProperty("touch.deviceType", "touchScreen"); 4499 prepareDisplay(DISPLAY_ORIENTATION_0); 4500 prepareAxes(POSITION | TOUCH | TOOL); 4501 addConfigurationProperty("touch.size.calibration", "diameter"); 4502 addConfigurationProperty("touch.size.scale", "10"); 4503 addConfigurationProperty("touch.size.bias", "160"); 4504 addConfigurationProperty("touch.size.isSummed", "1"); 4505 addMapperAndConfigure(mapper); 4506 4507 // These calculations are based on the input device calibration documentation. 4508 // Note: We only provide a single common touch/tool value because the device is assumed 4509 // not to emit separate values for each pointer (isSummed = 1). 4510 int32_t rawX = 100; 4511 int32_t rawY = 200; 4512 int32_t rawX2 = 150; 4513 int32_t rawY2 = 250; 4514 int32_t rawTouchMajor = 5; 4515 int32_t rawToolMajor = 8; 4516 4517 float x = toDisplayX(rawX); 4518 float y = toDisplayY(rawY); 4519 float x2 = toDisplayX(rawX2); 4520 float y2 = toDisplayY(rawY2); 4521 float size = float(rawTouchMajor) / 2 / RAW_TOUCH_MAX; 4522 float touch = float(rawTouchMajor) / 2 * 10.0f + 160.0f; 4523 float tool = float(rawToolMajor) / 2 * 10.0f + 160.0f; 4524 4525 processPosition(mapper, rawX, rawY); 4526 processTouchMajor(mapper, rawTouchMajor); 4527 processToolMajor(mapper, rawToolMajor); 4528 processMTSync(mapper); 4529 processPosition(mapper, rawX2, rawY2); 4530 processTouchMajor(mapper, rawTouchMajor); 4531 processToolMajor(mapper, rawToolMajor); 4532 processMTSync(mapper); 4533 processSync(mapper); 4534 4535 NotifyMotionArgs args; 4536 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args)); 4537 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action); 4538 4539 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args)); 4540 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_DOWN | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT), 4541 args.action); 4542 ASSERT_EQ(size_t(2), args.pointerCount); 4543 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 4544 x, y, 1.0f, size, touch, touch, tool, tool, 0, 0)); 4545 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[1], 4546 x2, y2, 1.0f, size, touch, touch, tool, tool, 0, 0)); 4547 } 4548 4549 TEST_F(MultiTouchInputMapperTest, Process_TouchAndToolAxes_AreaCalibration) { 4550 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice); 4551 addConfigurationProperty("touch.deviceType", "touchScreen"); 4552 prepareDisplay(DISPLAY_ORIENTATION_0); 4553 prepareAxes(POSITION | TOUCH | TOOL); 4554 addConfigurationProperty("touch.size.calibration", "area"); 4555 addConfigurationProperty("touch.size.scale", "43"); 4556 addConfigurationProperty("touch.size.bias", "3"); 4557 addMapperAndConfigure(mapper); 4558 4559 // These calculations are based on the input device calibration documentation. 4560 int32_t rawX = 100; 4561 int32_t rawY = 200; 4562 int32_t rawTouchMajor = 5; 4563 int32_t rawToolMajor = 8; 4564 4565 float x = toDisplayX(rawX); 4566 float y = toDisplayY(rawY); 4567 float size = float(rawTouchMajor) / RAW_TOUCH_MAX; 4568 float touch = sqrtf(rawTouchMajor) * 43.0f + 3.0f; 4569 float tool = sqrtf(rawToolMajor) * 43.0f + 3.0f; 4570 4571 processPosition(mapper, rawX, rawY); 4572 processTouchMajor(mapper, rawTouchMajor); 4573 processToolMajor(mapper, rawToolMajor); 4574 processMTSync(mapper); 4575 processSync(mapper); 4576 4577 NotifyMotionArgs args; 4578 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args)); 4579 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 4580 x, y, 1.0f, size, touch, touch, tool, tool, 0, 0)); 4581 } 4582 4583 TEST_F(MultiTouchInputMapperTest, Process_PressureAxis_AmplitudeCalibration) { 4584 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice); 4585 addConfigurationProperty("touch.deviceType", "touchScreen"); 4586 prepareDisplay(DISPLAY_ORIENTATION_0); 4587 prepareAxes(POSITION | PRESSURE); 4588 addConfigurationProperty("touch.pressure.calibration", "amplitude"); 4589 addConfigurationProperty("touch.pressure.scale", "0.01"); 4590 addMapperAndConfigure(mapper); 4591 4592 // These calculations are based on the input device calibration documentation. 4593 int32_t rawX = 100; 4594 int32_t rawY = 200; 4595 int32_t rawPressure = 60; 4596 4597 float x = toDisplayX(rawX); 4598 float y = toDisplayY(rawY); 4599 float pressure = float(rawPressure) * 0.01f; 4600 4601 processPosition(mapper, rawX, rawY); 4602 processPressure(mapper, rawPressure); 4603 processMTSync(mapper); 4604 processSync(mapper); 4605 4606 NotifyMotionArgs args; 4607 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args)); 4608 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 4609 x, y, pressure, 0, 0, 0, 0, 0, 0, 0)); 4610 } 4611 4612 TEST_F(MultiTouchInputMapperTest, Process_ShouldHandleAllButtons) { 4613 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice); 4614 addConfigurationProperty("touch.deviceType", "touchScreen"); 4615 prepareDisplay(DISPLAY_ORIENTATION_0); 4616 prepareAxes(POSITION | ID | SLOT); 4617 addMapperAndConfigure(mapper); 4618 4619 NotifyMotionArgs motionArgs; 4620 NotifyKeyArgs keyArgs; 4621 4622 processId(mapper, 1); 4623 processPosition(mapper, 100, 200); 4624 processSync(mapper); 4625 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4626 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action); 4627 ASSERT_EQ(0, motionArgs.buttonState); 4628 4629 // press BTN_LEFT, release BTN_LEFT 4630 processKey(mapper, BTN_LEFT, 1); 4631 processSync(mapper); 4632 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4633 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4634 ASSERT_EQ(AMOTION_EVENT_BUTTON_PRIMARY, motionArgs.buttonState); 4635 4636 processKey(mapper, BTN_LEFT, 0); 4637 processSync(mapper); 4638 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4639 ASSERT_EQ(0, motionArgs.buttonState); 4640 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4641 4642 // press BTN_RIGHT + BTN_MIDDLE, release BTN_RIGHT, release BTN_MIDDLE 4643 processKey(mapper, BTN_RIGHT, 1); 4644 processKey(mapper, BTN_MIDDLE, 1); 4645 processSync(mapper); 4646 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4647 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4648 ASSERT_EQ(AMOTION_EVENT_BUTTON_SECONDARY | AMOTION_EVENT_BUTTON_TERTIARY, 4649 motionArgs.buttonState); 4650 4651 processKey(mapper, BTN_RIGHT, 0); 4652 processSync(mapper); 4653 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4654 ASSERT_EQ(AMOTION_EVENT_BUTTON_TERTIARY, motionArgs.buttonState); 4655 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4656 4657 processKey(mapper, BTN_MIDDLE, 0); 4658 processSync(mapper); 4659 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4660 ASSERT_EQ(0, motionArgs.buttonState); 4661 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4662 4663 // press BTN_BACK, release BTN_BACK 4664 processKey(mapper, BTN_BACK, 1); 4665 processSync(mapper); 4666 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs)); 4667 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action); 4668 ASSERT_EQ(AKEYCODE_BACK, keyArgs.keyCode); 4669 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4670 ASSERT_EQ(AMOTION_EVENT_BUTTON_BACK, motionArgs.buttonState); 4671 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4672 4673 processKey(mapper, BTN_BACK, 0); 4674 processSync(mapper); 4675 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4676 ASSERT_EQ(0, motionArgs.buttonState); 4677 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4678 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs)); 4679 ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action); 4680 ASSERT_EQ(AKEYCODE_BACK, keyArgs.keyCode); 4681 4682 // press BTN_SIDE, release BTN_SIDE 4683 processKey(mapper, BTN_SIDE, 1); 4684 processSync(mapper); 4685 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs)); 4686 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action); 4687 ASSERT_EQ(AKEYCODE_BACK, keyArgs.keyCode); 4688 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4689 ASSERT_EQ(AMOTION_EVENT_BUTTON_BACK, motionArgs.buttonState); 4690 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4691 4692 processKey(mapper, BTN_SIDE, 0); 4693 processSync(mapper); 4694 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4695 ASSERT_EQ(0, motionArgs.buttonState); 4696 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4697 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs)); 4698 ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action); 4699 ASSERT_EQ(AKEYCODE_BACK, keyArgs.keyCode); 4700 4701 // press BTN_FORWARD, release BTN_FORWARD 4702 processKey(mapper, BTN_FORWARD, 1); 4703 processSync(mapper); 4704 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs)); 4705 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action); 4706 ASSERT_EQ(AKEYCODE_FORWARD, keyArgs.keyCode); 4707 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4708 ASSERT_EQ(AMOTION_EVENT_BUTTON_FORWARD, motionArgs.buttonState); 4709 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4710 4711 processKey(mapper, BTN_FORWARD, 0); 4712 processSync(mapper); 4713 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4714 ASSERT_EQ(0, motionArgs.buttonState); 4715 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4716 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs)); 4717 ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action); 4718 ASSERT_EQ(AKEYCODE_FORWARD, keyArgs.keyCode); 4719 4720 // press BTN_EXTRA, release BTN_EXTRA 4721 processKey(mapper, BTN_EXTRA, 1); 4722 processSync(mapper); 4723 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs)); 4724 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action); 4725 ASSERT_EQ(AKEYCODE_FORWARD, keyArgs.keyCode); 4726 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4727 ASSERT_EQ(AMOTION_EVENT_BUTTON_FORWARD, motionArgs.buttonState); 4728 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4729 4730 processKey(mapper, BTN_EXTRA, 0); 4731 processSync(mapper); 4732 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4733 ASSERT_EQ(0, motionArgs.buttonState); 4734 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4735 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs)); 4736 ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action); 4737 ASSERT_EQ(AKEYCODE_FORWARD, keyArgs.keyCode); 4738 4739 // press BTN_STYLUS, release BTN_STYLUS 4740 processKey(mapper, BTN_STYLUS, 1); 4741 processSync(mapper); 4742 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4743 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4744 ASSERT_EQ(AMOTION_EVENT_BUTTON_SECONDARY, motionArgs.buttonState); 4745 4746 processKey(mapper, BTN_STYLUS, 0); 4747 processSync(mapper); 4748 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4749 ASSERT_EQ(0, motionArgs.buttonState); 4750 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4751 4752 // press BTN_STYLUS2, release BTN_STYLUS2 4753 processKey(mapper, BTN_STYLUS2, 1); 4754 processSync(mapper); 4755 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4756 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4757 ASSERT_EQ(AMOTION_EVENT_BUTTON_TERTIARY, motionArgs.buttonState); 4758 4759 processKey(mapper, BTN_STYLUS2, 0); 4760 processSync(mapper); 4761 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4762 ASSERT_EQ(0, motionArgs.buttonState); 4763 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4764 4765 // release touch 4766 processId(mapper, -1); 4767 processSync(mapper); 4768 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4769 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action); 4770 ASSERT_EQ(0, motionArgs.buttonState); 4771 } 4772 4773 TEST_F(MultiTouchInputMapperTest, Process_ShouldHandleAllToolTypes) { 4774 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice); 4775 addConfigurationProperty("touch.deviceType", "touchScreen"); 4776 prepareDisplay(DISPLAY_ORIENTATION_0); 4777 prepareAxes(POSITION | ID | SLOT | TOOL_TYPE); 4778 addMapperAndConfigure(mapper); 4779 4780 NotifyMotionArgs motionArgs; 4781 4782 // default tool type is finger 4783 processId(mapper, 1); 4784 processPosition(mapper, 100, 200); 4785 processSync(mapper); 4786 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4787 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action); 4788 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4789 4790 // eraser 4791 processKey(mapper, BTN_TOOL_RUBBER, 1); 4792 processSync(mapper); 4793 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4794 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4795 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_ERASER, motionArgs.pointerProperties[0].toolType); 4796 4797 // stylus 4798 processKey(mapper, BTN_TOOL_RUBBER, 0); 4799 processKey(mapper, BTN_TOOL_PEN, 1); 4800 processSync(mapper); 4801 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4802 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4803 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_STYLUS, motionArgs.pointerProperties[0].toolType); 4804 4805 // brush 4806 processKey(mapper, BTN_TOOL_PEN, 0); 4807 processKey(mapper, BTN_TOOL_BRUSH, 1); 4808 processSync(mapper); 4809 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4810 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4811 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_STYLUS, motionArgs.pointerProperties[0].toolType); 4812 4813 // pencil 4814 processKey(mapper, BTN_TOOL_BRUSH, 0); 4815 processKey(mapper, BTN_TOOL_PENCIL, 1); 4816 processSync(mapper); 4817 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4818 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4819 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_STYLUS, motionArgs.pointerProperties[0].toolType); 4820 4821 // airbrush 4822 processKey(mapper, BTN_TOOL_PENCIL, 0); 4823 processKey(mapper, BTN_TOOL_AIRBRUSH, 1); 4824 processSync(mapper); 4825 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4826 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4827 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_STYLUS, motionArgs.pointerProperties[0].toolType); 4828 4829 // mouse 4830 processKey(mapper, BTN_TOOL_AIRBRUSH, 0); 4831 processKey(mapper, BTN_TOOL_MOUSE, 1); 4832 processSync(mapper); 4833 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4834 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4835 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_MOUSE, motionArgs.pointerProperties[0].toolType); 4836 4837 // lens 4838 processKey(mapper, BTN_TOOL_MOUSE, 0); 4839 processKey(mapper, BTN_TOOL_LENS, 1); 4840 processSync(mapper); 4841 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4842 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4843 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_MOUSE, motionArgs.pointerProperties[0].toolType); 4844 4845 // double-tap 4846 processKey(mapper, BTN_TOOL_LENS, 0); 4847 processKey(mapper, BTN_TOOL_DOUBLETAP, 1); 4848 processSync(mapper); 4849 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4850 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4851 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4852 4853 // triple-tap 4854 processKey(mapper, BTN_TOOL_DOUBLETAP, 0); 4855 processKey(mapper, BTN_TOOL_TRIPLETAP, 1); 4856 processSync(mapper); 4857 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4858 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4859 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4860 4861 // quad-tap 4862 processKey(mapper, BTN_TOOL_TRIPLETAP, 0); 4863 processKey(mapper, BTN_TOOL_QUADTAP, 1); 4864 processSync(mapper); 4865 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4866 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4867 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4868 4869 // finger 4870 processKey(mapper, BTN_TOOL_QUADTAP, 0); 4871 processKey(mapper, BTN_TOOL_FINGER, 1); 4872 processSync(mapper); 4873 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4874 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4875 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4876 4877 // stylus trumps finger 4878 processKey(mapper, BTN_TOOL_PEN, 1); 4879 processSync(mapper); 4880 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4881 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4882 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_STYLUS, motionArgs.pointerProperties[0].toolType); 4883 4884 // eraser trumps stylus 4885 processKey(mapper, BTN_TOOL_RUBBER, 1); 4886 processSync(mapper); 4887 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4888 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4889 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_ERASER, motionArgs.pointerProperties[0].toolType); 4890 4891 // mouse trumps eraser 4892 processKey(mapper, BTN_TOOL_MOUSE, 1); 4893 processSync(mapper); 4894 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4895 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4896 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_MOUSE, motionArgs.pointerProperties[0].toolType); 4897 4898 // MT tool type trumps BTN tool types: MT_TOOL_FINGER 4899 processToolType(mapper, MT_TOOL_FINGER); // this is the first time we send MT_TOOL_TYPE 4900 processSync(mapper); 4901 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4902 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4903 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4904 4905 // MT tool type trumps BTN tool types: MT_TOOL_PEN 4906 processToolType(mapper, MT_TOOL_PEN); 4907 processSync(mapper); 4908 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4909 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4910 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_STYLUS, motionArgs.pointerProperties[0].toolType); 4911 4912 // back to default tool type 4913 processToolType(mapper, -1); // use a deliberately undefined tool type, for testing 4914 processKey(mapper, BTN_TOOL_MOUSE, 0); 4915 processKey(mapper, BTN_TOOL_RUBBER, 0); 4916 processKey(mapper, BTN_TOOL_PEN, 0); 4917 processKey(mapper, BTN_TOOL_FINGER, 0); 4918 processSync(mapper); 4919 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4920 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action); 4921 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType); 4922 } 4923 4924 TEST_F(MultiTouchInputMapperTest, Process_WhenBtnTouchPresent_HoversIfItsValueIsZero) { 4925 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice); 4926 addConfigurationProperty("touch.deviceType", "touchScreen"); 4927 prepareDisplay(DISPLAY_ORIENTATION_0); 4928 prepareAxes(POSITION | ID | SLOT); 4929 mFakeEventHub->addKey(DEVICE_ID, BTN_TOUCH, 0, AKEYCODE_UNKNOWN, 0); 4930 addMapperAndConfigure(mapper); 4931 4932 NotifyMotionArgs motionArgs; 4933 4934 // initially hovering because BTN_TOUCH not sent yet, pressure defaults to 0 4935 processId(mapper, 1); 4936 processPosition(mapper, 100, 200); 4937 processSync(mapper); 4938 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4939 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_ENTER, motionArgs.action); 4940 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4941 toDisplayX(100), toDisplayY(200), 0, 0, 0, 0, 0, 0, 0, 0)); 4942 4943 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4944 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action); 4945 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4946 toDisplayX(100), toDisplayY(200), 0, 0, 0, 0, 0, 0, 0, 0)); 4947 4948 // move a little 4949 processPosition(mapper, 150, 250); 4950 processSync(mapper); 4951 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4952 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action); 4953 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4954 toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0)); 4955 4956 // down when BTN_TOUCH is pressed, pressure defaults to 1 4957 processKey(mapper, BTN_TOUCH, 1); 4958 processSync(mapper); 4959 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4960 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_EXIT, motionArgs.action); 4961 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4962 toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0)); 4963 4964 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4965 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action); 4966 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4967 toDisplayX(150), toDisplayY(250), 1, 0, 0, 0, 0, 0, 0, 0)); 4968 4969 // up when BTN_TOUCH is released, hover restored 4970 processKey(mapper, BTN_TOUCH, 0); 4971 processSync(mapper); 4972 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4973 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action); 4974 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4975 toDisplayX(150), toDisplayY(250), 1, 0, 0, 0, 0, 0, 0, 0)); 4976 4977 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4978 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_ENTER, motionArgs.action); 4979 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4980 toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0)); 4981 4982 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4983 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action); 4984 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4985 toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0)); 4986 4987 // exit hover when pointer goes away 4988 processId(mapper, -1); 4989 processSync(mapper); 4990 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 4991 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_EXIT, motionArgs.action); 4992 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 4993 toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0)); 4994 } 4995 4996 TEST_F(MultiTouchInputMapperTest, Process_WhenAbsMTPressureIsPresent_HoversIfItsValueIsZero) { 4997 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice); 4998 addConfigurationProperty("touch.deviceType", "touchScreen"); 4999 prepareDisplay(DISPLAY_ORIENTATION_0); 5000 prepareAxes(POSITION | ID | SLOT | PRESSURE); 5001 addMapperAndConfigure(mapper); 5002 5003 NotifyMotionArgs motionArgs; 5004 5005 // initially hovering because pressure is 0 5006 processId(mapper, 1); 5007 processPosition(mapper, 100, 200); 5008 processPressure(mapper, 0); 5009 processSync(mapper); 5010 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 5011 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_ENTER, motionArgs.action); 5012 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 5013 toDisplayX(100), toDisplayY(200), 0, 0, 0, 0, 0, 0, 0, 0)); 5014 5015 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 5016 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action); 5017 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 5018 toDisplayX(100), toDisplayY(200), 0, 0, 0, 0, 0, 0, 0, 0)); 5019 5020 // move a little 5021 processPosition(mapper, 150, 250); 5022 processSync(mapper); 5023 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 5024 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action); 5025 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 5026 toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0)); 5027 5028 // down when pressure becomes non-zero 5029 processPressure(mapper, RAW_PRESSURE_MAX); 5030 processSync(mapper); 5031 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 5032 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_EXIT, motionArgs.action); 5033 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 5034 toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0)); 5035 5036 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 5037 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action); 5038 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 5039 toDisplayX(150), toDisplayY(250), 1, 0, 0, 0, 0, 0, 0, 0)); 5040 5041 // up when pressure becomes 0, hover restored 5042 processPressure(mapper, 0); 5043 processSync(mapper); 5044 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 5045 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action); 5046 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 5047 toDisplayX(150), toDisplayY(250), 1, 0, 0, 0, 0, 0, 0, 0)); 5048 5049 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 5050 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_ENTER, motionArgs.action); 5051 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 5052 toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0)); 5053 5054 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 5055 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action); 5056 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 5057 toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0)); 5058 5059 // exit hover when pointer goes away 5060 processId(mapper, -1); 5061 processSync(mapper); 5062 ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs)); 5063 ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_EXIT, motionArgs.action); 5064 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], 5065 toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0)); 5066 } 5067 5068 5069 } // namespace android 5070