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