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