Home | History | Annotate | Download | only in tests 
      1 //
      2 // Copyright 2010 The Android Open Source Project
      3 //
      4 
      5 #include <ui/InputReader.h>
      6 #include <utils/List.h>
      7 #include <gtest/gtest.h>
      8 #include <math.h>
      9 
     10 namespace android {
     11 
     12 // An arbitrary time value.
     13 static const nsecs_t ARBITRARY_TIME = 1234;
     14 
     15 // Arbitrary display properties.
     16 static const int32_t DISPLAY_ID = 0;
     17 static const int32_t DISPLAY_WIDTH = 480;
     18 static const int32_t DISPLAY_HEIGHT = 800;
     19 
     20 // Error tolerance for floating point assertions.
     21 static const float EPSILON = 0.001f;
     22 
     23 template<typename T>
     24 static inline T min(T a, T b) {
     25     return a < b ? a : b;
     26 }
     27 
     28 static inline float avg(float x, float y) {
     29     return (x + y) / 2;
     30 }
     31 
     32 
     33 // --- FakeInputReaderPolicy ---
     34 
     35 class FakeInputReaderPolicy : public InputReaderPolicyInterface {
     36     struct DisplayInfo {
     37         int32_t width;
     38         int32_t height;
     39         int32_t orientation;
     40     };
     41 
     42     KeyedVector<int32_t, DisplayInfo> mDisplayInfos;
     43     bool mFilterTouchEvents;
     44     bool mFilterJumpyTouchEvents;
     45     KeyedVector<String8, Vector<VirtualKeyDefinition> > mVirtualKeyDefinitions;
     46     KeyedVector<String8, InputDeviceCalibration> mInputDeviceCalibrations;
     47     Vector<String8> mExcludedDeviceNames;
     48 
     49 protected:
     50     virtual ~FakeInputReaderPolicy() { }
     51 
     52 public:
     53     FakeInputReaderPolicy() :
     54             mFilterTouchEvents(false), mFilterJumpyTouchEvents(false) {
     55     }
     56 
     57     void removeDisplayInfo(int32_t displayId) {
     58         mDisplayInfos.removeItem(displayId);
     59     }
     60 
     61     void setDisplayInfo(int32_t displayId, int32_t width, int32_t height, int32_t orientation) {
     62         removeDisplayInfo(displayId);
     63 
     64         DisplayInfo info;
     65         info.width = width;
     66         info.height = height;
     67         info.orientation = orientation;
     68         mDisplayInfos.add(displayId, info);
     69     }
     70 
     71     void setFilterTouchEvents(bool enabled) {
     72         mFilterTouchEvents = enabled;
     73     }
     74 
     75     void setFilterJumpyTouchEvents(bool enabled) {
     76         mFilterJumpyTouchEvents = enabled;
     77     }
     78 
     79     void addInputDeviceCalibration(const String8& deviceName,
     80             const InputDeviceCalibration& calibration) {
     81         mInputDeviceCalibrations.add(deviceName, calibration);
     82     }
     83 
     84     void addInputDeviceCalibrationProperty(const String8& deviceName,
     85             const String8& key, const String8& value) {
     86         ssize_t index = mInputDeviceCalibrations.indexOfKey(deviceName);
     87         if (index < 0) {
     88             index = mInputDeviceCalibrations.add(deviceName, InputDeviceCalibration());
     89         }
     90         mInputDeviceCalibrations.editValueAt(index).addProperty(key, value);
     91     }
     92 
     93     void addVirtualKeyDefinition(const String8& deviceName,
     94             const VirtualKeyDefinition& definition) {
     95         if (mVirtualKeyDefinitions.indexOfKey(deviceName) < 0) {
     96             mVirtualKeyDefinitions.add(deviceName, Vector<VirtualKeyDefinition>());
     97         }
     98 
     99         mVirtualKeyDefinitions.editValueFor(deviceName).push(definition);
    100     }
    101 
    102     void addExcludedDeviceName(const String8& deviceName) {
    103         mExcludedDeviceNames.push(deviceName);
    104     }
    105 
    106 private:
    107     virtual bool getDisplayInfo(int32_t displayId,
    108             int32_t* width, int32_t* height, int32_t* orientation) {
    109         ssize_t index = mDisplayInfos.indexOfKey(displayId);
    110         if (index >= 0) {
    111             const DisplayInfo& info = mDisplayInfos.valueAt(index);
    112             if (width) {
    113                 *width = info.width;
    114             }
    115             if (height) {
    116                 *height = info.height;
    117             }
    118             if (orientation) {
    119                 *orientation = info.orientation;
    120             }
    121             return true;
    122         }
    123         return false;
    124     }
    125 
    126     virtual bool filterTouchEvents() {
    127         return mFilterTouchEvents;
    128     }
    129 
    130     virtual bool filterJumpyTouchEvents() {
    131         return mFilterJumpyTouchEvents;
    132     }
    133 
    134     virtual void getVirtualKeyDefinitions(const String8& deviceName,
    135             Vector<VirtualKeyDefinition>& outVirtualKeyDefinitions) {
    136         ssize_t index = mVirtualKeyDefinitions.indexOfKey(deviceName);
    137         if (index >= 0) {
    138             outVirtualKeyDefinitions.appendVector(mVirtualKeyDefinitions.valueAt(index));
    139         }
    140     }
    141 
    142     virtual void getInputDeviceCalibration(const String8& deviceName,
    143             InputDeviceCalibration& outCalibration) {
    144         ssize_t index = mInputDeviceCalibrations.indexOfKey(deviceName);
    145         if (index >= 0) {
    146             outCalibration = mInputDeviceCalibrations.valueAt(index);
    147         }
    148     }
    149 
    150     virtual void getExcludedDeviceNames(Vector<String8>& outExcludedDeviceNames) {
    151         outExcludedDeviceNames.appendVector(mExcludedDeviceNames);
    152     }
    153 };
    154 
    155 
    156 // --- FakeInputDispatcher ---
    157 
    158 class FakeInputDispatcher : public InputDispatcherInterface {
    159 public:
    160     struct NotifyConfigurationChangedArgs {
    161         nsecs_t eventTime;
    162     };
    163 
    164     struct NotifyKeyArgs {
    165         nsecs_t eventTime;
    166         int32_t deviceId;
    167         int32_t source;
    168         uint32_t policyFlags;
    169         int32_t action;
    170         int32_t flags;
    171         int32_t keyCode;
    172         int32_t scanCode;
    173         int32_t metaState;
    174         nsecs_t downTime;
    175     };
    176 
    177     struct NotifyMotionArgs {
    178         nsecs_t eventTime;
    179         int32_t deviceId;
    180         int32_t source;
    181         uint32_t policyFlags;
    182         int32_t action;
    183         int32_t flags;
    184         int32_t metaState;
    185         int32_t edgeFlags;
    186         uint32_t pointerCount;
    187         Vector<int32_t> pointerIds;
    188         Vector<PointerCoords> pointerCoords;
    189         float xPrecision;
    190         float yPrecision;
    191         nsecs_t downTime;
    192     };
    193 
    194     struct NotifySwitchArgs {
    195         nsecs_t when;
    196         int32_t switchCode;
    197         int32_t switchValue;
    198         uint32_t policyFlags;
    199     };
    200 
    201 private:
    202     List<NotifyConfigurationChangedArgs> mNotifyConfigurationChangedArgs;
    203     List<NotifyKeyArgs> mNotifyKeyArgs;
    204     List<NotifyMotionArgs> mNotifyMotionArgs;
    205     List<NotifySwitchArgs> mNotifySwitchArgs;
    206 
    207 protected:
    208     virtual ~FakeInputDispatcher() { }
    209 
    210 public:
    211     FakeInputDispatcher() {
    212     }
    213 
    214     void assertNotifyConfigurationChangedWasCalled(NotifyConfigurationChangedArgs* outArgs = NULL) {
    215         ASSERT_FALSE(mNotifyConfigurationChangedArgs.empty())
    216                 << "Expected notifyConfigurationChanged() to have been called.";
    217         if (outArgs) {
    218             *outArgs = *mNotifyConfigurationChangedArgs.begin();
    219         }
    220         mNotifyConfigurationChangedArgs.erase(mNotifyConfigurationChangedArgs.begin());
    221     }
    222 
    223     void assertNotifyKeyWasCalled(NotifyKeyArgs* outArgs = NULL) {
    224         ASSERT_FALSE(mNotifyKeyArgs.empty())
    225                 << "Expected notifyKey() to have been called.";
    226         if (outArgs) {
    227             *outArgs = *mNotifyKeyArgs.begin();
    228         }
    229         mNotifyKeyArgs.erase(mNotifyKeyArgs.begin());
    230     }
    231 
    232     void assertNotifyKeyWasNotCalled() {
    233         ASSERT_TRUE(mNotifyKeyArgs.empty())
    234                 << "Expected notifyKey() to not have been called.";
    235     }
    236 
    237     void assertNotifyMotionWasCalled(NotifyMotionArgs* outArgs = NULL) {
    238         ASSERT_FALSE(mNotifyMotionArgs.empty())
    239                 << "Expected notifyMotion() to have been called.";
    240         if (outArgs) {
    241             *outArgs = *mNotifyMotionArgs.begin();
    242         }
    243         mNotifyMotionArgs.erase(mNotifyMotionArgs.begin());
    244     }
    245 
    246     void assertNotifyMotionWasNotCalled() {
    247         ASSERT_TRUE(mNotifyMotionArgs.empty())
    248                 << "Expected notifyMotion() to not have been called.";
    249     }
    250 
    251     void assertNotifySwitchWasCalled(NotifySwitchArgs* outArgs = NULL) {
    252         ASSERT_FALSE(mNotifySwitchArgs.empty())
    253                 << "Expected notifySwitch() to have been called.";
    254         if (outArgs) {
    255             *outArgs = *mNotifySwitchArgs.begin();
    256         }
    257         mNotifySwitchArgs.erase(mNotifySwitchArgs.begin());
    258     }
    259 
    260 private:
    261     virtual void notifyConfigurationChanged(nsecs_t eventTime) {
    262         NotifyConfigurationChangedArgs args;
    263         args.eventTime = eventTime;
    264         mNotifyConfigurationChangedArgs.push_back(args);
    265     }
    266 
    267     virtual void notifyKey(nsecs_t eventTime, int32_t deviceId, int32_t source,
    268             uint32_t policyFlags, int32_t action, int32_t flags, int32_t keyCode,
    269             int32_t scanCode, int32_t metaState, nsecs_t downTime) {
    270         NotifyKeyArgs args;
    271         args.eventTime = eventTime;
    272         args.deviceId = deviceId;
    273         args.source = source;
    274         args.policyFlags = policyFlags;
    275         args.action = action;
    276         args.flags = flags;
    277         args.keyCode = keyCode;
    278         args.scanCode = scanCode;
    279         args.metaState = metaState;
    280         args.downTime = downTime;
    281         mNotifyKeyArgs.push_back(args);
    282     }
    283 
    284     virtual void notifyMotion(nsecs_t eventTime, int32_t deviceId, int32_t source,
    285             uint32_t policyFlags, int32_t action, int32_t flags,
    286             int32_t metaState, int32_t edgeFlags,
    287             uint32_t pointerCount, const int32_t* pointerIds, const PointerCoords* pointerCoords,
    288             float xPrecision, float yPrecision, nsecs_t downTime) {
    289         NotifyMotionArgs args;
    290         args.eventTime = eventTime;
    291         args.deviceId = deviceId;
    292         args.source = source;
    293         args.policyFlags = policyFlags;
    294         args.action = action;
    295         args.flags = flags;
    296         args.metaState = metaState;
    297         args.edgeFlags = edgeFlags;
    298         args.pointerCount = pointerCount;
    299         args.pointerIds.clear();
    300         args.pointerIds.appendArray(pointerIds, pointerCount);
    301         args.pointerCoords.clear();
    302         args.pointerCoords.appendArray(pointerCoords, pointerCount);
    303         args.xPrecision = xPrecision;
    304         args.yPrecision = yPrecision;
    305         args.downTime = downTime;
    306         mNotifyMotionArgs.push_back(args);
    307     }
    308 
    309     virtual void notifySwitch(nsecs_t when,
    310             int32_t switchCode, int32_t switchValue, uint32_t policyFlags) {
    311         NotifySwitchArgs args;
    312         args.when = when;
    313         args.switchCode = switchCode;
    314         args.switchValue = switchValue;
    315         args.policyFlags = policyFlags;
    316         mNotifySwitchArgs.push_back(args);
    317     }
    318 
    319     virtual void dump(String8& dump) {
    320         ADD_FAILURE() << "Should never be called by input reader.";
    321     }
    322 
    323     virtual void dispatchOnce() {
    324         ADD_FAILURE() << "Should never be called by input reader.";
    325     }
    326 
    327     virtual int32_t injectInputEvent(const InputEvent* event,
    328             int32_t injectorPid, int32_t injectorUid, int32_t syncMode, int32_t timeoutMillis) {
    329         ADD_FAILURE() << "Should never be called by input reader.";
    330         return INPUT_EVENT_INJECTION_FAILED;
    331     }
    332 
    333     virtual void setInputWindows(const Vector<InputWindow>& inputWindows) {
    334         ADD_FAILURE() << "Should never be called by input reader.";
    335     }
    336 
    337     virtual void setFocusedApplication(const InputApplication* inputApplication) {
    338         ADD_FAILURE() << "Should never be called by input reader.";
    339     }
    340 
    341     virtual void setInputDispatchMode(bool enabled, bool frozen) {
    342         ADD_FAILURE() << "Should never be called by input reader.";
    343     }
    344 
    345     virtual status_t registerInputChannel(const sp<InputChannel>& inputChannel, bool monitor) {
    346         ADD_FAILURE() << "Should never be called by input reader.";
    347         return 0;
    348     }
    349 
    350     virtual status_t unregisterInputChannel(const sp<InputChannel>& inputChannel) {
    351         ADD_FAILURE() << "Should never be called by input reader.";
    352         return 0;
    353     }
    354 };
    355 
    356 
    357 // --- FakeEventHub ---
    358 
    359 class FakeEventHub : public EventHubInterface {
    360     struct KeyInfo {
    361         int32_t keyCode;
    362         uint32_t flags;
    363     };
    364 
    365     struct Device {
    366         String8 name;
    367         uint32_t classes;
    368         KeyedVector<int, RawAbsoluteAxisInfo> axes;
    369         KeyedVector<int32_t, int32_t> keyCodeStates;
    370         KeyedVector<int32_t, int32_t> scanCodeStates;
    371         KeyedVector<int32_t, int32_t> switchStates;
    372         KeyedVector<int32_t, KeyInfo> keys;
    373 
    374         Device(const String8& name, uint32_t classes) :
    375                 name(name), classes(classes) {
    376         }
    377     };
    378 
    379     KeyedVector<int32_t, Device*> mDevices;
    380     Vector<String8> mExcludedDevices;
    381     List<RawEvent> mEvents;
    382 
    383 protected:
    384     virtual ~FakeEventHub() {
    385         for (size_t i = 0; i < mDevices.size(); i++) {
    386             delete mDevices.valueAt(i);
    387         }
    388     }
    389 
    390 public:
    391     FakeEventHub() { }
    392 
    393     void addDevice(int32_t deviceId, const String8& name, uint32_t classes) {
    394         Device* device = new Device(name, classes);
    395         mDevices.add(deviceId, device);
    396 
    397         enqueueEvent(ARBITRARY_TIME, deviceId, EventHubInterface::DEVICE_ADDED, 0, 0, 0, 0);
    398     }
    399 
    400     void removeDevice(int32_t deviceId) {
    401         delete mDevices.valueFor(deviceId);
    402         mDevices.removeItem(deviceId);
    403 
    404         enqueueEvent(ARBITRARY_TIME, deviceId, EventHubInterface::DEVICE_REMOVED, 0, 0, 0, 0);
    405     }
    406 
    407     void finishDeviceScan() {
    408         enqueueEvent(ARBITRARY_TIME, 0, EventHubInterface::FINISHED_DEVICE_SCAN, 0, 0, 0, 0);
    409     }
    410 
    411     void addAxis(int32_t deviceId, int axis,
    412             int32_t minValue, int32_t maxValue, int flat, int fuzz) {
    413         Device* device = getDevice(deviceId);
    414 
    415         RawAbsoluteAxisInfo info;
    416         info.valid = true;
    417         info.minValue = minValue;
    418         info.maxValue = maxValue;
    419         info.flat = flat;
    420         info.fuzz = fuzz;
    421         device->axes.add(axis, info);
    422     }
    423 
    424     void setKeyCodeState(int32_t deviceId, int32_t keyCode, int32_t state) {
    425         Device* device = getDevice(deviceId);
    426         device->keyCodeStates.replaceValueFor(keyCode, state);
    427     }
    428 
    429     void setScanCodeState(int32_t deviceId, int32_t scanCode, int32_t state) {
    430         Device* device = getDevice(deviceId);
    431         device->scanCodeStates.replaceValueFor(scanCode, state);
    432     }
    433 
    434     void setSwitchState(int32_t deviceId, int32_t switchCode, int32_t state) {
    435         Device* device = getDevice(deviceId);
    436         device->switchStates.replaceValueFor(switchCode, state);
    437     }
    438 
    439     void addKey(int32_t deviceId, int32_t scanCode, int32_t keyCode, uint32_t flags) {
    440         Device* device = getDevice(deviceId);
    441         KeyInfo info;
    442         info.keyCode = keyCode;
    443         info.flags = flags;
    444         device->keys.add(scanCode, info);
    445     }
    446 
    447     Vector<String8>& getExcludedDevices() {
    448         return mExcludedDevices;
    449     }
    450 
    451     void enqueueEvent(nsecs_t when, int32_t deviceId, int32_t type,
    452             int32_t scanCode, int32_t keyCode, int32_t value, uint32_t flags) {
    453         RawEvent event;
    454         event.when = when;
    455         event.deviceId = deviceId;
    456         event.type = type;
    457         event.scanCode = scanCode;
    458         event.keyCode = keyCode;
    459         event.value = value;
    460         event.flags = flags;
    461         mEvents.push_back(event);
    462     }
    463 
    464     void assertQueueIsEmpty() {
    465         ASSERT_EQ(size_t(0), mEvents.size())
    466                 << "Expected the event queue to be empty (fully consumed).";
    467     }
    468 
    469 private:
    470     Device* getDevice(int32_t deviceId) const {
    471         ssize_t index = mDevices.indexOfKey(deviceId);
    472         return index >= 0 ? mDevices.valueAt(index) : NULL;
    473     }
    474 
    475     virtual uint32_t getDeviceClasses(int32_t deviceId) const {
    476         Device* device = getDevice(deviceId);
    477         return device ? device->classes : 0;
    478     }
    479 
    480     virtual String8 getDeviceName(int32_t deviceId) const {
    481         Device* device = getDevice(deviceId);
    482         return device ? device->name : String8("unknown");
    483     }
    484 
    485     virtual status_t getAbsoluteAxisInfo(int32_t deviceId, int axis,
    486             RawAbsoluteAxisInfo* outAxisInfo) const {
    487         Device* device = getDevice(deviceId);
    488         if (device) {
    489             ssize_t index = device->axes.indexOfKey(axis);
    490             if (index >= 0) {
    491                 *outAxisInfo = device->axes.valueAt(index);
    492                 return OK;
    493             }
    494         }
    495         return -1;
    496     }
    497 
    498     virtual status_t scancodeToKeycode(int32_t deviceId, int scancode,
    499             int32_t* outKeycode, uint32_t* outFlags) const {
    500         Device* device = getDevice(deviceId);
    501         if (device) {
    502             ssize_t index = device->keys.indexOfKey(scancode);
    503             if (index >= 0) {
    504                 if (outKeycode) {
    505                     *outKeycode = device->keys.valueAt(index).keyCode;
    506                 }
    507                 if (outFlags) {
    508                     *outFlags = device->keys.valueAt(index).flags;
    509                 }
    510                 return OK;
    511             }
    512         }
    513         return NAME_NOT_FOUND;
    514     }
    515 
    516     virtual void addExcludedDevice(const char* deviceName) {
    517         mExcludedDevices.add(String8(deviceName));
    518     }
    519 
    520     virtual bool getEvent(RawEvent* outEvent) {
    521         if (mEvents.empty()) {
    522             return false;
    523         }
    524 
    525         *outEvent = *mEvents.begin();
    526         mEvents.erase(mEvents.begin());
    527         return true;
    528     }
    529 
    530     virtual int32_t getScanCodeState(int32_t deviceId, int32_t scanCode) const {
    531         Device* device = getDevice(deviceId);
    532         if (device) {
    533             ssize_t index = device->scanCodeStates.indexOfKey(scanCode);
    534             if (index >= 0) {
    535                 return device->scanCodeStates.valueAt(index);
    536             }
    537         }
    538         return AKEY_STATE_UNKNOWN;
    539     }
    540 
    541     virtual int32_t getKeyCodeState(int32_t deviceId, int32_t keyCode) const {
    542         Device* device = getDevice(deviceId);
    543         if (device) {
    544             ssize_t index = device->keyCodeStates.indexOfKey(keyCode);
    545             if (index >= 0) {
    546                 return device->keyCodeStates.valueAt(index);
    547             }
    548         }
    549         return AKEY_STATE_UNKNOWN;
    550     }
    551 
    552     virtual int32_t getSwitchState(int32_t deviceId, int32_t sw) const {
    553         Device* device = getDevice(deviceId);
    554         if (device) {
    555             ssize_t index = device->switchStates.indexOfKey(sw);
    556             if (index >= 0) {
    557                 return device->switchStates.valueAt(index);
    558             }
    559         }
    560         return AKEY_STATE_UNKNOWN;
    561     }
    562 
    563     virtual bool markSupportedKeyCodes(int32_t deviceId, size_t numCodes, const int32_t* keyCodes,
    564             uint8_t* outFlags) const {
    565         bool result = false;
    566         Device* device = getDevice(deviceId);
    567         if (device) {
    568             for (size_t i = 0; i < numCodes; i++) {
    569                 for (size_t j = 0; j < device->keys.size(); j++) {
    570                     if (keyCodes[i] == device->keys.valueAt(j).keyCode) {
    571                         outFlags[i] = 1;
    572                         result = true;
    573                     }
    574                 }
    575             }
    576         }
    577         return result;
    578     }
    579 
    580     virtual void dump(String8& dump) {
    581     }
    582 };
    583 
    584 
    585 // --- FakeInputReaderContext ---
    586 
    587 class FakeInputReaderContext : public InputReaderContext {
    588     sp<EventHubInterface> mEventHub;
    589     sp<InputReaderPolicyInterface> mPolicy;
    590     sp<InputDispatcherInterface> mDispatcher;
    591     int32_t mGlobalMetaState;
    592     bool mUpdateGlobalMetaStateWasCalled;
    593 
    594 public:
    595     FakeInputReaderContext(const sp<EventHubInterface>& eventHub,
    596             const sp<InputReaderPolicyInterface>& policy,
    597             const sp<InputDispatcherInterface>& dispatcher) :
    598             mEventHub(eventHub), mPolicy(policy), mDispatcher(dispatcher),
    599             mGlobalMetaState(0) {
    600     }
    601 
    602     virtual ~FakeInputReaderContext() { }
    603 
    604     void assertUpdateGlobalMetaStateWasCalled() {
    605         ASSERT_TRUE(mUpdateGlobalMetaStateWasCalled)
    606                 << "Expected updateGlobalMetaState() to have been called.";
    607         mUpdateGlobalMetaStateWasCalled = false;
    608     }
    609 
    610     void setGlobalMetaState(int32_t state) {
    611         mGlobalMetaState = state;
    612     }
    613 
    614 private:
    615     virtual void updateGlobalMetaState() {
    616         mUpdateGlobalMetaStateWasCalled = true;
    617     }
    618 
    619     virtual int32_t getGlobalMetaState() {
    620         return mGlobalMetaState;
    621     }
    622 
    623     virtual EventHubInterface* getEventHub() {
    624         return mEventHub.get();
    625     }
    626 
    627     virtual InputReaderPolicyInterface* getPolicy() {
    628         return mPolicy.get();
    629     }
    630 
    631     virtual InputDispatcherInterface* getDispatcher() {
    632         return mDispatcher.get();
    633     }
    634 };
    635 
    636 
    637 // --- FakeInputMapper ---
    638 
    639 class FakeInputMapper : public InputMapper {
    640     uint32_t mSources;
    641     int32_t mKeyboardType;
    642     int32_t mMetaState;
    643     KeyedVector<int32_t, int32_t> mKeyCodeStates;
    644     KeyedVector<int32_t, int32_t> mScanCodeStates;
    645     KeyedVector<int32_t, int32_t> mSwitchStates;
    646     Vector<int32_t> mSupportedKeyCodes;
    647     RawEvent mLastEvent;
    648 
    649     bool mConfigureWasCalled;
    650     bool mResetWasCalled;
    651     bool mProcessWasCalled;
    652 
    653 public:
    654     FakeInputMapper(InputDevice* device, uint32_t sources) :
    655             InputMapper(device),
    656             mSources(sources), mKeyboardType(AINPUT_KEYBOARD_TYPE_NONE),
    657             mMetaState(0),
    658             mConfigureWasCalled(false), mResetWasCalled(false), mProcessWasCalled(false) {
    659     }
    660 
    661     virtual ~FakeInputMapper() { }
    662 
    663     void setKeyboardType(int32_t keyboardType) {
    664         mKeyboardType = keyboardType;
    665     }
    666 
    667     void setMetaState(int32_t metaState) {
    668         mMetaState = metaState;
    669     }
    670 
    671     void assertConfigureWasCalled() {
    672         ASSERT_TRUE(mConfigureWasCalled)
    673                 << "Expected configure() to have been called.";
    674         mConfigureWasCalled = false;
    675     }
    676 
    677     void assertResetWasCalled() {
    678         ASSERT_TRUE(mResetWasCalled)
    679                 << "Expected reset() to have been called.";
    680         mResetWasCalled = false;
    681     }
    682 
    683     void assertProcessWasCalled(RawEvent* outLastEvent = NULL) {
    684         ASSERT_TRUE(mProcessWasCalled)
    685                 << "Expected process() to have been called.";
    686         if (outLastEvent) {
    687             *outLastEvent = mLastEvent;
    688         }
    689         mProcessWasCalled = false;
    690     }
    691 
    692     void setKeyCodeState(int32_t keyCode, int32_t state) {
    693         mKeyCodeStates.replaceValueFor(keyCode, state);
    694     }
    695 
    696     void setScanCodeState(int32_t scanCode, int32_t state) {
    697         mScanCodeStates.replaceValueFor(scanCode, state);
    698     }
    699 
    700     void setSwitchState(int32_t switchCode, int32_t state) {
    701         mSwitchStates.replaceValueFor(switchCode, state);
    702     }
    703 
    704     void addSupportedKeyCode(int32_t keyCode) {
    705         mSupportedKeyCodes.add(keyCode);
    706     }
    707 
    708 private:
    709     virtual uint32_t getSources() {
    710         return mSources;
    711     }
    712 
    713     virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo) {
    714         InputMapper::populateDeviceInfo(deviceInfo);
    715 
    716         if (mKeyboardType != AINPUT_KEYBOARD_TYPE_NONE) {
    717             deviceInfo->setKeyboardType(mKeyboardType);
    718         }
    719     }
    720 
    721     virtual void configure() {
    722         mConfigureWasCalled = true;
    723     }
    724 
    725     virtual void reset() {
    726         mResetWasCalled = true;
    727     }
    728 
    729     virtual void process(const RawEvent* rawEvent) {
    730         mLastEvent = *rawEvent;
    731         mProcessWasCalled = true;
    732     }
    733 
    734     virtual int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode) {
    735         ssize_t index = mKeyCodeStates.indexOfKey(keyCode);
    736         return index >= 0 ? mKeyCodeStates.valueAt(index) : AKEY_STATE_UNKNOWN;
    737     }
    738 
    739     virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode) {
    740         ssize_t index = mScanCodeStates.indexOfKey(scanCode);
    741         return index >= 0 ? mScanCodeStates.valueAt(index) : AKEY_STATE_UNKNOWN;
    742     }
    743 
    744     virtual int32_t getSwitchState(uint32_t sourceMask, int32_t switchCode) {
    745         ssize_t index = mSwitchStates.indexOfKey(switchCode);
    746         return index >= 0 ? mSwitchStates.valueAt(index) : AKEY_STATE_UNKNOWN;
    747     }
    748 
    749     virtual bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes,
    750             const int32_t* keyCodes, uint8_t* outFlags) {
    751         bool result = false;
    752         for (size_t i = 0; i < numCodes; i++) {
    753             for (size_t j = 0; j < mSupportedKeyCodes.size(); j++) {
    754                 if (keyCodes[i] == mSupportedKeyCodes[j]) {
    755                     outFlags[i] = 1;
    756                     result = true;
    757                 }
    758             }
    759         }
    760         return result;
    761     }
    762 
    763     virtual int32_t getMetaState() {
    764         return mMetaState;
    765     }
    766 };
    767 
    768 
    769 // --- InstrumentedInputReader ---
    770 
    771 class InstrumentedInputReader : public InputReader {
    772     InputDevice* mNextDevice;
    773 
    774 public:
    775     InstrumentedInputReader(const sp<EventHubInterface>& eventHub,
    776             const sp<InputReaderPolicyInterface>& policy,
    777             const sp<InputDispatcherInterface>& dispatcher) :
    778             InputReader(eventHub, policy, dispatcher) {
    779     }
    780 
    781     virtual ~InstrumentedInputReader() {
    782         if (mNextDevice) {
    783             delete mNextDevice;
    784         }
    785     }
    786 
    787     void setNextDevice(InputDevice* device) {
    788         mNextDevice = device;
    789     }
    790 
    791 protected:
    792     virtual InputDevice* createDevice(int32_t deviceId, const String8& name, uint32_t classes) {
    793         if (mNextDevice) {
    794             InputDevice* device = mNextDevice;
    795             mNextDevice = NULL;
    796             return device;
    797         }
    798         return InputReader::createDevice(deviceId, name, classes);
    799     }
    800 
    801     friend class InputReaderTest;
    802 };
    803 
    804 
    805 // --- InputReaderTest ---
    806 
    807 class InputReaderTest : public testing::Test {
    808 protected:
    809     sp<FakeInputDispatcher> mFakeDispatcher;
    810     sp<FakeInputReaderPolicy> mFakePolicy;
    811     sp<FakeEventHub> mFakeEventHub;
    812     sp<InstrumentedInputReader> mReader;
    813 
    814     virtual void SetUp() {
    815         mFakeEventHub = new FakeEventHub();
    816         mFakePolicy = new FakeInputReaderPolicy();
    817         mFakeDispatcher = new FakeInputDispatcher();
    818 
    819         mReader = new InstrumentedInputReader(mFakeEventHub, mFakePolicy, mFakeDispatcher);
    820     }
    821 
    822     virtual void TearDown() {
    823         mReader.clear();
    824 
    825         mFakeDispatcher.clear();
    826         mFakePolicy.clear();
    827         mFakeEventHub.clear();
    828     }
    829 
    830     void addDevice(int32_t deviceId, const String8& name, uint32_t classes) {
    831         mFakeEventHub->addDevice(deviceId, name, classes);
    832         mFakeEventHub->finishDeviceScan();
    833         mReader->loopOnce();
    834         mReader->loopOnce();
    835         mFakeEventHub->assertQueueIsEmpty();
    836     }
    837 
    838     FakeInputMapper* addDeviceWithFakeInputMapper(int32_t deviceId,
    839             const String8& name, uint32_t classes, uint32_t sources) {
    840         InputDevice* device = new InputDevice(mReader.get(), deviceId, name);
    841         FakeInputMapper* mapper = new FakeInputMapper(device, sources);
    842         device->addMapper(mapper);
    843         mReader->setNextDevice(device);
    844         addDevice(deviceId, name, classes);
    845         return mapper;
    846     }
    847 };
    848 
    849 TEST_F(InputReaderTest, GetInputConfiguration_WhenNoDevices_ReturnsDefaults) {
    850     InputConfiguration config;
    851     mReader->getInputConfiguration(&config);
    852 
    853     ASSERT_EQ(InputConfiguration::KEYBOARD_NOKEYS, config.keyboard);
    854     ASSERT_EQ(InputConfiguration::NAVIGATION_NONAV, config.navigation);
    855     ASSERT_EQ(InputConfiguration::TOUCHSCREEN_NOTOUCH, config.touchScreen);
    856 }
    857 
    858 TEST_F(InputReaderTest, GetInputConfiguration_WhenAlphabeticKeyboardPresent_ReturnsQwertyKeyboard) {
    859     ASSERT_NO_FATAL_FAILURE(addDevice(0, String8("keyboard"),
    860             INPUT_DEVICE_CLASS_KEYBOARD | INPUT_DEVICE_CLASS_ALPHAKEY));
    861 
    862     InputConfiguration config;
    863     mReader->getInputConfiguration(&config);
    864 
    865     ASSERT_EQ(InputConfiguration::KEYBOARD_QWERTY, config.keyboard);
    866     ASSERT_EQ(InputConfiguration::NAVIGATION_NONAV, config.navigation);
    867     ASSERT_EQ(InputConfiguration::TOUCHSCREEN_NOTOUCH, config.touchScreen);
    868 }
    869 
    870 TEST_F(InputReaderTest, GetInputConfiguration_WhenTouchScreenPresent_ReturnsFingerTouchScreen) {
    871     ASSERT_NO_FATAL_FAILURE(addDevice(0, String8("touchscreen"),
    872             INPUT_DEVICE_CLASS_TOUCHSCREEN));
    873 
    874     InputConfiguration config;
    875     mReader->getInputConfiguration(&config);
    876 
    877     ASSERT_EQ(InputConfiguration::KEYBOARD_NOKEYS, config.keyboard);
    878     ASSERT_EQ(InputConfiguration::NAVIGATION_NONAV, config.navigation);
    879     ASSERT_EQ(InputConfiguration::TOUCHSCREEN_FINGER, config.touchScreen);
    880 }
    881 
    882 TEST_F(InputReaderTest, GetInputConfiguration_WhenTrackballPresent_ReturnsTrackballNavigation) {
    883     ASSERT_NO_FATAL_FAILURE(addDevice(0, String8("trackball"),
    884             INPUT_DEVICE_CLASS_TRACKBALL));
    885 
    886     InputConfiguration config;
    887     mReader->getInputConfiguration(&config);
    888 
    889     ASSERT_EQ(InputConfiguration::KEYBOARD_NOKEYS, config.keyboard);
    890     ASSERT_EQ(InputConfiguration::NAVIGATION_TRACKBALL, config.navigation);
    891     ASSERT_EQ(InputConfiguration::TOUCHSCREEN_NOTOUCH, config.touchScreen);
    892 }
    893 
    894 TEST_F(InputReaderTest, GetInputConfiguration_WhenDPadPresent_ReturnsDPadNavigation) {
    895     ASSERT_NO_FATAL_FAILURE(addDevice(0, String8("dpad"),
    896             INPUT_DEVICE_CLASS_DPAD));
    897 
    898     InputConfiguration config;
    899     mReader->getInputConfiguration(&config);
    900 
    901     ASSERT_EQ(InputConfiguration::KEYBOARD_NOKEYS, config.keyboard);
    902     ASSERT_EQ(InputConfiguration::NAVIGATION_DPAD, config.navigation);
    903     ASSERT_EQ(InputConfiguration::TOUCHSCREEN_NOTOUCH, config.touchScreen);
    904 }
    905 
    906 TEST_F(InputReaderTest, GetInputDeviceInfo_WhenDeviceIdIsValid) {
    907     ASSERT_NO_FATAL_FAILURE(addDevice(1, String8("keyboard"),
    908             INPUT_DEVICE_CLASS_KEYBOARD));
    909 
    910     InputDeviceInfo info;
    911     status_t result = mReader->getInputDeviceInfo(1, &info);
    912 
    913     ASSERT_EQ(OK, result);
    914     ASSERT_EQ(1, info.getId());
    915     ASSERT_STREQ("keyboard", info.getName().string());
    916     ASSERT_EQ(AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC, info.getKeyboardType());
    917     ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, info.getSources());
    918     ASSERT_EQ(size_t(0), info.getMotionRanges().size());
    919 }
    920 
    921 TEST_F(InputReaderTest, GetInputDeviceInfo_WhenDeviceIdIsInvalid) {
    922     InputDeviceInfo info;
    923     status_t result = mReader->getInputDeviceInfo(-1, &info);
    924 
    925     ASSERT_EQ(NAME_NOT_FOUND, result);
    926 }
    927 
    928 TEST_F(InputReaderTest, GetInputDeviceInfo_WhenDeviceIdIsIgnored) {
    929     addDevice(1, String8("ignored"), 0); // no classes so device will be ignored
    930 
    931     InputDeviceInfo info;
    932     status_t result = mReader->getInputDeviceInfo(1, &info);
    933 
    934     ASSERT_EQ(NAME_NOT_FOUND, result);
    935 }
    936 
    937 TEST_F(InputReaderTest, GetInputDeviceIds) {
    938     ASSERT_NO_FATAL_FAILURE(addDevice(1, String8("keyboard"),
    939             INPUT_DEVICE_CLASS_KEYBOARD | INPUT_DEVICE_CLASS_ALPHAKEY));
    940     ASSERT_NO_FATAL_FAILURE(addDevice(2, String8("trackball"),
    941             INPUT_DEVICE_CLASS_TRACKBALL));
    942 
    943     Vector<int32_t> ids;
    944     mReader->getInputDeviceIds(ids);
    945 
    946     ASSERT_EQ(size_t(2), ids.size());
    947     ASSERT_EQ(1, ids[0]);
    948     ASSERT_EQ(2, ids[1]);
    949 }
    950 
    951 TEST_F(InputReaderTest, GetKeyCodeState_ForwardsRequestsToMappers) {
    952     FakeInputMapper* mapper = NULL;
    953     ASSERT_NO_FATAL_FAILURE(mapper = addDeviceWithFakeInputMapper(1, String8("fake"),
    954             INPUT_DEVICE_CLASS_KEYBOARD, AINPUT_SOURCE_KEYBOARD));
    955     mapper->setKeyCodeState(AKEYCODE_A, AKEY_STATE_DOWN);
    956 
    957     ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getKeyCodeState(0,
    958             AINPUT_SOURCE_ANY, AKEYCODE_A))
    959             << "Should return unknown when the device id is >= 0 but unknown.";
    960 
    961     ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getKeyCodeState(1,
    962             AINPUT_SOURCE_TRACKBALL, AKEYCODE_A))
    963             << "Should return unknown when the device id is valid but the sources are not supported by the device.";
    964 
    965     ASSERT_EQ(AKEY_STATE_DOWN, mReader->getKeyCodeState(1,
    966             AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, AKEYCODE_A))
    967             << "Should return value provided by mapper when device id is valid and the device supports some of the sources.";
    968 
    969     ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getKeyCodeState(-1,
    970             AINPUT_SOURCE_TRACKBALL, AKEYCODE_A))
    971             << "Should return unknown when the device id is < 0 but the sources are not supported by any device.";
    972 
    973     ASSERT_EQ(AKEY_STATE_DOWN, mReader->getKeyCodeState(-1,
    974             AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, AKEYCODE_A))
    975             << "Should return value provided by mapper when device id is < 0 and one of the devices supports some of the sources.";
    976 }
    977 
    978 TEST_F(InputReaderTest, GetScanCodeState_ForwardsRequestsToMappers) {
    979     FakeInputMapper* mapper = NULL;
    980     ASSERT_NO_FATAL_FAILURE(mapper = addDeviceWithFakeInputMapper(1, String8("fake"),
    981             INPUT_DEVICE_CLASS_KEYBOARD, AINPUT_SOURCE_KEYBOARD));
    982     mapper->setScanCodeState(KEY_A, AKEY_STATE_DOWN);
    983 
    984     ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getScanCodeState(0,
    985             AINPUT_SOURCE_ANY, KEY_A))
    986             << "Should return unknown when the device id is >= 0 but unknown.";
    987 
    988     ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getScanCodeState(1,
    989             AINPUT_SOURCE_TRACKBALL, KEY_A))
    990             << "Should return unknown when the device id is valid but the sources are not supported by the device.";
    991 
    992     ASSERT_EQ(AKEY_STATE_DOWN, mReader->getScanCodeState(1,
    993             AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, KEY_A))
    994             << "Should return value provided by mapper when device id is valid and the device supports some of the sources.";
    995 
    996     ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getScanCodeState(-1,
    997             AINPUT_SOURCE_TRACKBALL, KEY_A))
    998             << "Should return unknown when the device id is < 0 but the sources are not supported by any device.";
    999 
   1000     ASSERT_EQ(AKEY_STATE_DOWN, mReader->getScanCodeState(-1,
   1001             AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, KEY_A))
   1002             << "Should return value provided by mapper when device id is < 0 and one of the devices supports some of the sources.";
   1003 }
   1004 
   1005 TEST_F(InputReaderTest, GetSwitchState_ForwardsRequestsToMappers) {
   1006     FakeInputMapper* mapper = NULL;
   1007     ASSERT_NO_FATAL_FAILURE(mapper = addDeviceWithFakeInputMapper(1, String8("fake"),
   1008             INPUT_DEVICE_CLASS_KEYBOARD, AINPUT_SOURCE_KEYBOARD));
   1009     mapper->setSwitchState(SW_LID, AKEY_STATE_DOWN);
   1010 
   1011     ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getSwitchState(0,
   1012             AINPUT_SOURCE_ANY, SW_LID))
   1013             << "Should return unknown when the device id is >= 0 but unknown.";
   1014 
   1015     ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getSwitchState(1,
   1016             AINPUT_SOURCE_TRACKBALL, SW_LID))
   1017             << "Should return unknown when the device id is valid but the sources are not supported by the device.";
   1018 
   1019     ASSERT_EQ(AKEY_STATE_DOWN, mReader->getSwitchState(1,
   1020             AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, SW_LID))
   1021             << "Should return value provided by mapper when device id is valid and the device supports some of the sources.";
   1022 
   1023     ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getSwitchState(-1,
   1024             AINPUT_SOURCE_TRACKBALL, SW_LID))
   1025             << "Should return unknown when the device id is < 0 but the sources are not supported by any device.";
   1026 
   1027     ASSERT_EQ(AKEY_STATE_DOWN, mReader->getSwitchState(-1,
   1028             AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, SW_LID))
   1029             << "Should return value provided by mapper when device id is < 0 and one of the devices supports some of the sources.";
   1030 }
   1031 
   1032 TEST_F(InputReaderTest, MarkSupportedKeyCodes_ForwardsRequestsToMappers) {
   1033     FakeInputMapper* mapper = NULL;
   1034     ASSERT_NO_FATAL_FAILURE(mapper = addDeviceWithFakeInputMapper(1, String8("fake"),
   1035             INPUT_DEVICE_CLASS_KEYBOARD, AINPUT_SOURCE_KEYBOARD));
   1036     mapper->addSupportedKeyCode(AKEYCODE_A);
   1037     mapper->addSupportedKeyCode(AKEYCODE_B);
   1038 
   1039     const int32_t keyCodes[4] = { AKEYCODE_A, AKEYCODE_B, AKEYCODE_1, AKEYCODE_2 };
   1040     uint8_t flags[4] = { 0, 0, 0, 1 };
   1041 
   1042     ASSERT_FALSE(mReader->hasKeys(0, AINPUT_SOURCE_ANY, 4, keyCodes, flags))
   1043             << "Should return false when device id is >= 0 but unknown.";
   1044     ASSERT_TRUE(!flags[0] && !flags[1] && !flags[2] && !flags[3]);
   1045 
   1046     flags[3] = 1;
   1047     ASSERT_FALSE(mReader->hasKeys(1, AINPUT_SOURCE_TRACKBALL, 4, keyCodes, flags))
   1048             << "Should return false when device id is valid but the sources are not supported by the device.";
   1049     ASSERT_TRUE(!flags[0] && !flags[1] && !flags[2] && !flags[3]);
   1050 
   1051     flags[3] = 1;
   1052     ASSERT_TRUE(mReader->hasKeys(1, AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, 4, keyCodes, flags))
   1053             << "Should return value provided by mapper when device id is valid and the device supports some of the sources.";
   1054     ASSERT_TRUE(flags[0] && flags[1] && !flags[2] && !flags[3]);
   1055 
   1056     flags[3] = 1;
   1057     ASSERT_FALSE(mReader->hasKeys(-1, AINPUT_SOURCE_TRACKBALL, 4, keyCodes, flags))
   1058             << "Should return false when the device id is < 0 but the sources are not supported by any device.";
   1059     ASSERT_TRUE(!flags[0] && !flags[1] && !flags[2] && !flags[3]);
   1060 
   1061     flags[3] = 1;
   1062     ASSERT_TRUE(mReader->hasKeys(-1, AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, 4, keyCodes, flags))
   1063             << "Should return value provided by mapper when device id is < 0 and one of the devices supports some of the sources.";
   1064     ASSERT_TRUE(flags[0] && flags[1] && !flags[2] && !flags[3]);
   1065 }
   1066 
   1067 TEST_F(InputReaderTest, LoopOnce_WhenDeviceScanFinished_SendsConfigurationChanged) {
   1068     addDevice(1, String8("ignored"), INPUT_DEVICE_CLASS_KEYBOARD);
   1069 
   1070     FakeInputDispatcher::NotifyConfigurationChangedArgs args;
   1071     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyConfigurationChangedWasCalled(&args));
   1072     ASSERT_EQ(ARBITRARY_TIME, args.eventTime);
   1073 }
   1074 
   1075 TEST_F(InputReaderTest, LoopOnce_ForwardsRawEventsToMappers) {
   1076     FakeInputMapper* mapper = NULL;
   1077     ASSERT_NO_FATAL_FAILURE(mapper = addDeviceWithFakeInputMapper(1, String8("fake"),
   1078             INPUT_DEVICE_CLASS_KEYBOARD, AINPUT_SOURCE_KEYBOARD));
   1079 
   1080     mFakeEventHub->enqueueEvent(0, 1, EV_KEY, KEY_A, AKEYCODE_A, 1, POLICY_FLAG_WAKE);
   1081     mReader->loopOnce();
   1082     ASSERT_NO_FATAL_FAILURE(mFakeEventHub->assertQueueIsEmpty());
   1083 
   1084     RawEvent event;
   1085     ASSERT_NO_FATAL_FAILURE(mapper->assertProcessWasCalled(&event));
   1086     ASSERT_EQ(0, event.when);
   1087     ASSERT_EQ(1, event.deviceId);
   1088     ASSERT_EQ(EV_KEY, event.type);
   1089     ASSERT_EQ(KEY_A, event.scanCode);
   1090     ASSERT_EQ(AKEYCODE_A, event.keyCode);
   1091     ASSERT_EQ(1, event.value);
   1092     ASSERT_EQ(POLICY_FLAG_WAKE, event.flags);
   1093 }
   1094 
   1095 
   1096 // --- InputDeviceTest ---
   1097 
   1098 class InputDeviceTest : public testing::Test {
   1099 protected:
   1100     static const char* DEVICE_NAME;
   1101     static const int32_t DEVICE_ID;
   1102 
   1103     sp<FakeEventHub> mFakeEventHub;
   1104     sp<FakeInputReaderPolicy> mFakePolicy;
   1105     sp<FakeInputDispatcher> mFakeDispatcher;
   1106     FakeInputReaderContext* mFakeContext;
   1107 
   1108     InputDevice* mDevice;
   1109 
   1110     virtual void SetUp() {
   1111         mFakeEventHub = new FakeEventHub();
   1112         mFakePolicy = new FakeInputReaderPolicy();
   1113         mFakeDispatcher = new FakeInputDispatcher();
   1114         mFakeContext = new FakeInputReaderContext(mFakeEventHub, mFakePolicy, mFakeDispatcher);
   1115 
   1116         mDevice = new InputDevice(mFakeContext, DEVICE_ID, String8(DEVICE_NAME));
   1117     }
   1118 
   1119     virtual void TearDown() {
   1120         delete mDevice;
   1121 
   1122         delete mFakeContext;
   1123         mFakeDispatcher.clear();
   1124         mFakePolicy.clear();
   1125         mFakeEventHub.clear();
   1126     }
   1127 };
   1128 
   1129 const char* InputDeviceTest::DEVICE_NAME = "device";
   1130 const int32_t InputDeviceTest::DEVICE_ID = 1;
   1131 
   1132 TEST_F(InputDeviceTest, ImmutableProperties) {
   1133     ASSERT_EQ(DEVICE_ID, mDevice->getId());
   1134     ASSERT_STREQ(DEVICE_NAME, mDevice->getName());
   1135 }
   1136 
   1137 TEST_F(InputDeviceTest, WhenNoMappersAreRegistered_DeviceIsIgnored) {
   1138     // Configuration.
   1139     mDevice->configure();
   1140 
   1141     // Metadata.
   1142     ASSERT_TRUE(mDevice->isIgnored());
   1143     ASSERT_EQ(AINPUT_SOURCE_UNKNOWN, mDevice->getSources());
   1144 
   1145     InputDeviceInfo info;
   1146     mDevice->getDeviceInfo(&info);
   1147     ASSERT_EQ(DEVICE_ID, info.getId());
   1148     ASSERT_STREQ(DEVICE_NAME, info.getName().string());
   1149     ASSERT_EQ(AINPUT_KEYBOARD_TYPE_NONE, info.getKeyboardType());
   1150     ASSERT_EQ(AINPUT_SOURCE_UNKNOWN, info.getSources());
   1151 
   1152     // State queries.
   1153     ASSERT_EQ(0, mDevice->getMetaState());
   1154 
   1155     ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getKeyCodeState(AINPUT_SOURCE_KEYBOARD, 0))
   1156             << "Ignored device should return unknown key code state.";
   1157     ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getScanCodeState(AINPUT_SOURCE_KEYBOARD, 0))
   1158             << "Ignored device should return unknown scan code state.";
   1159     ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getSwitchState(AINPUT_SOURCE_KEYBOARD, 0))
   1160             << "Ignored device should return unknown switch state.";
   1161 
   1162     const int32_t keyCodes[2] = { AKEYCODE_A, AKEYCODE_B };
   1163     uint8_t flags[2] = { 0, 1 };
   1164     ASSERT_FALSE(mDevice->markSupportedKeyCodes(AINPUT_SOURCE_KEYBOARD, 2, keyCodes, flags))
   1165             << "Ignored device should never mark any key codes.";
   1166     ASSERT_EQ(0, flags[0]) << "Flag for unsupported key should be unchanged.";
   1167     ASSERT_EQ(1, flags[1]) << "Flag for unsupported key should be unchanged.";
   1168 
   1169     // Reset.
   1170     mDevice->reset();
   1171 }
   1172 
   1173 TEST_F(InputDeviceTest, WhenMappersAreRegistered_DeviceIsNotIgnoredAndForwardsRequestsToMappers) {
   1174     // Configuration.
   1175     InputDeviceCalibration calibration;
   1176     calibration.addProperty(String8("key"), String8("value"));
   1177     mFakePolicy->addInputDeviceCalibration(String8(DEVICE_NAME), calibration);
   1178 
   1179     FakeInputMapper* mapper1 = new FakeInputMapper(mDevice, AINPUT_SOURCE_KEYBOARD);
   1180     mapper1->setKeyboardType(AINPUT_KEYBOARD_TYPE_ALPHABETIC);
   1181     mapper1->setMetaState(AMETA_ALT_ON);
   1182     mapper1->addSupportedKeyCode(AKEYCODE_A);
   1183     mapper1->addSupportedKeyCode(AKEYCODE_B);
   1184     mapper1->setKeyCodeState(AKEYCODE_A, AKEY_STATE_DOWN);
   1185     mapper1->setKeyCodeState(AKEYCODE_B, AKEY_STATE_UP);
   1186     mapper1->setScanCodeState(2, AKEY_STATE_DOWN);
   1187     mapper1->setScanCodeState(3, AKEY_STATE_UP);
   1188     mapper1->setSwitchState(4, AKEY_STATE_DOWN);
   1189     mDevice->addMapper(mapper1);
   1190 
   1191     FakeInputMapper* mapper2 = new FakeInputMapper(mDevice, AINPUT_SOURCE_TOUCHSCREEN);
   1192     mapper2->setMetaState(AMETA_SHIFT_ON);
   1193     mDevice->addMapper(mapper2);
   1194 
   1195     mDevice->configure();
   1196 
   1197     String8 propertyValue;
   1198     ASSERT_TRUE(mDevice->getCalibration().tryGetProperty(String8("key"), propertyValue))
   1199             << "Device should have read calibration during configuration phase.";
   1200     ASSERT_STREQ("value", propertyValue.string());
   1201 
   1202     ASSERT_NO_FATAL_FAILURE(mapper1->assertConfigureWasCalled());
   1203     ASSERT_NO_FATAL_FAILURE(mapper2->assertConfigureWasCalled());
   1204 
   1205     // Metadata.
   1206     ASSERT_FALSE(mDevice->isIgnored());
   1207     ASSERT_EQ(uint32_t(AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TOUCHSCREEN), mDevice->getSources());
   1208 
   1209     InputDeviceInfo info;
   1210     mDevice->getDeviceInfo(&info);
   1211     ASSERT_EQ(DEVICE_ID, info.getId());
   1212     ASSERT_STREQ(DEVICE_NAME, info.getName().string());
   1213     ASSERT_EQ(AINPUT_KEYBOARD_TYPE_ALPHABETIC, info.getKeyboardType());
   1214     ASSERT_EQ(uint32_t(AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TOUCHSCREEN), info.getSources());
   1215 
   1216     // State queries.
   1217     ASSERT_EQ(AMETA_ALT_ON | AMETA_SHIFT_ON, mDevice->getMetaState())
   1218             << "Should query mappers and combine meta states.";
   1219 
   1220     ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getKeyCodeState(AINPUT_SOURCE_TRACKBALL, AKEYCODE_A))
   1221             << "Should return unknown key code state when source not supported.";
   1222     ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getScanCodeState(AINPUT_SOURCE_TRACKBALL, AKEYCODE_A))
   1223             << "Should return unknown scan code state when source not supported.";
   1224     ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getSwitchState(AINPUT_SOURCE_TRACKBALL, AKEYCODE_A))
   1225             << "Should return unknown switch state when source not supported.";
   1226 
   1227     ASSERT_EQ(AKEY_STATE_DOWN, mDevice->getKeyCodeState(AINPUT_SOURCE_KEYBOARD, AKEYCODE_A))
   1228             << "Should query mapper when source is supported.";
   1229     ASSERT_EQ(AKEY_STATE_UP, mDevice->getScanCodeState(AINPUT_SOURCE_KEYBOARD, 3))
   1230             << "Should query mapper when source is supported.";
   1231     ASSERT_EQ(AKEY_STATE_DOWN, mDevice->getSwitchState(AINPUT_SOURCE_KEYBOARD, 4))
   1232             << "Should query mapper when source is supported.";
   1233 
   1234     const int32_t keyCodes[4] = { AKEYCODE_A, AKEYCODE_B, AKEYCODE_1, AKEYCODE_2 };
   1235     uint8_t flags[4] = { 0, 0, 0, 1 };
   1236     ASSERT_FALSE(mDevice->markSupportedKeyCodes(AINPUT_SOURCE_TRACKBALL, 4, keyCodes, flags))
   1237             << "Should do nothing when source is unsupported.";
   1238     ASSERT_EQ(0, flags[0]) << "Flag should be unchanged when source is unsupported.";
   1239     ASSERT_EQ(0, flags[1]) << "Flag should be unchanged when source is unsupported.";
   1240     ASSERT_EQ(0, flags[2]) << "Flag should be unchanged when source is unsupported.";
   1241     ASSERT_EQ(1, flags[3]) << "Flag should be unchanged when source is unsupported.";
   1242 
   1243     ASSERT_TRUE(mDevice->markSupportedKeyCodes(AINPUT_SOURCE_KEYBOARD, 4, keyCodes, flags))
   1244             << "Should query mapper when source is supported.";
   1245     ASSERT_EQ(1, flags[0]) << "Flag for supported key should be set.";
   1246     ASSERT_EQ(1, flags[1]) << "Flag for supported key should be set.";
   1247     ASSERT_EQ(0, flags[2]) << "Flag for unsupported key should be unchanged.";
   1248     ASSERT_EQ(1, flags[3]) << "Flag for unsupported key should be unchanged.";
   1249 
   1250     // Event handling.
   1251     RawEvent event;
   1252     mDevice->process(&event);
   1253 
   1254     ASSERT_NO_FATAL_FAILURE(mapper1->assertProcessWasCalled());
   1255     ASSERT_NO_FATAL_FAILURE(mapper2->assertProcessWasCalled());
   1256 
   1257     // Reset.
   1258     mDevice->reset();
   1259 
   1260     ASSERT_NO_FATAL_FAILURE(mapper1->assertResetWasCalled());
   1261     ASSERT_NO_FATAL_FAILURE(mapper2->assertResetWasCalled());
   1262 }
   1263 
   1264 
   1265 // --- InputMapperTest ---
   1266 
   1267 class InputMapperTest : public testing::Test {
   1268 protected:
   1269     static const char* DEVICE_NAME;
   1270     static const int32_t DEVICE_ID;
   1271 
   1272     sp<FakeEventHub> mFakeEventHub;
   1273     sp<FakeInputReaderPolicy> mFakePolicy;
   1274     sp<FakeInputDispatcher> mFakeDispatcher;
   1275     FakeInputReaderContext* mFakeContext;
   1276     InputDevice* mDevice;
   1277 
   1278     virtual void SetUp() {
   1279         mFakeEventHub = new FakeEventHub();
   1280         mFakePolicy = new FakeInputReaderPolicy();
   1281         mFakeDispatcher = new FakeInputDispatcher();
   1282         mFakeContext = new FakeInputReaderContext(mFakeEventHub, mFakePolicy, mFakeDispatcher);
   1283         mDevice = new InputDevice(mFakeContext, DEVICE_ID, String8(DEVICE_NAME));
   1284 
   1285         mFakeEventHub->addDevice(DEVICE_ID, String8(DEVICE_NAME), 0);
   1286     }
   1287 
   1288     virtual void TearDown() {
   1289         delete mDevice;
   1290         delete mFakeContext;
   1291         mFakeDispatcher.clear();
   1292         mFakePolicy.clear();
   1293         mFakeEventHub.clear();
   1294     }
   1295 
   1296     void prepareCalibration(const char* key, const char* value) {
   1297         mFakePolicy->addInputDeviceCalibrationProperty(String8(DEVICE_NAME),
   1298                 String8(key), String8(value));
   1299     }
   1300 
   1301     void addMapperAndConfigure(InputMapper* mapper) {
   1302         mDevice->addMapper(mapper);
   1303         mDevice->configure();
   1304     }
   1305 
   1306     static void process(InputMapper* mapper, nsecs_t when, int32_t deviceId, int32_t type,
   1307             int32_t scanCode, int32_t keyCode, int32_t value, uint32_t flags) {
   1308         RawEvent event;
   1309         event.when = when;
   1310         event.deviceId = deviceId;
   1311         event.type = type;
   1312         event.scanCode = scanCode;
   1313         event.keyCode = keyCode;
   1314         event.value = value;
   1315         event.flags = flags;
   1316         mapper->process(&event);
   1317     }
   1318 
   1319     static void assertMotionRange(const InputDeviceInfo& info,
   1320             int32_t rangeType, float min, float max, float flat, float fuzz) {
   1321         const InputDeviceInfo::MotionRange* range = info.getMotionRange(rangeType);
   1322         ASSERT_TRUE(range != NULL) << "Range: " << rangeType;
   1323         ASSERT_NEAR(min, range->min, EPSILON) << "Range: " << rangeType;
   1324         ASSERT_NEAR(max, range->max, EPSILON) << "Range: " << rangeType;
   1325         ASSERT_NEAR(flat, range->flat, EPSILON) << "Range: " << rangeType;
   1326         ASSERT_NEAR(fuzz, range->fuzz, EPSILON) << "Range: " << rangeType;
   1327     }
   1328 
   1329     static void assertPointerCoords(const PointerCoords& coords,
   1330             float x, float y, float pressure, float size,
   1331             float touchMajor, float touchMinor, float toolMajor, float toolMinor,
   1332             float orientation) {
   1333         ASSERT_NEAR(x, coords.x, 1);
   1334         ASSERT_NEAR(y, coords.y, 1);
   1335         ASSERT_NEAR(pressure, coords.pressure, EPSILON);
   1336         ASSERT_NEAR(size, coords.size, EPSILON);
   1337         ASSERT_NEAR(touchMajor, coords.touchMajor, 1);
   1338         ASSERT_NEAR(touchMinor, coords.touchMinor, 1);
   1339         ASSERT_NEAR(toolMajor, coords.toolMajor, 1);
   1340         ASSERT_NEAR(toolMinor, coords.toolMinor, 1);
   1341         ASSERT_NEAR(orientation, coords.orientation, EPSILON);
   1342     }
   1343 };
   1344 
   1345 const char* InputMapperTest::DEVICE_NAME = "device";
   1346 const int32_t InputMapperTest::DEVICE_ID = 1;
   1347 
   1348 
   1349 // --- SwitchInputMapperTest ---
   1350 
   1351 class SwitchInputMapperTest : public InputMapperTest {
   1352 protected:
   1353 };
   1354 
   1355 TEST_F(SwitchInputMapperTest, GetSources) {
   1356     SwitchInputMapper* mapper = new SwitchInputMapper(mDevice);
   1357     addMapperAndConfigure(mapper);
   1358 
   1359     ASSERT_EQ(uint32_t(0), mapper->getSources());
   1360 }
   1361 
   1362 TEST_F(SwitchInputMapperTest, GetSwitchState) {
   1363     SwitchInputMapper* mapper = new SwitchInputMapper(mDevice);
   1364     addMapperAndConfigure(mapper);
   1365 
   1366     mFakeEventHub->setSwitchState(DEVICE_ID, SW_LID, 1);
   1367     ASSERT_EQ(1, mapper->getSwitchState(AINPUT_SOURCE_ANY, SW_LID));
   1368 
   1369     mFakeEventHub->setSwitchState(DEVICE_ID, SW_LID, 0);
   1370     ASSERT_EQ(0, mapper->getSwitchState(AINPUT_SOURCE_ANY, SW_LID));
   1371 }
   1372 
   1373 TEST_F(SwitchInputMapperTest, Process) {
   1374     SwitchInputMapper* mapper = new SwitchInputMapper(mDevice);
   1375     addMapperAndConfigure(mapper);
   1376 
   1377     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SW, SW_LID, 0, 1, 0);
   1378 
   1379     FakeInputDispatcher::NotifySwitchArgs args;
   1380     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifySwitchWasCalled(&args));
   1381     ASSERT_EQ(ARBITRARY_TIME, args.when);
   1382     ASSERT_EQ(SW_LID, args.switchCode);
   1383     ASSERT_EQ(1, args.switchValue);
   1384     ASSERT_EQ(uint32_t(0), args.policyFlags);
   1385 }
   1386 
   1387 
   1388 // --- KeyboardInputMapperTest ---
   1389 
   1390 class KeyboardInputMapperTest : public InputMapperTest {
   1391 protected:
   1392     void testDPadKeyRotation(KeyboardInputMapper* mapper,
   1393             int32_t originalScanCode, int32_t originalKeyCode, int32_t rotatedKeyCode);
   1394 };
   1395 
   1396 void KeyboardInputMapperTest::testDPadKeyRotation(KeyboardInputMapper* mapper,
   1397         int32_t originalScanCode, int32_t originalKeyCode, int32_t rotatedKeyCode) {
   1398     FakeInputDispatcher::NotifyKeyArgs args;
   1399 
   1400     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, originalScanCode, originalKeyCode, 1, 0);
   1401     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
   1402     ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, args.action);
   1403     ASSERT_EQ(originalScanCode, args.scanCode);
   1404     ASSERT_EQ(rotatedKeyCode, args.keyCode);
   1405 
   1406     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, originalScanCode, originalKeyCode, 0, 0);
   1407     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
   1408     ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action);
   1409     ASSERT_EQ(originalScanCode, args.scanCode);
   1410     ASSERT_EQ(rotatedKeyCode, args.keyCode);
   1411 }
   1412 
   1413 
   1414 TEST_F(KeyboardInputMapperTest, GetSources) {
   1415     KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, -1,
   1416             AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
   1417     addMapperAndConfigure(mapper);
   1418 
   1419     ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, mapper->getSources());
   1420 }
   1421 
   1422 TEST_F(KeyboardInputMapperTest, Process_SimpleKeyPress) {
   1423     KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, -1,
   1424             AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
   1425     addMapperAndConfigure(mapper);
   1426 
   1427     // Key down.
   1428     process(mapper, ARBITRARY_TIME, DEVICE_ID,
   1429             EV_KEY, KEY_HOME, AKEYCODE_HOME, 1, POLICY_FLAG_WAKE);
   1430     FakeInputDispatcher::NotifyKeyArgs args;
   1431     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
   1432     ASSERT_EQ(DEVICE_ID, args.deviceId);
   1433     ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source);
   1434     ASSERT_EQ(ARBITRARY_TIME, args.eventTime);
   1435     ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, args.action);
   1436     ASSERT_EQ(AKEYCODE_HOME, args.keyCode);
   1437     ASSERT_EQ(KEY_HOME, args.scanCode);
   1438     ASSERT_EQ(AMETA_NONE, args.metaState);
   1439     ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, args.flags);
   1440     ASSERT_EQ(POLICY_FLAG_WAKE, args.policyFlags);
   1441     ASSERT_EQ(ARBITRARY_TIME, args.downTime);
   1442 
   1443     // Key up.
   1444     process(mapper, ARBITRARY_TIME + 1, DEVICE_ID,
   1445             EV_KEY, KEY_HOME, AKEYCODE_HOME, 0, POLICY_FLAG_WAKE);
   1446     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
   1447     ASSERT_EQ(DEVICE_ID, args.deviceId);
   1448     ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source);
   1449     ASSERT_EQ(ARBITRARY_TIME + 1, args.eventTime);
   1450     ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action);
   1451     ASSERT_EQ(AKEYCODE_HOME, args.keyCode);
   1452     ASSERT_EQ(KEY_HOME, args.scanCode);
   1453     ASSERT_EQ(AMETA_NONE, args.metaState);
   1454     ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, args.flags);
   1455     ASSERT_EQ(POLICY_FLAG_WAKE, args.policyFlags);
   1456     ASSERT_EQ(ARBITRARY_TIME, args.downTime);
   1457 }
   1458 
   1459 TEST_F(KeyboardInputMapperTest, Reset_WhenKeysAreNotDown_DoesNotSynthesizeKeyUp) {
   1460     KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, -1,
   1461             AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
   1462     addMapperAndConfigure(mapper);
   1463 
   1464     // Key down.
   1465     process(mapper, ARBITRARY_TIME, DEVICE_ID,
   1466             EV_KEY, KEY_HOME, AKEYCODE_HOME, 1, POLICY_FLAG_WAKE);
   1467     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
   1468 
   1469     // Key up.
   1470     process(mapper, ARBITRARY_TIME, DEVICE_ID,
   1471             EV_KEY, KEY_HOME, AKEYCODE_HOME, 0, POLICY_FLAG_WAKE);
   1472     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
   1473 
   1474     // Reset.  Since no keys still down, should not synthesize any key ups.
   1475     mapper->reset();
   1476     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled());
   1477 }
   1478 
   1479 TEST_F(KeyboardInputMapperTest, Reset_WhenKeysAreDown_SynthesizesKeyUps) {
   1480     KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, -1,
   1481             AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
   1482     addMapperAndConfigure(mapper);
   1483 
   1484     // Metakey down.
   1485     process(mapper, ARBITRARY_TIME, DEVICE_ID,
   1486             EV_KEY, KEY_LEFTSHIFT, AKEYCODE_SHIFT_LEFT, 1, 0);
   1487     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
   1488 
   1489     // Key down.
   1490     process(mapper, ARBITRARY_TIME + 1, DEVICE_ID,
   1491             EV_KEY, KEY_A, AKEYCODE_A, 1, 0);
   1492     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
   1493 
   1494     // Reset.  Since two keys are still down, should synthesize two key ups in reverse order.
   1495     mapper->reset();
   1496 
   1497     FakeInputDispatcher::NotifyKeyArgs args;
   1498     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
   1499     ASSERT_EQ(DEVICE_ID, args.deviceId);
   1500     ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source);
   1501     ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action);
   1502     ASSERT_EQ(AKEYCODE_A, args.keyCode);
   1503     ASSERT_EQ(KEY_A, args.scanCode);
   1504     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
   1505     ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, args.flags);
   1506     ASSERT_EQ(uint32_t(0), args.policyFlags);
   1507     ASSERT_EQ(ARBITRARY_TIME + 1, args.downTime);
   1508 
   1509     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
   1510     ASSERT_EQ(DEVICE_ID, args.deviceId);
   1511     ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source);
   1512     ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action);
   1513     ASSERT_EQ(AKEYCODE_SHIFT_LEFT, args.keyCode);
   1514     ASSERT_EQ(KEY_LEFTSHIFT, args.scanCode);
   1515     ASSERT_EQ(AMETA_NONE, args.metaState);
   1516     ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, args.flags);
   1517     ASSERT_EQ(uint32_t(0), args.policyFlags);
   1518     ASSERT_EQ(ARBITRARY_TIME + 1, args.downTime);
   1519 
   1520     // And that's it.
   1521     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled());
   1522 }
   1523 
   1524 TEST_F(KeyboardInputMapperTest, Process_ShouldUpdateMetaState) {
   1525     KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, -1,
   1526             AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
   1527     addMapperAndConfigure(mapper);
   1528 
   1529     // Initial metastate.
   1530     ASSERT_EQ(AMETA_NONE, mapper->getMetaState());
   1531 
   1532     // Metakey down.
   1533     process(mapper, ARBITRARY_TIME, DEVICE_ID,
   1534             EV_KEY, KEY_LEFTSHIFT, AKEYCODE_SHIFT_LEFT, 1, 0);
   1535     FakeInputDispatcher::NotifyKeyArgs args;
   1536     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
   1537     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
   1538     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, mapper->getMetaState());
   1539     ASSERT_NO_FATAL_FAILURE(mFakeContext->assertUpdateGlobalMetaStateWasCalled());
   1540 
   1541     // Key down.
   1542     process(mapper, ARBITRARY_TIME + 1, DEVICE_ID,
   1543             EV_KEY, KEY_A, AKEYCODE_A, 1, 0);
   1544     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
   1545     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
   1546     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, mapper->getMetaState());
   1547 
   1548     // Key up.
   1549     process(mapper, ARBITRARY_TIME + 2, DEVICE_ID,
   1550             EV_KEY, KEY_A, AKEYCODE_A, 0, 0);
   1551     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
   1552     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
   1553     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, mapper->getMetaState());
   1554 
   1555     // Metakey up.
   1556     process(mapper, ARBITRARY_TIME + 3, DEVICE_ID,
   1557             EV_KEY, KEY_LEFTSHIFT, AKEYCODE_SHIFT_LEFT, 0, 0);
   1558     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
   1559     ASSERT_EQ(AMETA_NONE, args.metaState);
   1560     ASSERT_EQ(AMETA_NONE, mapper->getMetaState());
   1561     ASSERT_NO_FATAL_FAILURE(mFakeContext->assertUpdateGlobalMetaStateWasCalled());
   1562 }
   1563 
   1564 TEST_F(KeyboardInputMapperTest, Process_WhenNotAttachedToDisplay_ShouldNotRotateDPad) {
   1565     KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, -1,
   1566             AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
   1567     addMapperAndConfigure(mapper);
   1568 
   1569     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
   1570             KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_UP));
   1571     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
   1572             KEY_RIGHT, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_RIGHT));
   1573     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
   1574             KEY_DOWN, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_DOWN));
   1575     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
   1576             KEY_LEFT, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_LEFT));
   1577 }
   1578 
   1579 TEST_F(KeyboardInputMapperTest, Process_WhenAttachedToDisplay_ShouldRotateDPad) {
   1580     KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, DISPLAY_ID,
   1581             AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
   1582     addMapperAndConfigure(mapper);
   1583 
   1584     mFakePolicy->setDisplayInfo(DISPLAY_ID,
   1585             DISPLAY_WIDTH, DISPLAY_HEIGHT,
   1586             InputReaderPolicyInterface::ROTATION_0);
   1587     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
   1588             KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_UP));
   1589     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
   1590             KEY_RIGHT, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_RIGHT));
   1591     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
   1592             KEY_DOWN, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_DOWN));
   1593     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
   1594             KEY_LEFT, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_LEFT));
   1595 
   1596     mFakePolicy->setDisplayInfo(DISPLAY_ID,
   1597             DISPLAY_WIDTH, DISPLAY_HEIGHT,
   1598             InputReaderPolicyInterface::ROTATION_90);
   1599     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
   1600             KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_LEFT));
   1601     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
   1602             KEY_RIGHT, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_UP));
   1603     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
   1604             KEY_DOWN, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_RIGHT));
   1605     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
   1606             KEY_LEFT, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_DOWN));
   1607 
   1608     mFakePolicy->setDisplayInfo(DISPLAY_ID,
   1609             DISPLAY_WIDTH, DISPLAY_HEIGHT,
   1610             InputReaderPolicyInterface::ROTATION_180);
   1611     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
   1612             KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_DOWN));
   1613     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
   1614             KEY_RIGHT, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_LEFT));
   1615     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
   1616             KEY_DOWN, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_UP));
   1617     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
   1618             KEY_LEFT, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_RIGHT));
   1619 
   1620     mFakePolicy->setDisplayInfo(DISPLAY_ID,
   1621             DISPLAY_WIDTH, DISPLAY_HEIGHT,
   1622             InputReaderPolicyInterface::ROTATION_270);
   1623     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
   1624             KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_RIGHT));
   1625     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
   1626             KEY_RIGHT, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_DOWN));
   1627     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
   1628             KEY_DOWN, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_LEFT));
   1629     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
   1630             KEY_LEFT, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_UP));
   1631 
   1632     // Special case: if orientation changes while key is down, we still emit the same keycode
   1633     // in the key up as we did in the key down.
   1634     FakeInputDispatcher::NotifyKeyArgs args;
   1635 
   1636     mFakePolicy->setDisplayInfo(DISPLAY_ID,
   1637             DISPLAY_WIDTH, DISPLAY_HEIGHT,
   1638             InputReaderPolicyInterface::ROTATION_270);
   1639     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, KEY_UP, AKEYCODE_DPAD_UP, 1, 0);
   1640     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
   1641     ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, args.action);
   1642     ASSERT_EQ(KEY_UP, args.scanCode);
   1643     ASSERT_EQ(AKEYCODE_DPAD_RIGHT, args.keyCode);
   1644 
   1645     mFakePolicy->setDisplayInfo(DISPLAY_ID,
   1646             DISPLAY_WIDTH, DISPLAY_HEIGHT,
   1647             InputReaderPolicyInterface::ROTATION_180);
   1648     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, KEY_UP, AKEYCODE_DPAD_UP, 0, 0);
   1649     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
   1650     ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action);
   1651     ASSERT_EQ(KEY_UP, args.scanCode);
   1652     ASSERT_EQ(AKEYCODE_DPAD_RIGHT, args.keyCode);
   1653 }
   1654 
   1655 TEST_F(KeyboardInputMapperTest, GetKeyCodeState) {
   1656     KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, -1,
   1657             AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
   1658     addMapperAndConfigure(mapper);
   1659 
   1660     mFakeEventHub->setKeyCodeState(DEVICE_ID, AKEYCODE_A, 1);
   1661     ASSERT_EQ(1, mapper->getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_A));
   1662 
   1663     mFakeEventHub->setKeyCodeState(DEVICE_ID, AKEYCODE_A, 0);
   1664     ASSERT_EQ(0, mapper->getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_A));
   1665 }
   1666 
   1667 TEST_F(KeyboardInputMapperTest, GetScanCodeState) {
   1668     KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, -1,
   1669             AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
   1670     addMapperAndConfigure(mapper);
   1671 
   1672     mFakeEventHub->setScanCodeState(DEVICE_ID, KEY_A, 1);
   1673     ASSERT_EQ(1, mapper->getScanCodeState(AINPUT_SOURCE_ANY, KEY_A));
   1674 
   1675     mFakeEventHub->setScanCodeState(DEVICE_ID, KEY_A, 0);
   1676     ASSERT_EQ(0, mapper->getScanCodeState(AINPUT_SOURCE_ANY, KEY_A));
   1677 }
   1678 
   1679 TEST_F(KeyboardInputMapperTest, MarkSupportedKeyCodes) {
   1680     KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, -1,
   1681             AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
   1682     addMapperAndConfigure(mapper);
   1683 
   1684     mFakeEventHub->addKey(DEVICE_ID, KEY_A, AKEYCODE_A, 0);
   1685 
   1686     const int32_t keyCodes[2] = { AKEYCODE_A, AKEYCODE_B };
   1687     uint8_t flags[2] = { 0, 0 };
   1688     ASSERT_TRUE(mapper->markSupportedKeyCodes(AINPUT_SOURCE_ANY, 1, keyCodes, flags));
   1689     ASSERT_TRUE(flags[0]);
   1690     ASSERT_FALSE(flags[1]);
   1691 }
   1692 
   1693 
   1694 // --- TrackballInputMapperTest ---
   1695 
   1696 class TrackballInputMapperTest : public InputMapperTest {
   1697 protected:
   1698     static const int32_t TRACKBALL_MOVEMENT_THRESHOLD;
   1699 
   1700     void testMotionRotation(TrackballInputMapper* mapper,
   1701             int32_t originalX, int32_t originalY, int32_t rotatedX, int32_t rotatedY);
   1702 };
   1703 
   1704 const int32_t TrackballInputMapperTest::TRACKBALL_MOVEMENT_THRESHOLD = 6;
   1705 
   1706 void TrackballInputMapperTest::testMotionRotation(TrackballInputMapper* mapper,
   1707         int32_t originalX, int32_t originalY, int32_t rotatedX, int32_t rotatedY) {
   1708     FakeInputDispatcher::NotifyMotionArgs args;
   1709 
   1710     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_X, 0, originalX, 0);
   1711     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_Y, 0, originalY, 0);
   1712     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0, 0, 0);
   1713     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
   1714     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
   1715     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
   1716             float(rotatedX) / TRACKBALL_MOVEMENT_THRESHOLD,
   1717             float(rotatedY) / TRACKBALL_MOVEMENT_THRESHOLD,
   1718             0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
   1719 }
   1720 
   1721 TEST_F(TrackballInputMapperTest, GetSources) {
   1722     TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, -1);
   1723     addMapperAndConfigure(mapper);
   1724 
   1725     ASSERT_EQ(AINPUT_SOURCE_TRACKBALL, mapper->getSources());
   1726 }
   1727 
   1728 TEST_F(TrackballInputMapperTest, PopulateDeviceInfo) {
   1729     TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, -1);
   1730     addMapperAndConfigure(mapper);
   1731 
   1732     InputDeviceInfo info;
   1733     mapper->populateDeviceInfo(&info);
   1734 
   1735     ASSERT_NO_FATAL_FAILURE(assertMotionRange(info, AINPUT_MOTION_RANGE_X,
   1736             -1.0f, 1.0f, 0.0f, 1.0f / TRACKBALL_MOVEMENT_THRESHOLD));
   1737     ASSERT_NO_FATAL_FAILURE(assertMotionRange(info, AINPUT_MOTION_RANGE_Y,
   1738             -1.0f, 1.0f, 0.0f, 1.0f / TRACKBALL_MOVEMENT_THRESHOLD));
   1739 }
   1740 
   1741 TEST_F(TrackballInputMapperTest, Process_ShouldSetAllFieldsAndIncludeGlobalMetaState) {
   1742     TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, -1);
   1743     addMapperAndConfigure(mapper);
   1744 
   1745     mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
   1746 
   1747     FakeInputDispatcher::NotifyMotionArgs args;
   1748 
   1749     // Button press.
   1750     // Mostly testing non x/y behavior here so we don't need to check again elsewhere.
   1751     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 1, 0);
   1752     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
   1753     ASSERT_EQ(ARBITRARY_TIME, args.eventTime);
   1754     ASSERT_EQ(DEVICE_ID, args.deviceId);
   1755     ASSERT_EQ(AINPUT_SOURCE_TRACKBALL, args.source);
   1756     ASSERT_EQ(uint32_t(0), args.policyFlags);
   1757     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action);
   1758     ASSERT_EQ(0, args.flags);
   1759     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
   1760     ASSERT_EQ(0, args.edgeFlags);
   1761     ASSERT_EQ(uint32_t(1), args.pointerCount);
   1762     ASSERT_EQ(0, args.pointerIds[0]);
   1763     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
   1764             0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
   1765     ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.xPrecision);
   1766     ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.yPrecision);
   1767     ASSERT_EQ(ARBITRARY_TIME, args.downTime);
   1768 
   1769     // Button release.  Should have same down time.
   1770     process(mapper, ARBITRARY_TIME + 1, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 0, 0);
   1771     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
   1772     ASSERT_EQ(ARBITRARY_TIME + 1, args.eventTime);
   1773     ASSERT_EQ(DEVICE_ID, args.deviceId);
   1774     ASSERT_EQ(AINPUT_SOURCE_TRACKBALL, args.source);
   1775     ASSERT_EQ(uint32_t(0), args.policyFlags);
   1776     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, args.action);
   1777     ASSERT_EQ(0, args.flags);
   1778     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
   1779     ASSERT_EQ(0, args.edgeFlags);
   1780     ASSERT_EQ(uint32_t(1), args.pointerCount);
   1781     ASSERT_EQ(0, args.pointerIds[0]);
   1782     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
   1783             0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
   1784     ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.xPrecision);
   1785     ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.yPrecision);
   1786     ASSERT_EQ(ARBITRARY_TIME, args.downTime);
   1787 }
   1788 
   1789 TEST_F(TrackballInputMapperTest, Process_ShouldHandleIndependentXYUpdates) {
   1790     TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, -1);
   1791     addMapperAndConfigure(mapper);
   1792 
   1793     FakeInputDispatcher::NotifyMotionArgs args;
   1794 
   1795     // Motion in X but not Y.
   1796     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_X, 0, 1, 0);
   1797     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0, 0, 0);
   1798     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
   1799     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
   1800     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
   1801             1.0f / TRACKBALL_MOVEMENT_THRESHOLD, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
   1802 
   1803     // Motion in Y but not X.
   1804     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_Y, 0, -2, 0);
   1805     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0, 0, 0);
   1806     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
   1807     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
   1808     ASSERT_NEAR(0.0f, args.pointerCoords[0].x, EPSILON);
   1809     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
   1810             0.0f, -2.0f / TRACKBALL_MOVEMENT_THRESHOLD, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
   1811 }
   1812 
   1813 TEST_F(TrackballInputMapperTest, Process_ShouldHandleIndependentButtonUpdates) {
   1814     TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, -1);
   1815     addMapperAndConfigure(mapper);
   1816 
   1817     FakeInputDispatcher::NotifyMotionArgs args;
   1818 
   1819     // Button press without following sync.
   1820     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 1, 0);
   1821     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
   1822     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action);
   1823     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
   1824             0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
   1825 
   1826     // Button release without following sync.
   1827     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 0, 0);
   1828     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
   1829     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, args.action);
   1830     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
   1831             0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
   1832 }
   1833 
   1834 TEST_F(TrackballInputMapperTest, Process_ShouldHandleCombinedXYAndButtonUpdates) {
   1835     TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, -1);
   1836     addMapperAndConfigure(mapper);
   1837 
   1838     FakeInputDispatcher::NotifyMotionArgs args;
   1839 
   1840     // Combined X, Y and Button.
   1841     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_X, 0, 1, 0);
   1842     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_Y, 0, -2, 0);
   1843     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 1, 0);
   1844     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0, 0, 0);
   1845     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
   1846     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action);
   1847     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
   1848             1.0f / TRACKBALL_MOVEMENT_THRESHOLD, -2.0f / TRACKBALL_MOVEMENT_THRESHOLD,
   1849             1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
   1850 
   1851     // Move X, Y a bit while pressed.
   1852     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_X, 0, 2, 0);
   1853     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_Y, 0, 1, 0);
   1854     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0, 0, 0);
   1855     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
   1856     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
   1857     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
   1858             2.0f / TRACKBALL_MOVEMENT_THRESHOLD, 1.0f / TRACKBALL_MOVEMENT_THRESHOLD,
   1859             1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
   1860 
   1861     // Release Button.
   1862     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 0, 0);
   1863     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
   1864     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, args.action);
   1865     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
   1866             0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
   1867 }
   1868 
   1869 TEST_F(TrackballInputMapperTest, Reset_WhenButtonIsNotDown_ShouldNotSynthesizeButtonUp) {
   1870     TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, -1);
   1871     addMapperAndConfigure(mapper);
   1872 
   1873     FakeInputDispatcher::NotifyMotionArgs args;
   1874 
   1875     // Button press.
   1876     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 1, 0);
   1877     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
   1878 
   1879     // Button release.
   1880     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 0, 0);
   1881     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
   1882 
   1883     // Reset.  Should not synthesize button up since button is not pressed.
   1884     mapper->reset();
   1885 
   1886     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled());
   1887 }
   1888 
   1889 TEST_F(TrackballInputMapperTest, Reset_WhenButtonIsDown_ShouldSynthesizeButtonUp) {
   1890     TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, -1);
   1891     addMapperAndConfigure(mapper);
   1892 
   1893     FakeInputDispatcher::NotifyMotionArgs args;
   1894 
   1895     // Button press.
   1896     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 1, 0);
   1897     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
   1898 
   1899     // Reset.  Should synthesize button up.
   1900     mapper->reset();
   1901 
   1902     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
   1903     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, args.action);
   1904     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
   1905             0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
   1906 }
   1907 
   1908 TEST_F(TrackballInputMapperTest, Process_WhenNotAttachedToDisplay_ShouldNotRotateMotions) {
   1909     TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, -1);
   1910     addMapperAndConfigure(mapper);
   1911 
   1912     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  0,  1,  0,  1));
   1913     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1,  1,  1,  1));
   1914     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1,  0,  1,  0));
   1915     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1, -1,  1, -1));
   1916     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  0, -1,  0, -1));
   1917     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1, -1, -1));
   1918     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1,  0, -1,  0));
   1919     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1,  1, -1,  1));
   1920 }
   1921 
   1922 TEST_F(TrackballInputMapperTest, Process_WhenAttachedToDisplay_ShouldRotateMotions) {
   1923     TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, DISPLAY_ID);
   1924     addMapperAndConfigure(mapper);
   1925 
   1926     mFakePolicy->setDisplayInfo(DISPLAY_ID,
   1927             DISPLAY_WIDTH, DISPLAY_HEIGHT,
   1928             InputReaderPolicyInterface::ROTATION_0);
   1929     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  0,  1,  0,  1));
   1930     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1,  1,  1,  1));
   1931     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1,  0,  1,  0));
   1932     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1, -1,  1, -1));
   1933     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  0, -1,  0, -1));
   1934     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1, -1, -1));
   1935     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1,  0, -1,  0));
   1936     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1,  1, -1,  1));
   1937 
   1938     mFakePolicy->setDisplayInfo(DISPLAY_ID,
   1939             DISPLAY_WIDTH, DISPLAY_HEIGHT,
   1940             InputReaderPolicyInterface::ROTATION_90);
   1941     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  0,  1,  1,  0));
   1942     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1,  1,  1, -1));
   1943     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1,  0,  0, -1));
   1944     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1, -1, -1, -1));
   1945     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  0, -1, -1,  0));
   1946     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1, -1,  1));
   1947     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1,  0,  0,  1));
   1948     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1,  1,  1,  1));
   1949 
   1950     mFakePolicy->setDisplayInfo(DISPLAY_ID,
   1951             DISPLAY_WIDTH, DISPLAY_HEIGHT,
   1952             InputReaderPolicyInterface::ROTATION_180);
   1953     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  0,  1,  0, -1));
   1954     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1,  1, -1, -1));
   1955     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1,  0, -1,  0));
   1956     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1, -1, -1,  1));
   1957     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  0, -1,  0,  1));
   1958     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1,  1,  1));
   1959     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1,  0,  1,  0));
   1960     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1,  1,  1, -1));
   1961 
   1962     mFakePolicy->setDisplayInfo(DISPLAY_ID,
   1963             DISPLAY_WIDTH, DISPLAY_HEIGHT,
   1964             InputReaderPolicyInterface::ROTATION_270);
   1965     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  0,  1, -1,  0));
   1966     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1,  1, -1,  1));
   1967     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1,  0,  0,  1));
   1968     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1, -1,  1,  1));
   1969     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  0, -1,  1,  0));
   1970     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1,  1, -1));
   1971     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1,  0,  0, -1));
   1972     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1,  1, -1, -1));
   1973 }
   1974 
   1975 
   1976 // --- TouchInputMapperTest ---
   1977 
   1978 class TouchInputMapperTest : public InputMapperTest {
   1979 protected:
   1980     static const int32_t RAW_X_MIN;
   1981     static const int32_t RAW_X_MAX;
   1982     static const int32_t RAW_Y_MIN;
   1983     static const int32_t RAW_Y_MAX;
   1984     static const int32_t RAW_TOUCH_MIN;
   1985     static const int32_t RAW_TOUCH_MAX;
   1986     static const int32_t RAW_TOOL_MIN;
   1987     static const int32_t RAW_TOOL_MAX;
   1988     static const int32_t RAW_PRESSURE_MIN;
   1989     static const int32_t RAW_PRESSURE_MAX;
   1990     static const int32_t RAW_ORIENTATION_MIN;
   1991     static const int32_t RAW_ORIENTATION_MAX;
   1992     static const int32_t RAW_ID_MIN;
   1993     static const int32_t RAW_ID_MAX;
   1994     static const float X_PRECISION;
   1995     static const float Y_PRECISION;
   1996 
   1997     static const VirtualKeyDefinition VIRTUAL_KEYS[2];
   1998 
   1999     enum Axes {
   2000         POSITION = 1 << 0,
   2001         TOUCH = 1 << 1,
   2002         TOOL = 1 << 2,
   2003         PRESSURE = 1 << 3,
   2004         ORIENTATION = 1 << 4,
   2005         MINOR = 1 << 5,
   2006         ID = 1 << 6,
   2007     };
   2008 
   2009     void prepareDisplay(int32_t orientation);
   2010     void prepareVirtualKeys();
   2011     int32_t toRawX(float displayX);
   2012     int32_t toRawY(float displayY);
   2013     float toDisplayX(int32_t rawX);
   2014     float toDisplayY(int32_t rawY);
   2015 };
   2016 
   2017 const int32_t TouchInputMapperTest::RAW_X_MIN = 25;
   2018 const int32_t TouchInputMapperTest::RAW_X_MAX = 1020;
   2019 const int32_t TouchInputMapperTest::RAW_Y_MIN = 30;
   2020 const int32_t TouchInputMapperTest::RAW_Y_MAX = 1010;
   2021 const int32_t TouchInputMapperTest::RAW_TOUCH_MIN = 0;
   2022 const int32_t TouchInputMapperTest::RAW_TOUCH_MAX = 31;
   2023 const int32_t TouchInputMapperTest::RAW_TOOL_MIN = 0;
   2024 const int32_t TouchInputMapperTest::RAW_TOOL_MAX = 15;
   2025 const int32_t TouchInputMapperTest::RAW_PRESSURE_MIN = RAW_TOUCH_MIN;
   2026 const int32_t TouchInputMapperTest::RAW_PRESSURE_MAX = RAW_TOUCH_MAX;
   2027 const int32_t TouchInputMapperTest::RAW_ORIENTATION_MIN = -7;
   2028 const int32_t TouchInputMapperTest::RAW_ORIENTATION_MAX = 7;
   2029 const int32_t TouchInputMapperTest::RAW_ID_MIN = 0;
   2030 const int32_t TouchInputMapperTest::RAW_ID_MAX = 9;
   2031 const float TouchInputMapperTest::X_PRECISION = float(RAW_X_MAX - RAW_X_MIN) / DISPLAY_WIDTH;
   2032 const float TouchInputMapperTest::Y_PRECISION = float(RAW_Y_MAX - RAW_Y_MIN) / DISPLAY_HEIGHT;
   2033 
   2034 const VirtualKeyDefinition TouchInputMapperTest::VIRTUAL_KEYS[2] = {
   2035         { KEY_HOME, 60, DISPLAY_HEIGHT + 15, 20, 20 },
   2036         { KEY_MENU, DISPLAY_HEIGHT - 60, DISPLAY_WIDTH + 15, 20, 20 },
   2037 };
   2038 
   2039 void TouchInputMapperTest::prepareDisplay(int32_t orientation) {
   2040     mFakePolicy->setDisplayInfo(DISPLAY_ID, DISPLAY_WIDTH, DISPLAY_HEIGHT, orientation);
   2041 }
   2042 
   2043 void TouchInputMapperTest::prepareVirtualKeys() {
   2044     mFakePolicy->addVirtualKeyDefinition(String8(DEVICE_NAME), VIRTUAL_KEYS[0]);
   2045     mFakePolicy->addVirtualKeyDefinition(String8(DEVICE_NAME), VIRTUAL_KEYS[1]);
   2046     mFakeEventHub->addKey(DEVICE_ID, KEY_HOME, AKEYCODE_HOME, POLICY_FLAG_WAKE);
   2047     mFakeEventHub->addKey(DEVICE_ID, KEY_MENU, AKEYCODE_MENU, POLICY_FLAG_WAKE);
   2048 }
   2049 
   2050 int32_t TouchInputMapperTest::toRawX(float displayX) {
   2051     return int32_t(displayX * (RAW_X_MAX - RAW_X_MIN) / DISPLAY_WIDTH + RAW_X_MIN);
   2052 }
   2053 
   2054 int32_t TouchInputMapperTest::toRawY(float displayY) {
   2055     return int32_t(displayY * (RAW_Y_MAX - RAW_Y_MIN) / DISPLAY_HEIGHT + RAW_Y_MIN);
   2056 }
   2057 
   2058 float TouchInputMapperTest::toDisplayX(int32_t rawX) {
   2059     return float(rawX - RAW_X_MIN) * DISPLAY_WIDTH / (RAW_X_MAX - RAW_X_MIN);
   2060 }
   2061 
   2062 float TouchInputMapperTest::toDisplayY(int32_t rawY) {
   2063     return float(rawY - RAW_Y_MIN) * DISPLAY_HEIGHT / (RAW_Y_MAX - RAW_Y_MIN);
   2064 }
   2065 
   2066 
   2067 // --- SingleTouchInputMapperTest ---
   2068 
   2069 class SingleTouchInputMapperTest : public TouchInputMapperTest {
   2070 protected:
   2071     void prepareAxes(int axes);
   2072 
   2073     void processDown(SingleTouchInputMapper* mapper, int32_t x, int32_t y);
   2074     void processMove(SingleTouchInputMapper* mapper, int32_t x, int32_t y);
   2075     void processUp(SingleTouchInputMapper* mappery);
   2076     void processPressure(SingleTouchInputMapper* mapper, int32_t pressure);
   2077     void processToolMajor(SingleTouchInputMapper* mapper, int32_t toolMajor);
   2078     void processSync(SingleTouchInputMapper* mapper);
   2079 };
   2080 
   2081 void SingleTouchInputMapperTest::prepareAxes(int axes) {
   2082     if (axes & POSITION) {
   2083         mFakeEventHub->addAxis(DEVICE_ID, ABS_X, RAW_X_MIN, RAW_X_MAX, 0, 0);
   2084         mFakeEventHub->addAxis(DEVICE_ID, ABS_Y, RAW_Y_MIN, RAW_Y_MAX, 0, 0);
   2085     }
   2086     if (axes & PRESSURE) {
   2087         mFakeEventHub->addAxis(DEVICE_ID, ABS_PRESSURE, RAW_PRESSURE_MIN, RAW_PRESSURE_MAX, 0, 0);
   2088     }
   2089     if (axes & TOOL) {
   2090         mFakeEventHub->addAxis(DEVICE_ID, ABS_TOOL_WIDTH, RAW_TOOL_MIN, RAW_TOOL_MAX, 0, 0);
   2091     }
   2092 }
   2093 
   2094 void SingleTouchInputMapperTest::processDown(SingleTouchInputMapper* mapper, int32_t x, int32_t y) {
   2095     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_TOUCH, 0, 1, 0);
   2096     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_X, 0, x, 0);
   2097     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_Y, 0, y, 0);
   2098 }
   2099 
   2100 void SingleTouchInputMapperTest::processMove(SingleTouchInputMapper* mapper, int32_t x, int32_t y) {
   2101     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_X, 0, x, 0);
   2102     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_Y, 0, y, 0);
   2103 }
   2104 
   2105 void SingleTouchInputMapperTest::processUp(SingleTouchInputMapper* mapper) {
   2106     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_TOUCH, 0, 0, 0);
   2107 }
   2108 
   2109 void SingleTouchInputMapperTest::processPressure(
   2110         SingleTouchInputMapper* mapper, int32_t pressure) {
   2111     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_PRESSURE, 0, pressure, 0);
   2112 }
   2113 
   2114 void SingleTouchInputMapperTest::processToolMajor(
   2115         SingleTouchInputMapper* mapper, int32_t toolMajor) {
   2116     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_TOOL_WIDTH, 0, toolMajor, 0);
   2117 }
   2118 
   2119 void SingleTouchInputMapperTest::processSync(SingleTouchInputMapper* mapper) {
   2120     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0, 0, 0);
   2121 }
   2122 
   2123 
   2124 TEST_F(SingleTouchInputMapperTest, GetSources_WhenNotAttachedToADisplay_ReturnsTouchPad) {
   2125     SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, -1);
   2126     prepareAxes(POSITION);
   2127     addMapperAndConfigure(mapper);
   2128 
   2129     ASSERT_EQ(AINPUT_SOURCE_TOUCHPAD, mapper->getSources());
   2130 }
   2131 
   2132 TEST_F(SingleTouchInputMapperTest, GetSources_WhenAttachedToADisplay_ReturnsTouchScreen) {
   2133     SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
   2134     prepareAxes(POSITION);
   2135     addMapperAndConfigure(mapper);
   2136 
   2137     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, mapper->getSources());
   2138 }
   2139 
   2140 TEST_F(SingleTouchInputMapperTest, GetKeyCodeState) {
   2141     SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
   2142     prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
   2143     prepareAxes(POSITION);
   2144     prepareVirtualKeys();
   2145     addMapperAndConfigure(mapper);
   2146 
   2147     // Unknown key.
   2148     ASSERT_EQ(AKEY_STATE_UNKNOWN, mapper->getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_A));
   2149 
   2150     // Virtual key is down.
   2151     int32_t x = toRawX(VIRTUAL_KEYS[0].centerX);
   2152     int32_t y = toRawY(VIRTUAL_KEYS[0].centerY);
   2153     processDown(mapper, x, y);
   2154     processSync(mapper);
   2155     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
   2156 
   2157     ASSERT_EQ(AKEY_STATE_VIRTUAL, mapper->getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_HOME));
   2158 
   2159     // Virtual key is up.
   2160     processUp(mapper);
   2161     processSync(mapper);
   2162     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
   2163 
   2164     ASSERT_EQ(AKEY_STATE_UP, mapper->getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_HOME));
   2165 }
   2166 
   2167 TEST_F(SingleTouchInputMapperTest, GetScanCodeState) {
   2168     SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
   2169     prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
   2170     prepareAxes(POSITION);
   2171     prepareVirtualKeys();
   2172     addMapperAndConfigure(mapper);
   2173 
   2174     // Unknown key.
   2175     ASSERT_EQ(AKEY_STATE_UNKNOWN, mapper->getScanCodeState(AINPUT_SOURCE_ANY, KEY_A));
   2176 
   2177     // Virtual key is down.
   2178     int32_t x = toRawX(VIRTUAL_KEYS[0].centerX);
   2179     int32_t y = toRawY(VIRTUAL_KEYS[0].centerY);
   2180     processDown(mapper, x, y);
   2181     processSync(mapper);
   2182     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
   2183 
   2184     ASSERT_EQ(AKEY_STATE_VIRTUAL, mapper->getScanCodeState(AINPUT_SOURCE_ANY, KEY_HOME));
   2185 
   2186     // Virtual key is up.
   2187     processUp(mapper);
   2188     processSync(mapper);
   2189     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
   2190 
   2191     ASSERT_EQ(AKEY_STATE_UP, mapper->getScanCodeState(AINPUT_SOURCE_ANY, KEY_HOME));
   2192 }
   2193 
   2194 TEST_F(SingleTouchInputMapperTest, MarkSupportedKeyCodes) {
   2195     SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
   2196     prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
   2197     prepareAxes(POSITION);
   2198     prepareVirtualKeys();
   2199     addMapperAndConfigure(mapper);
   2200 
   2201     const int32_t keys[2] = { AKEYCODE_HOME, AKEYCODE_A };
   2202     uint8_t flags[2] = { 0, 0 };
   2203     ASSERT_TRUE(mapper->markSupportedKeyCodes(AINPUT_SOURCE_ANY, 2, keys, flags));
   2204     ASSERT_TRUE(flags[0]);
   2205     ASSERT_FALSE(flags[1]);
   2206 }
   2207 
   2208 TEST_F(SingleTouchInputMapperTest, Reset_WhenVirtualKeysAreDown_SendsUp) {
   2209     // Note: Ideally we should send cancels but the implementation is more straightforward
   2210     // with up and this will only happen if a device is forcibly removed.
   2211     SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
   2212     prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
   2213     prepareAxes(POSITION);
   2214     prepareVirtualKeys();
   2215     addMapperAndConfigure(mapper);
   2216 
   2217     mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
   2218 
   2219     // Press virtual key.
   2220     int32_t x = toRawX(VIRTUAL_KEYS[0].centerX);
   2221     int32_t y = toRawY(VIRTUAL_KEYS[0].centerY);
   2222     processDown(mapper, x, y);
   2223     processSync(mapper);
   2224     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
   2225 
   2226     // Reset.  Since key is down, synthesize key up.
   2227     mapper->reset();
   2228 
   2229     FakeInputDispatcher::NotifyKeyArgs args;
   2230     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
   2231     //ASSERT_EQ(ARBITRARY_TIME, args.eventTime);
   2232     ASSERT_EQ(DEVICE_ID, args.deviceId);
   2233     ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source);
   2234     ASSERT_EQ(POLICY_FLAG_VIRTUAL, args.policyFlags);
   2235     ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action);
   2236     ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY, args.flags);
   2237     ASSERT_EQ(AKEYCODE_HOME, args.keyCode);
   2238     ASSERT_EQ(KEY_HOME, args.scanCode);
   2239     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
   2240     ASSERT_EQ(ARBITRARY_TIME, args.downTime);
   2241 }
   2242 
   2243 TEST_F(SingleTouchInputMapperTest, Reset_WhenNothingIsPressed_NothingMuchHappens) {
   2244     SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
   2245     prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
   2246     prepareAxes(POSITION);
   2247     prepareVirtualKeys();
   2248     addMapperAndConfigure(mapper);
   2249 
   2250     // Press virtual key.
   2251     int32_t x = toRawX(VIRTUAL_KEYS[0].centerX);
   2252     int32_t y = toRawY(VIRTUAL_KEYS[0].centerY);
   2253     processDown(mapper, x, y);
   2254     processSync(mapper);
   2255     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
   2256 
   2257     // Release virtual key.
   2258     processUp(mapper);
   2259     processSync(mapper);
   2260     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
   2261 
   2262     // Reset.  Since no key is down, nothing happens.
   2263     mapper->reset();
   2264 
   2265     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled());
   2266     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled());
   2267 }
   2268 
   2269 TEST_F(SingleTouchInputMapperTest, Process_WhenVirtualKeyIsPressedAndReleasedNormally_SendsKeyDownAndKeyUp) {
   2270     SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
   2271     prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
   2272     prepareAxes(POSITION);
   2273     prepareVirtualKeys();
   2274     addMapperAndConfigure(mapper);
   2275 
   2276     mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
   2277 
   2278     FakeInputDispatcher::NotifyKeyArgs args;
   2279 
   2280     // Press virtual key.
   2281     int32_t x = toRawX(VIRTUAL_KEYS[0].centerX);
   2282     int32_t y = toRawY(VIRTUAL_KEYS[0].centerY);
   2283     processDown(mapper, x, y);
   2284     processSync(mapper);
   2285 
   2286     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
   2287     ASSERT_EQ(ARBITRARY_TIME, args.eventTime);
   2288     ASSERT_EQ(DEVICE_ID, args.deviceId);
   2289     ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source);
   2290     ASSERT_EQ(POLICY_FLAG_VIRTUAL, args.policyFlags);
   2291     ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, args.action);
   2292     ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY, args.flags);
   2293     ASSERT_EQ(AKEYCODE_HOME, args.keyCode);
   2294     ASSERT_EQ(KEY_HOME, args.scanCode);
   2295     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
   2296     ASSERT_EQ(ARBITRARY_TIME, args.downTime);
   2297 
   2298     // Release virtual key.
   2299     processUp(mapper);
   2300     processSync(mapper);
   2301 
   2302     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
   2303     ASSERT_EQ(ARBITRARY_TIME, args.eventTime);
   2304     ASSERT_EQ(DEVICE_ID, args.deviceId);
   2305     ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source);
   2306     ASSERT_EQ(POLICY_FLAG_VIRTUAL, args.policyFlags);
   2307     ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action);
   2308     ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY, args.flags);
   2309     ASSERT_EQ(AKEYCODE_HOME, args.keyCode);
   2310     ASSERT_EQ(KEY_HOME, args.scanCode);
   2311     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
   2312     ASSERT_EQ(ARBITRARY_TIME, args.downTime);
   2313 
   2314     // Should not have sent any motions.
   2315     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled());
   2316 }
   2317 
   2318 TEST_F(SingleTouchInputMapperTest, Process_WhenVirtualKeyIsPressedAndMovedOutOfBounds_SendsKeyDownAndKeyCancel) {
   2319     SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
   2320     prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
   2321     prepareAxes(POSITION);
   2322     prepareVirtualKeys();
   2323     addMapperAndConfigure(mapper);
   2324 
   2325     mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
   2326 
   2327     FakeInputDispatcher::NotifyKeyArgs keyArgs;
   2328 
   2329     // Press virtual key.
   2330     int32_t x = toRawX(VIRTUAL_KEYS[0].centerX);
   2331     int32_t y = toRawY(VIRTUAL_KEYS[0].centerY);
   2332     processDown(mapper, x, y);
   2333     processSync(mapper);
   2334 
   2335     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&keyArgs));
   2336     ASSERT_EQ(ARBITRARY_TIME, keyArgs.eventTime);
   2337     ASSERT_EQ(DEVICE_ID, keyArgs.deviceId);
   2338     ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, keyArgs.source);
   2339     ASSERT_EQ(POLICY_FLAG_VIRTUAL, keyArgs.policyFlags);
   2340     ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action);
   2341     ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY, keyArgs.flags);
   2342     ASSERT_EQ(AKEYCODE_HOME, keyArgs.keyCode);
   2343     ASSERT_EQ(KEY_HOME, keyArgs.scanCode);
   2344     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, keyArgs.metaState);
   2345     ASSERT_EQ(ARBITRARY_TIME, keyArgs.downTime);
   2346 
   2347     // Move out of bounds.  This should generate a cancel and a pointer down since we moved
   2348     // into the display area.
   2349     y -= 100;
   2350     processMove(mapper, x, y);
   2351     processSync(mapper);
   2352 
   2353     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&keyArgs));
   2354     ASSERT_EQ(ARBITRARY_TIME, keyArgs.eventTime);
   2355     ASSERT_EQ(DEVICE_ID, keyArgs.deviceId);
   2356     ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, keyArgs.source);
   2357     ASSERT_EQ(POLICY_FLAG_VIRTUAL, keyArgs.policyFlags);
   2358     ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action);
   2359     ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY
   2360             | AKEY_EVENT_FLAG_CANCELED, keyArgs.flags);
   2361     ASSERT_EQ(AKEYCODE_HOME, keyArgs.keyCode);
   2362     ASSERT_EQ(KEY_HOME, keyArgs.scanCode);
   2363     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, keyArgs.metaState);
   2364     ASSERT_EQ(ARBITRARY_TIME, keyArgs.downTime);
   2365 
   2366     FakeInputDispatcher::NotifyMotionArgs motionArgs;
   2367     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
   2368     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
   2369     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
   2370     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
   2371     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
   2372     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
   2373     ASSERT_EQ(0, motionArgs.flags);
   2374     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
   2375     ASSERT_EQ(0, motionArgs.edgeFlags);
   2376     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
   2377     ASSERT_EQ(0, motionArgs.pointerIds[0]);
   2378     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
   2379             toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
   2380     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
   2381     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
   2382     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
   2383 
   2384     // Keep moving out of bounds.  Should generate a pointer move.
   2385     y -= 50;
   2386     processMove(mapper, x, y);
   2387     processSync(mapper);
   2388 
   2389     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
   2390     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
   2391     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
   2392     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
   2393     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
   2394     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
   2395     ASSERT_EQ(0, motionArgs.flags);
   2396     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
   2397     ASSERT_EQ(0, motionArgs.edgeFlags);
   2398     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
   2399     ASSERT_EQ(0, motionArgs.pointerIds[0]);
   2400     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
   2401             toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
   2402     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
   2403     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
   2404     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
   2405 
   2406     // Release out of bounds.  Should generate a pointer up.
   2407     processUp(mapper);
   2408     processSync(mapper);
   2409 
   2410     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
   2411     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
   2412     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
   2413     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
   2414     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
   2415     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
   2416     ASSERT_EQ(0, motionArgs.flags);
   2417     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
   2418     ASSERT_EQ(0, motionArgs.edgeFlags);
   2419     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
   2420     ASSERT_EQ(0, motionArgs.pointerIds[0]);
   2421     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
   2422             toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
   2423     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
   2424     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
   2425     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
   2426 
   2427     // Should not have sent any more keys or motions.
   2428     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled());
   2429     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled());
   2430 }
   2431 
   2432 TEST_F(SingleTouchInputMapperTest, Process_WhenTouchStartsOutsideDisplayAndMovesIn_SendsDownAsTouchEntersDisplay) {
   2433     SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
   2434     prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
   2435     prepareAxes(POSITION);
   2436     prepareVirtualKeys();
   2437     addMapperAndConfigure(mapper);
   2438 
   2439     mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
   2440 
   2441     FakeInputDispatcher::NotifyMotionArgs motionArgs;
   2442 
   2443     // Initially go down out of bounds.
   2444     int32_t x = -10;
   2445     int32_t y = -10;
   2446     processDown(mapper, x, y);
   2447     processSync(mapper);
   2448 
   2449     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled());
   2450 
   2451     // Move into the display area.  Should generate a pointer down.
   2452     x = 50;
   2453     y = 75;
   2454     processMove(mapper, x, y);
   2455     processSync(mapper);
   2456 
   2457     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
   2458     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
   2459     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
   2460     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
   2461     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
   2462     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
   2463     ASSERT_EQ(0, motionArgs.flags);
   2464     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
   2465     ASSERT_EQ(0, motionArgs.edgeFlags);
   2466     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
   2467     ASSERT_EQ(0, motionArgs.pointerIds[0]);
   2468     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
   2469             toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
   2470     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
   2471     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
   2472     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
   2473 
   2474     // Release.  Should generate a pointer up.
   2475     processUp(mapper);
   2476     processSync(mapper);
   2477 
   2478     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
   2479     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
   2480     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
   2481     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
   2482     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
   2483     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
   2484     ASSERT_EQ(0, motionArgs.flags);
   2485     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
   2486     ASSERT_EQ(0, motionArgs.edgeFlags);
   2487     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
   2488     ASSERT_EQ(0, motionArgs.pointerIds[0]);
   2489     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
   2490             toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
   2491     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
   2492     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
   2493     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
   2494 
   2495     // Should not have sent any more keys or motions.
   2496     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled());
   2497     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled());
   2498 }
   2499 
   2500 TEST_F(SingleTouchInputMapperTest, Process_NormalSingleTouchGesture) {
   2501     SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
   2502     prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
   2503     prepareAxes(POSITION);
   2504     prepareVirtualKeys();
   2505     addMapperAndConfigure(mapper);
   2506 
   2507     mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
   2508 
   2509     FakeInputDispatcher::NotifyMotionArgs motionArgs;
   2510 
   2511     // Down.
   2512     int32_t x = 100;
   2513     int32_t y = 125;
   2514     processDown(mapper, x, y);
   2515     processSync(mapper);
   2516 
   2517     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
   2518     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
   2519     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
   2520     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
   2521     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
   2522     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
   2523     ASSERT_EQ(0, motionArgs.flags);
   2524     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
   2525     ASSERT_EQ(0, motionArgs.edgeFlags);
   2526     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
   2527     ASSERT_EQ(0, motionArgs.pointerIds[0]);
   2528     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
   2529             toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
   2530     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
   2531     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
   2532     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
   2533 
   2534     // Move.
   2535     x += 50;
   2536     y += 75;
   2537     processMove(mapper, x, y);
   2538     processSync(mapper);
   2539 
   2540     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
   2541     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
   2542     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
   2543     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
   2544     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
   2545     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
   2546     ASSERT_EQ(0, motionArgs.flags);
   2547     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
   2548     ASSERT_EQ(0, motionArgs.edgeFlags);
   2549     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
   2550     ASSERT_EQ(0, motionArgs.pointerIds[0]);
   2551     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
   2552             toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
   2553     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
   2554     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
   2555     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
   2556 
   2557     // Up.
   2558     processUp(mapper);
   2559     processSync(mapper);
   2560 
   2561     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
   2562     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
   2563     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
   2564     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
   2565     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
   2566     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
   2567     ASSERT_EQ(0, motionArgs.flags);
   2568     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
   2569     ASSERT_EQ(0, motionArgs.edgeFlags);
   2570     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
   2571     ASSERT_EQ(0, motionArgs.pointerIds[0]);
   2572     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
   2573             toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
   2574     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
   2575     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
   2576     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
   2577 
   2578     // Should not have sent any more keys or motions.
   2579     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled());
   2580     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled());
   2581 }
   2582 
   2583 TEST_F(SingleTouchInputMapperTest, Process_Rotation) {
   2584     SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
   2585     prepareAxes(POSITION);
   2586     addMapperAndConfigure(mapper);
   2587 
   2588     FakeInputDispatcher::NotifyMotionArgs args;
   2589 
   2590     // Rotation 0.
   2591     prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
   2592     processDown(mapper, toRawX(50), toRawY(75));
   2593     processSync(mapper);
   2594 
   2595     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
   2596     ASSERT_NEAR(50, args.pointerCoords[0].x, 1);
   2597     ASSERT_NEAR(75, args.pointerCoords[0].y, 1);
   2598 
   2599     processUp(mapper);
   2600     processSync(mapper);
   2601     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled());
   2602 
   2603     // Rotation 90.
   2604     prepareDisplay(InputReaderPolicyInterface::ROTATION_90);
   2605     processDown(mapper, toRawX(50), toRawY(75));
   2606     processSync(mapper);
   2607 
   2608     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
   2609     ASSERT_NEAR(75, args.pointerCoords[0].x, 1);
   2610     ASSERT_NEAR(DISPLAY_WIDTH - 50, args.pointerCoords[0].y, 1);
   2611 
   2612     processUp(mapper);
   2613     processSync(mapper);
   2614     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled());
   2615 
   2616     // Rotation 180.
   2617     prepareDisplay(InputReaderPolicyInterface::ROTATION_180);
   2618     processDown(mapper, toRawX(50), toRawY(75));
   2619     processSync(mapper);
   2620 
   2621     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
   2622     ASSERT_NEAR(DISPLAY_WIDTH - 50, args.pointerCoords[0].x, 1);
   2623     ASSERT_NEAR(DISPLAY_HEIGHT - 75, args.pointerCoords[0].y, 1);
   2624 
   2625     processUp(mapper);
   2626     processSync(mapper);
   2627     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled());
   2628 
   2629     // Rotation 270.
   2630     prepareDisplay(InputReaderPolicyInterface::ROTATION_270);
   2631     processDown(mapper, toRawX(50), toRawY(75));
   2632     processSync(mapper);
   2633 
   2634     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
   2635     ASSERT_NEAR(DISPLAY_HEIGHT - 75, args.pointerCoords[0].x, 1);
   2636     ASSERT_NEAR(50, args.pointerCoords[0].y, 1);
   2637 
   2638     processUp(mapper);
   2639     processSync(mapper);
   2640     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled());
   2641 }
   2642 
   2643 TEST_F(SingleTouchInputMapperTest, Process_AllAxes_DefaultCalibration) {
   2644     SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
   2645     prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
   2646     prepareAxes(POSITION | PRESSURE | TOOL);
   2647     addMapperAndConfigure(mapper);
   2648 
   2649     // These calculations are based on the input device calibration documentation.
   2650     int32_t rawX = 100;
   2651     int32_t rawY = 200;
   2652     int32_t rawPressure = 10;
   2653     int32_t rawToolMajor = 12;
   2654 
   2655     float x = toDisplayX(rawX);
   2656     float y = toDisplayY(rawY);
   2657     float pressure = float(rawPressure) / RAW_PRESSURE_MAX;
   2658     float size = float(rawToolMajor) / RAW_TOOL_MAX;
   2659     float tool = min(DISPLAY_WIDTH, DISPLAY_HEIGHT) * size;
   2660     float touch = min(tool * pressure, tool);
   2661 
   2662     processDown(mapper, rawX, rawY);
   2663     processPressure(mapper, rawPressure);
   2664     processToolMajor(mapper, rawToolMajor);
   2665     processSync(mapper);
   2666 
   2667     FakeInputDispatcher::NotifyMotionArgs args;
   2668     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
   2669     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
   2670             x, y, pressure, size, touch, touch, tool, tool, 0));
   2671 }
   2672 
   2673 
   2674 // --- MultiTouchInputMapperTest ---
   2675 
   2676 class MultiTouchInputMapperTest : public TouchInputMapperTest {
   2677 protected:
   2678     void prepareAxes(int axes);
   2679 
   2680     void processPosition(MultiTouchInputMapper* mapper, int32_t x, int32_t y);
   2681     void processTouchMajor(MultiTouchInputMapper* mapper, int32_t touchMajor);
   2682     void processTouchMinor(MultiTouchInputMapper* mapper, int32_t touchMinor);
   2683     void processToolMajor(MultiTouchInputMapper* mapper, int32_t toolMajor);
   2684     void processToolMinor(MultiTouchInputMapper* mapper, int32_t toolMinor);
   2685     void processOrientation(MultiTouchInputMapper* mapper, int32_t orientation);
   2686     void processPressure(MultiTouchInputMapper* mapper, int32_t pressure);
   2687     void processId(MultiTouchInputMapper* mapper, int32_t id);
   2688     void processMTSync(MultiTouchInputMapper* mapper);
   2689     void processSync(MultiTouchInputMapper* mapper);
   2690 };
   2691 
   2692 void MultiTouchInputMapperTest::prepareAxes(int axes) {
   2693     if (axes & POSITION) {
   2694         mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_POSITION_X, RAW_X_MIN, RAW_X_MAX, 0, 0);
   2695         mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_POSITION_Y, RAW_Y_MIN, RAW_Y_MAX, 0, 0);
   2696     }
   2697     if (axes & TOUCH) {
   2698         mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_TOUCH_MAJOR, RAW_TOUCH_MIN, RAW_TOUCH_MAX, 0, 0);
   2699         if (axes & MINOR) {
   2700             mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_TOUCH_MINOR,
   2701                     RAW_TOUCH_MIN, RAW_TOUCH_MAX, 0, 0);
   2702         }
   2703     }
   2704     if (axes & TOOL) {
   2705         mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_WIDTH_MAJOR, RAW_TOOL_MIN, RAW_TOOL_MAX, 0, 0);
   2706         if (axes & MINOR) {
   2707             mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_WIDTH_MINOR,
   2708                     RAW_TOOL_MAX, RAW_TOOL_MAX, 0, 0);
   2709         }
   2710     }
   2711     if (axes & ORIENTATION) {
   2712         mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_ORIENTATION,
   2713                 RAW_ORIENTATION_MIN, RAW_ORIENTATION_MAX, 0, 0);
   2714     }
   2715     if (axes & PRESSURE) {
   2716         mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_PRESSURE,
   2717                 RAW_PRESSURE_MIN, RAW_PRESSURE_MAX, 0, 0);
   2718     }
   2719     if (axes & ID) {
   2720         mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_TRACKING_ID,
   2721                 RAW_ID_MIN, RAW_ID_MAX, 0, 0);
   2722     }
   2723 }
   2724 
   2725 void MultiTouchInputMapperTest::processPosition(
   2726         MultiTouchInputMapper* mapper, int32_t x, int32_t y) {
   2727     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_POSITION_X, 0, x, 0);
   2728     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_POSITION_Y, 0, y, 0);
   2729 }
   2730 
   2731 void MultiTouchInputMapperTest::processTouchMajor(
   2732         MultiTouchInputMapper* mapper, int32_t touchMajor) {
   2733     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_TOUCH_MAJOR, 0, touchMajor, 0);
   2734 }
   2735 
   2736 void MultiTouchInputMapperTest::processTouchMinor(
   2737         MultiTouchInputMapper* mapper, int32_t touchMinor) {
   2738     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_TOUCH_MINOR, 0, touchMinor, 0);
   2739 }
   2740 
   2741 void MultiTouchInputMapperTest::processToolMajor(
   2742         MultiTouchInputMapper* mapper, int32_t toolMajor) {
   2743     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_WIDTH_MAJOR, 0, toolMajor, 0);
   2744 }
   2745 
   2746 void MultiTouchInputMapperTest::processToolMinor(
   2747         MultiTouchInputMapper* mapper, int32_t toolMinor) {
   2748     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_WIDTH_MINOR, 0, toolMinor, 0);
   2749 }
   2750 
   2751 void MultiTouchInputMapperTest::processOrientation(
   2752         MultiTouchInputMapper* mapper, int32_t orientation) {
   2753     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_ORIENTATION, 0, orientation, 0);
   2754 }
   2755 
   2756 void MultiTouchInputMapperTest::processPressure(
   2757         MultiTouchInputMapper* mapper, int32_t pressure) {
   2758     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_PRESSURE, 0, pressure, 0);
   2759 }
   2760 
   2761 void MultiTouchInputMapperTest::processId(
   2762         MultiTouchInputMapper* mapper, int32_t id) {
   2763     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_TRACKING_ID, 0, id, 0);
   2764 }
   2765 
   2766 void MultiTouchInputMapperTest::processMTSync(MultiTouchInputMapper* mapper) {
   2767     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_MT_REPORT, 0, 0, 0);
   2768 }
   2769 
   2770 void MultiTouchInputMapperTest::processSync(MultiTouchInputMapper* mapper) {
   2771     process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0, 0, 0);
   2772 }
   2773 
   2774 
   2775 TEST_F(MultiTouchInputMapperTest, Process_NormalMultiTouchGesture_WithoutTrackingIds) {
   2776     MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice, DISPLAY_ID);
   2777     prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
   2778     prepareAxes(POSITION);
   2779     prepareVirtualKeys();
   2780     addMapperAndConfigure(mapper);
   2781 
   2782     mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
   2783 
   2784     FakeInputDispatcher::NotifyMotionArgs motionArgs;
   2785 
   2786     // Two fingers down at once.
   2787     int32_t x1 = 100, y1 = 125, x2 = 300, y2 = 500;
   2788     processPosition(mapper, x1, y1);
   2789     processMTSync(mapper);
   2790     processPosition(mapper, x2, y2);
   2791     processMTSync(mapper);
   2792     processSync(mapper);
   2793 
   2794     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
   2795     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
   2796     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
   2797     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
   2798     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
   2799     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
   2800     ASSERT_EQ(0, motionArgs.flags);
   2801     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
   2802     ASSERT_EQ(0, motionArgs.edgeFlags);
   2803     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
   2804     ASSERT_EQ(0, motionArgs.pointerIds[0]);
   2805     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
   2806             toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
   2807     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
   2808     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
   2809     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
   2810 
   2811     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
   2812     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
   2813     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
   2814     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
   2815     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
   2816     ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_DOWN | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
   2817             motionArgs.action);
   2818     ASSERT_EQ(0, motionArgs.flags);
   2819     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
   2820     ASSERT_EQ(0, motionArgs.edgeFlags);
   2821     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
   2822     ASSERT_EQ(0, motionArgs.pointerIds[0]);
   2823     ASSERT_EQ(1, motionArgs.pointerIds[1]);
   2824     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
   2825             toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
   2826     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
   2827             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
   2828     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
   2829     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
   2830     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
   2831 
   2832     // Move.
   2833     x1 += 10; y1 += 15; x2 += 5; y2 -= 10;
   2834     processPosition(mapper, x1, y1);
   2835     processMTSync(mapper);
   2836     processPosition(mapper, x2, y2);
   2837     processMTSync(mapper);
   2838     processSync(mapper);
   2839 
   2840     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
   2841     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
   2842     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
   2843     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
   2844     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
   2845     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
   2846     ASSERT_EQ(0, motionArgs.flags);
   2847     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
   2848     ASSERT_EQ(0, motionArgs.edgeFlags);
   2849     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
   2850     ASSERT_EQ(0, motionArgs.pointerIds[0]);
   2851     ASSERT_EQ(1, motionArgs.pointerIds[1]);
   2852     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
   2853             toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
   2854     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
   2855             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
   2856     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
   2857     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
   2858     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
   2859 
   2860     // First finger up.
   2861     x2 += 15; y2 -= 20;
   2862     processPosition(mapper, x2, y2);
   2863     processMTSync(mapper);
   2864     processSync(mapper);
   2865 
   2866     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
   2867     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
   2868     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
   2869     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
   2870     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
   2871     ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_UP | (0 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
   2872             motionArgs.action);
   2873     ASSERT_EQ(0, motionArgs.flags);
   2874     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
   2875     ASSERT_EQ(0, motionArgs.edgeFlags);
   2876     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
   2877     ASSERT_EQ(0, motionArgs.pointerIds[0]);
   2878     ASSERT_EQ(1, motionArgs.pointerIds[1]);
   2879     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
   2880             toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
   2881     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
   2882             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
   2883     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
   2884     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
   2885     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
   2886 
   2887     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
   2888     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
   2889     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
   2890     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
   2891     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
   2892     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
   2893     ASSERT_EQ(0, motionArgs.flags);
   2894     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
   2895     ASSERT_EQ(0, motionArgs.edgeFlags);
   2896     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
   2897     ASSERT_EQ(1, motionArgs.pointerIds[0]);
   2898     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
   2899             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
   2900     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
   2901     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
   2902     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
   2903 
   2904     // Move.
   2905     x2 += 20; y2 -= 25;
   2906     processPosition(mapper, x2, y2);
   2907     processMTSync(mapper);
   2908     processSync(mapper);
   2909 
   2910     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
   2911     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
   2912     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
   2913     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
   2914     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
   2915     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
   2916     ASSERT_EQ(0, motionArgs.flags);
   2917     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
   2918     ASSERT_EQ(0, motionArgs.edgeFlags);
   2919     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
   2920     ASSERT_EQ(1, motionArgs.pointerIds[0]);
   2921     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
   2922             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
   2923     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
   2924     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
   2925     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
   2926 
   2927     // New finger down.
   2928     int32_t x3 = 700, y3 = 300;
   2929     processPosition(mapper, x2, y2);
   2930     processMTSync(mapper);
   2931     processPosition(mapper, x3, y3);
   2932     processMTSync(mapper);
   2933     processSync(mapper);
   2934 
   2935     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
   2936     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
   2937     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
   2938     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
   2939     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
   2940     ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_DOWN | (0 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
   2941             motionArgs.action);
   2942     ASSERT_EQ(0, motionArgs.flags);
   2943     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
   2944     ASSERT_EQ(0, motionArgs.edgeFlags);
   2945     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
   2946     ASSERT_EQ(0, motionArgs.pointerIds[0]);
   2947     ASSERT_EQ(1, motionArgs.pointerIds[1]);
   2948     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
   2949             toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
   2950     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
   2951             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
   2952     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
   2953     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
   2954     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
   2955 
   2956     // Second finger up.
   2957     x3 += 30; y3 -= 20;
   2958     processPosition(mapper, x3, y3);
   2959     processMTSync(mapper);
   2960     processSync(mapper);
   2961 
   2962     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
   2963     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
   2964     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
   2965     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
   2966     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
   2967     ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_UP | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
   2968             motionArgs.action);
   2969     ASSERT_EQ(0, motionArgs.flags);
   2970     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
   2971     ASSERT_EQ(0, motionArgs.edgeFlags);
   2972     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
   2973     ASSERT_EQ(0, motionArgs.pointerIds[0]);
   2974     ASSERT_EQ(1, motionArgs.pointerIds[1]);
   2975     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
   2976             toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
   2977     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
   2978             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
   2979     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
   2980     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
   2981     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
   2982 
   2983     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
   2984     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
   2985     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
   2986     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
   2987     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
   2988     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
   2989     ASSERT_EQ(0, motionArgs.flags);
   2990     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
   2991     ASSERT_EQ(0, motionArgs.edgeFlags);
   2992     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
   2993     ASSERT_EQ(0, motionArgs.pointerIds[0]);
   2994     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
   2995             toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
   2996     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
   2997     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
   2998     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
   2999 
   3000     // Last finger up.
   3001     processMTSync(mapper);
   3002     processSync(mapper);
   3003 
   3004     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
   3005     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
   3006     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
   3007     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
   3008     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
   3009     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
   3010     ASSERT_EQ(0, motionArgs.flags);
   3011     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
   3012     ASSERT_EQ(0, motionArgs.edgeFlags);
   3013     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
   3014     ASSERT_EQ(0, motionArgs.pointerIds[0]);
   3015     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
   3016             toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
   3017     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
   3018     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
   3019     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
   3020 
   3021     // Should not have sent any more keys or motions.
   3022     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled());
   3023     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled());
   3024 }
   3025 
   3026 TEST_F(MultiTouchInputMapperTest, Process_NormalMultiTouchGesture_WithTrackingIds) {
   3027     MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice, DISPLAY_ID);
   3028     prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
   3029     prepareAxes(POSITION | ID);
   3030     prepareVirtualKeys();
   3031     addMapperAndConfigure(mapper);
   3032 
   3033     mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
   3034 
   3035     FakeInputDispatcher::NotifyMotionArgs motionArgs;
   3036 
   3037     // Two fingers down at once.
   3038     int32_t x1 = 100, y1 = 125, x2 = 300, y2 = 500;
   3039     processPosition(mapper, x1, y1);
   3040     processId(mapper, 1);
   3041     processMTSync(mapper);
   3042     processPosition(mapper, x2, y2);
   3043     processId(mapper, 2);
   3044     processMTSync(mapper);
   3045     processSync(mapper);
   3046 
   3047     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
   3048     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
   3049     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
   3050     ASSERT_EQ(1, motionArgs.pointerIds[0]);
   3051     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
   3052             toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
   3053 
   3054     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
   3055     ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_DOWN | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
   3056             motionArgs.action);
   3057     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
   3058     ASSERT_EQ(1, motionArgs.pointerIds[0]);
   3059     ASSERT_EQ(2, motionArgs.pointerIds[1]);
   3060     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
   3061             toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
   3062     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
   3063             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
   3064 
   3065     // Move.
   3066     x1 += 10; y1 += 15; x2 += 5; y2 -= 10;
   3067     processPosition(mapper, x1, y1);
   3068     processId(mapper, 1);
   3069     processMTSync(mapper);
   3070     processPosition(mapper, x2, y2);
   3071     processId(mapper, 2);
   3072     processMTSync(mapper);
   3073     processSync(mapper);
   3074 
   3075     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
   3076     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
   3077     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
   3078     ASSERT_EQ(1, motionArgs.pointerIds[0]);
   3079     ASSERT_EQ(2, motionArgs.pointerIds[1]);
   3080     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
   3081             toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
   3082     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
   3083             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
   3084 
   3085     // First finger up.
   3086     x2 += 15; y2 -= 20;
   3087     processPosition(mapper, x2, y2);
   3088     processId(mapper, 2);
   3089     processMTSync(mapper);
   3090     processSync(mapper);
   3091 
   3092     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
   3093     ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_UP | (0 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
   3094             motionArgs.action);
   3095     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
   3096     ASSERT_EQ(1, motionArgs.pointerIds[0]);
   3097     ASSERT_EQ(2, motionArgs.pointerIds[1]);
   3098     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
   3099             toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
   3100     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
   3101             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
   3102 
   3103     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
   3104     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
   3105     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
   3106     ASSERT_EQ(2, motionArgs.pointerIds[0]);
   3107     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
   3108             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
   3109 
   3110     // Move.
   3111     x2 += 20; y2 -= 25;
   3112     processPosition(mapper, x2, y2);
   3113     processId(mapper, 2);
   3114     processMTSync(mapper);
   3115     processSync(mapper);
   3116 
   3117     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
   3118     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
   3119     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
   3120     ASSERT_EQ(2, motionArgs.pointerIds[0]);
   3121     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
   3122             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
   3123 
   3124     // New finger down.
   3125     int32_t x3 = 700, y3 = 300;
   3126     processPosition(mapper, x2, y2);
   3127     processId(mapper, 2);
   3128     processMTSync(mapper);
   3129     processPosition(mapper, x3, y3);
   3130     processId(mapper, 3);
   3131     processMTSync(mapper);
   3132     processSync(mapper);
   3133 
   3134     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
   3135     ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_DOWN | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
   3136             motionArgs.action);
   3137     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
   3138     ASSERT_EQ(2, motionArgs.pointerIds[0]);
   3139     ASSERT_EQ(3, motionArgs.pointerIds[1]);
   3140     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
   3141             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
   3142     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
   3143             toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
   3144 
   3145     // Second finger up.
   3146     x3 += 30; y3 -= 20;
   3147     processPosition(mapper, x3, y3);
   3148     processId(mapper, 3);
   3149     processMTSync(mapper);
   3150     processSync(mapper);
   3151 
   3152     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
   3153     ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_UP | (0 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
   3154             motionArgs.action);
   3155     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
   3156     ASSERT_EQ(2, motionArgs.pointerIds[0]);
   3157     ASSERT_EQ(3, motionArgs.pointerIds[1]);
   3158     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
   3159             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
   3160     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
   3161             toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
   3162 
   3163     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
   3164     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
   3165     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
   3166     ASSERT_EQ(3, motionArgs.pointerIds[0]);
   3167     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
   3168             toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
   3169 
   3170     // Last finger up.
   3171     processMTSync(mapper);
   3172     processSync(mapper);
   3173 
   3174     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
   3175     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
   3176     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
   3177     ASSERT_EQ(3, motionArgs.pointerIds[0]);
   3178     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
   3179             toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
   3180 
   3181     // Should not have sent any more keys or motions.
   3182     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled());
   3183     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled());
   3184 }
   3185 
   3186 TEST_F(MultiTouchInputMapperTest, Process_AllAxes_WithDefaultCalibration) {
   3187     MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice, DISPLAY_ID);
   3188     prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
   3189     prepareAxes(POSITION | TOUCH | TOOL | PRESSURE | ORIENTATION | ID | MINOR);
   3190     addMapperAndConfigure(mapper);
   3191 
   3192     // These calculations are based on the input device calibration documentation.
   3193     int32_t rawX = 100;
   3194     int32_t rawY = 200;
   3195     int32_t rawTouchMajor = 7;
   3196     int32_t rawTouchMinor = 6;
   3197     int32_t rawToolMajor = 9;
   3198     int32_t rawToolMinor = 8;
   3199     int32_t rawPressure = 11;
   3200     int32_t rawOrientation = 3;
   3201     int32_t id = 5;
   3202 
   3203     float x = toDisplayX(rawX);
   3204     float y = toDisplayY(rawY);
   3205     float pressure = float(rawPressure) / RAW_PRESSURE_MAX;
   3206     float size = avg(rawToolMajor, rawToolMinor) / RAW_TOOL_MAX;
   3207     float toolMajor = float(min(DISPLAY_WIDTH, DISPLAY_HEIGHT)) * rawToolMajor / RAW_TOOL_MAX;
   3208     float toolMinor = float(min(DISPLAY_WIDTH, DISPLAY_HEIGHT)) * rawToolMinor / RAW_TOOL_MAX;
   3209     float touchMajor = min(toolMajor * pressure, toolMajor);
   3210     float touchMinor = min(toolMinor * pressure, toolMinor);
   3211     float orientation = float(rawOrientation) / RAW_ORIENTATION_MAX * M_PI_2;
   3212 
   3213     processPosition(mapper, rawX, rawY);
   3214     processTouchMajor(mapper, rawTouchMajor);
   3215     processTouchMinor(mapper, rawTouchMinor);
   3216     processToolMajor(mapper, rawToolMajor);
   3217     processToolMinor(mapper, rawToolMinor);
   3218     processPressure(mapper, rawPressure);
   3219     processOrientation(mapper, rawOrientation);
   3220     processId(mapper, id);
   3221     processMTSync(mapper);
   3222     processSync(mapper);
   3223 
   3224     FakeInputDispatcher::NotifyMotionArgs args;
   3225     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
   3226     ASSERT_EQ(id, args.pointerIds[0]);
   3227     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
   3228             x, y, pressure, size, touchMajor, touchMinor, toolMajor, toolMinor, orientation));
   3229 }
   3230 
   3231 TEST_F(MultiTouchInputMapperTest, Process_TouchAndToolAxes_GeometricCalibration) {
   3232     MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice, DISPLAY_ID);
   3233     prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
   3234     prepareAxes(POSITION | TOUCH | TOOL | MINOR);
   3235     prepareCalibration("touch.touchSize.calibration", "geometric");
   3236     prepareCalibration("touch.toolSize.calibration", "geometric");
   3237     addMapperAndConfigure(mapper);
   3238 
   3239     // These calculations are based on the input device calibration documentation.
   3240     int32_t rawX = 100;
   3241     int32_t rawY = 200;
   3242     int32_t rawTouchMajor = 140;
   3243     int32_t rawTouchMinor = 120;
   3244     int32_t rawToolMajor = 180;
   3245     int32_t rawToolMinor = 160;
   3246 
   3247     float x = toDisplayX(rawX);
   3248     float y = toDisplayY(rawY);
   3249     float pressure = float(rawTouchMajor) / RAW_TOUCH_MAX;
   3250     float size = avg(rawToolMajor, rawToolMinor) / RAW_TOOL_MAX;
   3251     float scale = avg(float(DISPLAY_WIDTH) / (RAW_X_MAX - RAW_X_MIN),
   3252             float(DISPLAY_HEIGHT) / (RAW_Y_MAX - RAW_Y_MIN));
   3253     float toolMajor = float(rawToolMajor) * scale;
   3254     float toolMinor = float(rawToolMinor) * scale;
   3255     float touchMajor = min(float(rawTouchMajor) * scale, toolMajor);
   3256     float touchMinor = min(float(rawTouchMinor) * scale, toolMinor);
   3257 
   3258     processPosition(mapper, rawX, rawY);
   3259     processTouchMajor(mapper, rawTouchMajor);
   3260     processTouchMinor(mapper, rawTouchMinor);
   3261     processToolMajor(mapper, rawToolMajor);
   3262     processToolMinor(mapper, rawToolMinor);
   3263     processMTSync(mapper);
   3264     processSync(mapper);
   3265 
   3266     FakeInputDispatcher::NotifyMotionArgs args;
   3267     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
   3268     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
   3269             x, y, pressure, size, touchMajor, touchMinor, toolMajor, toolMinor, 0));
   3270 }
   3271 
   3272 TEST_F(MultiTouchInputMapperTest, Process_TouchToolPressureSizeAxes_SummedLinearCalibration) {
   3273     MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice, DISPLAY_ID);
   3274     prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
   3275     prepareAxes(POSITION | TOUCH | TOOL);
   3276     prepareCalibration("touch.touchSize.calibration", "pressure");
   3277     prepareCalibration("touch.toolSize.calibration", "linear");
   3278     prepareCalibration("touch.toolSize.linearScale", "10");
   3279     prepareCalibration("touch.toolSize.linearBias", "160");
   3280     prepareCalibration("touch.toolSize.isSummed", "1");
   3281     prepareCalibration("touch.pressure.calibration", "amplitude");
   3282     prepareCalibration("touch.pressure.source", "touch");
   3283     prepareCalibration("touch.pressure.scale", "0.01");
   3284     addMapperAndConfigure(mapper);
   3285 
   3286     // These calculations are based on the input device calibration documentation.
   3287     // Note: We only provide a single common touch/tool value because the device is assumed
   3288     //       not to emit separate values for each pointer (isSummed = 1).
   3289     int32_t rawX = 100;
   3290     int32_t rawY = 200;
   3291     int32_t rawX2 = 150;
   3292     int32_t rawY2 = 250;
   3293     int32_t rawTouchMajor = 60;
   3294     int32_t rawToolMajor = 5;
   3295 
   3296     float x = toDisplayX(rawX);
   3297     float y = toDisplayY(rawY);
   3298     float x2 = toDisplayX(rawX2);
   3299     float y2 = toDisplayY(rawY2);
   3300     float pressure = float(rawTouchMajor) * 0.01f;
   3301     float size = float(rawToolMajor) / RAW_TOOL_MAX;
   3302     float tool = (float(rawToolMajor) * 10.0f + 160.0f) / 2;
   3303     float touch = min(tool * pressure, tool);
   3304 
   3305     processPosition(mapper, rawX, rawY);
   3306     processTouchMajor(mapper, rawTouchMajor);
   3307     processToolMajor(mapper, rawToolMajor);
   3308     processMTSync(mapper);
   3309     processPosition(mapper, rawX2, rawY2);
   3310     processTouchMajor(mapper, rawTouchMajor);
   3311     processToolMajor(mapper, rawToolMajor);
   3312     processMTSync(mapper);
   3313     processSync(mapper);
   3314 
   3315     FakeInputDispatcher::NotifyMotionArgs args;
   3316     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
   3317     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action);
   3318     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
   3319     ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_DOWN | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
   3320             args.action);
   3321     ASSERT_EQ(size_t(2), args.pointerCount);
   3322     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
   3323             x, y, pressure, size, touch, touch, tool, tool, 0));
   3324     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[1],
   3325             x2, y2, pressure, size, touch, touch, tool, tool, 0));
   3326 }
   3327 
   3328 TEST_F(MultiTouchInputMapperTest, Process_TouchToolPressureSizeAxes_AreaCalibration) {
   3329     MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice, DISPLAY_ID);
   3330     prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
   3331     prepareAxes(POSITION | TOUCH | TOOL);
   3332     prepareCalibration("touch.touchSize.calibration", "pressure");
   3333     prepareCalibration("touch.toolSize.calibration", "area");
   3334     prepareCalibration("touch.toolSize.areaScale", "22");
   3335     prepareCalibration("touch.toolSize.areaBias", "1");
   3336     prepareCalibration("touch.toolSize.linearScale", "9.2");
   3337     prepareCalibration("touch.toolSize.linearBias", "3");
   3338     prepareCalibration("touch.pressure.calibration", "amplitude");
   3339     prepareCalibration("touch.pressure.source", "touch");
   3340     prepareCalibration("touch.pressure.scale", "0.01");
   3341     addMapperAndConfigure(mapper);
   3342 
   3343     // These calculations are based on the input device calibration documentation.
   3344     int32_t rawX = 100;
   3345     int32_t rawY = 200;
   3346     int32_t rawTouchMajor = 60;
   3347     int32_t rawToolMajor = 5;
   3348 
   3349     float x = toDisplayX(rawX);
   3350     float y = toDisplayY(rawY);
   3351     float pressure = float(rawTouchMajor) * 0.01f;
   3352     float size = float(rawToolMajor) / RAW_TOOL_MAX;
   3353     float tool = sqrtf(float(rawToolMajor) * 22.0f + 1.0f) * 9.2f + 3.0f;
   3354     float touch = min(tool * pressure, tool);
   3355 
   3356     processPosition(mapper, rawX, rawY);
   3357     processTouchMajor(mapper, rawTouchMajor);
   3358     processToolMajor(mapper, rawToolMajor);
   3359     processMTSync(mapper);
   3360     processSync(mapper);
   3361 
   3362     FakeInputDispatcher::NotifyMotionArgs args;
   3363     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
   3364     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
   3365             x, y, pressure, size, touch, touch, tool, tool, 0));
   3366 }
   3367 
   3368 } // namespace android
   3369