services/inputflinger/tests/InputReader_test.cpp

   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
  23 namespace android {
  24
  25 // An arbitrary time value.
  26 static const nsecs_t ARBITRARY_TIME = 1234;
  27
  28 // Arbitrary display properties.
  29 static const int32_t DISPLAY_ID = 0;
  30 static const int32_t DISPLAY_WIDTH = 480;
  31 static const int32_t DISPLAY_HEIGHT = 800;
  32
  33 // Error tolerance for floating point assertions.
  34 static const float EPSILON = 0.001f;
  35
  36 template<typename T>
  37 static inline T min(T a, T b) {
  38     return a < b ? a : b;
  39 }
  40
  41 static inline float avg(float x, float y) {
  42     return (x + y) / 2;
  43 }
  44
  45
  46 // --- FakePointerController ---
  47
  48 class FakePointerController : public PointerControllerInterface {
  49     bool mHaveBounds;
  50     float mMinX, mMinY, mMaxX, mMaxY;
  51     float mX, mY;
  52     int32_t mButtonState;
  53
  54 protected:
  55     virtual ~FakePointerController() { }
  56
  57 public:
  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
  89 private:
  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
 126 class FakeInputReaderPolicy : public InputReaderPolicyInterface {
 127     InputReaderConfiguration mConfig;
 128     KeyedVector<int32_t, sp<FakePointerController> > mPointerControllers;
 129     Vector<InputDeviceInfo> mInputDevices;
 130     TouchAffineTransformation transform;
 131
 132 protected:
 133     virtual ~FakeInputReaderPolicy() { }
 134
 135 public:
 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
 185 private:
 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
 210 class FakeInputListener : public InputListenerInterface {
 211 private:
 212     List<NotifyConfigurationChangedArgs> mNotifyConfigurationChangedArgsQueue;
 213     List<NotifyDeviceResetArgs> mNotifyDeviceResetArgsQueue;
 214     List<NotifyKeyArgs> mNotifyKeyArgsQueue;
 215     List<NotifyMotionArgs> mNotifyMotionArgsQueue;
 216     List<NotifySwitchArgs> mNotifySwitchArgsQueue;
 217
 218 protected:
 219     virtual ~FakeInputListener() { }
 220
 221 public:
 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
 282 private:
 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
 307 class 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
 337 protected:
 338     virtual ~FakeEventHub() {
 339         for (size_t i = 0; i < mDevices.size(); i++) {
 340             delete mDevices.valueAt(i);
 341         }
 342     }
 343
 344 public:
 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
 468 private:
 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
 719 class 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
 727 public:
 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
 747 private:
 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
 797 class 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
 811 public:
 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
 866 private:
 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
 932 class InstrumentedInputReader : public InputReader {
 933     InputDevice* mNextDevice;
 934
 935 public:
 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
 962 protected:
 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
 979 class InputReaderTest : public testing::Test {
 980 protected:
 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
1027 TEST_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
1053 TEST_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
1080 TEST_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
1107 TEST_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
1134 TEST_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
1169 TEST_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
1178 TEST_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
1199 class InputDeviceTest : public testing::Test {
1200 protected:
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
1237 const char* InputDeviceTest::DEVICE_NAME = "device";
1238 const int32_t InputDeviceTest::DEVICE_ID = 1;
1239 const int32_t InputDeviceTest::DEVICE_GENERATION = 2;
1240 const int32_t InputDeviceTest::DEVICE_CONTROLLER_NUMBER = 0;
1241 const uint32_t InputDeviceTest::DEVICE_CLASSES = INPUT_DEVICE_CLASS_KEYBOARD
1242         | INPUT_DEVICE_CLASS_TOUCH | INPUT_DEVICE_CLASS_JOYSTICK;
1243
1244 TEST_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
1250 TEST_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
1292 TEST_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
1389 class InputMapperTest : public testing::Test {
1390 protected:
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
1488 const char* InputMapperTest::DEVICE_NAME = "device";
1489 const int32_t InputMapperTest::DEVICE_ID = 1;
1490 const int32_t InputMapperTest::DEVICE_GENERATION = 2;
1491 const int32_t InputMapperTest::DEVICE_CONTROLLER_NUMBER = 0;
1492 const uint32_t InputMapperTest::DEVICE_CLASSES = 0; // not needed for current tests
1493
1494
1495 // --- SwitchInputMapperTest ---
1496
1497 class SwitchInputMapperTest : public InputMapperTest {
1498 protected:
1499 };
1500
1501 TEST_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
1508 TEST_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
1519 TEST_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
1540 class KeyboardInputMapperTest : public InputMapperTest {
1541 protected:
1542     void testDPadKeyRotation(KeyboardInputMapper* mapper,
1543             int32_t originalScanCode, int32_t originalKeyCode, int32_t rotatedKeyCode);
1544 };
1545
1546 void 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
1564 TEST_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
1572 TEST_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
1682 TEST_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
1725 TEST_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
1748 TEST_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
1830 TEST_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
1842 TEST_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
1854 TEST_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
1868 TEST_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
1949 class CursorInputMapperTest : public InputMapperTest {
1950 protected:
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
1966 const int32_t CursorInputMapperTest::TRACKBALL_MOVEMENT_THRESHOLD = 6;
1967
1968 void 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
1983 TEST_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
1991 TEST_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
1999 TEST_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
2030 TEST_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
2049 TEST_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
2142 TEST_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
2166 TEST_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
2200 TEST_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
2248 TEST_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
2266 TEST_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
2317 TEST_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
2605 TEST_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
2629 class TouchInputMapperTest : public InputMapperTest {
2630 protected:
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
2684 const int32_t TouchInputMapperTest::RAW_X_MIN = 25;
2685 const int32_t TouchInputMapperTest::RAW_X_MAX = 1019;
2686 const int32_t TouchInputMapperTest::RAW_Y_MIN = 30;
2687 const int32_t TouchInputMapperTest::RAW_Y_MAX = 1009;
2688 const int32_t TouchInputMapperTest::RAW_TOUCH_MIN = 0;
2689 const int32_t TouchInputMapperTest::RAW_TOUCH_MAX = 31;
2690 const int32_t TouchInputMapperTest::RAW_TOOL_MIN = 0;
2691 const int32_t TouchInputMapperTest::RAW_TOOL_MAX = 15;
2692 const int32_t TouchInputMapperTest::RAW_PRESSURE_MIN = RAW_TOUCH_MIN;
2693 const int32_t TouchInputMapperTest::RAW_PRESSURE_MAX = RAW_TOUCH_MAX;
2694 const int32_t TouchInputMapperTest::RAW_ORIENTATION_MIN = -7;
2695 const int32_t TouchInputMapperTest::RAW_ORIENTATION_MAX = 7;
2696 const int32_t TouchInputMapperTest::RAW_DISTANCE_MIN = 0;
2697 const int32_t TouchInputMapperTest::RAW_DISTANCE_MAX = 7;
2698 const int32_t TouchInputMapperTest::RAW_TILT_MIN = 0;
2699 const int32_t TouchInputMapperTest::RAW_TILT_MAX = 150;
2700 const int32_t TouchInputMapperTest::RAW_ID_MIN = 0;
2701 const int32_t TouchInputMapperTest::RAW_ID_MAX = 9;
2702 const int32_t TouchInputMapperTest::RAW_SLOT_MIN = 0;
2703 const int32_t TouchInputMapperTest::RAW_SLOT_MAX = 9;
2704 const float TouchInputMapperTest::X_PRECISION = float(RAW_X_MAX - RAW_X_MIN + 1) / DISPLAY_WIDTH;
2705 const float TouchInputMapperTest::Y_PRECISION = float(RAW_Y_MAX - RAW_Y_MIN + 1) / DISPLAY_HEIGHT;
2706 const TouchAffineTransformation TouchInputMapperTest::AFFINE_TRANSFORM =
2707         TouchAffineTransformation(1, -2, 3, -4, 5, -6);
2708
2709 const 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
2713 const 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
2718 void TouchInputMapperTest::prepareDisplay(int32_t orientation) {
2719     setDisplayInfoAndReconfigure(DISPLAY_ID, DISPLAY_WIDTH, DISPLAY_HEIGHT, orientation);
2720 }
2721
2722 void 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
2729 void TouchInputMapperTest::prepareLocationCalibration() {
2730     mFakePolicy->setTouchAffineTransformation(AFFINE_TRANSFORM);
2731 }
2732
2733 int32_t TouchInputMapperTest::toRawX(float displayX) {
2734     return int32_t(displayX * (RAW_X_MAX - RAW_X_MIN + 1) / DISPLAY_WIDTH + RAW_X_MIN);
2735 }
2736
2737 int32_t TouchInputMapperTest::toRawY(float displayY) {
2738     return int32_t(displayY * (RAW_Y_MAX - RAW_Y_MIN + 1) / DISPLAY_HEIGHT + RAW_Y_MIN);
2739 }
2740
2741 float TouchInputMapperTest::toCookedX(float rawX, float rawY) {
2742     AFFINE_TRANSFORM.applyTo(rawX, rawY);
2743     return rawX;
2744 }
2745
2746 float TouchInputMapperTest::toCookedY(float rawX, float rawY) {
2747     AFFINE_TRANSFORM.applyTo(rawX, rawY);
2748     return rawY;
2749 }
2750
2751 float TouchInputMapperTest::toDisplayX(int32_t rawX) {
2752     return float(rawX - RAW_X_MIN) * DISPLAY_WIDTH / (RAW_X_MAX - RAW_X_MIN + 1);
2753 }
2754
2755 float 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
2762 class SingleTouchInputMapperTest : public TouchInputMapperTest {
2763 protected:
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
2778 void SingleTouchInputMapperTest::prepareButtons() {
2779     mFakeEventHub->addKey(DEVICE_ID, BTN_TOUCH, 0, AKEYCODE_UNKNOWN, 0);
2780 }
2781
2782 void 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
2809 void 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
2815 void 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
2820 void SingleTouchInputMapperTest::processUp(SingleTouchInputMapper* mapper) {
2821     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_TOUCH, 0);
2822 }
2823
2824 void SingleTouchInputMapperTest::processPressure(
2825         SingleTouchInputMapper* mapper, int32_t pressure) {
2826     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_PRESSURE, pressure);
2827 }
2828
2829 void SingleTouchInputMapperTest::processToolMajor(
2830         SingleTouchInputMapper* mapper, int32_t toolMajor) {
2831     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_TOOL_WIDTH, toolMajor);
2832 }
2833
2834 void SingleTouchInputMapperTest::processDistance(
2835         SingleTouchInputMapper* mapper, int32_t distance) {
2836     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_DISTANCE, distance);
2837 }
2838
2839 void 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
2845 void SingleTouchInputMapperTest::processKey(
2846         SingleTouchInputMapper* mapper, int32_t code, int32_t value) {
2847     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, code, value);
2848 }
2849
2850 void SingleTouchInputMapperTest::processSync(SingleTouchInputMapper* mapper) {
2851     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0);
2852 }
2853
2854
2855 TEST_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
2864 TEST_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
2875 TEST_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
2885 TEST_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
2895 TEST_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
2924 TEST_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
2953 TEST_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
2969 TEST_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
3020 TEST_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
3142 TEST_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
3216 TEST_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
3307 TEST_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
3331 TEST_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
3393 TEST_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
3438 TEST_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
3462 TEST_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
3706 TEST_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
3842 TEST_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
3915 TEST_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
3990 class MultiTouchInputMapperTest : public TouchInputMapperTest {
3991 protected:
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
4010 void 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
4060 void 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
4066 void MultiTouchInputMapperTest::processTouchMajor(
4067         MultiTouchInputMapper* mapper, int32_t touchMajor) {
4068     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_TOUCH_MAJOR, touchMajor);
4069 }
4070
4071 void MultiTouchInputMapperTest::processTouchMinor(
4072         MultiTouchInputMapper* mapper, int32_t touchMinor) {
4073     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_TOUCH_MINOR, touchMinor);
4074 }
4075
4076 void MultiTouchInputMapperTest::processToolMajor(
4077         MultiTouchInputMapper* mapper, int32_t toolMajor) {
4078     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_WIDTH_MAJOR, toolMajor);
4079 }
4080
4081 void MultiTouchInputMapperTest::processToolMinor(
4082         MultiTouchInputMapper* mapper, int32_t toolMinor) {
4083     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_WIDTH_MINOR, toolMinor);
4084 }
4085
4086 void MultiTouchInputMapperTest::processOrientation(
4087         MultiTouchInputMapper* mapper, int32_t orientation) {
4088     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_ORIENTATION, orientation);
4089 }
4090
4091 void MultiTouchInputMapperTest::processPressure(
4092         MultiTouchInputMapper* mapper, int32_t pressure) {
4093     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_PRESSURE, pressure);
4094 }
4095
4096 void MultiTouchInputMapperTest::processDistance(
4097         MultiTouchInputMapper* mapper, int32_t distance) {
4098     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_DISTANCE, distance);
4099 }
4100
4101 void MultiTouchInputMapperTest::processId(
4102         MultiTouchInputMapper* mapper, int32_t id) {
4103     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_TRACKING_ID, id);
4104 }
4105
4106 void MultiTouchInputMapperTest::processSlot(
4107         MultiTouchInputMapper* mapper, int32_t slot) {
4108     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_SLOT, slot);
4109 }
4110
4111 void MultiTouchInputMapperTest::processToolType(
4112         MultiTouchInputMapper* mapper, int32_t toolType) {
4113     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_TOOL_TYPE, toolType);
4114 }
4115
4116 void MultiTouchInputMapperTest::processKey(
4117         MultiTouchInputMapper* mapper, int32_t code, int32_t value) {
4118     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, code, value);
4119 }
4120
4121 void MultiTouchInputMapperTest::processMTSync(MultiTouchInputMapper* mapper) {
4122     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_MT_REPORT, 0);
4123 }
4124
4125 void MultiTouchInputMapperTest::processSync(MultiTouchInputMapper* mapper) {
4126     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0);
4127 }
4128
4129
4130 TEST_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
4407 TEST_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
4583 TEST_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
4754 TEST_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
4804 TEST_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
4842 TEST_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
4895 TEST_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
4929 TEST_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
4958 TEST_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
5202 TEST_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
5353 TEST_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
5425 TEST_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