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