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