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