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