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