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