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