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