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