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