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