• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 <cinttypes>
18 #include <memory>
19 
20 #include <CursorInputMapper.h>
21 #include <InputDevice.h>
22 #include <InputMapper.h>
23 #include <InputReader.h>
24 #include <InputReaderBase.h>
25 #include <InputReaderFactory.h>
26 #include <JoystickInputMapper.h>
27 #include <KeyboardInputMapper.h>
28 #include <MultiTouchInputMapper.h>
29 #include <PeripheralController.h>
30 #include <SensorInputMapper.h>
31 #include <SingleTouchInputMapper.h>
32 #include <SwitchInputMapper.h>
33 #include <TestInputListener.h>
34 #include <TouchInputMapper.h>
35 #include <UinputDevice.h>
36 #include <VibratorInputMapper.h>
37 #include <android-base/thread_annotations.h>
38 #include <gtest/gtest.h>
39 #include <gui/constants.h>
40 
41 #include "input/DisplayViewport.h"
42 #include "input/Input.h"
43 
44 namespace android {
45 
46 using namespace ftl::flag_operators;
47 
48 using std::chrono_literals::operator""ms;
49 
50 // Timeout for waiting for an expected event
51 static constexpr std::chrono::duration WAIT_TIMEOUT = 100ms;
52 
53 // An arbitrary time value.
54 static constexpr nsecs_t ARBITRARY_TIME = 1234;
55 static constexpr nsecs_t READ_TIME = 4321;
56 
57 // Arbitrary display properties.
58 static constexpr int32_t DISPLAY_ID = 0;
59 static const std::string DISPLAY_UNIQUE_ID = "local:1";
60 static constexpr int32_t SECONDARY_DISPLAY_ID = DISPLAY_ID + 1;
61 static const std::string SECONDARY_DISPLAY_UNIQUE_ID = "local:2";
62 static constexpr int32_t DISPLAY_WIDTH = 480;
63 static constexpr int32_t DISPLAY_HEIGHT = 800;
64 static constexpr int32_t VIRTUAL_DISPLAY_ID = 1;
65 static constexpr int32_t VIRTUAL_DISPLAY_WIDTH = 400;
66 static constexpr int32_t VIRTUAL_DISPLAY_HEIGHT = 500;
67 static const char* VIRTUAL_DISPLAY_UNIQUE_ID = "virtual:1";
68 static constexpr std::optional<uint8_t> NO_PORT = std::nullopt; // no physical port is specified
69 
70 static constexpr int32_t FIRST_SLOT = 0;
71 static constexpr int32_t SECOND_SLOT = 1;
72 static constexpr int32_t THIRD_SLOT = 2;
73 static constexpr int32_t INVALID_TRACKING_ID = -1;
74 static constexpr int32_t FIRST_TRACKING_ID = 0;
75 static constexpr int32_t SECOND_TRACKING_ID = 1;
76 static constexpr int32_t THIRD_TRACKING_ID = 2;
77 static constexpr int32_t DEFAULT_BATTERY = 1;
78 static constexpr int32_t BATTERY_STATUS = 4;
79 static constexpr int32_t BATTERY_CAPACITY = 66;
80 static constexpr int32_t LIGHT_BRIGHTNESS = 0x55000000;
81 static constexpr int32_t LIGHT_COLOR = 0x7F448866;
82 static constexpr int32_t LIGHT_PLAYER_ID = 2;
83 
84 static constexpr int32_t ACTION_POINTER_0_DOWN =
85         AMOTION_EVENT_ACTION_POINTER_DOWN | (0 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
86 static constexpr int32_t ACTION_POINTER_0_UP =
87         AMOTION_EVENT_ACTION_POINTER_UP | (0 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
88 static constexpr int32_t ACTION_POINTER_1_DOWN =
89         AMOTION_EVENT_ACTION_POINTER_DOWN | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
90 static constexpr int32_t ACTION_POINTER_1_UP =
91         AMOTION_EVENT_ACTION_POINTER_UP | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
92 
93 // Error tolerance for floating point assertions.
94 static const float EPSILON = 0.001f;
95 
96 using ::testing::AllOf;
97 
98 MATCHER_P(WithAction, action, "InputEvent with specified action") {
99     return arg.action == action;
100 }
101 
102 MATCHER_P(WithSource, source, "InputEvent with specified source") {
103     return arg.source == source;
104 }
105 
106 MATCHER_P(WithDisplayId, displayId, "InputEvent with specified displayId") {
107     return arg.displayId == displayId;
108 }
109 
110 MATCHER_P2(WithCoords, x, y, "MotionEvent with specified action") {
111     return arg.pointerCoords[0].getX() == x && arg.pointerCoords[0].getY();
112 }
113 
114 MATCHER_P(WithToolType, toolType, "InputEvent with specified tool type") {
115     const auto argToolType = arg.pointerProperties[0].toolType;
116     *result_listener << "expected tool type " << motionToolTypeToString(toolType) << ", but got "
117                      << motionToolTypeToString(argToolType);
118     return argToolType == toolType;
119 }
120 
121 template<typename T>
min(T a,T b)122 static inline T min(T a, T b) {
123     return a < b ? a : b;
124 }
125 
avg(float x,float y)126 static inline float avg(float x, float y) {
127     return (x + y) / 2;
128 }
129 
130 // Mapping for light color name and the light color
131 const std::unordered_map<std::string, LightColor> LIGHT_COLORS = {{"red", LightColor::RED},
132                                                                   {"green", LightColor::GREEN},
133                                                                   {"blue", LightColor::BLUE}};
134 
getInverseRotation(int32_t orientation)135 static int32_t getInverseRotation(int32_t orientation) {
136     switch (orientation) {
137         case DISPLAY_ORIENTATION_90:
138             return DISPLAY_ORIENTATION_270;
139         case DISPLAY_ORIENTATION_270:
140             return DISPLAY_ORIENTATION_90;
141         default:
142             return orientation;
143     }
144 }
145 
assertAxisResolution(MultiTouchInputMapper & mapper,int axis,float resolution)146 static void assertAxisResolution(MultiTouchInputMapper& mapper, int axis, float resolution) {
147     InputDeviceInfo info;
148     mapper.populateDeviceInfo(&info);
149 
150     const InputDeviceInfo::MotionRange* motionRange =
151             info.getMotionRange(axis, AINPUT_SOURCE_TOUCHSCREEN);
152     ASSERT_NEAR(motionRange->resolution, resolution, EPSILON);
153 }
154 
assertAxisNotPresent(MultiTouchInputMapper & mapper,int axis)155 static void assertAxisNotPresent(MultiTouchInputMapper& mapper, int axis) {
156     InputDeviceInfo info;
157     mapper.populateDeviceInfo(&info);
158 
159     const InputDeviceInfo::MotionRange* motionRange =
160             info.getMotionRange(axis, AINPUT_SOURCE_TOUCHSCREEN);
161     ASSERT_EQ(nullptr, motionRange);
162 }
163 
164 // --- FakePointerController ---
165 
166 class FakePointerController : public PointerControllerInterface {
167     bool mHaveBounds;
168     float mMinX, mMinY, mMaxX, mMaxY;
169     float mX, mY;
170     int32_t mButtonState;
171     int32_t mDisplayId;
172 
173 public:
FakePointerController()174     FakePointerController() :
175         mHaveBounds(false), mMinX(0), mMinY(0), mMaxX(0), mMaxY(0), mX(0), mY(0),
176         mButtonState(0), mDisplayId(ADISPLAY_ID_DEFAULT) {
177     }
178 
~FakePointerController()179     virtual ~FakePointerController() {}
180 
setBounds(float minX,float minY,float maxX,float maxY)181     void setBounds(float minX, float minY, float maxX, float maxY) {
182         mHaveBounds = true;
183         mMinX = minX;
184         mMinY = minY;
185         mMaxX = maxX;
186         mMaxY = maxY;
187     }
188 
setPosition(float x,float y)189     void setPosition(float x, float y) override {
190         mX = x;
191         mY = y;
192     }
193 
setButtonState(int32_t buttonState)194     void setButtonState(int32_t buttonState) override { mButtonState = buttonState; }
195 
getButtonState() const196     int32_t getButtonState() const override { return mButtonState; }
197 
getPosition(float * outX,float * outY) const198     void getPosition(float* outX, float* outY) const override {
199         *outX = mX;
200         *outY = mY;
201     }
202 
getDisplayId() const203     int32_t getDisplayId() const override { return mDisplayId; }
204 
setDisplayViewport(const DisplayViewport & viewport)205     void setDisplayViewport(const DisplayViewport& viewport) override {
206         mDisplayId = viewport.displayId;
207     }
208 
getSpots()209     const std::map<int32_t, std::vector<int32_t>>& getSpots() {
210         return mSpotsByDisplay;
211     }
212 
213 private:
getBounds(float * outMinX,float * outMinY,float * outMaxX,float * outMaxY) const214     bool getBounds(float* outMinX, float* outMinY, float* outMaxX, float* outMaxY) const override {
215         *outMinX = mMinX;
216         *outMinY = mMinY;
217         *outMaxX = mMaxX;
218         *outMaxY = mMaxY;
219         return mHaveBounds;
220     }
221 
move(float deltaX,float deltaY)222     void move(float deltaX, float deltaY) override {
223         mX += deltaX;
224         if (mX < mMinX) mX = mMinX;
225         if (mX > mMaxX) mX = mMaxX;
226         mY += deltaY;
227         if (mY < mMinY) mY = mMinY;
228         if (mY > mMaxY) mY = mMaxY;
229     }
230 
fade(Transition)231     void fade(Transition) override {}
232 
unfade(Transition)233     void unfade(Transition) override {}
234 
setPresentation(Presentation)235     void setPresentation(Presentation) override {}
236 
setSpots(const PointerCoords *,const uint32_t *,BitSet32 spotIdBits,int32_t displayId)237     void setSpots(const PointerCoords*, const uint32_t*, BitSet32 spotIdBits,
238                   int32_t displayId) override {
239         std::vector<int32_t> newSpots;
240         // Add spots for fingers that are down.
241         for (BitSet32 idBits(spotIdBits); !idBits.isEmpty(); ) {
242             uint32_t id = idBits.clearFirstMarkedBit();
243             newSpots.push_back(id);
244         }
245 
246         mSpotsByDisplay[displayId] = newSpots;
247     }
248 
clearSpots()249     void clearSpots() override {}
250 
251     std::map<int32_t, std::vector<int32_t>> mSpotsByDisplay;
252 };
253 
254 
255 // --- FakeInputReaderPolicy ---
256 
257 class FakeInputReaderPolicy : public InputReaderPolicyInterface {
258     std::mutex mLock;
259     std::condition_variable mDevicesChangedCondition;
260 
261     InputReaderConfiguration mConfig;
262     std::shared_ptr<FakePointerController> mPointerController;
263     std::vector<InputDeviceInfo> mInputDevices GUARDED_BY(mLock);
GUARDED_BY(mLock)264     bool mInputDevicesChanged GUARDED_BY(mLock){false};
265     std::vector<DisplayViewport> mViewports;
266     TouchAffineTransformation transform;
267 
268 protected:
~FakeInputReaderPolicy()269     virtual ~FakeInputReaderPolicy() {}
270 
271 public:
FakeInputReaderPolicy()272     FakeInputReaderPolicy() {
273     }
274 
assertInputDevicesChanged()275     void assertInputDevicesChanged() {
276         waitForInputDevices([](bool devicesChanged) {
277             if (!devicesChanged) {
278                 FAIL() << "Timed out waiting for notifyInputDevicesChanged() to be called.";
279             }
280         });
281     }
282 
assertInputDevicesNotChanged()283     void assertInputDevicesNotChanged() {
284         waitForInputDevices([](bool devicesChanged) {
285             if (devicesChanged) {
286                 FAIL() << "Expected notifyInputDevicesChanged() to not be called.";
287             }
288         });
289     }
290 
clearViewports()291     virtual void clearViewports() {
292         mViewports.clear();
293         mConfig.setDisplayViewports(mViewports);
294     }
295 
getDisplayViewportByUniqueId(const std::string & uniqueId) const296     std::optional<DisplayViewport> getDisplayViewportByUniqueId(const std::string& uniqueId) const {
297         return mConfig.getDisplayViewportByUniqueId(uniqueId);
298     }
getDisplayViewportByType(ViewportType type) const299     std::optional<DisplayViewport> getDisplayViewportByType(ViewportType type) const {
300         return mConfig.getDisplayViewportByType(type);
301     }
302 
getDisplayViewportByPort(uint8_t displayPort) const303     std::optional<DisplayViewport> getDisplayViewportByPort(uint8_t displayPort) const {
304         return mConfig.getDisplayViewportByPort(displayPort);
305     }
306 
addDisplayViewport(DisplayViewport viewport)307     void addDisplayViewport(DisplayViewport viewport) {
308         mViewports.push_back(std::move(viewport));
309         mConfig.setDisplayViewports(mViewports);
310     }
311 
addDisplayViewport(int32_t displayId,int32_t width,int32_t height,int32_t orientation,bool isActive,const std::string & uniqueId,std::optional<uint8_t> physicalPort,ViewportType type)312     void addDisplayViewport(int32_t displayId, int32_t width, int32_t height, int32_t orientation,
313                             bool isActive, const std::string& uniqueId,
314                             std::optional<uint8_t> physicalPort, ViewportType type) {
315         const bool isRotated =
316                 (orientation == DISPLAY_ORIENTATION_90 || orientation == DISPLAY_ORIENTATION_270);
317         DisplayViewport v;
318         v.displayId = displayId;
319         v.orientation = orientation;
320         v.logicalLeft = 0;
321         v.logicalTop = 0;
322         v.logicalRight = isRotated ? height : width;
323         v.logicalBottom = isRotated ? width : height;
324         v.physicalLeft = 0;
325         v.physicalTop = 0;
326         v.physicalRight = isRotated ? height : width;
327         v.physicalBottom = isRotated ? width : height;
328         v.deviceWidth = isRotated ? height : width;
329         v.deviceHeight = isRotated ? width : height;
330         v.isActive = isActive;
331         v.uniqueId = uniqueId;
332         v.physicalPort = physicalPort;
333         v.type = type;
334 
335         addDisplayViewport(v);
336     }
337 
updateViewport(const DisplayViewport & viewport)338     bool updateViewport(const DisplayViewport& viewport) {
339         size_t count = mViewports.size();
340         for (size_t i = 0; i < count; i++) {
341             const DisplayViewport& currentViewport = mViewports[i];
342             if (currentViewport.displayId == viewport.displayId) {
343                 mViewports[i] = viewport;
344                 mConfig.setDisplayViewports(mViewports);
345                 return true;
346             }
347         }
348         // no viewport found.
349         return false;
350     }
351 
addExcludedDeviceName(const std::string & deviceName)352     void addExcludedDeviceName(const std::string& deviceName) {
353         mConfig.excludedDeviceNames.push_back(deviceName);
354     }
355 
addInputPortAssociation(const std::string & inputPort,uint8_t displayPort)356     void addInputPortAssociation(const std::string& inputPort, uint8_t displayPort) {
357         mConfig.portAssociations.insert({inputPort, displayPort});
358     }
359 
addInputUniqueIdAssociation(const std::string & inputUniqueId,const std::string & displayUniqueId)360     void addInputUniqueIdAssociation(const std::string& inputUniqueId,
361                                      const std::string& displayUniqueId) {
362         mConfig.uniqueIdAssociations.insert({inputUniqueId, displayUniqueId});
363     }
364 
addDisabledDevice(int32_t deviceId)365     void addDisabledDevice(int32_t deviceId) { mConfig.disabledDevices.insert(deviceId); }
366 
removeDisabledDevice(int32_t deviceId)367     void removeDisabledDevice(int32_t deviceId) { mConfig.disabledDevices.erase(deviceId); }
368 
setPointerController(std::shared_ptr<FakePointerController> controller)369     void setPointerController(std::shared_ptr<FakePointerController> controller) {
370         mPointerController = std::move(controller);
371     }
372 
getReaderConfiguration() const373     const InputReaderConfiguration* getReaderConfiguration() const {
374         return &mConfig;
375     }
376 
getInputDevices() const377     const std::vector<InputDeviceInfo>& getInputDevices() const {
378         return mInputDevices;
379     }
380 
getTouchAffineTransformation(const std::string & inputDeviceDescriptor,int32_t surfaceRotation)381     TouchAffineTransformation getTouchAffineTransformation(const std::string& inputDeviceDescriptor,
382             int32_t surfaceRotation) {
383         return transform;
384     }
385 
setTouchAffineTransformation(const TouchAffineTransformation t)386     void setTouchAffineTransformation(const TouchAffineTransformation t) {
387         transform = t;
388     }
389 
setPointerCapture(bool enabled)390     PointerCaptureRequest setPointerCapture(bool enabled) {
391         mConfig.pointerCaptureRequest = {enabled, mNextPointerCaptureSequenceNumber++};
392         return mConfig.pointerCaptureRequest;
393     }
394 
setShowTouches(bool enabled)395     void setShowTouches(bool enabled) {
396         mConfig.showTouches = enabled;
397     }
398 
setDefaultPointerDisplayId(int32_t pointerDisplayId)399     void setDefaultPointerDisplayId(int32_t pointerDisplayId) {
400         mConfig.defaultPointerDisplayId = pointerDisplayId;
401     }
402 
getPointerGestureMovementSpeedRatio()403     float getPointerGestureMovementSpeedRatio() { return mConfig.pointerGestureMovementSpeedRatio; }
404 
setVelocityControlParams(const VelocityControlParameters & params)405     void setVelocityControlParams(const VelocityControlParameters& params) {
406         mConfig.pointerVelocityControlParameters = params;
407         mConfig.wheelVelocityControlParameters = params;
408     }
409 
410 private:
411     uint32_t mNextPointerCaptureSequenceNumber = 0;
412 
getReaderConfiguration(InputReaderConfiguration * outConfig)413     void getReaderConfiguration(InputReaderConfiguration* outConfig) override {
414         *outConfig = mConfig;
415     }
416 
obtainPointerController(int32_t)417     std::shared_ptr<PointerControllerInterface> obtainPointerController(
418             int32_t /*deviceId*/) override {
419         return mPointerController;
420     }
421 
notifyInputDevicesChanged(const std::vector<InputDeviceInfo> & inputDevices)422     void notifyInputDevicesChanged(const std::vector<InputDeviceInfo>& inputDevices) override {
423         std::scoped_lock<std::mutex> lock(mLock);
424         mInputDevices = inputDevices;
425         mInputDevicesChanged = true;
426         mDevicesChangedCondition.notify_all();
427     }
428 
getKeyboardLayoutOverlay(const InputDeviceIdentifier &)429     std::shared_ptr<KeyCharacterMap> getKeyboardLayoutOverlay(
430             const InputDeviceIdentifier&) override {
431         return nullptr;
432     }
433 
getDeviceAlias(const InputDeviceIdentifier &)434     std::string getDeviceAlias(const InputDeviceIdentifier&) override { return ""; }
435 
waitForInputDevices(std::function<void (bool)> processDevicesChanged)436     void waitForInputDevices(std::function<void(bool)> processDevicesChanged) {
437         std::unique_lock<std::mutex> lock(mLock);
438         base::ScopedLockAssertion assumeLocked(mLock);
439 
440         const bool devicesChanged =
441                 mDevicesChangedCondition.wait_for(lock, WAIT_TIMEOUT, [this]() REQUIRES(mLock) {
442                     return mInputDevicesChanged;
443                 });
444         ASSERT_NO_FATAL_FAILURE(processDevicesChanged(devicesChanged));
445         mInputDevicesChanged = false;
446     }
447 };
448 
449 // --- FakeEventHub ---
450 
451 class FakeEventHub : public EventHubInterface {
452     struct KeyInfo {
453         int32_t keyCode;
454         uint32_t flags;
455     };
456 
457     struct SensorInfo {
458         InputDeviceSensorType sensorType;
459         int32_t sensorDataIndex;
460     };
461 
462     struct Device {
463         InputDeviceIdentifier identifier;
464         ftl::Flags<InputDeviceClass> classes;
465         PropertyMap configuration;
466         KeyedVector<int, RawAbsoluteAxisInfo> absoluteAxes;
467         KeyedVector<int, bool> relativeAxes;
468         KeyedVector<int32_t, int32_t> keyCodeStates;
469         KeyedVector<int32_t, int32_t> scanCodeStates;
470         KeyedVector<int32_t, int32_t> switchStates;
471         KeyedVector<int32_t, int32_t> absoluteAxisValue;
472         KeyedVector<int32_t, KeyInfo> keysByScanCode;
473         KeyedVector<int32_t, KeyInfo> keysByUsageCode;
474         KeyedVector<int32_t, bool> leds;
475         // fake mapping which would normally come from keyCharacterMap
476         std::unordered_map<int32_t, int32_t> keyCodeMapping;
477         std::unordered_map<int32_t, SensorInfo> sensorsByAbsCode;
478         BitArray<MSC_MAX> mscBitmask;
479         std::vector<VirtualKeyDefinition> virtualKeys;
480         bool enabled;
481 
enableandroid::FakeEventHub::Device482         status_t enable() {
483             enabled = true;
484             return OK;
485         }
486 
disableandroid::FakeEventHub::Device487         status_t disable() {
488             enabled = false;
489             return OK;
490         }
491 
Deviceandroid::FakeEventHub::Device492         explicit Device(ftl::Flags<InputDeviceClass> classes) : classes(classes), enabled(true) {}
493     };
494 
495     std::mutex mLock;
496     std::condition_variable mEventsCondition;
497 
498     KeyedVector<int32_t, Device*> mDevices;
499     std::vector<std::string> mExcludedDevices;
500     std::vector<RawEvent> mEvents GUARDED_BY(mLock);
501     std::unordered_map<int32_t /*deviceId*/, std::vector<TouchVideoFrame>> mVideoFrames;
502     std::vector<int32_t> mVibrators = {0, 1};
503     std::unordered_map<int32_t, RawLightInfo> mRawLightInfos;
504     // Simulates a device light brightness, from light id to light brightness.
505     std::unordered_map<int32_t /* lightId */, int32_t /* brightness*/> mLightBrightness;
506     // Simulates a device light intensities, from light id to light intensities map.
507     std::unordered_map<int32_t /* lightId */, std::unordered_map<LightColor, int32_t>>
508             mLightIntensities;
509 
510 public:
~FakeEventHub()511     virtual ~FakeEventHub() {
512         for (size_t i = 0; i < mDevices.size(); i++) {
513             delete mDevices.valueAt(i);
514         }
515     }
516 
FakeEventHub()517     FakeEventHub() { }
518 
addDevice(int32_t deviceId,const std::string & name,ftl::Flags<InputDeviceClass> classes)519     void addDevice(int32_t deviceId, const std::string& name,
520                    ftl::Flags<InputDeviceClass> classes) {
521         Device* device = new Device(classes);
522         device->identifier.name = name;
523         mDevices.add(deviceId, device);
524 
525         enqueueEvent(ARBITRARY_TIME, READ_TIME, deviceId, EventHubInterface::DEVICE_ADDED, 0, 0);
526     }
527 
removeDevice(int32_t deviceId)528     void removeDevice(int32_t deviceId) {
529         delete mDevices.valueFor(deviceId);
530         mDevices.removeItem(deviceId);
531 
532         enqueueEvent(ARBITRARY_TIME, READ_TIME, deviceId, EventHubInterface::DEVICE_REMOVED, 0, 0);
533     }
534 
isDeviceEnabled(int32_t deviceId)535     bool isDeviceEnabled(int32_t deviceId) {
536         Device* device = getDevice(deviceId);
537         if (device == nullptr) {
538             ALOGE("Incorrect device id=%" PRId32 " provided to %s", deviceId, __func__);
539             return false;
540         }
541         return device->enabled;
542     }
543 
enableDevice(int32_t deviceId)544     status_t enableDevice(int32_t deviceId) {
545         status_t result;
546         Device* device = getDevice(deviceId);
547         if (device == nullptr) {
548             ALOGE("Incorrect device id=%" PRId32 " provided to %s", deviceId, __func__);
549             return BAD_VALUE;
550         }
551         if (device->enabled) {
552             ALOGW("Duplicate call to %s, device %" PRId32 " already enabled", __func__, deviceId);
553             return OK;
554         }
555         result = device->enable();
556         return result;
557     }
558 
disableDevice(int32_t deviceId)559     status_t disableDevice(int32_t deviceId) {
560         Device* device = getDevice(deviceId);
561         if (device == nullptr) {
562             ALOGE("Incorrect device id=%" PRId32 " provided to %s", deviceId, __func__);
563             return BAD_VALUE;
564         }
565         if (!device->enabled) {
566             ALOGW("Duplicate call to %s, device %" PRId32 " already disabled", __func__, deviceId);
567             return OK;
568         }
569         return device->disable();
570     }
571 
finishDeviceScan()572     void finishDeviceScan() {
573         enqueueEvent(ARBITRARY_TIME, READ_TIME, 0, EventHubInterface::FINISHED_DEVICE_SCAN, 0, 0);
574     }
575 
addConfigurationProperty(int32_t deviceId,const String8 & key,const String8 & value)576     void addConfigurationProperty(int32_t deviceId, const String8& key, const String8& value) {
577         Device* device = getDevice(deviceId);
578         device->configuration.addProperty(key, value);
579     }
580 
addConfigurationMap(int32_t deviceId,const PropertyMap * configuration)581     void addConfigurationMap(int32_t deviceId, const PropertyMap* configuration) {
582         Device* device = getDevice(deviceId);
583         device->configuration.addAll(configuration);
584     }
585 
addAbsoluteAxis(int32_t deviceId,int axis,int32_t minValue,int32_t maxValue,int flat,int fuzz,int resolution=0)586     void addAbsoluteAxis(int32_t deviceId, int axis,
587             int32_t minValue, int32_t maxValue, int flat, int fuzz, int resolution = 0) {
588         Device* device = getDevice(deviceId);
589 
590         RawAbsoluteAxisInfo info;
591         info.valid = true;
592         info.minValue = minValue;
593         info.maxValue = maxValue;
594         info.flat = flat;
595         info.fuzz = fuzz;
596         info.resolution = resolution;
597         device->absoluteAxes.add(axis, info);
598     }
599 
addRelativeAxis(int32_t deviceId,int32_t axis)600     void addRelativeAxis(int32_t deviceId, int32_t axis) {
601         Device* device = getDevice(deviceId);
602         device->relativeAxes.add(axis, true);
603     }
604 
setKeyCodeState(int32_t deviceId,int32_t keyCode,int32_t state)605     void setKeyCodeState(int32_t deviceId, int32_t keyCode, int32_t state) {
606         Device* device = getDevice(deviceId);
607         device->keyCodeStates.replaceValueFor(keyCode, state);
608     }
609 
setScanCodeState(int32_t deviceId,int32_t scanCode,int32_t state)610     void setScanCodeState(int32_t deviceId, int32_t scanCode, int32_t state) {
611         Device* device = getDevice(deviceId);
612         device->scanCodeStates.replaceValueFor(scanCode, state);
613     }
614 
setSwitchState(int32_t deviceId,int32_t switchCode,int32_t state)615     void setSwitchState(int32_t deviceId, int32_t switchCode, int32_t state) {
616         Device* device = getDevice(deviceId);
617         device->switchStates.replaceValueFor(switchCode, state);
618     }
619 
setAbsoluteAxisValue(int32_t deviceId,int32_t axis,int32_t value)620     void setAbsoluteAxisValue(int32_t deviceId, int32_t axis, int32_t value) {
621         Device* device = getDevice(deviceId);
622         device->absoluteAxisValue.replaceValueFor(axis, value);
623     }
624 
addKey(int32_t deviceId,int32_t scanCode,int32_t usageCode,int32_t keyCode,uint32_t flags)625     void addKey(int32_t deviceId, int32_t scanCode, int32_t usageCode,
626             int32_t keyCode, uint32_t flags) {
627         Device* device = getDevice(deviceId);
628         KeyInfo info;
629         info.keyCode = keyCode;
630         info.flags = flags;
631         if (scanCode) {
632             device->keysByScanCode.add(scanCode, info);
633         }
634         if (usageCode) {
635             device->keysByUsageCode.add(usageCode, info);
636         }
637     }
638 
addKeyCodeMapping(int32_t deviceId,int32_t fromKeyCode,int32_t toKeyCode)639     void addKeyCodeMapping(int32_t deviceId, int32_t fromKeyCode, int32_t toKeyCode) {
640         Device* device = getDevice(deviceId);
641         device->keyCodeMapping.insert_or_assign(fromKeyCode, toKeyCode);
642     }
643 
addLed(int32_t deviceId,int32_t led,bool initialState)644     void addLed(int32_t deviceId, int32_t led, bool initialState) {
645         Device* device = getDevice(deviceId);
646         device->leds.add(led, initialState);
647     }
648 
addSensorAxis(int32_t deviceId,int32_t absCode,InputDeviceSensorType sensorType,int32_t sensorDataIndex)649     void addSensorAxis(int32_t deviceId, int32_t absCode, InputDeviceSensorType sensorType,
650                        int32_t sensorDataIndex) {
651         Device* device = getDevice(deviceId);
652         SensorInfo info;
653         info.sensorType = sensorType;
654         info.sensorDataIndex = sensorDataIndex;
655         device->sensorsByAbsCode.emplace(absCode, info);
656     }
657 
setMscEvent(int32_t deviceId,int32_t mscEvent)658     void setMscEvent(int32_t deviceId, int32_t mscEvent) {
659         Device* device = getDevice(deviceId);
660         typename BitArray<MSC_MAX>::Buffer buffer;
661         buffer[mscEvent / 32] = 1 << mscEvent % 32;
662         device->mscBitmask.loadFromBuffer(buffer);
663     }
664 
addRawLightInfo(int32_t rawId,RawLightInfo && info)665     void addRawLightInfo(int32_t rawId, RawLightInfo&& info) {
666         mRawLightInfos.emplace(rawId, std::move(info));
667     }
668 
fakeLightBrightness(int32_t rawId,int32_t brightness)669     void fakeLightBrightness(int32_t rawId, int32_t brightness) {
670         mLightBrightness.emplace(rawId, brightness);
671     }
672 
fakeLightIntensities(int32_t rawId,const std::unordered_map<LightColor,int32_t> intensities)673     void fakeLightIntensities(int32_t rawId,
674                               const std::unordered_map<LightColor, int32_t> intensities) {
675         mLightIntensities.emplace(rawId, std::move(intensities));
676     }
677 
getLedState(int32_t deviceId,int32_t led)678     bool getLedState(int32_t deviceId, int32_t led) {
679         Device* device = getDevice(deviceId);
680         return device->leds.valueFor(led);
681     }
682 
getExcludedDevices()683     std::vector<std::string>& getExcludedDevices() {
684         return mExcludedDevices;
685     }
686 
addVirtualKeyDefinition(int32_t deviceId,const VirtualKeyDefinition & definition)687     void addVirtualKeyDefinition(int32_t deviceId, const VirtualKeyDefinition& definition) {
688         Device* device = getDevice(deviceId);
689         device->virtualKeys.push_back(definition);
690     }
691 
enqueueEvent(nsecs_t when,nsecs_t readTime,int32_t deviceId,int32_t type,int32_t code,int32_t value)692     void enqueueEvent(nsecs_t when, nsecs_t readTime, int32_t deviceId, int32_t type, int32_t code,
693                       int32_t value) {
694         std::scoped_lock<std::mutex> lock(mLock);
695         RawEvent event;
696         event.when = when;
697         event.readTime = readTime;
698         event.deviceId = deviceId;
699         event.type = type;
700         event.code = code;
701         event.value = value;
702         mEvents.push_back(event);
703 
704         if (type == EV_ABS) {
705             setAbsoluteAxisValue(deviceId, code, value);
706         }
707     }
708 
setVideoFrames(std::unordered_map<int32_t,std::vector<TouchVideoFrame>> videoFrames)709     void setVideoFrames(std::unordered_map<int32_t /*deviceId*/,
710             std::vector<TouchVideoFrame>> videoFrames) {
711         mVideoFrames = std::move(videoFrames);
712     }
713 
assertQueueIsEmpty()714     void assertQueueIsEmpty() {
715         std::unique_lock<std::mutex> lock(mLock);
716         base::ScopedLockAssertion assumeLocked(mLock);
717         const bool queueIsEmpty =
718                 mEventsCondition.wait_for(lock, WAIT_TIMEOUT,
719                                           [this]() REQUIRES(mLock) { return mEvents.size() == 0; });
720         if (!queueIsEmpty) {
721             FAIL() << "Timed out waiting for EventHub queue to be emptied.";
722         }
723     }
724 
725 private:
getDevice(int32_t deviceId) const726     Device* getDevice(int32_t deviceId) const {
727         ssize_t index = mDevices.indexOfKey(deviceId);
728         return index >= 0 ? mDevices.valueAt(index) : nullptr;
729     }
730 
getDeviceClasses(int32_t deviceId) const731     ftl::Flags<InputDeviceClass> getDeviceClasses(int32_t deviceId) const override {
732         Device* device = getDevice(deviceId);
733         return device ? device->classes : ftl::Flags<InputDeviceClass>(0);
734     }
735 
getDeviceIdentifier(int32_t deviceId) const736     InputDeviceIdentifier getDeviceIdentifier(int32_t deviceId) const override {
737         Device* device = getDevice(deviceId);
738         return device ? device->identifier : InputDeviceIdentifier();
739     }
740 
getDeviceControllerNumber(int32_t) const741     int32_t getDeviceControllerNumber(int32_t) const override { return 0; }
742 
getConfiguration(int32_t deviceId,PropertyMap * outConfiguration) const743     void getConfiguration(int32_t deviceId, PropertyMap* outConfiguration) const override {
744         Device* device = getDevice(deviceId);
745         if (device) {
746             *outConfiguration = device->configuration;
747         }
748     }
749 
getAbsoluteAxisInfo(int32_t deviceId,int axis,RawAbsoluteAxisInfo * outAxisInfo) const750     status_t getAbsoluteAxisInfo(int32_t deviceId, int axis,
751                                  RawAbsoluteAxisInfo* outAxisInfo) const override {
752         Device* device = getDevice(deviceId);
753         if (device && device->enabled) {
754             ssize_t index = device->absoluteAxes.indexOfKey(axis);
755             if (index >= 0) {
756                 *outAxisInfo = device->absoluteAxes.valueAt(index);
757                 return OK;
758             }
759         }
760         outAxisInfo->clear();
761         return -1;
762     }
763 
hasRelativeAxis(int32_t deviceId,int axis) const764     bool hasRelativeAxis(int32_t deviceId, int axis) const override {
765         Device* device = getDevice(deviceId);
766         if (device) {
767             return device->relativeAxes.indexOfKey(axis) >= 0;
768         }
769         return false;
770     }
771 
hasInputProperty(int32_t,int) const772     bool hasInputProperty(int32_t, int) const override { return false; }
773 
hasMscEvent(int32_t deviceId,int mscEvent) const774     bool hasMscEvent(int32_t deviceId, int mscEvent) const override final {
775         Device* device = getDevice(deviceId);
776         if (device) {
777             return mscEvent >= 0 && mscEvent <= MSC_MAX ? device->mscBitmask.test(mscEvent) : false;
778         }
779         return false;
780     }
781 
mapKey(int32_t deviceId,int32_t scanCode,int32_t usageCode,int32_t metaState,int32_t * outKeycode,int32_t * outMetaState,uint32_t * outFlags) const782     status_t mapKey(int32_t deviceId, int32_t scanCode, int32_t usageCode, int32_t metaState,
783                     int32_t* outKeycode, int32_t* outMetaState, uint32_t* outFlags) const override {
784         Device* device = getDevice(deviceId);
785         if (device) {
786             const KeyInfo* key = getKey(device, scanCode, usageCode);
787             if (key) {
788                 if (outKeycode) {
789                     *outKeycode = key->keyCode;
790                 }
791                 if (outFlags) {
792                     *outFlags = key->flags;
793                 }
794                 if (outMetaState) {
795                     *outMetaState = metaState;
796                 }
797                 return OK;
798             }
799         }
800         return NAME_NOT_FOUND;
801     }
802 
getKey(Device * device,int32_t scanCode,int32_t usageCode) const803     const KeyInfo* getKey(Device* device, int32_t scanCode, int32_t usageCode) const {
804         if (usageCode) {
805             ssize_t index = device->keysByUsageCode.indexOfKey(usageCode);
806             if (index >= 0) {
807                 return &device->keysByUsageCode.valueAt(index);
808             }
809         }
810         if (scanCode) {
811             ssize_t index = device->keysByScanCode.indexOfKey(scanCode);
812             if (index >= 0) {
813                 return &device->keysByScanCode.valueAt(index);
814             }
815         }
816         return nullptr;
817     }
818 
mapAxis(int32_t,int32_t,AxisInfo *) const819     status_t mapAxis(int32_t, int32_t, AxisInfo*) const override { return NAME_NOT_FOUND; }
820 
mapSensor(int32_t deviceId,int32_t absCode)821     base::Result<std::pair<InputDeviceSensorType, int32_t>> mapSensor(int32_t deviceId,
822                                                                       int32_t absCode) {
823         Device* device = getDevice(deviceId);
824         if (!device) {
825             return Errorf("Sensor device not found.");
826         }
827         auto it = device->sensorsByAbsCode.find(absCode);
828         if (it == device->sensorsByAbsCode.end()) {
829             return Errorf("Sensor map not found.");
830         }
831         const SensorInfo& info = it->second;
832         return std::make_pair(info.sensorType, info.sensorDataIndex);
833     }
834 
setExcludedDevices(const std::vector<std::string> & devices)835     void setExcludedDevices(const std::vector<std::string>& devices) override {
836         mExcludedDevices = devices;
837     }
838 
getEvents(int,RawEvent * buffer,size_t bufferSize)839     size_t getEvents(int, RawEvent* buffer, size_t bufferSize) override {
840         std::scoped_lock lock(mLock);
841 
842         const size_t filledSize = std::min(mEvents.size(), bufferSize);
843         std::copy(mEvents.begin(), mEvents.begin() + filledSize, buffer);
844 
845         mEvents.erase(mEvents.begin(), mEvents.begin() + filledSize);
846         mEventsCondition.notify_all();
847         return filledSize;
848     }
849 
getVideoFrames(int32_t deviceId)850     std::vector<TouchVideoFrame> getVideoFrames(int32_t deviceId) override {
851         auto it = mVideoFrames.find(deviceId);
852         if (it != mVideoFrames.end()) {
853             std::vector<TouchVideoFrame> frames = std::move(it->second);
854             mVideoFrames.erase(deviceId);
855             return frames;
856         }
857         return {};
858     }
859 
getScanCodeState(int32_t deviceId,int32_t scanCode) const860     int32_t getScanCodeState(int32_t deviceId, int32_t scanCode) const override {
861         Device* device = getDevice(deviceId);
862         if (device) {
863             ssize_t index = device->scanCodeStates.indexOfKey(scanCode);
864             if (index >= 0) {
865                 return device->scanCodeStates.valueAt(index);
866             }
867         }
868         return AKEY_STATE_UNKNOWN;
869     }
870 
getKeyCodeState(int32_t deviceId,int32_t keyCode) const871     int32_t getKeyCodeState(int32_t deviceId, int32_t keyCode) const override {
872         Device* device = getDevice(deviceId);
873         if (device) {
874             ssize_t index = device->keyCodeStates.indexOfKey(keyCode);
875             if (index >= 0) {
876                 return device->keyCodeStates.valueAt(index);
877             }
878         }
879         return AKEY_STATE_UNKNOWN;
880     }
881 
getSwitchState(int32_t deviceId,int32_t sw) const882     int32_t getSwitchState(int32_t deviceId, int32_t sw) const override {
883         Device* device = getDevice(deviceId);
884         if (device) {
885             ssize_t index = device->switchStates.indexOfKey(sw);
886             if (index >= 0) {
887                 return device->switchStates.valueAt(index);
888             }
889         }
890         return AKEY_STATE_UNKNOWN;
891     }
892 
getAbsoluteAxisValue(int32_t deviceId,int32_t axis,int32_t * outValue) const893     status_t getAbsoluteAxisValue(int32_t deviceId, int32_t axis,
894                                   int32_t* outValue) const override {
895         Device* device = getDevice(deviceId);
896         if (device) {
897             ssize_t index = device->absoluteAxisValue.indexOfKey(axis);
898             if (index >= 0) {
899                 *outValue = device->absoluteAxisValue.valueAt(index);
900                 return OK;
901             }
902         }
903         *outValue = 0;
904         return -1;
905     }
906 
getKeyCodeForKeyLocation(int32_t deviceId,int32_t locationKeyCode) const907     int32_t getKeyCodeForKeyLocation(int32_t deviceId, int32_t locationKeyCode) const override {
908         Device* device = getDevice(deviceId);
909         if (!device) {
910             return AKEYCODE_UNKNOWN;
911         }
912         auto it = device->keyCodeMapping.find(locationKeyCode);
913         return it != device->keyCodeMapping.end() ? it->second : locationKeyCode;
914     }
915 
916     // Return true if the device has non-empty key layout.
markSupportedKeyCodes(int32_t deviceId,size_t numCodes,const int32_t * keyCodes,uint8_t * outFlags) const917     bool markSupportedKeyCodes(int32_t deviceId, size_t numCodes, const int32_t* keyCodes,
918                                uint8_t* outFlags) const override {
919         bool result = false;
920         Device* device = getDevice(deviceId);
921         if (device) {
922             result = device->keysByScanCode.size() > 0 || device->keysByUsageCode.size() > 0;
923             for (size_t i = 0; i < numCodes; i++) {
924                 for (size_t j = 0; j < device->keysByScanCode.size(); j++) {
925                     if (keyCodes[i] == device->keysByScanCode.valueAt(j).keyCode) {
926                         outFlags[i] = 1;
927                     }
928                 }
929                 for (size_t j = 0; j < device->keysByUsageCode.size(); j++) {
930                     if (keyCodes[i] == device->keysByUsageCode.valueAt(j).keyCode) {
931                         outFlags[i] = 1;
932                     }
933                 }
934             }
935         }
936         return result;
937     }
938 
hasScanCode(int32_t deviceId,int32_t scanCode) const939     bool hasScanCode(int32_t deviceId, int32_t scanCode) const override {
940         Device* device = getDevice(deviceId);
941         if (device) {
942             ssize_t index = device->keysByScanCode.indexOfKey(scanCode);
943             return index >= 0;
944         }
945         return false;
946     }
947 
hasKeyCode(int32_t deviceId,int32_t keyCode) const948     bool hasKeyCode(int32_t deviceId, int32_t keyCode) const override {
949         Device* device = getDevice(deviceId);
950         if (!device) {
951             return false;
952         }
953         for (size_t i = 0; i < device->keysByScanCode.size(); i++) {
954             if (keyCode == device->keysByScanCode.valueAt(i).keyCode) {
955                 return true;
956             }
957         }
958         for (size_t j = 0; j < device->keysByUsageCode.size(); j++) {
959             if (keyCode == device->keysByUsageCode.valueAt(j).keyCode) {
960                 return true;
961             }
962         }
963         return false;
964     }
965 
hasLed(int32_t deviceId,int32_t led) const966     bool hasLed(int32_t deviceId, int32_t led) const override {
967         Device* device = getDevice(deviceId);
968         return device && device->leds.indexOfKey(led) >= 0;
969     }
970 
setLedState(int32_t deviceId,int32_t led,bool on)971     void setLedState(int32_t deviceId, int32_t led, bool on) override {
972         Device* device = getDevice(deviceId);
973         if (device) {
974             ssize_t index = device->leds.indexOfKey(led);
975             if (index >= 0) {
976                 device->leds.replaceValueAt(led, on);
977             } else {
978                 ADD_FAILURE()
979                         << "Attempted to set the state of an LED that the EventHub declared "
980                         "was not present.  led=" << led;
981             }
982         }
983     }
984 
getVirtualKeyDefinitions(int32_t deviceId,std::vector<VirtualKeyDefinition> & outVirtualKeys) const985     void getVirtualKeyDefinitions(
986             int32_t deviceId, std::vector<VirtualKeyDefinition>& outVirtualKeys) const override {
987         outVirtualKeys.clear();
988 
989         Device* device = getDevice(deviceId);
990         if (device) {
991             outVirtualKeys = device->virtualKeys;
992         }
993     }
994 
getKeyCharacterMap(int32_t) const995     const std::shared_ptr<KeyCharacterMap> getKeyCharacterMap(int32_t) const override {
996         return nullptr;
997     }
998 
setKeyboardLayoutOverlay(int32_t,std::shared_ptr<KeyCharacterMap>)999     bool setKeyboardLayoutOverlay(int32_t, std::shared_ptr<KeyCharacterMap>) override {
1000         return false;
1001     }
1002 
vibrate(int32_t,const VibrationElement &)1003     void vibrate(int32_t, const VibrationElement&) override {}
1004 
cancelVibrate(int32_t)1005     void cancelVibrate(int32_t) override {}
1006 
getVibratorIds(int32_t deviceId)1007     std::vector<int32_t> getVibratorIds(int32_t deviceId) override { return mVibrators; };
1008 
getBatteryCapacity(int32_t,int32_t) const1009     std::optional<int32_t> getBatteryCapacity(int32_t, int32_t) const override {
1010         return BATTERY_CAPACITY;
1011     }
1012 
getBatteryStatus(int32_t,int32_t) const1013     std::optional<int32_t> getBatteryStatus(int32_t, int32_t) const override {
1014         return BATTERY_STATUS;
1015     }
1016 
getRawBatteryIds(int32_t deviceId)1017     const std::vector<int32_t> getRawBatteryIds(int32_t deviceId) { return {}; }
1018 
getRawBatteryInfo(int32_t deviceId,int32_t batteryId)1019     std::optional<RawBatteryInfo> getRawBatteryInfo(int32_t deviceId, int32_t batteryId) {
1020         return std::nullopt;
1021     }
1022 
getRawLightIds(int32_t deviceId)1023     const std::vector<int32_t> getRawLightIds(int32_t deviceId) override {
1024         std::vector<int32_t> ids;
1025         for (const auto& [rawId, info] : mRawLightInfos) {
1026             ids.push_back(rawId);
1027         }
1028         return ids;
1029     }
1030 
getRawLightInfo(int32_t deviceId,int32_t lightId)1031     std::optional<RawLightInfo> getRawLightInfo(int32_t deviceId, int32_t lightId) override {
1032         auto it = mRawLightInfos.find(lightId);
1033         if (it == mRawLightInfos.end()) {
1034             return std::nullopt;
1035         }
1036         return it->second;
1037     }
1038 
setLightBrightness(int32_t deviceId,int32_t lightId,int32_t brightness)1039     void setLightBrightness(int32_t deviceId, int32_t lightId, int32_t brightness) override {
1040         mLightBrightness.emplace(lightId, brightness);
1041     }
1042 
setLightIntensities(int32_t deviceId,int32_t lightId,std::unordered_map<LightColor,int32_t> intensities)1043     void setLightIntensities(int32_t deviceId, int32_t lightId,
1044                              std::unordered_map<LightColor, int32_t> intensities) override {
1045         mLightIntensities.emplace(lightId, intensities);
1046     };
1047 
getLightBrightness(int32_t deviceId,int32_t lightId)1048     std::optional<int32_t> getLightBrightness(int32_t deviceId, int32_t lightId) override {
1049         auto lightIt = mLightBrightness.find(lightId);
1050         if (lightIt == mLightBrightness.end()) {
1051             return std::nullopt;
1052         }
1053         return lightIt->second;
1054     }
1055 
getLightIntensities(int32_t deviceId,int32_t lightId)1056     std::optional<std::unordered_map<LightColor, int32_t>> getLightIntensities(
1057             int32_t deviceId, int32_t lightId) override {
1058         auto lightIt = mLightIntensities.find(lightId);
1059         if (lightIt == mLightIntensities.end()) {
1060             return std::nullopt;
1061         }
1062         return lightIt->second;
1063     };
1064 
isExternal(int32_t) const1065     virtual bool isExternal(int32_t) const {
1066         return false;
1067     }
1068 
dump(std::string &)1069     void dump(std::string&) override {}
1070 
monitor()1071     void monitor() override {}
1072 
requestReopenDevices()1073     void requestReopenDevices() override {}
1074 
wake()1075     void wake() override {}
1076 };
1077 
1078 // --- FakeInputMapper ---
1079 
1080 class FakeInputMapper : public InputMapper {
1081     uint32_t mSources;
1082     int32_t mKeyboardType;
1083     int32_t mMetaState;
1084     KeyedVector<int32_t, int32_t> mKeyCodeStates;
1085     KeyedVector<int32_t, int32_t> mScanCodeStates;
1086     KeyedVector<int32_t, int32_t> mSwitchStates;
1087     // fake mapping which would normally come from keyCharacterMap
1088     std::unordered_map<int32_t, int32_t> mKeyCodeMapping;
1089     std::vector<int32_t> mSupportedKeyCodes;
1090 
1091     std::mutex mLock;
1092     std::condition_variable mStateChangedCondition;
1093     bool mConfigureWasCalled GUARDED_BY(mLock);
1094     bool mResetWasCalled GUARDED_BY(mLock);
1095     bool mProcessWasCalled GUARDED_BY(mLock);
1096     RawEvent mLastEvent GUARDED_BY(mLock);
1097 
1098     std::optional<DisplayViewport> mViewport;
1099 public:
FakeInputMapper(InputDeviceContext & deviceContext,uint32_t sources)1100     FakeInputMapper(InputDeviceContext& deviceContext, uint32_t sources)
1101           : InputMapper(deviceContext),
1102             mSources(sources),
1103             mKeyboardType(AINPUT_KEYBOARD_TYPE_NONE),
1104             mMetaState(0),
1105             mConfigureWasCalled(false),
1106             mResetWasCalled(false),
1107             mProcessWasCalled(false) {}
1108 
~FakeInputMapper()1109     virtual ~FakeInputMapper() {}
1110 
setKeyboardType(int32_t keyboardType)1111     void setKeyboardType(int32_t keyboardType) {
1112         mKeyboardType = keyboardType;
1113     }
1114 
setMetaState(int32_t metaState)1115     void setMetaState(int32_t metaState) {
1116         mMetaState = metaState;
1117     }
1118 
assertConfigureWasCalled()1119     void assertConfigureWasCalled() {
1120         std::unique_lock<std::mutex> lock(mLock);
1121         base::ScopedLockAssertion assumeLocked(mLock);
1122         const bool configureCalled =
1123                 mStateChangedCondition.wait_for(lock, WAIT_TIMEOUT, [this]() REQUIRES(mLock) {
1124                     return mConfigureWasCalled;
1125                 });
1126         if (!configureCalled) {
1127             FAIL() << "Expected configure() to have been called.";
1128         }
1129         mConfigureWasCalled = false;
1130     }
1131 
assertResetWasCalled()1132     void assertResetWasCalled() {
1133         std::unique_lock<std::mutex> lock(mLock);
1134         base::ScopedLockAssertion assumeLocked(mLock);
1135         const bool resetCalled =
1136                 mStateChangedCondition.wait_for(lock, WAIT_TIMEOUT, [this]() REQUIRES(mLock) {
1137                     return mResetWasCalled;
1138                 });
1139         if (!resetCalled) {
1140             FAIL() << "Expected reset() to have been called.";
1141         }
1142         mResetWasCalled = false;
1143     }
1144 
assertProcessWasCalled(RawEvent * outLastEvent=nullptr)1145     void assertProcessWasCalled(RawEvent* outLastEvent = nullptr) {
1146         std::unique_lock<std::mutex> lock(mLock);
1147         base::ScopedLockAssertion assumeLocked(mLock);
1148         const bool processCalled =
1149                 mStateChangedCondition.wait_for(lock, WAIT_TIMEOUT, [this]() REQUIRES(mLock) {
1150                     return mProcessWasCalled;
1151                 });
1152         if (!processCalled) {
1153             FAIL() << "Expected process() to have been called.";
1154         }
1155         if (outLastEvent) {
1156             *outLastEvent = mLastEvent;
1157         }
1158         mProcessWasCalled = false;
1159     }
1160 
setKeyCodeState(int32_t keyCode,int32_t state)1161     void setKeyCodeState(int32_t keyCode, int32_t state) {
1162         mKeyCodeStates.replaceValueFor(keyCode, state);
1163     }
1164 
setScanCodeState(int32_t scanCode,int32_t state)1165     void setScanCodeState(int32_t scanCode, int32_t state) {
1166         mScanCodeStates.replaceValueFor(scanCode, state);
1167     }
1168 
setSwitchState(int32_t switchCode,int32_t state)1169     void setSwitchState(int32_t switchCode, int32_t state) {
1170         mSwitchStates.replaceValueFor(switchCode, state);
1171     }
1172 
addSupportedKeyCode(int32_t keyCode)1173     void addSupportedKeyCode(int32_t keyCode) {
1174         mSupportedKeyCodes.push_back(keyCode);
1175     }
1176 
addKeyCodeMapping(int32_t fromKeyCode,int32_t toKeyCode)1177     void addKeyCodeMapping(int32_t fromKeyCode, int32_t toKeyCode) {
1178         mKeyCodeMapping.insert_or_assign(fromKeyCode, toKeyCode);
1179     }
1180 
1181 private:
getSources() const1182     uint32_t getSources() const override { return mSources; }
1183 
populateDeviceInfo(InputDeviceInfo * deviceInfo)1184     void populateDeviceInfo(InputDeviceInfo* deviceInfo) override {
1185         InputMapper::populateDeviceInfo(deviceInfo);
1186 
1187         if (mKeyboardType != AINPUT_KEYBOARD_TYPE_NONE) {
1188             deviceInfo->setKeyboardType(mKeyboardType);
1189         }
1190     }
1191 
configure(nsecs_t,const InputReaderConfiguration * config,uint32_t changes)1192     void configure(nsecs_t, const InputReaderConfiguration* config, uint32_t changes) override {
1193         std::scoped_lock<std::mutex> lock(mLock);
1194         mConfigureWasCalled = true;
1195 
1196         // Find the associated viewport if exist.
1197         const std::optional<uint8_t> displayPort = getDeviceContext().getAssociatedDisplayPort();
1198         if (displayPort && (changes & InputReaderConfiguration::CHANGE_DISPLAY_INFO)) {
1199             mViewport = config->getDisplayViewportByPort(*displayPort);
1200         }
1201 
1202         mStateChangedCondition.notify_all();
1203     }
1204 
reset(nsecs_t)1205     void reset(nsecs_t) override {
1206         std::scoped_lock<std::mutex> lock(mLock);
1207         mResetWasCalled = true;
1208         mStateChangedCondition.notify_all();
1209     }
1210 
process(const RawEvent * rawEvent)1211     void process(const RawEvent* rawEvent) override {
1212         std::scoped_lock<std::mutex> lock(mLock);
1213         mLastEvent = *rawEvent;
1214         mProcessWasCalled = true;
1215         mStateChangedCondition.notify_all();
1216     }
1217 
getKeyCodeState(uint32_t,int32_t keyCode)1218     int32_t getKeyCodeState(uint32_t, int32_t keyCode) override {
1219         ssize_t index = mKeyCodeStates.indexOfKey(keyCode);
1220         return index >= 0 ? mKeyCodeStates.valueAt(index) : AKEY_STATE_UNKNOWN;
1221     }
1222 
getKeyCodeForKeyLocation(int32_t locationKeyCode) const1223     int32_t getKeyCodeForKeyLocation(int32_t locationKeyCode) const override {
1224         auto it = mKeyCodeMapping.find(locationKeyCode);
1225         return it != mKeyCodeMapping.end() ? it->second : locationKeyCode;
1226     }
1227 
getScanCodeState(uint32_t,int32_t scanCode)1228     int32_t getScanCodeState(uint32_t, int32_t scanCode) override {
1229         ssize_t index = mScanCodeStates.indexOfKey(scanCode);
1230         return index >= 0 ? mScanCodeStates.valueAt(index) : AKEY_STATE_UNKNOWN;
1231     }
1232 
getSwitchState(uint32_t,int32_t switchCode)1233     int32_t getSwitchState(uint32_t, int32_t switchCode) override {
1234         ssize_t index = mSwitchStates.indexOfKey(switchCode);
1235         return index >= 0 ? mSwitchStates.valueAt(index) : AKEY_STATE_UNKNOWN;
1236     }
1237 
1238     // Return true if the device has non-empty key layout.
markSupportedKeyCodes(uint32_t,size_t numCodes,const int32_t * keyCodes,uint8_t * outFlags)1239     bool markSupportedKeyCodes(uint32_t, size_t numCodes, const int32_t* keyCodes,
1240                                uint8_t* outFlags) override {
1241         for (size_t i = 0; i < numCodes; i++) {
1242             for (size_t j = 0; j < mSupportedKeyCodes.size(); j++) {
1243                 if (keyCodes[i] == mSupportedKeyCodes[j]) {
1244                     outFlags[i] = 1;
1245                 }
1246             }
1247         }
1248         bool result = mSupportedKeyCodes.size() > 0;
1249         return result;
1250     }
1251 
getMetaState()1252     virtual int32_t getMetaState() {
1253         return mMetaState;
1254     }
1255 
fadePointer()1256     virtual void fadePointer() {
1257     }
1258 
getAssociatedDisplay()1259     virtual std::optional<int32_t> getAssociatedDisplay() {
1260         if (mViewport) {
1261             return std::make_optional(mViewport->displayId);
1262         }
1263         return std::nullopt;
1264     }
1265 };
1266 
1267 
1268 // --- InstrumentedInputReader ---
1269 
1270 class InstrumentedInputReader : public InputReader {
1271     std::queue<std::shared_ptr<InputDevice>> mNextDevices;
1272 
1273 public:
InstrumentedInputReader(std::shared_ptr<EventHubInterface> eventHub,const sp<InputReaderPolicyInterface> & policy,InputListenerInterface & listener)1274     InstrumentedInputReader(std::shared_ptr<EventHubInterface> eventHub,
1275                             const sp<InputReaderPolicyInterface>& policy,
1276                             InputListenerInterface& listener)
1277           : InputReader(eventHub, policy, listener), mFakeContext(this) {}
1278 
~InstrumentedInputReader()1279     virtual ~InstrumentedInputReader() {}
1280 
pushNextDevice(std::shared_ptr<InputDevice> device)1281     void pushNextDevice(std::shared_ptr<InputDevice> device) { mNextDevices.push(device); }
1282 
newDevice(int32_t deviceId,const std::string & name,const std::string & location="")1283     std::shared_ptr<InputDevice> newDevice(int32_t deviceId, const std::string& name,
1284                                            const std::string& location = "") {
1285         InputDeviceIdentifier identifier;
1286         identifier.name = name;
1287         identifier.location = location;
1288         int32_t generation = deviceId + 1;
1289         return std::make_shared<InputDevice>(&mFakeContext, deviceId, generation, identifier);
1290     }
1291 
1292     // Make the protected loopOnce method accessible to tests.
1293     using InputReader::loopOnce;
1294 
1295 protected:
createDeviceLocked(int32_t eventHubId,const InputDeviceIdentifier & identifier)1296     virtual std::shared_ptr<InputDevice> createDeviceLocked(int32_t eventHubId,
1297                                                             const InputDeviceIdentifier& identifier)
1298             REQUIRES(mLock) {
1299         if (!mNextDevices.empty()) {
1300             std::shared_ptr<InputDevice> device(std::move(mNextDevices.front()));
1301             mNextDevices.pop();
1302             return device;
1303         }
1304         return InputReader::createDeviceLocked(eventHubId, identifier);
1305     }
1306 
1307     // --- FakeInputReaderContext ---
1308     class FakeInputReaderContext : public ContextImpl {
1309         int32_t mGlobalMetaState;
1310         bool mUpdateGlobalMetaStateWasCalled;
1311         int32_t mGeneration;
1312 
1313     public:
FakeInputReaderContext(InputReader * reader)1314         FakeInputReaderContext(InputReader* reader)
1315               : ContextImpl(reader),
1316                 mGlobalMetaState(0),
1317                 mUpdateGlobalMetaStateWasCalled(false),
1318                 mGeneration(1) {}
1319 
~FakeInputReaderContext()1320         virtual ~FakeInputReaderContext() {}
1321 
assertUpdateGlobalMetaStateWasCalled()1322         void assertUpdateGlobalMetaStateWasCalled() {
1323             ASSERT_TRUE(mUpdateGlobalMetaStateWasCalled)
1324                     << "Expected updateGlobalMetaState() to have been called.";
1325             mUpdateGlobalMetaStateWasCalled = false;
1326         }
1327 
setGlobalMetaState(int32_t state)1328         void setGlobalMetaState(int32_t state) { mGlobalMetaState = state; }
1329 
getGeneration()1330         uint32_t getGeneration() { return mGeneration; }
1331 
updateGlobalMetaState()1332         void updateGlobalMetaState() override {
1333             mUpdateGlobalMetaStateWasCalled = true;
1334             ContextImpl::updateGlobalMetaState();
1335         }
1336 
getGlobalMetaState()1337         int32_t getGlobalMetaState() override {
1338             return mGlobalMetaState | ContextImpl::getGlobalMetaState();
1339         }
1340 
bumpGeneration()1341         int32_t bumpGeneration() override {
1342             mGeneration = ContextImpl::bumpGeneration();
1343             return mGeneration;
1344         }
1345     } mFakeContext;
1346 
1347     friend class InputReaderTest;
1348 
1349 public:
getContext()1350     FakeInputReaderContext* getContext() { return &mFakeContext; }
1351 };
1352 
1353 // --- InputReaderPolicyTest ---
1354 class InputReaderPolicyTest : public testing::Test {
1355 protected:
1356     sp<FakeInputReaderPolicy> mFakePolicy;
1357 
SetUp()1358     void SetUp() override { mFakePolicy = new FakeInputReaderPolicy(); }
TearDown()1359     void TearDown() override { mFakePolicy.clear(); }
1360 };
1361 
1362 /**
1363  * Check that empty set of viewports is an acceptable configuration.
1364  * Also try to get internal viewport two different ways - by type and by uniqueId.
1365  *
1366  * There will be confusion if two viewports with empty uniqueId and identical type are present.
1367  * Such configuration is not currently allowed.
1368  */
TEST_F(InputReaderPolicyTest,Viewports_GetCleared)1369 TEST_F(InputReaderPolicyTest, Viewports_GetCleared) {
1370     static const std::string uniqueId = "local:0";
1371 
1372     // We didn't add any viewports yet, so there shouldn't be any.
1373     std::optional<DisplayViewport> internalViewport =
1374             mFakePolicy->getDisplayViewportByType(ViewportType::INTERNAL);
1375     ASSERT_FALSE(internalViewport);
1376 
1377     // Add an internal viewport, then clear it
1378     mFakePolicy->addDisplayViewport(DISPLAY_ID, DISPLAY_WIDTH, DISPLAY_HEIGHT,
1379                                     DISPLAY_ORIENTATION_0, true /*isActive*/, uniqueId, NO_PORT,
1380                                     ViewportType::INTERNAL);
1381 
1382     // Check matching by uniqueId
1383     internalViewport = mFakePolicy->getDisplayViewportByUniqueId(uniqueId);
1384     ASSERT_TRUE(internalViewport);
1385     ASSERT_EQ(ViewportType::INTERNAL, internalViewport->type);
1386 
1387     // Check matching by viewport type
1388     internalViewport = mFakePolicy->getDisplayViewportByType(ViewportType::INTERNAL);
1389     ASSERT_TRUE(internalViewport);
1390     ASSERT_EQ(uniqueId, internalViewport->uniqueId);
1391 
1392     mFakePolicy->clearViewports();
1393     // Make sure nothing is found after clear
1394     internalViewport = mFakePolicy->getDisplayViewportByUniqueId(uniqueId);
1395     ASSERT_FALSE(internalViewport);
1396     internalViewport = mFakePolicy->getDisplayViewportByType(ViewportType::INTERNAL);
1397     ASSERT_FALSE(internalViewport);
1398 }
1399 
TEST_F(InputReaderPolicyTest,Viewports_GetByType)1400 TEST_F(InputReaderPolicyTest, Viewports_GetByType) {
1401     const std::string internalUniqueId = "local:0";
1402     const std::string externalUniqueId = "local:1";
1403     const std::string virtualUniqueId1 = "virtual:2";
1404     const std::string virtualUniqueId2 = "virtual:3";
1405     constexpr int32_t virtualDisplayId1 = 2;
1406     constexpr int32_t virtualDisplayId2 = 3;
1407 
1408     // Add an internal viewport
1409     mFakePolicy->addDisplayViewport(DISPLAY_ID, DISPLAY_WIDTH, DISPLAY_HEIGHT,
1410                                     DISPLAY_ORIENTATION_0, true /*isActive*/, internalUniqueId,
1411                                     NO_PORT, ViewportType::INTERNAL);
1412     // Add an external viewport
1413     mFakePolicy->addDisplayViewport(DISPLAY_ID, DISPLAY_WIDTH, DISPLAY_HEIGHT,
1414                                     DISPLAY_ORIENTATION_0, true /*isActive*/, externalUniqueId,
1415                                     NO_PORT, ViewportType::EXTERNAL);
1416     // Add an virtual viewport
1417     mFakePolicy->addDisplayViewport(virtualDisplayId1, DISPLAY_WIDTH, DISPLAY_HEIGHT,
1418                                     DISPLAY_ORIENTATION_0, true /*isActive*/, virtualUniqueId1,
1419                                     NO_PORT, ViewportType::VIRTUAL);
1420     // Add another virtual viewport
1421     mFakePolicy->addDisplayViewport(virtualDisplayId2, DISPLAY_WIDTH, DISPLAY_HEIGHT,
1422                                     DISPLAY_ORIENTATION_0, true /*isActive*/, virtualUniqueId2,
1423                                     NO_PORT, ViewportType::VIRTUAL);
1424 
1425     // Check matching by type for internal
1426     std::optional<DisplayViewport> internalViewport =
1427             mFakePolicy->getDisplayViewportByType(ViewportType::INTERNAL);
1428     ASSERT_TRUE(internalViewport);
1429     ASSERT_EQ(internalUniqueId, internalViewport->uniqueId);
1430 
1431     // Check matching by type for external
1432     std::optional<DisplayViewport> externalViewport =
1433             mFakePolicy->getDisplayViewportByType(ViewportType::EXTERNAL);
1434     ASSERT_TRUE(externalViewport);
1435     ASSERT_EQ(externalUniqueId, externalViewport->uniqueId);
1436 
1437     // Check matching by uniqueId for virtual viewport #1
1438     std::optional<DisplayViewport> virtualViewport1 =
1439             mFakePolicy->getDisplayViewportByUniqueId(virtualUniqueId1);
1440     ASSERT_TRUE(virtualViewport1);
1441     ASSERT_EQ(ViewportType::VIRTUAL, virtualViewport1->type);
1442     ASSERT_EQ(virtualUniqueId1, virtualViewport1->uniqueId);
1443     ASSERT_EQ(virtualDisplayId1, virtualViewport1->displayId);
1444 
1445     // Check matching by uniqueId for virtual viewport #2
1446     std::optional<DisplayViewport> virtualViewport2 =
1447             mFakePolicy->getDisplayViewportByUniqueId(virtualUniqueId2);
1448     ASSERT_TRUE(virtualViewport2);
1449     ASSERT_EQ(ViewportType::VIRTUAL, virtualViewport2->type);
1450     ASSERT_EQ(virtualUniqueId2, virtualViewport2->uniqueId);
1451     ASSERT_EQ(virtualDisplayId2, virtualViewport2->displayId);
1452 }
1453 
1454 
1455 /**
1456  * We can have 2 viewports of the same kind. We can distinguish them by uniqueId, and confirm
1457  * that lookup works by checking display id.
1458  * Check that 2 viewports of each kind is possible, for all existing viewport types.
1459  */
TEST_F(InputReaderPolicyTest,Viewports_TwoOfSameType)1460 TEST_F(InputReaderPolicyTest, Viewports_TwoOfSameType) {
1461     const std::string uniqueId1 = "uniqueId1";
1462     const std::string uniqueId2 = "uniqueId2";
1463     constexpr int32_t displayId1 = 2;
1464     constexpr int32_t displayId2 = 3;
1465 
1466     std::vector<ViewportType> types = {ViewportType::INTERNAL, ViewportType::EXTERNAL,
1467                                        ViewportType::VIRTUAL};
1468     for (const ViewportType& type : types) {
1469         mFakePolicy->clearViewports();
1470         // Add a viewport
1471         mFakePolicy->addDisplayViewport(displayId1, DISPLAY_WIDTH, DISPLAY_HEIGHT,
1472                                         DISPLAY_ORIENTATION_0, true /*isActive*/, uniqueId1,
1473                                         NO_PORT, type);
1474         // Add another viewport
1475         mFakePolicy->addDisplayViewport(displayId2, DISPLAY_WIDTH, DISPLAY_HEIGHT,
1476                                         DISPLAY_ORIENTATION_0, true /*isActive*/, uniqueId2,
1477                                         NO_PORT, type);
1478 
1479         // Check that correct display viewport was returned by comparing the display IDs.
1480         std::optional<DisplayViewport> viewport1 =
1481                 mFakePolicy->getDisplayViewportByUniqueId(uniqueId1);
1482         ASSERT_TRUE(viewport1);
1483         ASSERT_EQ(displayId1, viewport1->displayId);
1484         ASSERT_EQ(type, viewport1->type);
1485 
1486         std::optional<DisplayViewport> viewport2 =
1487                 mFakePolicy->getDisplayViewportByUniqueId(uniqueId2);
1488         ASSERT_TRUE(viewport2);
1489         ASSERT_EQ(displayId2, viewport2->displayId);
1490         ASSERT_EQ(type, viewport2->type);
1491 
1492         // When there are multiple viewports of the same kind, and uniqueId is not specified
1493         // in the call to getDisplayViewport, then that situation is not supported.
1494         // The viewports can be stored in any order, so we cannot rely on the order, since that
1495         // is just implementation detail.
1496         // However, we can check that it still returns *a* viewport, we just cannot assert
1497         // which one specifically is returned.
1498         std::optional<DisplayViewport> someViewport = mFakePolicy->getDisplayViewportByType(type);
1499         ASSERT_TRUE(someViewport);
1500     }
1501 }
1502 
1503 /**
1504  * When we have multiple internal displays make sure we always return the default display when
1505  * querying by type.
1506  */
TEST_F(InputReaderPolicyTest,Viewports_ByTypeReturnsDefaultForInternal)1507 TEST_F(InputReaderPolicyTest, Viewports_ByTypeReturnsDefaultForInternal) {
1508     const std::string uniqueId1 = "uniqueId1";
1509     const std::string uniqueId2 = "uniqueId2";
1510     constexpr int32_t nonDefaultDisplayId = 2;
1511     static_assert(nonDefaultDisplayId != ADISPLAY_ID_DEFAULT,
1512                   "Test display ID should not be ADISPLAY_ID_DEFAULT");
1513 
1514     // Add the default display first and ensure it gets returned.
1515     mFakePolicy->clearViewports();
1516     mFakePolicy->addDisplayViewport(ADISPLAY_ID_DEFAULT, DISPLAY_WIDTH, DISPLAY_HEIGHT,
1517                                     DISPLAY_ORIENTATION_0, true /*isActive*/, uniqueId1, NO_PORT,
1518                                     ViewportType::INTERNAL);
1519     mFakePolicy->addDisplayViewport(nonDefaultDisplayId, DISPLAY_WIDTH, DISPLAY_HEIGHT,
1520                                     DISPLAY_ORIENTATION_0, true /*isActive*/, uniqueId2, NO_PORT,
1521                                     ViewportType::INTERNAL);
1522 
1523     std::optional<DisplayViewport> viewport =
1524             mFakePolicy->getDisplayViewportByType(ViewportType::INTERNAL);
1525     ASSERT_TRUE(viewport);
1526     ASSERT_EQ(ADISPLAY_ID_DEFAULT, viewport->displayId);
1527     ASSERT_EQ(ViewportType::INTERNAL, viewport->type);
1528 
1529     // Add the default display second to make sure order doesn't matter.
1530     mFakePolicy->clearViewports();
1531     mFakePolicy->addDisplayViewport(nonDefaultDisplayId, DISPLAY_WIDTH, DISPLAY_HEIGHT,
1532                                     DISPLAY_ORIENTATION_0, true /*isActive*/, uniqueId2, NO_PORT,
1533                                     ViewportType::INTERNAL);
1534     mFakePolicy->addDisplayViewport(ADISPLAY_ID_DEFAULT, DISPLAY_WIDTH, DISPLAY_HEIGHT,
1535                                     DISPLAY_ORIENTATION_0, true /*isActive*/, uniqueId1, NO_PORT,
1536                                     ViewportType::INTERNAL);
1537 
1538     viewport = mFakePolicy->getDisplayViewportByType(ViewportType::INTERNAL);
1539     ASSERT_TRUE(viewport);
1540     ASSERT_EQ(ADISPLAY_ID_DEFAULT, viewport->displayId);
1541     ASSERT_EQ(ViewportType::INTERNAL, viewport->type);
1542 }
1543 
1544 /**
1545  * Check getDisplayViewportByPort
1546  */
TEST_F(InputReaderPolicyTest,Viewports_GetByPort)1547 TEST_F(InputReaderPolicyTest, Viewports_GetByPort) {
1548     constexpr ViewportType type = ViewportType::EXTERNAL;
1549     const std::string uniqueId1 = "uniqueId1";
1550     const std::string uniqueId2 = "uniqueId2";
1551     constexpr int32_t displayId1 = 1;
1552     constexpr int32_t displayId2 = 2;
1553     const uint8_t hdmi1 = 0;
1554     const uint8_t hdmi2 = 1;
1555     const uint8_t hdmi3 = 2;
1556 
1557     mFakePolicy->clearViewports();
1558     // Add a viewport that's associated with some display port that's not of interest.
1559     mFakePolicy->addDisplayViewport(displayId1, DISPLAY_WIDTH, DISPLAY_HEIGHT,
1560                                     DISPLAY_ORIENTATION_0, true /*isActive*/, uniqueId1, hdmi3,
1561                                     type);
1562     // Add another viewport, connected to HDMI1 port
1563     mFakePolicy->addDisplayViewport(displayId2, DISPLAY_WIDTH, DISPLAY_HEIGHT,
1564                                     DISPLAY_ORIENTATION_0, true /*isActive*/, uniqueId2, hdmi1,
1565                                     type);
1566 
1567     // Check that correct display viewport was returned by comparing the display ports.
1568     std::optional<DisplayViewport> hdmi1Viewport = mFakePolicy->getDisplayViewportByPort(hdmi1);
1569     ASSERT_TRUE(hdmi1Viewport);
1570     ASSERT_EQ(displayId2, hdmi1Viewport->displayId);
1571     ASSERT_EQ(uniqueId2, hdmi1Viewport->uniqueId);
1572 
1573     // Check that we can still get the same viewport using the uniqueId
1574     hdmi1Viewport = mFakePolicy->getDisplayViewportByUniqueId(uniqueId2);
1575     ASSERT_TRUE(hdmi1Viewport);
1576     ASSERT_EQ(displayId2, hdmi1Viewport->displayId);
1577     ASSERT_EQ(uniqueId2, hdmi1Viewport->uniqueId);
1578     ASSERT_EQ(type, hdmi1Viewport->type);
1579 
1580     // Check that we cannot find a port with "HDMI2", because we never added one
1581     std::optional<DisplayViewport> hdmi2Viewport = mFakePolicy->getDisplayViewportByPort(hdmi2);
1582     ASSERT_FALSE(hdmi2Viewport);
1583 }
1584 
1585 // --- InputReaderTest ---
1586 
1587 class InputReaderTest : public testing::Test {
1588 protected:
1589     std::unique_ptr<TestInputListener> mFakeListener;
1590     sp<FakeInputReaderPolicy> mFakePolicy;
1591     std::shared_ptr<FakeEventHub> mFakeEventHub;
1592     std::unique_ptr<InstrumentedInputReader> mReader;
1593 
SetUp()1594     void SetUp() override {
1595         mFakeEventHub = std::make_unique<FakeEventHub>();
1596         mFakePolicy = new FakeInputReaderPolicy();
1597         mFakeListener = std::make_unique<TestInputListener>();
1598 
1599         mReader = std::make_unique<InstrumentedInputReader>(mFakeEventHub, mFakePolicy,
1600                                                             *mFakeListener);
1601     }
1602 
TearDown()1603     void TearDown() override {
1604         mFakeListener.reset();
1605         mFakePolicy.clear();
1606     }
1607 
addDevice(int32_t eventHubId,const std::string & name,ftl::Flags<InputDeviceClass> classes,const PropertyMap * configuration)1608     void addDevice(int32_t eventHubId, const std::string& name,
1609                    ftl::Flags<InputDeviceClass> classes, const PropertyMap* configuration) {
1610         mFakeEventHub->addDevice(eventHubId, name, classes);
1611 
1612         if (configuration) {
1613             mFakeEventHub->addConfigurationMap(eventHubId, configuration);
1614         }
1615         mFakeEventHub->finishDeviceScan();
1616         mReader->loopOnce();
1617         mReader->loopOnce();
1618         ASSERT_NO_FATAL_FAILURE(mFakePolicy->assertInputDevicesChanged());
1619         ASSERT_NO_FATAL_FAILURE(mFakeEventHub->assertQueueIsEmpty());
1620     }
1621 
disableDevice(int32_t deviceId)1622     void disableDevice(int32_t deviceId) {
1623         mFakePolicy->addDisabledDevice(deviceId);
1624         mReader->requestRefreshConfiguration(InputReaderConfiguration::CHANGE_ENABLED_STATE);
1625     }
1626 
enableDevice(int32_t deviceId)1627     void enableDevice(int32_t deviceId) {
1628         mFakePolicy->removeDisabledDevice(deviceId);
1629         mReader->requestRefreshConfiguration(InputReaderConfiguration::CHANGE_ENABLED_STATE);
1630     }
1631 
addDeviceWithFakeInputMapper(int32_t deviceId,int32_t eventHubId,const std::string & name,ftl::Flags<InputDeviceClass> classes,uint32_t sources,const PropertyMap * configuration)1632     FakeInputMapper& addDeviceWithFakeInputMapper(int32_t deviceId, int32_t eventHubId,
1633                                                   const std::string& name,
1634                                                   ftl::Flags<InputDeviceClass> classes,
1635                                                   uint32_t sources,
1636                                                   const PropertyMap* configuration) {
1637         std::shared_ptr<InputDevice> device = mReader->newDevice(deviceId, name);
1638         FakeInputMapper& mapper = device->addMapper<FakeInputMapper>(eventHubId, sources);
1639         mReader->pushNextDevice(device);
1640         addDevice(eventHubId, name, classes, configuration);
1641         return mapper;
1642     }
1643 };
1644 
TEST_F(InputReaderTest,PolicyGetInputDevices)1645 TEST_F(InputReaderTest, PolicyGetInputDevices) {
1646     ASSERT_NO_FATAL_FAILURE(addDevice(1, "keyboard", InputDeviceClass::KEYBOARD, nullptr));
1647     ASSERT_NO_FATAL_FAILURE(addDevice(2, "ignored", ftl::Flags<InputDeviceClass>(0),
1648                                       nullptr)); // no classes so device will be ignored
1649 
1650     // Should also have received a notification describing the new input devices.
1651     const std::vector<InputDeviceInfo>& inputDevices = mFakePolicy->getInputDevices();
1652     ASSERT_EQ(1U, inputDevices.size());
1653     ASSERT_EQ(END_RESERVED_ID + 1, inputDevices[0].getId());
1654     ASSERT_STREQ("keyboard", inputDevices[0].getIdentifier().name.c_str());
1655     ASSERT_EQ(AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC, inputDevices[0].getKeyboardType());
1656     ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, inputDevices[0].getSources());
1657     ASSERT_EQ(0U, inputDevices[0].getMotionRanges().size());
1658 }
1659 
TEST_F(InputReaderTest,GetMergedInputDevices)1660 TEST_F(InputReaderTest, GetMergedInputDevices) {
1661     constexpr int32_t deviceId = END_RESERVED_ID + 1000;
1662     constexpr int32_t eventHubIds[2] = {END_RESERVED_ID, END_RESERVED_ID + 1};
1663     // Add two subdevices to device
1664     std::shared_ptr<InputDevice> device = mReader->newDevice(deviceId, "fake");
1665     // Must add at least one mapper or the device will be ignored!
1666     device->addMapper<FakeInputMapper>(eventHubIds[0], AINPUT_SOURCE_KEYBOARD);
1667     device->addMapper<FakeInputMapper>(eventHubIds[1], AINPUT_SOURCE_KEYBOARD);
1668 
1669     // Push same device instance for next device to be added, so they'll have same identifier.
1670     mReader->pushNextDevice(device);
1671     mReader->pushNextDevice(device);
1672     ASSERT_NO_FATAL_FAILURE(
1673             addDevice(eventHubIds[0], "fake1", InputDeviceClass::KEYBOARD, nullptr));
1674     ASSERT_NO_FATAL_FAILURE(
1675             addDevice(eventHubIds[1], "fake2", InputDeviceClass::KEYBOARD, nullptr));
1676 
1677     // Two devices will be merged to one input device as they have same identifier
1678     ASSERT_EQ(1U, mFakePolicy->getInputDevices().size());
1679 }
1680 
TEST_F(InputReaderTest,GetMergedInputDevicesEnabled)1681 TEST_F(InputReaderTest, GetMergedInputDevicesEnabled) {
1682     constexpr int32_t deviceId = END_RESERVED_ID + 1000;
1683     constexpr int32_t eventHubIds[2] = {END_RESERVED_ID, END_RESERVED_ID + 1};
1684     // Add two subdevices to device
1685     std::shared_ptr<InputDevice> device = mReader->newDevice(deviceId, "fake");
1686     // Must add at least one mapper or the device will be ignored!
1687     device->addMapper<FakeInputMapper>(eventHubIds[0], AINPUT_SOURCE_KEYBOARD);
1688     device->addMapper<FakeInputMapper>(eventHubIds[1], AINPUT_SOURCE_KEYBOARD);
1689 
1690     // Push same device instance for next device to be added, so they'll have same identifier.
1691     mReader->pushNextDevice(device);
1692     mReader->pushNextDevice(device);
1693     // Sensor device is initially disabled
1694     ASSERT_NO_FATAL_FAILURE(addDevice(eventHubIds[0], "fake1",
1695                                       InputDeviceClass::KEYBOARD | InputDeviceClass::SENSOR,
1696                                       nullptr));
1697     // Device is disabled because the only sub device is a sensor device and disabled initially.
1698     ASSERT_FALSE(mFakeEventHub->isDeviceEnabled(eventHubIds[0]));
1699     ASSERT_FALSE(device->isEnabled());
1700     ASSERT_NO_FATAL_FAILURE(
1701             addDevice(eventHubIds[1], "fake2", InputDeviceClass::KEYBOARD, nullptr));
1702     // The merged device is enabled if any sub device is enabled
1703     ASSERT_TRUE(mFakeEventHub->isDeviceEnabled(eventHubIds[1]));
1704     ASSERT_TRUE(device->isEnabled());
1705 }
1706 
TEST_F(InputReaderTest,WhenEnabledChanges_SendsDeviceResetNotification)1707 TEST_F(InputReaderTest, WhenEnabledChanges_SendsDeviceResetNotification) {
1708     constexpr int32_t deviceId = END_RESERVED_ID + 1000;
1709     constexpr ftl::Flags<InputDeviceClass> deviceClass(InputDeviceClass::KEYBOARD);
1710     constexpr int32_t eventHubId = 1;
1711     std::shared_ptr<InputDevice> device = mReader->newDevice(deviceId, "fake");
1712     // Must add at least one mapper or the device will be ignored!
1713     device->addMapper<FakeInputMapper>(eventHubId, AINPUT_SOURCE_KEYBOARD);
1714     mReader->pushNextDevice(device);
1715     ASSERT_NO_FATAL_FAILURE(addDevice(eventHubId, "fake", deviceClass, nullptr));
1716 
1717     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyConfigurationChangedWasCalled(nullptr));
1718 
1719     NotifyDeviceResetArgs resetArgs;
1720     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled(&resetArgs));
1721     ASSERT_EQ(deviceId, resetArgs.deviceId);
1722 
1723     ASSERT_EQ(device->isEnabled(), true);
1724     disableDevice(deviceId);
1725     mReader->loopOnce();
1726 
1727     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled(&resetArgs));
1728     ASSERT_EQ(deviceId, resetArgs.deviceId);
1729     ASSERT_EQ(device->isEnabled(), false);
1730 
1731     disableDevice(deviceId);
1732     mReader->loopOnce();
1733     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasNotCalled());
1734     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyConfigurationChangedWasNotCalled());
1735     ASSERT_EQ(device->isEnabled(), false);
1736 
1737     enableDevice(deviceId);
1738     mReader->loopOnce();
1739     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled(&resetArgs));
1740     ASSERT_EQ(deviceId, resetArgs.deviceId);
1741     ASSERT_EQ(device->isEnabled(), true);
1742 }
1743 
TEST_F(InputReaderTest,GetKeyCodeState_ForwardsRequestsToMappers)1744 TEST_F(InputReaderTest, GetKeyCodeState_ForwardsRequestsToMappers) {
1745     constexpr int32_t deviceId = END_RESERVED_ID + 1000;
1746     constexpr ftl::Flags<InputDeviceClass> deviceClass = InputDeviceClass::KEYBOARD;
1747     constexpr int32_t eventHubId = 1;
1748     FakeInputMapper& mapper =
1749             addDeviceWithFakeInputMapper(deviceId, eventHubId, "fake", deviceClass,
1750                                          AINPUT_SOURCE_KEYBOARD, nullptr);
1751     mapper.setKeyCodeState(AKEYCODE_A, AKEY_STATE_DOWN);
1752 
1753     ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getKeyCodeState(0,
1754             AINPUT_SOURCE_ANY, AKEYCODE_A))
1755             << "Should return unknown when the device id is >= 0 but unknown.";
1756 
1757     ASSERT_EQ(AKEY_STATE_UNKNOWN,
1758               mReader->getKeyCodeState(deviceId, AINPUT_SOURCE_TRACKBALL, AKEYCODE_A))
1759             << "Should return unknown when the device id is valid but the sources are not "
1760                "supported by the device.";
1761 
1762     ASSERT_EQ(AKEY_STATE_DOWN,
1763               mReader->getKeyCodeState(deviceId, AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL,
1764                                        AKEYCODE_A))
1765             << "Should return value provided by mapper when device id is valid and the device "
1766                "supports some of the sources.";
1767 
1768     ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getKeyCodeState(-1,
1769             AINPUT_SOURCE_TRACKBALL, AKEYCODE_A))
1770             << "Should return unknown when the device id is < 0 but the sources are not supported by any device.";
1771 
1772     ASSERT_EQ(AKEY_STATE_DOWN, mReader->getKeyCodeState(-1,
1773             AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, AKEYCODE_A))
1774             << "Should return value provided by mapper when device id is < 0 and one of the devices supports some of the sources.";
1775 }
1776 
TEST_F(InputReaderTest,GetKeyCodeForKeyLocation_ForwardsRequestsToMappers)1777 TEST_F(InputReaderTest, GetKeyCodeForKeyLocation_ForwardsRequestsToMappers) {
1778     constexpr int32_t deviceId = END_RESERVED_ID + 1000;
1779     constexpr int32_t eventHubId = 1;
1780     FakeInputMapper& mapper = addDeviceWithFakeInputMapper(deviceId, eventHubId, "keyboard",
1781                                                            InputDeviceClass::KEYBOARD,
1782                                                            AINPUT_SOURCE_KEYBOARD, nullptr);
1783     mapper.addKeyCodeMapping(AKEYCODE_Y, AKEYCODE_Z);
1784 
1785     ASSERT_EQ(AKEYCODE_UNKNOWN, mReader->getKeyCodeForKeyLocation(0, AKEYCODE_Y))
1786             << "Should return unknown when the device with the specified id is not found.";
1787 
1788     ASSERT_EQ(AKEYCODE_Z, mReader->getKeyCodeForKeyLocation(deviceId, AKEYCODE_Y))
1789             << "Should return correct mapping when device id is valid and mapping exists.";
1790 
1791     ASSERT_EQ(AKEYCODE_A, mReader->getKeyCodeForKeyLocation(deviceId, AKEYCODE_A))
1792             << "Should return the location key code when device id is valid and there's no "
1793                "mapping.";
1794 }
1795 
TEST_F(InputReaderTest,GetKeyCodeForKeyLocation_NoKeyboardMapper)1796 TEST_F(InputReaderTest, GetKeyCodeForKeyLocation_NoKeyboardMapper) {
1797     constexpr int32_t deviceId = END_RESERVED_ID + 1000;
1798     constexpr int32_t eventHubId = 1;
1799     FakeInputMapper& mapper = addDeviceWithFakeInputMapper(deviceId, eventHubId, "joystick",
1800                                                            InputDeviceClass::JOYSTICK,
1801                                                            AINPUT_SOURCE_GAMEPAD, nullptr);
1802     mapper.addKeyCodeMapping(AKEYCODE_Y, AKEYCODE_Z);
1803 
1804     ASSERT_EQ(AKEYCODE_UNKNOWN, mReader->getKeyCodeForKeyLocation(deviceId, AKEYCODE_Y))
1805             << "Should return unknown when the device id is valid but there is no keyboard mapper";
1806 }
1807 
TEST_F(InputReaderTest,GetScanCodeState_ForwardsRequestsToMappers)1808 TEST_F(InputReaderTest, GetScanCodeState_ForwardsRequestsToMappers) {
1809     constexpr int32_t deviceId = END_RESERVED_ID + 1000;
1810     constexpr ftl::Flags<InputDeviceClass> deviceClass = InputDeviceClass::KEYBOARD;
1811     constexpr int32_t eventHubId = 1;
1812     FakeInputMapper& mapper =
1813             addDeviceWithFakeInputMapper(deviceId, eventHubId, "fake", deviceClass,
1814                                          AINPUT_SOURCE_KEYBOARD, nullptr);
1815     mapper.setScanCodeState(KEY_A, AKEY_STATE_DOWN);
1816 
1817     ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getScanCodeState(0,
1818             AINPUT_SOURCE_ANY, KEY_A))
1819             << "Should return unknown when the device id is >= 0 but unknown.";
1820 
1821     ASSERT_EQ(AKEY_STATE_UNKNOWN,
1822               mReader->getScanCodeState(deviceId, AINPUT_SOURCE_TRACKBALL, KEY_A))
1823             << "Should return unknown when the device id is valid but the sources are not "
1824                "supported by the device.";
1825 
1826     ASSERT_EQ(AKEY_STATE_DOWN,
1827               mReader->getScanCodeState(deviceId, AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL,
1828                                         KEY_A))
1829             << "Should return value provided by mapper when device id is valid and the device "
1830                "supports some of the sources.";
1831 
1832     ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getScanCodeState(-1,
1833             AINPUT_SOURCE_TRACKBALL, KEY_A))
1834             << "Should return unknown when the device id is < 0 but the sources are not supported by any device.";
1835 
1836     ASSERT_EQ(AKEY_STATE_DOWN, mReader->getScanCodeState(-1,
1837             AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, KEY_A))
1838             << "Should return value provided by mapper when device id is < 0 and one of the devices supports some of the sources.";
1839 }
1840 
TEST_F(InputReaderTest,GetSwitchState_ForwardsRequestsToMappers)1841 TEST_F(InputReaderTest, GetSwitchState_ForwardsRequestsToMappers) {
1842     constexpr int32_t deviceId = END_RESERVED_ID + 1000;
1843     constexpr ftl::Flags<InputDeviceClass> deviceClass = InputDeviceClass::KEYBOARD;
1844     constexpr int32_t eventHubId = 1;
1845     FakeInputMapper& mapper =
1846             addDeviceWithFakeInputMapper(deviceId, eventHubId, "fake", deviceClass,
1847                                          AINPUT_SOURCE_KEYBOARD, nullptr);
1848     mapper.setSwitchState(SW_LID, AKEY_STATE_DOWN);
1849 
1850     ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getSwitchState(0,
1851             AINPUT_SOURCE_ANY, SW_LID))
1852             << "Should return unknown when the device id is >= 0 but unknown.";
1853 
1854     ASSERT_EQ(AKEY_STATE_UNKNOWN,
1855               mReader->getSwitchState(deviceId, AINPUT_SOURCE_TRACKBALL, SW_LID))
1856             << "Should return unknown when the device id is valid but the sources are not "
1857                "supported by the device.";
1858 
1859     ASSERT_EQ(AKEY_STATE_DOWN,
1860               mReader->getSwitchState(deviceId, AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL,
1861                                       SW_LID))
1862             << "Should return value provided by mapper when device id is valid and the device "
1863                "supports some of the sources.";
1864 
1865     ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getSwitchState(-1,
1866             AINPUT_SOURCE_TRACKBALL, SW_LID))
1867             << "Should return unknown when the device id is < 0 but the sources are not supported by any device.";
1868 
1869     ASSERT_EQ(AKEY_STATE_DOWN, mReader->getSwitchState(-1,
1870             AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, SW_LID))
1871             << "Should return value provided by mapper when device id is < 0 and one of the devices supports some of the sources.";
1872 }
1873 
TEST_F(InputReaderTest,MarkSupportedKeyCodes_ForwardsRequestsToMappers)1874 TEST_F(InputReaderTest, MarkSupportedKeyCodes_ForwardsRequestsToMappers) {
1875     constexpr int32_t deviceId = END_RESERVED_ID + 1000;
1876     constexpr ftl::Flags<InputDeviceClass> deviceClass = InputDeviceClass::KEYBOARD;
1877     constexpr int32_t eventHubId = 1;
1878     FakeInputMapper& mapper =
1879             addDeviceWithFakeInputMapper(deviceId, eventHubId, "fake", deviceClass,
1880                                          AINPUT_SOURCE_KEYBOARD, nullptr);
1881 
1882     mapper.addSupportedKeyCode(AKEYCODE_A);
1883     mapper.addSupportedKeyCode(AKEYCODE_B);
1884 
1885     const int32_t keyCodes[4] = { AKEYCODE_A, AKEYCODE_B, AKEYCODE_1, AKEYCODE_2 };
1886     uint8_t flags[4] = { 0, 0, 0, 1 };
1887 
1888     ASSERT_FALSE(mReader->hasKeys(0, AINPUT_SOURCE_ANY, 4, keyCodes, flags))
1889             << "Should return false when device id is >= 0 but unknown.";
1890     ASSERT_TRUE(!flags[0] && !flags[1] && !flags[2] && !flags[3]);
1891 
1892     flags[3] = 1;
1893     ASSERT_FALSE(mReader->hasKeys(deviceId, AINPUT_SOURCE_TRACKBALL, 4, keyCodes, flags))
1894             << "Should return false when device id is valid but the sources are not supported by "
1895                "the device.";
1896     ASSERT_TRUE(!flags[0] && !flags[1] && !flags[2] && !flags[3]);
1897 
1898     flags[3] = 1;
1899     ASSERT_TRUE(mReader->hasKeys(deviceId, AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, 4,
1900                                  keyCodes, flags))
1901             << "Should return value provided by mapper when device id is valid and the device "
1902                "supports some of the sources.";
1903     ASSERT_TRUE(flags[0] && flags[1] && !flags[2] && !flags[3]);
1904 
1905     flags[3] = 1;
1906     ASSERT_FALSE(mReader->hasKeys(-1, AINPUT_SOURCE_TRACKBALL, 4, keyCodes, flags))
1907             << "Should return false when the device id is < 0 but the sources are not supported by any device.";
1908     ASSERT_TRUE(!flags[0] && !flags[1] && !flags[2] && !flags[3]);
1909 
1910     flags[3] = 1;
1911     ASSERT_TRUE(mReader->hasKeys(-1, AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, 4, keyCodes, flags))
1912             << "Should return value provided by mapper when device id is < 0 and one of the devices supports some of the sources.";
1913     ASSERT_TRUE(flags[0] && flags[1] && !flags[2] && !flags[3]);
1914 }
1915 
TEST_F(InputReaderTest,LoopOnce_WhenDeviceScanFinished_SendsConfigurationChanged)1916 TEST_F(InputReaderTest, LoopOnce_WhenDeviceScanFinished_SendsConfigurationChanged) {
1917     constexpr int32_t eventHubId = 1;
1918     addDevice(eventHubId, "ignored", InputDeviceClass::KEYBOARD, nullptr);
1919 
1920     NotifyConfigurationChangedArgs args;
1921 
1922     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyConfigurationChangedWasCalled(&args));
1923     ASSERT_EQ(ARBITRARY_TIME, args.eventTime);
1924 }
1925 
TEST_F(InputReaderTest,LoopOnce_ForwardsRawEventsToMappers)1926 TEST_F(InputReaderTest, LoopOnce_ForwardsRawEventsToMappers) {
1927     constexpr int32_t deviceId = END_RESERVED_ID + 1000;
1928     constexpr ftl::Flags<InputDeviceClass> deviceClass = InputDeviceClass::KEYBOARD;
1929     constexpr nsecs_t when = 0;
1930     constexpr int32_t eventHubId = 1;
1931     constexpr nsecs_t readTime = 2;
1932     FakeInputMapper& mapper =
1933             addDeviceWithFakeInputMapper(deviceId, eventHubId, "fake", deviceClass,
1934                                          AINPUT_SOURCE_KEYBOARD, nullptr);
1935 
1936     mFakeEventHub->enqueueEvent(when, readTime, eventHubId, EV_KEY, KEY_A, 1);
1937     mReader->loopOnce();
1938     ASSERT_NO_FATAL_FAILURE(mFakeEventHub->assertQueueIsEmpty());
1939 
1940     RawEvent event;
1941     ASSERT_NO_FATAL_FAILURE(mapper.assertProcessWasCalled(&event));
1942     ASSERT_EQ(when, event.when);
1943     ASSERT_EQ(readTime, event.readTime);
1944     ASSERT_EQ(eventHubId, event.deviceId);
1945     ASSERT_EQ(EV_KEY, event.type);
1946     ASSERT_EQ(KEY_A, event.code);
1947     ASSERT_EQ(1, event.value);
1948 }
1949 
TEST_F(InputReaderTest,DeviceReset_RandomId)1950 TEST_F(InputReaderTest, DeviceReset_RandomId) {
1951     constexpr int32_t deviceId = END_RESERVED_ID + 1000;
1952     constexpr ftl::Flags<InputDeviceClass> deviceClass = InputDeviceClass::KEYBOARD;
1953     constexpr int32_t eventHubId = 1;
1954     std::shared_ptr<InputDevice> device = mReader->newDevice(deviceId, "fake");
1955     // Must add at least one mapper or the device will be ignored!
1956     device->addMapper<FakeInputMapper>(eventHubId, AINPUT_SOURCE_KEYBOARD);
1957     mReader->pushNextDevice(device);
1958     ASSERT_NO_FATAL_FAILURE(addDevice(eventHubId, "fake", deviceClass, nullptr));
1959 
1960     NotifyDeviceResetArgs resetArgs;
1961     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled(&resetArgs));
1962     int32_t prevId = resetArgs.id;
1963 
1964     disableDevice(deviceId);
1965     mReader->loopOnce();
1966     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled(&resetArgs));
1967     ASSERT_NE(prevId, resetArgs.id);
1968     prevId = resetArgs.id;
1969 
1970     enableDevice(deviceId);
1971     mReader->loopOnce();
1972     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled(&resetArgs));
1973     ASSERT_NE(prevId, resetArgs.id);
1974     prevId = resetArgs.id;
1975 
1976     disableDevice(deviceId);
1977     mReader->loopOnce();
1978     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled(&resetArgs));
1979     ASSERT_NE(prevId, resetArgs.id);
1980     prevId = resetArgs.id;
1981 }
1982 
TEST_F(InputReaderTest,DeviceReset_GenerateIdWithInputReaderSource)1983 TEST_F(InputReaderTest, DeviceReset_GenerateIdWithInputReaderSource) {
1984     constexpr int32_t deviceId = 1;
1985     constexpr ftl::Flags<InputDeviceClass> deviceClass = InputDeviceClass::KEYBOARD;
1986     constexpr int32_t eventHubId = 1;
1987     std::shared_ptr<InputDevice> device = mReader->newDevice(deviceId, "fake");
1988     // Must add at least one mapper or the device will be ignored!
1989     device->addMapper<FakeInputMapper>(eventHubId, AINPUT_SOURCE_KEYBOARD);
1990     mReader->pushNextDevice(device);
1991     ASSERT_NO_FATAL_FAILURE(addDevice(deviceId, "fake", deviceClass, nullptr));
1992 
1993     NotifyDeviceResetArgs resetArgs;
1994     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled(&resetArgs));
1995     ASSERT_EQ(IdGenerator::Source::INPUT_READER, IdGenerator::getSource(resetArgs.id));
1996 }
1997 
TEST_F(InputReaderTest,Device_CanDispatchToDisplay)1998 TEST_F(InputReaderTest, Device_CanDispatchToDisplay) {
1999     constexpr int32_t deviceId = END_RESERVED_ID + 1000;
2000     constexpr ftl::Flags<InputDeviceClass> deviceClass = InputDeviceClass::KEYBOARD;
2001     constexpr int32_t eventHubId = 1;
2002     const char* DEVICE_LOCATION = "USB1";
2003     std::shared_ptr<InputDevice> device = mReader->newDevice(deviceId, "fake", DEVICE_LOCATION);
2004     FakeInputMapper& mapper =
2005             device->addMapper<FakeInputMapper>(eventHubId, AINPUT_SOURCE_TOUCHSCREEN);
2006     mReader->pushNextDevice(device);
2007 
2008     const uint8_t hdmi1 = 1;
2009 
2010     // Associated touch screen with second display.
2011     mFakePolicy->addInputPortAssociation(DEVICE_LOCATION, hdmi1);
2012 
2013     // Add default and second display.
2014     mFakePolicy->clearViewports();
2015     mFakePolicy->addDisplayViewport(DISPLAY_ID, DISPLAY_WIDTH, DISPLAY_HEIGHT,
2016                                     DISPLAY_ORIENTATION_0, true /*isActive*/, "local:0", NO_PORT,
2017                                     ViewportType::INTERNAL);
2018     mFakePolicy->addDisplayViewport(SECONDARY_DISPLAY_ID, DISPLAY_WIDTH, DISPLAY_HEIGHT,
2019                                     DISPLAY_ORIENTATION_0, true /*isActive*/, "local:1", hdmi1,
2020                                     ViewportType::EXTERNAL);
2021     mReader->requestRefreshConfiguration(InputReaderConfiguration::CHANGE_DISPLAY_INFO);
2022     mReader->loopOnce();
2023 
2024     // Add the device, and make sure all of the callbacks are triggered.
2025     // The device is added after the input port associations are processed since
2026     // we do not yet support dynamic device-to-display associations.
2027     ASSERT_NO_FATAL_FAILURE(addDevice(eventHubId, "fake", deviceClass, nullptr));
2028     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyConfigurationChangedWasCalled());
2029     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled());
2030     ASSERT_NO_FATAL_FAILURE(mapper.assertConfigureWasCalled());
2031 
2032     // Device should only dispatch to the specified display.
2033     ASSERT_EQ(deviceId, device->getId());
2034     ASSERT_FALSE(mReader->canDispatchToDisplay(deviceId, DISPLAY_ID));
2035     ASSERT_TRUE(mReader->canDispatchToDisplay(deviceId, SECONDARY_DISPLAY_ID));
2036 
2037     // Can't dispatch event from a disabled device.
2038     disableDevice(deviceId);
2039     mReader->loopOnce();
2040     ASSERT_FALSE(mReader->canDispatchToDisplay(deviceId, SECONDARY_DISPLAY_ID));
2041 }
2042 
TEST_F(InputReaderTest,WhenEnabledChanges_AllSubdevicesAreUpdated)2043 TEST_F(InputReaderTest, WhenEnabledChanges_AllSubdevicesAreUpdated) {
2044     constexpr int32_t deviceId = END_RESERVED_ID + 1000;
2045     constexpr ftl::Flags<InputDeviceClass> deviceClass = InputDeviceClass::KEYBOARD;
2046     constexpr int32_t eventHubIds[2] = {END_RESERVED_ID, END_RESERVED_ID + 1};
2047     std::shared_ptr<InputDevice> device = mReader->newDevice(deviceId, "fake");
2048     // Must add at least one mapper or the device will be ignored!
2049     device->addMapper<FakeInputMapper>(eventHubIds[0], AINPUT_SOURCE_KEYBOARD);
2050     device->addMapper<FakeInputMapper>(eventHubIds[1], AINPUT_SOURCE_KEYBOARD);
2051     mReader->pushNextDevice(device);
2052     mReader->pushNextDevice(device);
2053     ASSERT_NO_FATAL_FAILURE(addDevice(eventHubIds[0], "fake1", deviceClass, nullptr));
2054     ASSERT_NO_FATAL_FAILURE(addDevice(eventHubIds[1], "fake2", deviceClass, nullptr));
2055 
2056     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyConfigurationChangedWasCalled(nullptr));
2057 
2058     NotifyDeviceResetArgs resetArgs;
2059     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled(&resetArgs));
2060     ASSERT_EQ(deviceId, resetArgs.deviceId);
2061     ASSERT_TRUE(device->isEnabled());
2062     ASSERT_TRUE(mFakeEventHub->isDeviceEnabled(eventHubIds[0]));
2063     ASSERT_TRUE(mFakeEventHub->isDeviceEnabled(eventHubIds[1]));
2064 
2065     disableDevice(deviceId);
2066     mReader->loopOnce();
2067 
2068     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled(&resetArgs));
2069     ASSERT_EQ(deviceId, resetArgs.deviceId);
2070     ASSERT_FALSE(device->isEnabled());
2071     ASSERT_FALSE(mFakeEventHub->isDeviceEnabled(eventHubIds[0]));
2072     ASSERT_FALSE(mFakeEventHub->isDeviceEnabled(eventHubIds[1]));
2073 
2074     enableDevice(deviceId);
2075     mReader->loopOnce();
2076 
2077     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled(&resetArgs));
2078     ASSERT_EQ(deviceId, resetArgs.deviceId);
2079     ASSERT_TRUE(device->isEnabled());
2080     ASSERT_TRUE(mFakeEventHub->isDeviceEnabled(eventHubIds[0]));
2081     ASSERT_TRUE(mFakeEventHub->isDeviceEnabled(eventHubIds[1]));
2082 }
2083 
TEST_F(InputReaderTest,GetKeyCodeState_ForwardsRequestsToSubdeviceMappers)2084 TEST_F(InputReaderTest, GetKeyCodeState_ForwardsRequestsToSubdeviceMappers) {
2085     constexpr int32_t deviceId = END_RESERVED_ID + 1000;
2086     constexpr ftl::Flags<InputDeviceClass> deviceClass = InputDeviceClass::KEYBOARD;
2087     constexpr int32_t eventHubIds[2] = {END_RESERVED_ID, END_RESERVED_ID + 1};
2088     // Add two subdevices to device
2089     std::shared_ptr<InputDevice> device = mReader->newDevice(deviceId, "fake");
2090     FakeInputMapper& mapperDevice1 =
2091             device->addMapper<FakeInputMapper>(eventHubIds[0], AINPUT_SOURCE_KEYBOARD);
2092     FakeInputMapper& mapperDevice2 =
2093             device->addMapper<FakeInputMapper>(eventHubIds[1], AINPUT_SOURCE_KEYBOARD);
2094     mReader->pushNextDevice(device);
2095     mReader->pushNextDevice(device);
2096     ASSERT_NO_FATAL_FAILURE(addDevice(eventHubIds[0], "fake1", deviceClass, nullptr));
2097     ASSERT_NO_FATAL_FAILURE(addDevice(eventHubIds[1], "fake2", deviceClass, nullptr));
2098 
2099     mapperDevice1.setKeyCodeState(AKEYCODE_A, AKEY_STATE_DOWN);
2100     mapperDevice2.setKeyCodeState(AKEYCODE_B, AKEY_STATE_DOWN);
2101 
2102     ASSERT_EQ(AKEY_STATE_DOWN,
2103               mReader->getKeyCodeState(deviceId, AINPUT_SOURCE_KEYBOARD, AKEYCODE_A));
2104     ASSERT_EQ(AKEY_STATE_DOWN,
2105               mReader->getKeyCodeState(deviceId, AINPUT_SOURCE_KEYBOARD, AKEYCODE_B));
2106     ASSERT_EQ(AKEY_STATE_UNKNOWN,
2107               mReader->getKeyCodeState(deviceId, AINPUT_SOURCE_KEYBOARD, AKEYCODE_C));
2108 }
2109 
TEST_F(InputReaderTest,ChangingPointerCaptureNotifiesInputListener)2110 TEST_F(InputReaderTest, ChangingPointerCaptureNotifiesInputListener) {
2111     NotifyPointerCaptureChangedArgs args;
2112 
2113     auto request = mFakePolicy->setPointerCapture(true);
2114     mReader->requestRefreshConfiguration(InputReaderConfiguration::CHANGE_POINTER_CAPTURE);
2115     mReader->loopOnce();
2116     mFakeListener->assertNotifyCaptureWasCalled(&args);
2117     ASSERT_TRUE(args.request.enable) << "Pointer Capture should be enabled.";
2118     ASSERT_EQ(args.request, request) << "Pointer Capture sequence number should match.";
2119 
2120     mFakePolicy->setPointerCapture(false);
2121     mReader->requestRefreshConfiguration(InputReaderConfiguration::CHANGE_POINTER_CAPTURE);
2122     mReader->loopOnce();
2123     mFakeListener->assertNotifyCaptureWasCalled(&args);
2124     ASSERT_FALSE(args.request.enable) << "Pointer Capture should be disabled.";
2125 
2126     // Verify that the Pointer Capture state is not updated when the configuration value
2127     // does not change.
2128     mReader->requestRefreshConfiguration(InputReaderConfiguration::CHANGE_POINTER_CAPTURE);
2129     mReader->loopOnce();
2130     mFakeListener->assertNotifyCaptureWasNotCalled();
2131 }
2132 
2133 class FakeVibratorInputMapper : public FakeInputMapper {
2134 public:
FakeVibratorInputMapper(InputDeviceContext & deviceContext,uint32_t sources)2135     FakeVibratorInputMapper(InputDeviceContext& deviceContext, uint32_t sources)
2136           : FakeInputMapper(deviceContext, sources) {}
2137 
getVibratorIds()2138     std::vector<int32_t> getVibratorIds() override { return getDeviceContext().getVibratorIds(); }
2139 };
2140 
TEST_F(InputReaderTest,VibratorGetVibratorIds)2141 TEST_F(InputReaderTest, VibratorGetVibratorIds) {
2142     constexpr int32_t deviceId = END_RESERVED_ID + 1000;
2143     ftl::Flags<InputDeviceClass> deviceClass =
2144             InputDeviceClass::KEYBOARD | InputDeviceClass::VIBRATOR;
2145     constexpr int32_t eventHubId = 1;
2146     const char* DEVICE_LOCATION = "BLUETOOTH";
2147     std::shared_ptr<InputDevice> device = mReader->newDevice(deviceId, "fake", DEVICE_LOCATION);
2148     FakeVibratorInputMapper& mapper =
2149             device->addMapper<FakeVibratorInputMapper>(eventHubId, AINPUT_SOURCE_KEYBOARD);
2150     mReader->pushNextDevice(device);
2151 
2152     ASSERT_NO_FATAL_FAILURE(addDevice(eventHubId, "fake", deviceClass, nullptr));
2153     ASSERT_NO_FATAL_FAILURE(mapper.assertConfigureWasCalled());
2154 
2155     ASSERT_EQ(mapper.getVibratorIds().size(), 2U);
2156     ASSERT_EQ(mReader->getVibratorIds(deviceId).size(), 2U);
2157 }
2158 
2159 // --- FakePeripheralController ---
2160 
2161 class FakePeripheralController : public PeripheralControllerInterface {
2162 public:
FakePeripheralController(InputDeviceContext & deviceContext)2163     FakePeripheralController(InputDeviceContext& deviceContext) : mDeviceContext(deviceContext) {}
2164 
~FakePeripheralController()2165     ~FakePeripheralController() override {}
2166 
getEventHubId() const2167     int32_t getEventHubId() const { return getDeviceContext().getEventHubId(); }
2168 
populateDeviceInfo(InputDeviceInfo * deviceInfo)2169     void populateDeviceInfo(InputDeviceInfo* deviceInfo) override {}
2170 
dump(std::string & dump)2171     void dump(std::string& dump) override {}
2172 
getBatteryCapacity(int32_t batteryId)2173     std::optional<int32_t> getBatteryCapacity(int32_t batteryId) override {
2174         return getDeviceContext().getBatteryCapacity(batteryId);
2175     }
2176 
getBatteryStatus(int32_t batteryId)2177     std::optional<int32_t> getBatteryStatus(int32_t batteryId) override {
2178         return getDeviceContext().getBatteryStatus(batteryId);
2179     }
2180 
setLightColor(int32_t lightId,int32_t color)2181     bool setLightColor(int32_t lightId, int32_t color) override {
2182         getDeviceContext().setLightBrightness(lightId, color >> 24);
2183         return true;
2184     }
2185 
getLightColor(int32_t lightId)2186     std::optional<int32_t> getLightColor(int32_t lightId) override {
2187         std::optional<int32_t> result = getDeviceContext().getLightBrightness(lightId);
2188         if (!result.has_value()) {
2189             return std::nullopt;
2190         }
2191         return result.value() << 24;
2192     }
2193 
setLightPlayerId(int32_t lightId,int32_t playerId)2194     bool setLightPlayerId(int32_t lightId, int32_t playerId) override { return true; }
2195 
getLightPlayerId(int32_t lightId)2196     std::optional<int32_t> getLightPlayerId(int32_t lightId) override { return std::nullopt; }
2197 
2198 private:
2199     InputDeviceContext& mDeviceContext;
getDeviceId()2200     inline int32_t getDeviceId() { return mDeviceContext.getId(); }
getDeviceContext()2201     inline InputDeviceContext& getDeviceContext() { return mDeviceContext; }
getDeviceContext() const2202     inline InputDeviceContext& getDeviceContext() const { return mDeviceContext; }
2203 };
2204 
TEST_F(InputReaderTest,BatteryGetCapacity)2205 TEST_F(InputReaderTest, BatteryGetCapacity) {
2206     constexpr int32_t deviceId = END_RESERVED_ID + 1000;
2207     ftl::Flags<InputDeviceClass> deviceClass =
2208             InputDeviceClass::KEYBOARD | InputDeviceClass::BATTERY;
2209     constexpr int32_t eventHubId = 1;
2210     const char* DEVICE_LOCATION = "BLUETOOTH";
2211     std::shared_ptr<InputDevice> device = mReader->newDevice(deviceId, "fake", DEVICE_LOCATION);
2212     FakePeripheralController& controller =
2213             device->addController<FakePeripheralController>(eventHubId);
2214     mReader->pushNextDevice(device);
2215 
2216     ASSERT_NO_FATAL_FAILURE(addDevice(eventHubId, "fake", deviceClass, nullptr));
2217 
2218     ASSERT_EQ(controller.getBatteryCapacity(DEFAULT_BATTERY), BATTERY_CAPACITY);
2219     ASSERT_EQ(mReader->getBatteryCapacity(deviceId), BATTERY_CAPACITY);
2220 }
2221 
TEST_F(InputReaderTest,BatteryGetStatus)2222 TEST_F(InputReaderTest, BatteryGetStatus) {
2223     constexpr int32_t deviceId = END_RESERVED_ID + 1000;
2224     ftl::Flags<InputDeviceClass> deviceClass =
2225             InputDeviceClass::KEYBOARD | InputDeviceClass::BATTERY;
2226     constexpr int32_t eventHubId = 1;
2227     const char* DEVICE_LOCATION = "BLUETOOTH";
2228     std::shared_ptr<InputDevice> device = mReader->newDevice(deviceId, "fake", DEVICE_LOCATION);
2229     FakePeripheralController& controller =
2230             device->addController<FakePeripheralController>(eventHubId);
2231     mReader->pushNextDevice(device);
2232 
2233     ASSERT_NO_FATAL_FAILURE(addDevice(eventHubId, "fake", deviceClass, nullptr));
2234 
2235     ASSERT_EQ(controller.getBatteryStatus(DEFAULT_BATTERY), BATTERY_STATUS);
2236     ASSERT_EQ(mReader->getBatteryStatus(deviceId), BATTERY_STATUS);
2237 }
2238 
TEST_F(InputReaderTest,LightGetColor)2239 TEST_F(InputReaderTest, LightGetColor) {
2240     constexpr int32_t deviceId = END_RESERVED_ID + 1000;
2241     ftl::Flags<InputDeviceClass> deviceClass = InputDeviceClass::KEYBOARD | InputDeviceClass::LIGHT;
2242     constexpr int32_t eventHubId = 1;
2243     const char* DEVICE_LOCATION = "BLUETOOTH";
2244     std::shared_ptr<InputDevice> device = mReader->newDevice(deviceId, "fake", DEVICE_LOCATION);
2245     FakePeripheralController& controller =
2246             device->addController<FakePeripheralController>(eventHubId);
2247     mReader->pushNextDevice(device);
2248     RawLightInfo info = {.id = 1,
2249                          .name = "Mono",
2250                          .maxBrightness = 255,
2251                          .flags = InputLightClass::BRIGHTNESS,
2252                          .path = ""};
2253     mFakeEventHub->addRawLightInfo(1 /* rawId */, std::move(info));
2254     mFakeEventHub->fakeLightBrightness(1 /* rawId */, 0x55);
2255 
2256     ASSERT_NO_FATAL_FAILURE(addDevice(eventHubId, "fake", deviceClass, nullptr));
2257 
2258     ASSERT_TRUE(controller.setLightColor(1 /* lightId */, LIGHT_BRIGHTNESS));
2259     ASSERT_EQ(controller.getLightColor(1 /* lightId */), LIGHT_BRIGHTNESS);
2260     ASSERT_TRUE(mReader->setLightColor(deviceId, 1 /* lightId */, LIGHT_BRIGHTNESS));
2261     ASSERT_EQ(mReader->getLightColor(deviceId, 1 /* lightId */), LIGHT_BRIGHTNESS);
2262 }
2263 
2264 // --- InputReaderIntegrationTest ---
2265 
2266 // These tests create and interact with the InputReader only through its interface.
2267 // The InputReader is started during SetUp(), which starts its processing in its own
2268 // thread. The tests use linux uinput to emulate input devices.
2269 // NOTE: Interacting with the physical device while these tests are running may cause
2270 // the tests to fail.
2271 class InputReaderIntegrationTest : public testing::Test {
2272 protected:
2273     std::unique_ptr<TestInputListener> mTestListener;
2274     sp<FakeInputReaderPolicy> mFakePolicy;
2275     std::unique_ptr<InputReaderInterface> mReader;
2276 
2277     std::shared_ptr<FakePointerController> mFakePointerController;
2278 
SetUp()2279     void SetUp() override {
2280         mFakePolicy = new FakeInputReaderPolicy();
2281         mFakePointerController = std::make_shared<FakePointerController>();
2282         mFakePolicy->setPointerController(mFakePointerController);
2283         mTestListener = std::make_unique<TestInputListener>(2000ms /*eventHappenedTimeout*/,
2284                                                             30ms /*eventDidNotHappenTimeout*/);
2285 
2286         mReader = std::make_unique<InputReader>(std::make_shared<EventHub>(), mFakePolicy,
2287                                                 *mTestListener);
2288         ASSERT_EQ(mReader->start(), OK);
2289 
2290         // Since this test is run on a real device, all the input devices connected
2291         // to the test device will show up in mReader. We wait for those input devices to
2292         // show up before beginning the tests.
2293         ASSERT_NO_FATAL_FAILURE(mFakePolicy->assertInputDevicesChanged());
2294         ASSERT_NO_FATAL_FAILURE(mTestListener->assertNotifyConfigurationChangedWasCalled());
2295     }
2296 
TearDown()2297     void TearDown() override {
2298         ASSERT_EQ(mReader->stop(), OK);
2299         mReader.reset();
2300         mTestListener.reset();
2301         mFakePolicy.clear();
2302     }
2303 };
2304 
TEST_F(InputReaderIntegrationTest,TestInvalidDevice)2305 TEST_F(InputReaderIntegrationTest, TestInvalidDevice) {
2306     // An invalid input device that is only used for this test.
2307     class InvalidUinputDevice : public UinputDevice {
2308     public:
2309         InvalidUinputDevice() : UinputDevice("Invalid Device") {}
2310 
2311     private:
2312         void configureDevice(int fd, uinput_user_dev* device) override {}
2313     };
2314 
2315     const size_t numDevices = mFakePolicy->getInputDevices().size();
2316 
2317     // UinputDevice does not set any event or key bits, so InputReader should not
2318     // consider it as a valid device.
2319     std::unique_ptr<UinputDevice> invalidDevice = createUinputDevice<InvalidUinputDevice>();
2320     ASSERT_NO_FATAL_FAILURE(mFakePolicy->assertInputDevicesNotChanged());
2321     ASSERT_NO_FATAL_FAILURE(mTestListener->assertNotifyConfigurationChangedWasNotCalled());
2322     ASSERT_EQ(numDevices, mFakePolicy->getInputDevices().size());
2323 
2324     invalidDevice.reset();
2325     ASSERT_NO_FATAL_FAILURE(mFakePolicy->assertInputDevicesNotChanged());
2326     ASSERT_NO_FATAL_FAILURE(mTestListener->assertNotifyConfigurationChangedWasNotCalled());
2327     ASSERT_EQ(numDevices, mFakePolicy->getInputDevices().size());
2328 }
2329 
TEST_F(InputReaderIntegrationTest,AddNewDevice)2330 TEST_F(InputReaderIntegrationTest, AddNewDevice) {
2331     const size_t initialNumDevices = mFakePolicy->getInputDevices().size();
2332 
2333     std::unique_ptr<UinputHomeKey> keyboard = createUinputDevice<UinputHomeKey>();
2334     ASSERT_NO_FATAL_FAILURE(mFakePolicy->assertInputDevicesChanged());
2335     ASSERT_NO_FATAL_FAILURE(mTestListener->assertNotifyConfigurationChangedWasCalled());
2336     ASSERT_EQ(initialNumDevices + 1, mFakePolicy->getInputDevices().size());
2337 
2338     // Find the test device by its name.
2339     const std::vector<InputDeviceInfo> inputDevices = mFakePolicy->getInputDevices();
2340     const auto& it =
2341             std::find_if(inputDevices.begin(), inputDevices.end(),
2342                          [&keyboard](const InputDeviceInfo& info) {
2343                              return info.getIdentifier().name == keyboard->getName();
2344                          });
2345 
2346     ASSERT_NE(it, inputDevices.end());
2347     ASSERT_EQ(AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC, it->getKeyboardType());
2348     ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, it->getSources());
2349     ASSERT_EQ(0U, it->getMotionRanges().size());
2350 
2351     keyboard.reset();
2352     ASSERT_NO_FATAL_FAILURE(mFakePolicy->assertInputDevicesChanged());
2353     ASSERT_NO_FATAL_FAILURE(mTestListener->assertNotifyConfigurationChangedWasCalled());
2354     ASSERT_EQ(initialNumDevices, mFakePolicy->getInputDevices().size());
2355 }
2356 
TEST_F(InputReaderIntegrationTest,SendsEventsToInputListener)2357 TEST_F(InputReaderIntegrationTest, SendsEventsToInputListener) {
2358     std::unique_ptr<UinputHomeKey> keyboard = createUinputDevice<UinputHomeKey>();
2359     ASSERT_NO_FATAL_FAILURE(mFakePolicy->assertInputDevicesChanged());
2360 
2361     NotifyConfigurationChangedArgs configChangedArgs;
2362     ASSERT_NO_FATAL_FAILURE(
2363             mTestListener->assertNotifyConfigurationChangedWasCalled(&configChangedArgs));
2364     int32_t prevId = configChangedArgs.id;
2365     nsecs_t prevTimestamp = configChangedArgs.eventTime;
2366 
2367     NotifyKeyArgs keyArgs;
2368     keyboard->pressAndReleaseHomeKey();
2369     ASSERT_NO_FATAL_FAILURE(mTestListener->assertNotifyKeyWasCalled(&keyArgs));
2370     ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action);
2371     ASSERT_NE(prevId, keyArgs.id);
2372     prevId = keyArgs.id;
2373     ASSERT_LE(prevTimestamp, keyArgs.eventTime);
2374     ASSERT_LE(keyArgs.eventTime, keyArgs.readTime);
2375     prevTimestamp = keyArgs.eventTime;
2376 
2377     ASSERT_NO_FATAL_FAILURE(mTestListener->assertNotifyKeyWasCalled(&keyArgs));
2378     ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action);
2379     ASSERT_NE(prevId, keyArgs.id);
2380     ASSERT_LE(prevTimestamp, keyArgs.eventTime);
2381     ASSERT_LE(keyArgs.eventTime, keyArgs.readTime);
2382 }
2383 
2384 /**
2385  * The Steam controller sends BTN_GEAR_DOWN and BTN_GEAR_UP for the two "paddle" buttons
2386  * on the back. In this test, we make sure that BTN_GEAR_DOWN / BTN_WHEEL and BTN_GEAR_UP
2387  * are passed to the listener.
2388  */
2389 static_assert(BTN_GEAR_DOWN == BTN_WHEEL);
TEST_F(InputReaderIntegrationTest,SendsGearDownAndUpToInputListener)2390 TEST_F(InputReaderIntegrationTest, SendsGearDownAndUpToInputListener) {
2391     std::unique_ptr<UinputSteamController> controller = createUinputDevice<UinputSteamController>();
2392     ASSERT_NO_FATAL_FAILURE(mFakePolicy->assertInputDevicesChanged());
2393     NotifyKeyArgs keyArgs;
2394 
2395     controller->pressAndReleaseKey(BTN_GEAR_DOWN);
2396     ASSERT_NO_FATAL_FAILURE(mTestListener->assertNotifyKeyWasCalled(&keyArgs)); // ACTION_DOWN
2397     ASSERT_NO_FATAL_FAILURE(mTestListener->assertNotifyKeyWasCalled(&keyArgs)); // ACTION_UP
2398     ASSERT_EQ(BTN_GEAR_DOWN, keyArgs.scanCode);
2399 
2400     controller->pressAndReleaseKey(BTN_GEAR_UP);
2401     ASSERT_NO_FATAL_FAILURE(mTestListener->assertNotifyKeyWasCalled(&keyArgs)); // ACTION_DOWN
2402     ASSERT_NO_FATAL_FAILURE(mTestListener->assertNotifyKeyWasCalled(&keyArgs)); // ACTION_UP
2403     ASSERT_EQ(BTN_GEAR_UP, keyArgs.scanCode);
2404 }
2405 
2406 // --- TouchProcessTest ---
2407 class TouchIntegrationTest : public InputReaderIntegrationTest {
2408 protected:
2409     const std::string UNIQUE_ID = "local:0";
2410 
SetUp()2411     void SetUp() override {
2412         InputReaderIntegrationTest::SetUp();
2413         // At least add an internal display.
2414         setDisplayInfoAndReconfigure(DISPLAY_ID, DISPLAY_WIDTH, DISPLAY_HEIGHT,
2415                                      DISPLAY_ORIENTATION_0, UNIQUE_ID, NO_PORT,
2416                                      ViewportType::INTERNAL);
2417 
2418         mDevice = createUinputDevice<UinputTouchScreen>(Rect(0, 0, DISPLAY_WIDTH, DISPLAY_HEIGHT));
2419         ASSERT_NO_FATAL_FAILURE(mFakePolicy->assertInputDevicesChanged());
2420         ASSERT_NO_FATAL_FAILURE(mTestListener->assertNotifyConfigurationChangedWasCalled());
2421     }
2422 
setDisplayInfoAndReconfigure(int32_t displayId,int32_t width,int32_t height,int32_t orientation,const std::string & uniqueId,std::optional<uint8_t> physicalPort,ViewportType viewportType)2423     void setDisplayInfoAndReconfigure(int32_t displayId, int32_t width, int32_t height,
2424                                       int32_t orientation, const std::string& uniqueId,
2425                                       std::optional<uint8_t> physicalPort,
2426                                       ViewportType viewportType) {
2427         mFakePolicy->addDisplayViewport(displayId, width, height, orientation, true /*isActive*/,
2428                                         uniqueId, physicalPort, viewportType);
2429         mReader->requestRefreshConfiguration(InputReaderConfiguration::CHANGE_DISPLAY_INFO);
2430     }
2431 
assertReceivedMotion(int32_t action,const std::vector<Point> & points)2432     void assertReceivedMotion(int32_t action, const std::vector<Point>& points) {
2433         NotifyMotionArgs args;
2434         ASSERT_NO_FATAL_FAILURE(mTestListener->assertNotifyMotionWasCalled(&args));
2435         EXPECT_EQ(action, args.action);
2436         ASSERT_EQ(points.size(), args.pointerCount);
2437         for (size_t i = 0; i < args.pointerCount; i++) {
2438             EXPECT_EQ(points[i].x, args.pointerCoords[i].getX());
2439             EXPECT_EQ(points[i].y, args.pointerCoords[i].getY());
2440         }
2441     }
2442 
2443     std::unique_ptr<UinputTouchScreen> mDevice;
2444 };
2445 
TEST_F(TouchIntegrationTest,InputEvent_ProcessSingleTouch)2446 TEST_F(TouchIntegrationTest, InputEvent_ProcessSingleTouch) {
2447     NotifyMotionArgs args;
2448     const Point centerPoint = mDevice->getCenterPoint();
2449 
2450     // ACTION_DOWN
2451     mDevice->sendTrackingId(FIRST_TRACKING_ID);
2452     mDevice->sendDown(centerPoint);
2453     mDevice->sendSync();
2454     ASSERT_NO_FATAL_FAILURE(mTestListener->assertNotifyMotionWasCalled(&args));
2455     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action);
2456 
2457     // ACTION_MOVE
2458     mDevice->sendMove(centerPoint + Point(1, 1));
2459     mDevice->sendSync();
2460     ASSERT_NO_FATAL_FAILURE(mTestListener->assertNotifyMotionWasCalled(&args));
2461     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
2462 
2463     // ACTION_UP
2464     mDevice->sendUp();
2465     mDevice->sendSync();
2466     ASSERT_NO_FATAL_FAILURE(mTestListener->assertNotifyMotionWasCalled(&args));
2467     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, args.action);
2468 }
2469 
TEST_F(TouchIntegrationTest,InputEvent_ProcessMultiTouch)2470 TEST_F(TouchIntegrationTest, InputEvent_ProcessMultiTouch) {
2471     NotifyMotionArgs args;
2472     const Point centerPoint = mDevice->getCenterPoint();
2473 
2474     // ACTION_DOWN
2475     mDevice->sendSlot(FIRST_SLOT);
2476     mDevice->sendTrackingId(FIRST_TRACKING_ID);
2477     mDevice->sendDown(centerPoint);
2478     mDevice->sendSync();
2479     ASSERT_NO_FATAL_FAILURE(mTestListener->assertNotifyMotionWasCalled(&args));
2480     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action);
2481 
2482     // ACTION_POINTER_DOWN (Second slot)
2483     const Point secondPoint = centerPoint + Point(100, 100);
2484     mDevice->sendSlot(SECOND_SLOT);
2485     mDevice->sendTrackingId(SECOND_TRACKING_ID);
2486     mDevice->sendDown(secondPoint);
2487     mDevice->sendSync();
2488     ASSERT_NO_FATAL_FAILURE(mTestListener->assertNotifyMotionWasCalled(&args));
2489     ASSERT_EQ(ACTION_POINTER_1_DOWN, args.action);
2490 
2491     // ACTION_MOVE (Second slot)
2492     mDevice->sendMove(secondPoint + Point(1, 1));
2493     mDevice->sendSync();
2494     ASSERT_NO_FATAL_FAILURE(mTestListener->assertNotifyMotionWasCalled(&args));
2495     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
2496 
2497     // ACTION_POINTER_UP (Second slot)
2498     mDevice->sendPointerUp();
2499     mDevice->sendSync();
2500     ASSERT_NO_FATAL_FAILURE(mTestListener->assertNotifyMotionWasCalled(&args));
2501     ASSERT_EQ(ACTION_POINTER_1_UP, args.action);
2502 
2503     // ACTION_UP
2504     mDevice->sendSlot(FIRST_SLOT);
2505     mDevice->sendUp();
2506     mDevice->sendSync();
2507     ASSERT_NO_FATAL_FAILURE(mTestListener->assertNotifyMotionWasCalled(&args));
2508     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, args.action);
2509 }
2510 
2511 /**
2512  * What happens when a pointer goes up while another pointer moves in the same frame? Are POINTER_UP
2513  * events guaranteed to contain the same data as a preceding MOVE, or can they contain different
2514  * data?
2515  * In this test, we try to send a change in coordinates in Pointer 0 in the same frame as the
2516  * liftoff of Pointer 1. We check that POINTER_UP event is generated first, and the MOVE event
2517  * for Pointer 0 only is generated after.
2518  * Suppose we are only interested in learning the movement of Pointer 0. If we only observe MOVE
2519  * events, we will not miss any information.
2520  * Even though the Pointer 1 up event contains updated Pointer 0 coordinates, there is another MOVE
2521  * event generated afterwards that contains the newest movement of pointer 0.
2522  * This is important for palm rejection. If there is a subsequent InputListener stage that detects
2523  * palms, and wants to cancel Pointer 1, then it is safe to simply drop POINTER_1_UP event without
2524  * losing information about non-palm pointers.
2525  */
TEST_F(TouchIntegrationTest,MultiTouch_PointerMoveAndSecondPointerUp)2526 TEST_F(TouchIntegrationTest, MultiTouch_PointerMoveAndSecondPointerUp) {
2527     NotifyMotionArgs args;
2528     const Point centerPoint = mDevice->getCenterPoint();
2529 
2530     // ACTION_DOWN
2531     mDevice->sendSlot(FIRST_SLOT);
2532     mDevice->sendTrackingId(FIRST_TRACKING_ID);
2533     mDevice->sendDown(centerPoint);
2534     mDevice->sendSync();
2535     assertReceivedMotion(AMOTION_EVENT_ACTION_DOWN, {centerPoint});
2536 
2537     // ACTION_POINTER_DOWN (Second slot)
2538     const Point secondPoint = centerPoint + Point(100, 100);
2539     mDevice->sendSlot(SECOND_SLOT);
2540     mDevice->sendTrackingId(SECOND_TRACKING_ID);
2541     mDevice->sendDown(secondPoint);
2542     mDevice->sendSync();
2543     assertReceivedMotion(ACTION_POINTER_1_DOWN, {centerPoint, secondPoint});
2544 
2545     // ACTION_MOVE (First slot)
2546     mDevice->sendSlot(FIRST_SLOT);
2547     mDevice->sendMove(centerPoint + Point(5, 5));
2548     // ACTION_POINTER_UP (Second slot)
2549     mDevice->sendSlot(SECOND_SLOT);
2550     mDevice->sendPointerUp();
2551     // Send a single sync for the above 2 pointer updates
2552     mDevice->sendSync();
2553 
2554     // First, we should get POINTER_UP for the second pointer
2555     assertReceivedMotion(ACTION_POINTER_1_UP,
2556                          {/*first pointer */ centerPoint + Point(5, 5),
2557                           /*second pointer*/ secondPoint});
2558 
2559     // Next, the MOVE event for the first pointer
2560     assertReceivedMotion(AMOTION_EVENT_ACTION_MOVE, {centerPoint + Point(5, 5)});
2561 }
2562 
2563 /**
2564  * Similar scenario as above. The difference is that when the second pointer goes up, it will first
2565  * move, and then it will go up, all in the same frame.
2566  * In this scenario, the movement of the second pointer just prior to liftoff is ignored, and never
2567  * gets sent to the listener.
2568  */
TEST_F(TouchIntegrationTest,MultiTouch_PointerMoveAndSecondPointerMoveAndUp)2569 TEST_F(TouchIntegrationTest, MultiTouch_PointerMoveAndSecondPointerMoveAndUp) {
2570     NotifyMotionArgs args;
2571     const Point centerPoint = mDevice->getCenterPoint();
2572 
2573     // ACTION_DOWN
2574     mDevice->sendSlot(FIRST_SLOT);
2575     mDevice->sendTrackingId(FIRST_TRACKING_ID);
2576     mDevice->sendDown(centerPoint);
2577     mDevice->sendSync();
2578     assertReceivedMotion(AMOTION_EVENT_ACTION_DOWN, {centerPoint});
2579 
2580     // ACTION_POINTER_DOWN (Second slot)
2581     const Point secondPoint = centerPoint + Point(100, 100);
2582     mDevice->sendSlot(SECOND_SLOT);
2583     mDevice->sendTrackingId(SECOND_TRACKING_ID);
2584     mDevice->sendDown(secondPoint);
2585     mDevice->sendSync();
2586     assertReceivedMotion(ACTION_POINTER_1_DOWN, {centerPoint, secondPoint});
2587 
2588     // ACTION_MOVE (First slot)
2589     mDevice->sendSlot(FIRST_SLOT);
2590     mDevice->sendMove(centerPoint + Point(5, 5));
2591     // ACTION_POINTER_UP (Second slot)
2592     mDevice->sendSlot(SECOND_SLOT);
2593     mDevice->sendMove(secondPoint + Point(6, 6));
2594     mDevice->sendPointerUp();
2595     // Send a single sync for the above 2 pointer updates
2596     mDevice->sendSync();
2597 
2598     // First, we should get POINTER_UP for the second pointer
2599     // The movement of the second pointer during the liftoff frame is ignored.
2600     // The coordinates 'secondPoint + Point(6, 6)' are never sent to the listener.
2601     assertReceivedMotion(ACTION_POINTER_1_UP,
2602                          {/*first pointer */ centerPoint + Point(5, 5),
2603                           /*second pointer*/ secondPoint});
2604 
2605     // Next, the MOVE event for the first pointer
2606     assertReceivedMotion(AMOTION_EVENT_ACTION_MOVE, {centerPoint + Point(5, 5)});
2607 }
2608 
TEST_F(TouchIntegrationTest,InputEvent_ProcessPalm)2609 TEST_F(TouchIntegrationTest, InputEvent_ProcessPalm) {
2610     NotifyMotionArgs args;
2611     const Point centerPoint = mDevice->getCenterPoint();
2612 
2613     // ACTION_DOWN
2614     mDevice->sendSlot(FIRST_SLOT);
2615     mDevice->sendTrackingId(FIRST_TRACKING_ID);
2616     mDevice->sendDown(centerPoint);
2617     mDevice->sendSync();
2618     ASSERT_NO_FATAL_FAILURE(mTestListener->assertNotifyMotionWasCalled(&args));
2619     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action);
2620 
2621     // ACTION_POINTER_DOWN (second slot)
2622     const Point secondPoint = centerPoint + Point(100, 100);
2623     mDevice->sendSlot(SECOND_SLOT);
2624     mDevice->sendTrackingId(SECOND_TRACKING_ID);
2625     mDevice->sendDown(secondPoint);
2626     mDevice->sendSync();
2627     ASSERT_NO_FATAL_FAILURE(mTestListener->assertNotifyMotionWasCalled(&args));
2628     ASSERT_EQ(ACTION_POINTER_1_DOWN, args.action);
2629 
2630     // ACTION_MOVE (second slot)
2631     mDevice->sendMove(secondPoint + Point(1, 1));
2632     mDevice->sendSync();
2633     ASSERT_NO_FATAL_FAILURE(mTestListener->assertNotifyMotionWasCalled(&args));
2634     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
2635 
2636     // Send MT_TOOL_PALM (second slot), which indicates that the touch IC has determined this to be
2637     // a palm event.
2638     // Expect to receive the ACTION_POINTER_UP with cancel flag.
2639     mDevice->sendToolType(MT_TOOL_PALM);
2640     mDevice->sendSync();
2641     ASSERT_NO_FATAL_FAILURE(mTestListener->assertNotifyMotionWasCalled(&args));
2642     ASSERT_EQ(ACTION_POINTER_1_UP, args.action);
2643     ASSERT_EQ(AMOTION_EVENT_FLAG_CANCELED, args.flags);
2644 
2645     // Send up to second slot, expect first slot send moving.
2646     mDevice->sendPointerUp();
2647     mDevice->sendSync();
2648     ASSERT_NO_FATAL_FAILURE(mTestListener->assertNotifyMotionWasCalled(&args));
2649     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
2650 
2651     // Send ACTION_UP (first slot)
2652     mDevice->sendSlot(FIRST_SLOT);
2653     mDevice->sendUp();
2654     mDevice->sendSync();
2655 
2656     ASSERT_NO_FATAL_FAILURE(mTestListener->assertNotifyMotionWasCalled(&args));
2657     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, args.action);
2658 }
2659 
2660 // --- InputDeviceTest ---
2661 class InputDeviceTest : public testing::Test {
2662 protected:
2663     static const char* DEVICE_NAME;
2664     static const char* DEVICE_LOCATION;
2665     static const int32_t DEVICE_ID;
2666     static const int32_t DEVICE_GENERATION;
2667     static const int32_t DEVICE_CONTROLLER_NUMBER;
2668     static const ftl::Flags<InputDeviceClass> DEVICE_CLASSES;
2669     static const int32_t EVENTHUB_ID;
2670 
2671     std::shared_ptr<FakeEventHub> mFakeEventHub;
2672     sp<FakeInputReaderPolicy> mFakePolicy;
2673     std::unique_ptr<TestInputListener> mFakeListener;
2674     std::unique_ptr<InstrumentedInputReader> mReader;
2675     std::shared_ptr<InputDevice> mDevice;
2676 
SetUp()2677     void SetUp() override {
2678         mFakeEventHub = std::make_unique<FakeEventHub>();
2679         mFakePolicy = new FakeInputReaderPolicy();
2680         mFakeListener = std::make_unique<TestInputListener>();
2681         mReader = std::make_unique<InstrumentedInputReader>(mFakeEventHub, mFakePolicy,
2682                                                             *mFakeListener);
2683         InputDeviceIdentifier identifier;
2684         identifier.name = DEVICE_NAME;
2685         identifier.location = DEVICE_LOCATION;
2686         mDevice = std::make_shared<InputDevice>(mReader->getContext(), DEVICE_ID, DEVICE_GENERATION,
2687                                                 identifier);
2688         mReader->pushNextDevice(mDevice);
2689         mFakeEventHub->addDevice(EVENTHUB_ID, DEVICE_NAME, ftl::Flags<InputDeviceClass>(0));
2690         mReader->loopOnce();
2691     }
2692 
TearDown()2693     void TearDown() override {
2694         mFakeListener.reset();
2695         mFakePolicy.clear();
2696     }
2697 };
2698 
2699 const char* InputDeviceTest::DEVICE_NAME = "device";
2700 const char* InputDeviceTest::DEVICE_LOCATION = "USB1";
2701 const int32_t InputDeviceTest::DEVICE_ID = END_RESERVED_ID + 1000;
2702 const int32_t InputDeviceTest::DEVICE_GENERATION = 2;
2703 const int32_t InputDeviceTest::DEVICE_CONTROLLER_NUMBER = 0;
2704 const ftl::Flags<InputDeviceClass> InputDeviceTest::DEVICE_CLASSES =
2705         InputDeviceClass::KEYBOARD | InputDeviceClass::TOUCH | InputDeviceClass::JOYSTICK;
2706 const int32_t InputDeviceTest::EVENTHUB_ID = 1;
2707 
TEST_F(InputDeviceTest,ImmutableProperties)2708 TEST_F(InputDeviceTest, ImmutableProperties) {
2709     ASSERT_EQ(DEVICE_ID, mDevice->getId());
2710     ASSERT_STREQ(DEVICE_NAME, mDevice->getName().c_str());
2711     ASSERT_EQ(ftl::Flags<InputDeviceClass>(0), mDevice->getClasses());
2712 }
2713 
TEST_F(InputDeviceTest,WhenDeviceCreated_EnabledIsFalse)2714 TEST_F(InputDeviceTest, WhenDeviceCreated_EnabledIsFalse) {
2715     ASSERT_EQ(mDevice->isEnabled(), false);
2716 }
2717 
TEST_F(InputDeviceTest,WhenNoMappersAreRegistered_DeviceIsIgnored)2718 TEST_F(InputDeviceTest, WhenNoMappersAreRegistered_DeviceIsIgnored) {
2719     // Configuration.
2720     InputReaderConfiguration config;
2721     mDevice->configure(ARBITRARY_TIME, &config, 0);
2722 
2723     // Reset.
2724     mDevice->reset(ARBITRARY_TIME);
2725 
2726     NotifyDeviceResetArgs resetArgs;
2727     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled(&resetArgs));
2728     ASSERT_EQ(ARBITRARY_TIME, resetArgs.eventTime);
2729     ASSERT_EQ(DEVICE_ID, resetArgs.deviceId);
2730 
2731     // Metadata.
2732     ASSERT_TRUE(mDevice->isIgnored());
2733     ASSERT_EQ(AINPUT_SOURCE_UNKNOWN, mDevice->getSources());
2734 
2735     InputDeviceInfo info = mDevice->getDeviceInfo();
2736     ASSERT_EQ(DEVICE_ID, info.getId());
2737     ASSERT_STREQ(DEVICE_NAME, info.getIdentifier().name.c_str());
2738     ASSERT_EQ(AINPUT_KEYBOARD_TYPE_NONE, info.getKeyboardType());
2739     ASSERT_EQ(AINPUT_SOURCE_UNKNOWN, info.getSources());
2740 
2741     // State queries.
2742     ASSERT_EQ(0, mDevice->getMetaState());
2743 
2744     ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getKeyCodeState(AINPUT_SOURCE_KEYBOARD, 0))
2745             << "Ignored device should return unknown key code state.";
2746     ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getScanCodeState(AINPUT_SOURCE_KEYBOARD, 0))
2747             << "Ignored device should return unknown scan code state.";
2748     ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getSwitchState(AINPUT_SOURCE_KEYBOARD, 0))
2749             << "Ignored device should return unknown switch state.";
2750 
2751     const int32_t keyCodes[2] = { AKEYCODE_A, AKEYCODE_B };
2752     uint8_t flags[2] = { 0, 1 };
2753     ASSERT_FALSE(mDevice->markSupportedKeyCodes(AINPUT_SOURCE_KEYBOARD, 2, keyCodes, flags))
2754             << "Ignored device should never mark any key codes.";
2755     ASSERT_EQ(0, flags[0]) << "Flag for unsupported key should be unchanged.";
2756     ASSERT_EQ(1, flags[1]) << "Flag for unsupported key should be unchanged.";
2757 }
2758 
TEST_F(InputDeviceTest,WhenMappersAreRegistered_DeviceIsNotIgnoredAndForwardsRequestsToMappers)2759 TEST_F(InputDeviceTest, WhenMappersAreRegistered_DeviceIsNotIgnoredAndForwardsRequestsToMappers) {
2760     // Configuration.
2761     mFakeEventHub->addConfigurationProperty(EVENTHUB_ID, String8("key"), String8("value"));
2762 
2763     FakeInputMapper& mapper1 =
2764             mDevice->addMapper<FakeInputMapper>(EVENTHUB_ID, AINPUT_SOURCE_KEYBOARD);
2765     mapper1.setKeyboardType(AINPUT_KEYBOARD_TYPE_ALPHABETIC);
2766     mapper1.setMetaState(AMETA_ALT_ON);
2767     mapper1.addSupportedKeyCode(AKEYCODE_A);
2768     mapper1.addSupportedKeyCode(AKEYCODE_B);
2769     mapper1.setKeyCodeState(AKEYCODE_A, AKEY_STATE_DOWN);
2770     mapper1.setKeyCodeState(AKEYCODE_B, AKEY_STATE_UP);
2771     mapper1.setScanCodeState(2, AKEY_STATE_DOWN);
2772     mapper1.setScanCodeState(3, AKEY_STATE_UP);
2773     mapper1.setSwitchState(4, AKEY_STATE_DOWN);
2774 
2775     FakeInputMapper& mapper2 =
2776             mDevice->addMapper<FakeInputMapper>(EVENTHUB_ID, AINPUT_SOURCE_TOUCHSCREEN);
2777     mapper2.setMetaState(AMETA_SHIFT_ON);
2778 
2779     InputReaderConfiguration config;
2780     mDevice->configure(ARBITRARY_TIME, &config, 0);
2781 
2782     String8 propertyValue;
2783     ASSERT_TRUE(mDevice->getConfiguration().tryGetProperty(String8("key"), propertyValue))
2784             << "Device should have read configuration during configuration phase.";
2785     ASSERT_STREQ("value", propertyValue.string());
2786 
2787     ASSERT_NO_FATAL_FAILURE(mapper1.assertConfigureWasCalled());
2788     ASSERT_NO_FATAL_FAILURE(mapper2.assertConfigureWasCalled());
2789 
2790     // Reset
2791     mDevice->reset(ARBITRARY_TIME);
2792     ASSERT_NO_FATAL_FAILURE(mapper1.assertResetWasCalled());
2793     ASSERT_NO_FATAL_FAILURE(mapper2.assertResetWasCalled());
2794 
2795     NotifyDeviceResetArgs resetArgs;
2796     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled(&resetArgs));
2797     ASSERT_EQ(ARBITRARY_TIME, resetArgs.eventTime);
2798     ASSERT_EQ(DEVICE_ID, resetArgs.deviceId);
2799 
2800     // Metadata.
2801     ASSERT_FALSE(mDevice->isIgnored());
2802     ASSERT_EQ(uint32_t(AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TOUCHSCREEN), mDevice->getSources());
2803 
2804     InputDeviceInfo info = mDevice->getDeviceInfo();
2805     ASSERT_EQ(DEVICE_ID, info.getId());
2806     ASSERT_STREQ(DEVICE_NAME, info.getIdentifier().name.c_str());
2807     ASSERT_EQ(AINPUT_KEYBOARD_TYPE_ALPHABETIC, info.getKeyboardType());
2808     ASSERT_EQ(uint32_t(AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TOUCHSCREEN), info.getSources());
2809 
2810     // State queries.
2811     ASSERT_EQ(AMETA_ALT_ON | AMETA_SHIFT_ON, mDevice->getMetaState())
2812             << "Should query mappers and combine meta states.";
2813 
2814     ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getKeyCodeState(AINPUT_SOURCE_TRACKBALL, AKEYCODE_A))
2815             << "Should return unknown key code state when source not supported.";
2816     ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getScanCodeState(AINPUT_SOURCE_TRACKBALL, AKEYCODE_A))
2817             << "Should return unknown scan code state when source not supported.";
2818     ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getSwitchState(AINPUT_SOURCE_TRACKBALL, AKEYCODE_A))
2819             << "Should return unknown switch state when source not supported.";
2820 
2821     ASSERT_EQ(AKEY_STATE_DOWN, mDevice->getKeyCodeState(AINPUT_SOURCE_KEYBOARD, AKEYCODE_A))
2822             << "Should query mapper when source is supported.";
2823     ASSERT_EQ(AKEY_STATE_UP, mDevice->getScanCodeState(AINPUT_SOURCE_KEYBOARD, 3))
2824             << "Should query mapper when source is supported.";
2825     ASSERT_EQ(AKEY_STATE_DOWN, mDevice->getSwitchState(AINPUT_SOURCE_KEYBOARD, 4))
2826             << "Should query mapper when source is supported.";
2827 
2828     const int32_t keyCodes[4] = { AKEYCODE_A, AKEYCODE_B, AKEYCODE_1, AKEYCODE_2 };
2829     uint8_t flags[4] = { 0, 0, 0, 1 };
2830     ASSERT_FALSE(mDevice->markSupportedKeyCodes(AINPUT_SOURCE_TRACKBALL, 4, keyCodes, flags))
2831             << "Should do nothing when source is unsupported.";
2832     ASSERT_EQ(0, flags[0]) << "Flag should be unchanged when source is unsupported.";
2833     ASSERT_EQ(0, flags[1]) << "Flag should be unchanged when source is unsupported.";
2834     ASSERT_EQ(0, flags[2]) << "Flag should be unchanged when source is unsupported.";
2835     ASSERT_EQ(1, flags[3]) << "Flag should be unchanged when source is unsupported.";
2836 
2837     ASSERT_TRUE(mDevice->markSupportedKeyCodes(AINPUT_SOURCE_KEYBOARD, 4, keyCodes, flags))
2838             << "Should query mapper when source is supported.";
2839     ASSERT_EQ(1, flags[0]) << "Flag for supported key should be set.";
2840     ASSERT_EQ(1, flags[1]) << "Flag for supported key should be set.";
2841     ASSERT_EQ(0, flags[2]) << "Flag for unsupported key should be unchanged.";
2842     ASSERT_EQ(1, flags[3]) << "Flag for unsupported key should be unchanged.";
2843 
2844     // Event handling.
2845     RawEvent event;
2846     event.deviceId = EVENTHUB_ID;
2847     mDevice->process(&event, 1);
2848 
2849     ASSERT_NO_FATAL_FAILURE(mapper1.assertProcessWasCalled());
2850     ASSERT_NO_FATAL_FAILURE(mapper2.assertProcessWasCalled());
2851 }
2852 
2853 // A single input device is associated with a specific display. Check that:
2854 // 1. Device is disabled if the viewport corresponding to the associated display is not found
2855 // 2. Device is disabled when setEnabled API is called
TEST_F(InputDeviceTest,Configure_AssignsDisplayPort)2856 TEST_F(InputDeviceTest, Configure_AssignsDisplayPort) {
2857     mDevice->addMapper<FakeInputMapper>(EVENTHUB_ID, AINPUT_SOURCE_TOUCHSCREEN);
2858 
2859     // First Configuration.
2860     mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), 0);
2861 
2862     // Device should be enabled by default.
2863     ASSERT_TRUE(mDevice->isEnabled());
2864 
2865     // Prepare associated info.
2866     constexpr uint8_t hdmi = 1;
2867     const std::string UNIQUE_ID = "local:1";
2868 
2869     mFakePolicy->addInputPortAssociation(DEVICE_LOCATION, hdmi);
2870     mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(),
2871                        InputReaderConfiguration::CHANGE_DISPLAY_INFO);
2872     // Device should be disabled because it is associated with a specific display via
2873     // input port <-> display port association, but the corresponding display is not found
2874     ASSERT_FALSE(mDevice->isEnabled());
2875 
2876     // Prepare displays.
2877     mFakePolicy->addDisplayViewport(SECONDARY_DISPLAY_ID, DISPLAY_WIDTH, DISPLAY_HEIGHT,
2878                                     DISPLAY_ORIENTATION_0, true /*isActive*/, UNIQUE_ID, hdmi,
2879                                     ViewportType::INTERNAL);
2880     mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(),
2881                        InputReaderConfiguration::CHANGE_DISPLAY_INFO);
2882     ASSERT_TRUE(mDevice->isEnabled());
2883 
2884     // Device should be disabled after set disable.
2885     mFakePolicy->addDisabledDevice(mDevice->getId());
2886     mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(),
2887                        InputReaderConfiguration::CHANGE_ENABLED_STATE);
2888     ASSERT_FALSE(mDevice->isEnabled());
2889 
2890     // Device should still be disabled even found the associated display.
2891     mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(),
2892                        InputReaderConfiguration::CHANGE_DISPLAY_INFO);
2893     ASSERT_FALSE(mDevice->isEnabled());
2894 }
2895 
TEST_F(InputDeviceTest,Configure_AssignsDisplayUniqueId)2896 TEST_F(InputDeviceTest, Configure_AssignsDisplayUniqueId) {
2897     // Device should be enabled by default.
2898     mFakePolicy->clearViewports();
2899     mDevice->addMapper<FakeInputMapper>(EVENTHUB_ID, AINPUT_SOURCE_KEYBOARD);
2900     mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), 0);
2901     ASSERT_TRUE(mDevice->isEnabled());
2902 
2903     // Device should be disabled because it is associated with a specific display, but the
2904     // corresponding display is not found.
2905     mFakePolicy->addInputUniqueIdAssociation(DEVICE_LOCATION, DISPLAY_UNIQUE_ID);
2906     mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(),
2907                        InputReaderConfiguration::CHANGE_DISPLAY_INFO);
2908     ASSERT_FALSE(mDevice->isEnabled());
2909 
2910     // Device should be enabled when a display is found.
2911     mFakePolicy->addDisplayViewport(SECONDARY_DISPLAY_ID, DISPLAY_WIDTH, DISPLAY_HEIGHT,
2912                                     DISPLAY_ORIENTATION_0, /* isActive= */ true, DISPLAY_UNIQUE_ID,
2913                                     NO_PORT, ViewportType::INTERNAL);
2914     mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(),
2915                        InputReaderConfiguration::CHANGE_DISPLAY_INFO);
2916     ASSERT_TRUE(mDevice->isEnabled());
2917 
2918     // Device should be disabled after set disable.
2919     mFakePolicy->addDisabledDevice(mDevice->getId());
2920     mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(),
2921                        InputReaderConfiguration::CHANGE_ENABLED_STATE);
2922     ASSERT_FALSE(mDevice->isEnabled());
2923 
2924     // Device should still be disabled even found the associated display.
2925     mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(),
2926                        InputReaderConfiguration::CHANGE_DISPLAY_INFO);
2927     ASSERT_FALSE(mDevice->isEnabled());
2928 }
2929 
TEST_F(InputDeviceTest,Configure_UniqueId_CorrectlyMatches)2930 TEST_F(InputDeviceTest, Configure_UniqueId_CorrectlyMatches) {
2931     mFakePolicy->clearViewports();
2932     mDevice->addMapper<FakeInputMapper>(EVENTHUB_ID, AINPUT_SOURCE_KEYBOARD);
2933     mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), 0);
2934 
2935     mFakePolicy->addInputUniqueIdAssociation(DEVICE_LOCATION, DISPLAY_UNIQUE_ID);
2936     mFakePolicy->addDisplayViewport(SECONDARY_DISPLAY_ID, DISPLAY_WIDTH, DISPLAY_HEIGHT,
2937                                     DISPLAY_ORIENTATION_0, /* isActive= */ true, DISPLAY_UNIQUE_ID,
2938                                     NO_PORT, ViewportType::INTERNAL);
2939     mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(),
2940                        InputReaderConfiguration::CHANGE_DISPLAY_INFO);
2941     ASSERT_EQ(DISPLAY_UNIQUE_ID, mDevice->getAssociatedDisplayUniqueId());
2942 }
2943 
2944 /**
2945  * This test reproduces a crash caused by a dangling reference that remains after device is added
2946  * and removed. The reference is accessed in InputDevice::dump(..);
2947  */
TEST_F(InputDeviceTest,DumpDoesNotCrash)2948 TEST_F(InputDeviceTest, DumpDoesNotCrash) {
2949     constexpr int32_t TEST_EVENTHUB_ID = 10;
2950     mFakeEventHub->addDevice(TEST_EVENTHUB_ID, "Test EventHub device", InputDeviceClass::BATTERY);
2951 
2952     InputDevice device(mReader->getContext(), 1 /*id*/, 2 /*generation*/, {} /*identifier*/);
2953     device.addEventHubDevice(TEST_EVENTHUB_ID, true /*populateMappers*/);
2954     device.removeEventHubDevice(TEST_EVENTHUB_ID);
2955     std::string dumpStr, eventHubDevStr;
2956     device.dump(dumpStr, eventHubDevStr);
2957 }
2958 
2959 // --- InputMapperTest ---
2960 
2961 class InputMapperTest : public testing::Test {
2962 protected:
2963     static const char* DEVICE_NAME;
2964     static const char* DEVICE_LOCATION;
2965     static const int32_t DEVICE_ID;
2966     static const int32_t DEVICE_GENERATION;
2967     static const int32_t DEVICE_CONTROLLER_NUMBER;
2968     static const ftl::Flags<InputDeviceClass> DEVICE_CLASSES;
2969     static const int32_t EVENTHUB_ID;
2970 
2971     std::shared_ptr<FakeEventHub> mFakeEventHub;
2972     sp<FakeInputReaderPolicy> mFakePolicy;
2973     std::unique_ptr<TestInputListener> mFakeListener;
2974     std::unique_ptr<InstrumentedInputReader> mReader;
2975     std::shared_ptr<InputDevice> mDevice;
2976 
SetUp(ftl::Flags<InputDeviceClass> classes)2977     virtual void SetUp(ftl::Flags<InputDeviceClass> classes) {
2978         mFakeEventHub = std::make_unique<FakeEventHub>();
2979         mFakePolicy = new FakeInputReaderPolicy();
2980         mFakeListener = std::make_unique<TestInputListener>();
2981         mReader = std::make_unique<InstrumentedInputReader>(mFakeEventHub, mFakePolicy,
2982                                                             *mFakeListener);
2983         mDevice = newDevice(DEVICE_ID, DEVICE_NAME, DEVICE_LOCATION, EVENTHUB_ID, classes);
2984         // Consume the device reset notification generated when adding a new device.
2985         mFakeListener->assertNotifyDeviceResetWasCalled();
2986     }
2987 
SetUp()2988     void SetUp() override {
2989         SetUp(DEVICE_CLASSES);
2990     }
2991 
TearDown()2992     void TearDown() override {
2993         mFakeListener.reset();
2994         mFakePolicy.clear();
2995     }
2996 
addConfigurationProperty(const char * key,const char * value)2997     void addConfigurationProperty(const char* key, const char* value) {
2998         mFakeEventHub->addConfigurationProperty(EVENTHUB_ID, String8(key), String8(value));
2999     }
3000 
configureDevice(uint32_t changes)3001     void configureDevice(uint32_t changes) {
3002         if (!changes ||
3003             (changes &
3004              (InputReaderConfiguration::CHANGE_DISPLAY_INFO |
3005               InputReaderConfiguration::CHANGE_POINTER_CAPTURE))) {
3006             mReader->requestRefreshConfiguration(changes);
3007             mReader->loopOnce();
3008         }
3009         mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), changes);
3010         // Loop the reader to flush the input listener queue.
3011         mReader->loopOnce();
3012     }
3013 
newDevice(int32_t deviceId,const std::string & name,const std::string & location,int32_t eventHubId,ftl::Flags<InputDeviceClass> classes)3014     std::shared_ptr<InputDevice> newDevice(int32_t deviceId, const std::string& name,
3015                                            const std::string& location, int32_t eventHubId,
3016                                            ftl::Flags<InputDeviceClass> classes) {
3017         InputDeviceIdentifier identifier;
3018         identifier.name = name;
3019         identifier.location = location;
3020         std::shared_ptr<InputDevice> device =
3021                 std::make_shared<InputDevice>(mReader->getContext(), deviceId, DEVICE_GENERATION,
3022                                               identifier);
3023         mReader->pushNextDevice(device);
3024         mFakeEventHub->addDevice(eventHubId, name, classes);
3025         mReader->loopOnce();
3026         return device;
3027     }
3028 
3029     template <class T, typename... Args>
addMapperAndConfigure(Args...args)3030     T& addMapperAndConfigure(Args... args) {
3031         T& mapper = mDevice->addMapper<T>(EVENTHUB_ID, args...);
3032         configureDevice(0);
3033         mDevice->reset(ARBITRARY_TIME);
3034         mapper.reset(ARBITRARY_TIME);
3035         // Loop the reader to flush the input listener queue.
3036         mReader->loopOnce();
3037         return mapper;
3038     }
3039 
setDisplayInfoAndReconfigure(int32_t displayId,int32_t width,int32_t height,int32_t orientation,const std::string & uniqueId,std::optional<uint8_t> physicalPort,ViewportType viewportType)3040     void setDisplayInfoAndReconfigure(int32_t displayId, int32_t width, int32_t height,
3041             int32_t orientation, const std::string& uniqueId,
3042             std::optional<uint8_t> physicalPort, ViewportType viewportType) {
3043         mFakePolicy->addDisplayViewport(displayId, width, height, orientation, true /*isActive*/,
3044                                         uniqueId, physicalPort, viewportType);
3045         configureDevice(InputReaderConfiguration::CHANGE_DISPLAY_INFO);
3046     }
3047 
clearViewports()3048     void clearViewports() {
3049         mFakePolicy->clearViewports();
3050     }
3051 
process(InputMapper & mapper,nsecs_t when,nsecs_t readTime,int32_t type,int32_t code,int32_t value)3052     void process(InputMapper& mapper, nsecs_t when, nsecs_t readTime, int32_t type, int32_t code,
3053                  int32_t value) {
3054         RawEvent event;
3055         event.when = when;
3056         event.readTime = readTime;
3057         event.deviceId = mapper.getDeviceContext().getEventHubId();
3058         event.type = type;
3059         event.code = code;
3060         event.value = value;
3061         mapper.process(&event);
3062         // Loop the reader to flush the input listener queue.
3063         mReader->loopOnce();
3064     }
3065 
assertMotionRange(const InputDeviceInfo & info,int32_t axis,uint32_t source,float min,float max,float flat,float fuzz)3066     static void assertMotionRange(const InputDeviceInfo& info,
3067             int32_t axis, uint32_t source, float min, float max, float flat, float fuzz) {
3068         const InputDeviceInfo::MotionRange* range = info.getMotionRange(axis, source);
3069         ASSERT_TRUE(range != nullptr) << "Axis: " << axis << " Source: " << source;
3070         ASSERT_EQ(axis, range->axis) << "Axis: " << axis << " Source: " << source;
3071         ASSERT_EQ(source, range->source) << "Axis: " << axis << " Source: " << source;
3072         ASSERT_NEAR(min, range->min, EPSILON) << "Axis: " << axis << " Source: " << source;
3073         ASSERT_NEAR(max, range->max, EPSILON) << "Axis: " << axis << " Source: " << source;
3074         ASSERT_NEAR(flat, range->flat, EPSILON) << "Axis: " << axis << " Source: " << source;
3075         ASSERT_NEAR(fuzz, range->fuzz, EPSILON) << "Axis: " << axis << " Source: " << source;
3076     }
3077 
assertPointerCoords(const PointerCoords & coords,float x,float y,float pressure,float size,float touchMajor,float touchMinor,float toolMajor,float toolMinor,float orientation,float distance,float scaledAxisEpsilon=1.f)3078     static void assertPointerCoords(const PointerCoords& coords, float x, float y, float pressure,
3079                                     float size, float touchMajor, float touchMinor, float toolMajor,
3080                                     float toolMinor, float orientation, float distance,
3081                                     float scaledAxisEpsilon = 1.f) {
3082         ASSERT_NEAR(x, coords.getAxisValue(AMOTION_EVENT_AXIS_X), scaledAxisEpsilon);
3083         ASSERT_NEAR(y, coords.getAxisValue(AMOTION_EVENT_AXIS_Y), scaledAxisEpsilon);
3084         ASSERT_NEAR(pressure, coords.getAxisValue(AMOTION_EVENT_AXIS_PRESSURE), EPSILON);
3085         ASSERT_NEAR(size, coords.getAxisValue(AMOTION_EVENT_AXIS_SIZE), EPSILON);
3086         ASSERT_NEAR(touchMajor, coords.getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR),
3087                     scaledAxisEpsilon);
3088         ASSERT_NEAR(touchMinor, coords.getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR),
3089                     scaledAxisEpsilon);
3090         ASSERT_NEAR(toolMajor, coords.getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR),
3091                     scaledAxisEpsilon);
3092         ASSERT_NEAR(toolMinor, coords.getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR),
3093                     scaledAxisEpsilon);
3094         ASSERT_NEAR(orientation, coords.getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION), EPSILON);
3095         ASSERT_NEAR(distance, coords.getAxisValue(AMOTION_EVENT_AXIS_DISTANCE), EPSILON);
3096     }
3097 
assertPosition(const FakePointerController & controller,float x,float y)3098     static void assertPosition(const FakePointerController& controller, float x, float y) {
3099         float actualX, actualY;
3100         controller.getPosition(&actualX, &actualY);
3101         ASSERT_NEAR(x, actualX, 1);
3102         ASSERT_NEAR(y, actualY, 1);
3103     }
3104 };
3105 
3106 const char* InputMapperTest::DEVICE_NAME = "device";
3107 const char* InputMapperTest::DEVICE_LOCATION = "USB1";
3108 const int32_t InputMapperTest::DEVICE_ID = END_RESERVED_ID + 1000;
3109 const int32_t InputMapperTest::DEVICE_GENERATION = 2;
3110 const int32_t InputMapperTest::DEVICE_CONTROLLER_NUMBER = 0;
3111 const ftl::Flags<InputDeviceClass> InputMapperTest::DEVICE_CLASSES =
3112         ftl::Flags<InputDeviceClass>(0); // not needed for current tests
3113 const int32_t InputMapperTest::EVENTHUB_ID = 1;
3114 
3115 // --- SwitchInputMapperTest ---
3116 
3117 class SwitchInputMapperTest : public InputMapperTest {
3118 protected:
3119 };
3120 
TEST_F(SwitchInputMapperTest,GetSources)3121 TEST_F(SwitchInputMapperTest, GetSources) {
3122     SwitchInputMapper& mapper = addMapperAndConfigure<SwitchInputMapper>();
3123 
3124     ASSERT_EQ(uint32_t(AINPUT_SOURCE_SWITCH), mapper.getSources());
3125 }
3126 
TEST_F(SwitchInputMapperTest,GetSwitchState)3127 TEST_F(SwitchInputMapperTest, GetSwitchState) {
3128     SwitchInputMapper& mapper = addMapperAndConfigure<SwitchInputMapper>();
3129 
3130     mFakeEventHub->setSwitchState(EVENTHUB_ID, SW_LID, 1);
3131     ASSERT_EQ(1, mapper.getSwitchState(AINPUT_SOURCE_ANY, SW_LID));
3132 
3133     mFakeEventHub->setSwitchState(EVENTHUB_ID, SW_LID, 0);
3134     ASSERT_EQ(0, mapper.getSwitchState(AINPUT_SOURCE_ANY, SW_LID));
3135 }
3136 
TEST_F(SwitchInputMapperTest,Process)3137 TEST_F(SwitchInputMapperTest, Process) {
3138     SwitchInputMapper& mapper = addMapperAndConfigure<SwitchInputMapper>();
3139 
3140     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SW, SW_LID, 1);
3141     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SW, SW_JACK_PHYSICAL_INSERT, 1);
3142     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SW, SW_HEADPHONE_INSERT, 0);
3143     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
3144 
3145     NotifySwitchArgs args;
3146     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifySwitchWasCalled(&args));
3147     ASSERT_EQ(ARBITRARY_TIME, args.eventTime);
3148     ASSERT_EQ((1U << SW_LID) | (1U << SW_JACK_PHYSICAL_INSERT), args.switchValues);
3149     ASSERT_EQ((1U << SW_LID) | (1U << SW_JACK_PHYSICAL_INSERT) | (1 << SW_HEADPHONE_INSERT),
3150             args.switchMask);
3151     ASSERT_EQ(uint32_t(0), args.policyFlags);
3152 }
3153 
3154 // --- VibratorInputMapperTest ---
3155 class VibratorInputMapperTest : public InputMapperTest {
3156 protected:
SetUp()3157     void SetUp() override { InputMapperTest::SetUp(DEVICE_CLASSES | InputDeviceClass::VIBRATOR); }
3158 };
3159 
TEST_F(VibratorInputMapperTest,GetSources)3160 TEST_F(VibratorInputMapperTest, GetSources) {
3161     VibratorInputMapper& mapper = addMapperAndConfigure<VibratorInputMapper>();
3162 
3163     ASSERT_EQ(AINPUT_SOURCE_UNKNOWN, mapper.getSources());
3164 }
3165 
TEST_F(VibratorInputMapperTest,GetVibratorIds)3166 TEST_F(VibratorInputMapperTest, GetVibratorIds) {
3167     VibratorInputMapper& mapper = addMapperAndConfigure<VibratorInputMapper>();
3168 
3169     ASSERT_EQ(mapper.getVibratorIds().size(), 2U);
3170 }
3171 
TEST_F(VibratorInputMapperTest,Vibrate)3172 TEST_F(VibratorInputMapperTest, Vibrate) {
3173     constexpr uint8_t DEFAULT_AMPLITUDE = 192;
3174     constexpr int32_t VIBRATION_TOKEN = 100;
3175     VibratorInputMapper& mapper = addMapperAndConfigure<VibratorInputMapper>();
3176 
3177     VibrationElement pattern(2);
3178     VibrationSequence sequence(2);
3179     pattern.duration = std::chrono::milliseconds(200);
3180     pattern.channels = {{0 /* vibratorId */, DEFAULT_AMPLITUDE / 2},
3181                         {1 /* vibratorId */, DEFAULT_AMPLITUDE}};
3182     sequence.addElement(pattern);
3183     pattern.duration = std::chrono::milliseconds(500);
3184     pattern.channels = {{0 /* vibratorId */, DEFAULT_AMPLITUDE / 4},
3185                         {1 /* vibratorId */, DEFAULT_AMPLITUDE}};
3186     sequence.addElement(pattern);
3187 
3188     std::vector<int64_t> timings = {0, 1};
3189     std::vector<uint8_t> amplitudes = {DEFAULT_AMPLITUDE, DEFAULT_AMPLITUDE / 2};
3190 
3191     ASSERT_FALSE(mapper.isVibrating());
3192     // Start vibrating
3193     mapper.vibrate(sequence, -1 /* repeat */, VIBRATION_TOKEN);
3194     ASSERT_TRUE(mapper.isVibrating());
3195     // Verify vibrator state listener was notified.
3196     mReader->loopOnce();
3197     NotifyVibratorStateArgs args;
3198     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyVibratorStateWasCalled(&args));
3199     ASSERT_EQ(DEVICE_ID, args.deviceId);
3200     ASSERT_TRUE(args.isOn);
3201     // Stop vibrating
3202     mapper.cancelVibrate(VIBRATION_TOKEN);
3203     ASSERT_FALSE(mapper.isVibrating());
3204     // Verify vibrator state listener was notified.
3205     mReader->loopOnce();
3206     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyVibratorStateWasCalled(&args));
3207     ASSERT_EQ(DEVICE_ID, args.deviceId);
3208     ASSERT_FALSE(args.isOn);
3209 }
3210 
3211 // --- SensorInputMapperTest ---
3212 
3213 class SensorInputMapperTest : public InputMapperTest {
3214 protected:
3215     static const int32_t ACCEL_RAW_MIN;
3216     static const int32_t ACCEL_RAW_MAX;
3217     static const int32_t ACCEL_RAW_FUZZ;
3218     static const int32_t ACCEL_RAW_FLAT;
3219     static const int32_t ACCEL_RAW_RESOLUTION;
3220 
3221     static const int32_t GYRO_RAW_MIN;
3222     static const int32_t GYRO_RAW_MAX;
3223     static const int32_t GYRO_RAW_FUZZ;
3224     static const int32_t GYRO_RAW_FLAT;
3225     static const int32_t GYRO_RAW_RESOLUTION;
3226 
3227     static const float GRAVITY_MS2_UNIT;
3228     static const float DEGREE_RADIAN_UNIT;
3229 
3230     void prepareAccelAxes();
3231     void prepareGyroAxes();
3232     void setAccelProperties();
3233     void setGyroProperties();
SetUp()3234     void SetUp() override { InputMapperTest::SetUp(DEVICE_CLASSES | InputDeviceClass::SENSOR); }
3235 };
3236 
3237 const int32_t SensorInputMapperTest::ACCEL_RAW_MIN = -32768;
3238 const int32_t SensorInputMapperTest::ACCEL_RAW_MAX = 32768;
3239 const int32_t SensorInputMapperTest::ACCEL_RAW_FUZZ = 16;
3240 const int32_t SensorInputMapperTest::ACCEL_RAW_FLAT = 0;
3241 const int32_t SensorInputMapperTest::ACCEL_RAW_RESOLUTION = 8192;
3242 
3243 const int32_t SensorInputMapperTest::GYRO_RAW_MIN = -2097152;
3244 const int32_t SensorInputMapperTest::GYRO_RAW_MAX = 2097152;
3245 const int32_t SensorInputMapperTest::GYRO_RAW_FUZZ = 16;
3246 const int32_t SensorInputMapperTest::GYRO_RAW_FLAT = 0;
3247 const int32_t SensorInputMapperTest::GYRO_RAW_RESOLUTION = 1024;
3248 
3249 const float SensorInputMapperTest::GRAVITY_MS2_UNIT = 9.80665f;
3250 const float SensorInputMapperTest::DEGREE_RADIAN_UNIT = 0.0174533f;
3251 
prepareAccelAxes()3252 void SensorInputMapperTest::prepareAccelAxes() {
3253     mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_X, ACCEL_RAW_MIN, ACCEL_RAW_MAX, ACCEL_RAW_FUZZ,
3254                                    ACCEL_RAW_FLAT, ACCEL_RAW_RESOLUTION);
3255     mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_Y, ACCEL_RAW_MIN, ACCEL_RAW_MAX, ACCEL_RAW_FUZZ,
3256                                    ACCEL_RAW_FLAT, ACCEL_RAW_RESOLUTION);
3257     mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_Z, ACCEL_RAW_MIN, ACCEL_RAW_MAX, ACCEL_RAW_FUZZ,
3258                                    ACCEL_RAW_FLAT, ACCEL_RAW_RESOLUTION);
3259 }
3260 
prepareGyroAxes()3261 void SensorInputMapperTest::prepareGyroAxes() {
3262     mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_RX, GYRO_RAW_MIN, GYRO_RAW_MAX, GYRO_RAW_FUZZ,
3263                                    GYRO_RAW_FLAT, GYRO_RAW_RESOLUTION);
3264     mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_RY, GYRO_RAW_MIN, GYRO_RAW_MAX, GYRO_RAW_FUZZ,
3265                                    GYRO_RAW_FLAT, GYRO_RAW_RESOLUTION);
3266     mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_RZ, GYRO_RAW_MIN, GYRO_RAW_MAX, GYRO_RAW_FUZZ,
3267                                    GYRO_RAW_FLAT, GYRO_RAW_RESOLUTION);
3268 }
3269 
setAccelProperties()3270 void SensorInputMapperTest::setAccelProperties() {
3271     mFakeEventHub->addSensorAxis(EVENTHUB_ID, /* absCode */ 0, InputDeviceSensorType::ACCELEROMETER,
3272                                  /* sensorDataIndex */ 0);
3273     mFakeEventHub->addSensorAxis(EVENTHUB_ID, /* absCode */ 1, InputDeviceSensorType::ACCELEROMETER,
3274                                  /* sensorDataIndex */ 1);
3275     mFakeEventHub->addSensorAxis(EVENTHUB_ID, /* absCode */ 2, InputDeviceSensorType::ACCELEROMETER,
3276                                  /* sensorDataIndex */ 2);
3277     mFakeEventHub->setMscEvent(EVENTHUB_ID, MSC_TIMESTAMP);
3278     addConfigurationProperty("sensor.accelerometer.reportingMode", "0");
3279     addConfigurationProperty("sensor.accelerometer.maxDelay", "100000");
3280     addConfigurationProperty("sensor.accelerometer.minDelay", "5000");
3281     addConfigurationProperty("sensor.accelerometer.power", "1.5");
3282 }
3283 
setGyroProperties()3284 void SensorInputMapperTest::setGyroProperties() {
3285     mFakeEventHub->addSensorAxis(EVENTHUB_ID, /* absCode */ 3, InputDeviceSensorType::GYROSCOPE,
3286                                  /* sensorDataIndex */ 0);
3287     mFakeEventHub->addSensorAxis(EVENTHUB_ID, /* absCode */ 4, InputDeviceSensorType::GYROSCOPE,
3288                                  /* sensorDataIndex */ 1);
3289     mFakeEventHub->addSensorAxis(EVENTHUB_ID, /* absCode */ 5, InputDeviceSensorType::GYROSCOPE,
3290                                  /* sensorDataIndex */ 2);
3291     mFakeEventHub->setMscEvent(EVENTHUB_ID, MSC_TIMESTAMP);
3292     addConfigurationProperty("sensor.gyroscope.reportingMode", "0");
3293     addConfigurationProperty("sensor.gyroscope.maxDelay", "100000");
3294     addConfigurationProperty("sensor.gyroscope.minDelay", "5000");
3295     addConfigurationProperty("sensor.gyroscope.power", "0.8");
3296 }
3297 
TEST_F(SensorInputMapperTest,GetSources)3298 TEST_F(SensorInputMapperTest, GetSources) {
3299     SensorInputMapper& mapper = addMapperAndConfigure<SensorInputMapper>();
3300 
3301     ASSERT_EQ(static_cast<uint32_t>(AINPUT_SOURCE_SENSOR), mapper.getSources());
3302 }
3303 
TEST_F(SensorInputMapperTest,ProcessAccelerometerSensor)3304 TEST_F(SensorInputMapperTest, ProcessAccelerometerSensor) {
3305     setAccelProperties();
3306     prepareAccelAxes();
3307     SensorInputMapper& mapper = addMapperAndConfigure<SensorInputMapper>();
3308 
3309     ASSERT_TRUE(mapper.enableSensor(InputDeviceSensorType::ACCELEROMETER,
3310                                     std::chrono::microseconds(10000),
3311                                     std::chrono::microseconds(0)));
3312     ASSERT_TRUE(mFakeEventHub->isDeviceEnabled(EVENTHUB_ID));
3313     process(mapper, ARBITRARY_TIME, READ_TIME, EV_ABS, ABS_X, 20000);
3314     process(mapper, ARBITRARY_TIME, READ_TIME, EV_ABS, ABS_Y, -20000);
3315     process(mapper, ARBITRARY_TIME, READ_TIME, EV_ABS, ABS_Z, 40000);
3316     process(mapper, ARBITRARY_TIME, READ_TIME, EV_MSC, MSC_TIMESTAMP, 1000);
3317     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
3318 
3319     NotifySensorArgs args;
3320     std::vector<float> values = {20000.0f / ACCEL_RAW_RESOLUTION * GRAVITY_MS2_UNIT,
3321                                  -20000.0f / ACCEL_RAW_RESOLUTION * GRAVITY_MS2_UNIT,
3322                                  40000.0f / ACCEL_RAW_RESOLUTION * GRAVITY_MS2_UNIT};
3323 
3324     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifySensorWasCalled(&args));
3325     ASSERT_EQ(args.source, AINPUT_SOURCE_SENSOR);
3326     ASSERT_EQ(args.deviceId, DEVICE_ID);
3327     ASSERT_EQ(args.sensorType, InputDeviceSensorType::ACCELEROMETER);
3328     ASSERT_EQ(args.accuracy, InputDeviceSensorAccuracy::ACCURACY_HIGH);
3329     ASSERT_EQ(args.hwTimestamp, ARBITRARY_TIME);
3330     ASSERT_EQ(args.values, values);
3331     mapper.flushSensor(InputDeviceSensorType::ACCELEROMETER);
3332 }
3333 
TEST_F(SensorInputMapperTest,ProcessGyroscopeSensor)3334 TEST_F(SensorInputMapperTest, ProcessGyroscopeSensor) {
3335     setGyroProperties();
3336     prepareGyroAxes();
3337     SensorInputMapper& mapper = addMapperAndConfigure<SensorInputMapper>();
3338 
3339     ASSERT_TRUE(mapper.enableSensor(InputDeviceSensorType::GYROSCOPE,
3340                                     std::chrono::microseconds(10000),
3341                                     std::chrono::microseconds(0)));
3342     ASSERT_TRUE(mFakeEventHub->isDeviceEnabled(EVENTHUB_ID));
3343     process(mapper, ARBITRARY_TIME, READ_TIME, EV_ABS, ABS_RX, 20000);
3344     process(mapper, ARBITRARY_TIME, READ_TIME, EV_ABS, ABS_RY, -20000);
3345     process(mapper, ARBITRARY_TIME, READ_TIME, EV_ABS, ABS_RZ, 40000);
3346     process(mapper, ARBITRARY_TIME, READ_TIME, EV_MSC, MSC_TIMESTAMP, 1000);
3347     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
3348 
3349     NotifySensorArgs args;
3350     std::vector<float> values = {20000.0f / GYRO_RAW_RESOLUTION * DEGREE_RADIAN_UNIT,
3351                                  -20000.0f / GYRO_RAW_RESOLUTION * DEGREE_RADIAN_UNIT,
3352                                  40000.0f / GYRO_RAW_RESOLUTION * DEGREE_RADIAN_UNIT};
3353 
3354     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifySensorWasCalled(&args));
3355     ASSERT_EQ(args.source, AINPUT_SOURCE_SENSOR);
3356     ASSERT_EQ(args.deviceId, DEVICE_ID);
3357     ASSERT_EQ(args.sensorType, InputDeviceSensorType::GYROSCOPE);
3358     ASSERT_EQ(args.accuracy, InputDeviceSensorAccuracy::ACCURACY_HIGH);
3359     ASSERT_EQ(args.hwTimestamp, ARBITRARY_TIME);
3360     ASSERT_EQ(args.values, values);
3361     mapper.flushSensor(InputDeviceSensorType::GYROSCOPE);
3362 }
3363 
3364 // --- KeyboardInputMapperTest ---
3365 
3366 class KeyboardInputMapperTest : public InputMapperTest {
3367 protected:
3368     const std::string UNIQUE_ID = "local:0";
3369 
3370     void prepareDisplay(int32_t orientation);
3371 
3372     void testDPadKeyRotation(KeyboardInputMapper& mapper, int32_t originalScanCode,
3373                              int32_t originalKeyCode, int32_t rotatedKeyCode,
3374                              int32_t displayId = ADISPLAY_ID_NONE);
3375 };
3376 
3377 /* Similar to setDisplayInfoAndReconfigure, but pre-populates all parameters except for the
3378  * orientation.
3379  */
prepareDisplay(int32_t orientation)3380 void KeyboardInputMapperTest::prepareDisplay(int32_t orientation) {
3381     setDisplayInfoAndReconfigure(DISPLAY_ID, DISPLAY_WIDTH, DISPLAY_HEIGHT, orientation, UNIQUE_ID,
3382                                  NO_PORT, ViewportType::INTERNAL);
3383 }
3384 
testDPadKeyRotation(KeyboardInputMapper & mapper,int32_t originalScanCode,int32_t originalKeyCode,int32_t rotatedKeyCode,int32_t displayId)3385 void KeyboardInputMapperTest::testDPadKeyRotation(KeyboardInputMapper& mapper,
3386                                                   int32_t originalScanCode, int32_t originalKeyCode,
3387                                                   int32_t rotatedKeyCode, int32_t displayId) {
3388     NotifyKeyArgs args;
3389 
3390     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, originalScanCode, 1);
3391     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
3392     ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, args.action);
3393     ASSERT_EQ(originalScanCode, args.scanCode);
3394     ASSERT_EQ(rotatedKeyCode, args.keyCode);
3395     ASSERT_EQ(displayId, args.displayId);
3396 
3397     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, originalScanCode, 0);
3398     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
3399     ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action);
3400     ASSERT_EQ(originalScanCode, args.scanCode);
3401     ASSERT_EQ(rotatedKeyCode, args.keyCode);
3402     ASSERT_EQ(displayId, args.displayId);
3403 }
3404 
TEST_F(KeyboardInputMapperTest,GetSources)3405 TEST_F(KeyboardInputMapperTest, GetSources) {
3406     KeyboardInputMapper& mapper =
3407             addMapperAndConfigure<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD,
3408                                                        AINPUT_KEYBOARD_TYPE_ALPHABETIC);
3409 
3410     ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, mapper.getSources());
3411 }
3412 
TEST_F(KeyboardInputMapperTest,Process_SimpleKeyPress)3413 TEST_F(KeyboardInputMapperTest, Process_SimpleKeyPress) {
3414     const int32_t USAGE_A = 0x070004;
3415     const int32_t USAGE_UNKNOWN = 0x07ffff;
3416     mFakeEventHub->addKey(EVENTHUB_ID, KEY_HOME, 0, AKEYCODE_HOME, POLICY_FLAG_WAKE);
3417     mFakeEventHub->addKey(EVENTHUB_ID, 0, USAGE_A, AKEYCODE_A, POLICY_FLAG_WAKE);
3418     mFakeEventHub->addKey(EVENTHUB_ID, 0, KEY_NUMLOCK, AKEYCODE_NUM_LOCK, POLICY_FLAG_WAKE);
3419     mFakeEventHub->addKey(EVENTHUB_ID, 0, KEY_CAPSLOCK, AKEYCODE_CAPS_LOCK, POLICY_FLAG_WAKE);
3420     mFakeEventHub->addKey(EVENTHUB_ID, 0, KEY_SCROLLLOCK, AKEYCODE_SCROLL_LOCK, POLICY_FLAG_WAKE);
3421 
3422     KeyboardInputMapper& mapper =
3423             addMapperAndConfigure<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD,
3424                                                        AINPUT_KEYBOARD_TYPE_ALPHABETIC);
3425     // Initial metastate is AMETA_NONE.
3426     ASSERT_EQ(AMETA_NONE, mapper.getMetaState());
3427 
3428     // Key down by scan code.
3429     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_HOME, 1);
3430     NotifyKeyArgs args;
3431     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
3432     ASSERT_EQ(DEVICE_ID, args.deviceId);
3433     ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source);
3434     ASSERT_EQ(ARBITRARY_TIME, args.eventTime);
3435     ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, args.action);
3436     ASSERT_EQ(AKEYCODE_HOME, args.keyCode);
3437     ASSERT_EQ(KEY_HOME, args.scanCode);
3438     ASSERT_EQ(AMETA_NONE, args.metaState);
3439     ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, args.flags);
3440     ASSERT_EQ(POLICY_FLAG_WAKE, args.policyFlags);
3441     ASSERT_EQ(ARBITRARY_TIME, args.downTime);
3442 
3443     // Key up by scan code.
3444     process(mapper, ARBITRARY_TIME + 1, READ_TIME, EV_KEY, KEY_HOME, 0);
3445     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
3446     ASSERT_EQ(DEVICE_ID, args.deviceId);
3447     ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source);
3448     ASSERT_EQ(ARBITRARY_TIME + 1, args.eventTime);
3449     ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action);
3450     ASSERT_EQ(AKEYCODE_HOME, args.keyCode);
3451     ASSERT_EQ(KEY_HOME, args.scanCode);
3452     ASSERT_EQ(AMETA_NONE, args.metaState);
3453     ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, args.flags);
3454     ASSERT_EQ(POLICY_FLAG_WAKE, args.policyFlags);
3455     ASSERT_EQ(ARBITRARY_TIME, args.downTime);
3456 
3457     // Key down by usage code.
3458     process(mapper, ARBITRARY_TIME, READ_TIME, EV_MSC, MSC_SCAN, USAGE_A);
3459     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, 0, 1);
3460     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
3461     ASSERT_EQ(DEVICE_ID, args.deviceId);
3462     ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source);
3463     ASSERT_EQ(ARBITRARY_TIME, args.eventTime);
3464     ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, args.action);
3465     ASSERT_EQ(AKEYCODE_A, args.keyCode);
3466     ASSERT_EQ(0, args.scanCode);
3467     ASSERT_EQ(AMETA_NONE, args.metaState);
3468     ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, args.flags);
3469     ASSERT_EQ(POLICY_FLAG_WAKE, args.policyFlags);
3470     ASSERT_EQ(ARBITRARY_TIME, args.downTime);
3471 
3472     // Key up by usage code.
3473     process(mapper, ARBITRARY_TIME, READ_TIME, EV_MSC, MSC_SCAN, USAGE_A);
3474     process(mapper, ARBITRARY_TIME + 1, READ_TIME, EV_KEY, 0, 0);
3475     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
3476     ASSERT_EQ(DEVICE_ID, args.deviceId);
3477     ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source);
3478     ASSERT_EQ(ARBITRARY_TIME + 1, args.eventTime);
3479     ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action);
3480     ASSERT_EQ(AKEYCODE_A, args.keyCode);
3481     ASSERT_EQ(0, args.scanCode);
3482     ASSERT_EQ(AMETA_NONE, args.metaState);
3483     ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, args.flags);
3484     ASSERT_EQ(POLICY_FLAG_WAKE, args.policyFlags);
3485     ASSERT_EQ(ARBITRARY_TIME, args.downTime);
3486 
3487     // Key down with unknown scan code or usage code.
3488     process(mapper, ARBITRARY_TIME, READ_TIME, EV_MSC, MSC_SCAN, USAGE_UNKNOWN);
3489     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_UNKNOWN, 1);
3490     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
3491     ASSERT_EQ(DEVICE_ID, args.deviceId);
3492     ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source);
3493     ASSERT_EQ(ARBITRARY_TIME, args.eventTime);
3494     ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, args.action);
3495     ASSERT_EQ(0, args.keyCode);
3496     ASSERT_EQ(KEY_UNKNOWN, args.scanCode);
3497     ASSERT_EQ(AMETA_NONE, args.metaState);
3498     ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, args.flags);
3499     ASSERT_EQ(0U, args.policyFlags);
3500     ASSERT_EQ(ARBITRARY_TIME, args.downTime);
3501 
3502     // Key up with unknown scan code or usage code.
3503     process(mapper, ARBITRARY_TIME, READ_TIME, EV_MSC, MSC_SCAN, USAGE_UNKNOWN);
3504     process(mapper, ARBITRARY_TIME + 1, READ_TIME, EV_KEY, KEY_UNKNOWN, 0);
3505     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
3506     ASSERT_EQ(DEVICE_ID, args.deviceId);
3507     ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source);
3508     ASSERT_EQ(ARBITRARY_TIME + 1, args.eventTime);
3509     ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action);
3510     ASSERT_EQ(0, args.keyCode);
3511     ASSERT_EQ(KEY_UNKNOWN, args.scanCode);
3512     ASSERT_EQ(AMETA_NONE, args.metaState);
3513     ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, args.flags);
3514     ASSERT_EQ(0U, args.policyFlags);
3515     ASSERT_EQ(ARBITRARY_TIME, args.downTime);
3516 }
3517 
3518 /**
3519  * Ensure that the readTime is set to the time when the EV_KEY is received.
3520  */
TEST_F(KeyboardInputMapperTest,Process_SendsReadTime)3521 TEST_F(KeyboardInputMapperTest, Process_SendsReadTime) {
3522     mFakeEventHub->addKey(EVENTHUB_ID, KEY_HOME, 0, AKEYCODE_HOME, POLICY_FLAG_WAKE);
3523 
3524     KeyboardInputMapper& mapper =
3525             addMapperAndConfigure<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD,
3526                                                        AINPUT_KEYBOARD_TYPE_ALPHABETIC);
3527     NotifyKeyArgs args;
3528 
3529     // Key down
3530     process(mapper, ARBITRARY_TIME, 12 /*readTime*/, EV_KEY, KEY_HOME, 1);
3531     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
3532     ASSERT_EQ(12, args.readTime);
3533 
3534     // Key up
3535     process(mapper, ARBITRARY_TIME, 15 /*readTime*/, EV_KEY, KEY_HOME, 1);
3536     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
3537     ASSERT_EQ(15, args.readTime);
3538 }
3539 
TEST_F(KeyboardInputMapperTest,Process_ShouldUpdateMetaState)3540 TEST_F(KeyboardInputMapperTest, Process_ShouldUpdateMetaState) {
3541     mFakeEventHub->addKey(EVENTHUB_ID, KEY_LEFTSHIFT, 0, AKEYCODE_SHIFT_LEFT, 0);
3542     mFakeEventHub->addKey(EVENTHUB_ID, KEY_A, 0, AKEYCODE_A, 0);
3543     mFakeEventHub->addKey(EVENTHUB_ID, 0, KEY_NUMLOCK, AKEYCODE_NUM_LOCK, 0);
3544     mFakeEventHub->addKey(EVENTHUB_ID, 0, KEY_CAPSLOCK, AKEYCODE_CAPS_LOCK, 0);
3545     mFakeEventHub->addKey(EVENTHUB_ID, 0, KEY_SCROLLLOCK, AKEYCODE_SCROLL_LOCK, 0);
3546 
3547     KeyboardInputMapper& mapper =
3548             addMapperAndConfigure<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD,
3549                                                        AINPUT_KEYBOARD_TYPE_ALPHABETIC);
3550 
3551     // Initial metastate is AMETA_NONE.
3552     ASSERT_EQ(AMETA_NONE, mapper.getMetaState());
3553 
3554     // Metakey down.
3555     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_LEFTSHIFT, 1);
3556     NotifyKeyArgs args;
3557     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
3558     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
3559     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, mapper.getMetaState());
3560     ASSERT_NO_FATAL_FAILURE(mReader->getContext()->assertUpdateGlobalMetaStateWasCalled());
3561 
3562     // Key down.
3563     process(mapper, ARBITRARY_TIME + 1, READ_TIME, EV_KEY, KEY_A, 1);
3564     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
3565     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
3566     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, mapper.getMetaState());
3567 
3568     // Key up.
3569     process(mapper, ARBITRARY_TIME + 2, READ_TIME, EV_KEY, KEY_A, 0);
3570     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
3571     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
3572     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, mapper.getMetaState());
3573 
3574     // Metakey up.
3575     process(mapper, ARBITRARY_TIME + 3, READ_TIME, EV_KEY, KEY_LEFTSHIFT, 0);
3576     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
3577     ASSERT_EQ(AMETA_NONE, args.metaState);
3578     ASSERT_EQ(AMETA_NONE, mapper.getMetaState());
3579     ASSERT_NO_FATAL_FAILURE(mReader->getContext()->assertUpdateGlobalMetaStateWasCalled());
3580 }
3581 
TEST_F(KeyboardInputMapperTest,Process_WhenNotOrientationAware_ShouldNotRotateDPad)3582 TEST_F(KeyboardInputMapperTest, Process_WhenNotOrientationAware_ShouldNotRotateDPad) {
3583     mFakeEventHub->addKey(EVENTHUB_ID, KEY_UP, 0, AKEYCODE_DPAD_UP, 0);
3584     mFakeEventHub->addKey(EVENTHUB_ID, KEY_RIGHT, 0, AKEYCODE_DPAD_RIGHT, 0);
3585     mFakeEventHub->addKey(EVENTHUB_ID, KEY_DOWN, 0, AKEYCODE_DPAD_DOWN, 0);
3586     mFakeEventHub->addKey(EVENTHUB_ID, KEY_LEFT, 0, AKEYCODE_DPAD_LEFT, 0);
3587 
3588     KeyboardInputMapper& mapper =
3589             addMapperAndConfigure<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD,
3590                                                        AINPUT_KEYBOARD_TYPE_ALPHABETIC);
3591 
3592     prepareDisplay(DISPLAY_ORIENTATION_90);
3593     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
3594             KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_UP));
3595     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
3596             KEY_RIGHT, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_RIGHT));
3597     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
3598             KEY_DOWN, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_DOWN));
3599     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
3600             KEY_LEFT, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_LEFT));
3601 }
3602 
TEST_F(KeyboardInputMapperTest,Process_WhenOrientationAware_ShouldRotateDPad)3603 TEST_F(KeyboardInputMapperTest, Process_WhenOrientationAware_ShouldRotateDPad) {
3604     mFakeEventHub->addKey(EVENTHUB_ID, KEY_UP, 0, AKEYCODE_DPAD_UP, 0);
3605     mFakeEventHub->addKey(EVENTHUB_ID, KEY_RIGHT, 0, AKEYCODE_DPAD_RIGHT, 0);
3606     mFakeEventHub->addKey(EVENTHUB_ID, KEY_DOWN, 0, AKEYCODE_DPAD_DOWN, 0);
3607     mFakeEventHub->addKey(EVENTHUB_ID, KEY_LEFT, 0, AKEYCODE_DPAD_LEFT, 0);
3608 
3609     addConfigurationProperty("keyboard.orientationAware", "1");
3610     KeyboardInputMapper& mapper =
3611             addMapperAndConfigure<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD,
3612                                                        AINPUT_KEYBOARD_TYPE_ALPHABETIC);
3613 
3614     prepareDisplay(DISPLAY_ORIENTATION_0);
3615     ASSERT_NO_FATAL_FAILURE(
3616             testDPadKeyRotation(mapper, KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_UP, DISPLAY_ID));
3617     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, KEY_RIGHT, AKEYCODE_DPAD_RIGHT,
3618                                                 AKEYCODE_DPAD_RIGHT, DISPLAY_ID));
3619     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, KEY_DOWN, AKEYCODE_DPAD_DOWN,
3620                                                 AKEYCODE_DPAD_DOWN, DISPLAY_ID));
3621     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, KEY_LEFT, AKEYCODE_DPAD_LEFT,
3622                                                 AKEYCODE_DPAD_LEFT, DISPLAY_ID));
3623 
3624     clearViewports();
3625     prepareDisplay(DISPLAY_ORIENTATION_90);
3626     ASSERT_NO_FATAL_FAILURE(
3627             testDPadKeyRotation(mapper, KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_LEFT, DISPLAY_ID));
3628     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, KEY_RIGHT, AKEYCODE_DPAD_RIGHT,
3629                                                 AKEYCODE_DPAD_UP, DISPLAY_ID));
3630     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, KEY_DOWN, AKEYCODE_DPAD_DOWN,
3631                                                 AKEYCODE_DPAD_RIGHT, DISPLAY_ID));
3632     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, KEY_LEFT, AKEYCODE_DPAD_LEFT,
3633                                                 AKEYCODE_DPAD_DOWN, DISPLAY_ID));
3634 
3635     clearViewports();
3636     prepareDisplay(DISPLAY_ORIENTATION_180);
3637     ASSERT_NO_FATAL_FAILURE(
3638             testDPadKeyRotation(mapper, KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_DOWN, DISPLAY_ID));
3639     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, KEY_RIGHT, AKEYCODE_DPAD_RIGHT,
3640                                                 AKEYCODE_DPAD_LEFT, DISPLAY_ID));
3641     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, KEY_DOWN, AKEYCODE_DPAD_DOWN,
3642                                                 AKEYCODE_DPAD_UP, DISPLAY_ID));
3643     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, KEY_LEFT, AKEYCODE_DPAD_LEFT,
3644                                                 AKEYCODE_DPAD_RIGHT, DISPLAY_ID));
3645 
3646     clearViewports();
3647     prepareDisplay(DISPLAY_ORIENTATION_270);
3648     ASSERT_NO_FATAL_FAILURE(
3649             testDPadKeyRotation(mapper, KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_RIGHT, DISPLAY_ID));
3650     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, KEY_RIGHT, AKEYCODE_DPAD_RIGHT,
3651                                                 AKEYCODE_DPAD_DOWN, DISPLAY_ID));
3652     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, KEY_DOWN, AKEYCODE_DPAD_DOWN,
3653                                                 AKEYCODE_DPAD_LEFT, DISPLAY_ID));
3654     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, KEY_LEFT, AKEYCODE_DPAD_LEFT,
3655                                                 AKEYCODE_DPAD_UP, DISPLAY_ID));
3656 
3657     // Special case: if orientation changes while key is down, we still emit the same keycode
3658     // in the key up as we did in the key down.
3659     NotifyKeyArgs args;
3660     clearViewports();
3661     prepareDisplay(DISPLAY_ORIENTATION_270);
3662     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_UP, 1);
3663     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
3664     ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, args.action);
3665     ASSERT_EQ(KEY_UP, args.scanCode);
3666     ASSERT_EQ(AKEYCODE_DPAD_RIGHT, args.keyCode);
3667 
3668     clearViewports();
3669     prepareDisplay(DISPLAY_ORIENTATION_180);
3670     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_UP, 0);
3671     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
3672     ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action);
3673     ASSERT_EQ(KEY_UP, args.scanCode);
3674     ASSERT_EQ(AKEYCODE_DPAD_RIGHT, args.keyCode);
3675 }
3676 
TEST_F(KeyboardInputMapperTest,DisplayIdConfigurationChange_NotOrientationAware)3677 TEST_F(KeyboardInputMapperTest, DisplayIdConfigurationChange_NotOrientationAware) {
3678     // If the keyboard is not orientation aware,
3679     // key events should not be associated with a specific display id
3680     mFakeEventHub->addKey(EVENTHUB_ID, KEY_UP, 0, AKEYCODE_DPAD_UP, 0);
3681 
3682     KeyboardInputMapper& mapper =
3683             addMapperAndConfigure<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD,
3684                                                        AINPUT_KEYBOARD_TYPE_ALPHABETIC);
3685     NotifyKeyArgs args;
3686 
3687     // Display id should be ADISPLAY_ID_NONE without any display configuration.
3688     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_UP, 1);
3689     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
3690     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_UP, 0);
3691     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
3692     ASSERT_EQ(ADISPLAY_ID_NONE, args.displayId);
3693 
3694     prepareDisplay(DISPLAY_ORIENTATION_0);
3695     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_UP, 1);
3696     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
3697     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_UP, 0);
3698     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
3699     ASSERT_EQ(ADISPLAY_ID_NONE, args.displayId);
3700 }
3701 
TEST_F(KeyboardInputMapperTest,DisplayIdConfigurationChange_OrientationAware)3702 TEST_F(KeyboardInputMapperTest, DisplayIdConfigurationChange_OrientationAware) {
3703     // If the keyboard is orientation aware,
3704     // key events should be associated with the internal viewport
3705     mFakeEventHub->addKey(EVENTHUB_ID, KEY_UP, 0, AKEYCODE_DPAD_UP, 0);
3706 
3707     addConfigurationProperty("keyboard.orientationAware", "1");
3708     KeyboardInputMapper& mapper =
3709             addMapperAndConfigure<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD,
3710                                                        AINPUT_KEYBOARD_TYPE_ALPHABETIC);
3711     NotifyKeyArgs args;
3712 
3713     // Display id should be ADISPLAY_ID_NONE without any display configuration.
3714     // ^--- already checked by the previous test
3715 
3716     setDisplayInfoAndReconfigure(DISPLAY_ID, DISPLAY_WIDTH, DISPLAY_HEIGHT, DISPLAY_ORIENTATION_0,
3717                                  UNIQUE_ID, NO_PORT, ViewportType::INTERNAL);
3718     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_UP, 1);
3719     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
3720     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_UP, 0);
3721     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
3722     ASSERT_EQ(DISPLAY_ID, args.displayId);
3723 
3724     constexpr int32_t newDisplayId = 2;
3725     clearViewports();
3726     setDisplayInfoAndReconfigure(newDisplayId, DISPLAY_WIDTH, DISPLAY_HEIGHT, DISPLAY_ORIENTATION_0,
3727                                  UNIQUE_ID, NO_PORT, ViewportType::INTERNAL);
3728     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_UP, 1);
3729     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
3730     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_UP, 0);
3731     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
3732     ASSERT_EQ(newDisplayId, args.displayId);
3733 }
3734 
TEST_F(KeyboardInputMapperTest,GetKeyCodeState)3735 TEST_F(KeyboardInputMapperTest, GetKeyCodeState) {
3736     KeyboardInputMapper& mapper =
3737             addMapperAndConfigure<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD,
3738                                                        AINPUT_KEYBOARD_TYPE_ALPHABETIC);
3739 
3740     mFakeEventHub->setKeyCodeState(EVENTHUB_ID, AKEYCODE_A, 1);
3741     ASSERT_EQ(1, mapper.getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_A));
3742 
3743     mFakeEventHub->setKeyCodeState(EVENTHUB_ID, AKEYCODE_A, 0);
3744     ASSERT_EQ(0, mapper.getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_A));
3745 }
3746 
TEST_F(KeyboardInputMapperTest,GetKeyCodeForKeyLocation)3747 TEST_F(KeyboardInputMapperTest, GetKeyCodeForKeyLocation) {
3748     KeyboardInputMapper& mapper =
3749             addMapperAndConfigure<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD,
3750                                                        AINPUT_KEYBOARD_TYPE_ALPHABETIC);
3751 
3752     mFakeEventHub->addKeyCodeMapping(EVENTHUB_ID, AKEYCODE_Y, AKEYCODE_Z);
3753     ASSERT_EQ(AKEYCODE_Z, mapper.getKeyCodeForKeyLocation(AKEYCODE_Y))
3754             << "If a mapping is available, the result is equal to the mapping";
3755 
3756     ASSERT_EQ(AKEYCODE_A, mapper.getKeyCodeForKeyLocation(AKEYCODE_A))
3757             << "If no mapping is available, the result is the key location";
3758 }
3759 
TEST_F(KeyboardInputMapperTest,GetScanCodeState)3760 TEST_F(KeyboardInputMapperTest, GetScanCodeState) {
3761     KeyboardInputMapper& mapper =
3762             addMapperAndConfigure<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD,
3763                                                        AINPUT_KEYBOARD_TYPE_ALPHABETIC);
3764 
3765     mFakeEventHub->setScanCodeState(EVENTHUB_ID, KEY_A, 1);
3766     ASSERT_EQ(1, mapper.getScanCodeState(AINPUT_SOURCE_ANY, KEY_A));
3767 
3768     mFakeEventHub->setScanCodeState(EVENTHUB_ID, KEY_A, 0);
3769     ASSERT_EQ(0, mapper.getScanCodeState(AINPUT_SOURCE_ANY, KEY_A));
3770 }
3771 
TEST_F(KeyboardInputMapperTest,MarkSupportedKeyCodes)3772 TEST_F(KeyboardInputMapperTest, MarkSupportedKeyCodes) {
3773     KeyboardInputMapper& mapper =
3774             addMapperAndConfigure<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD,
3775                                                        AINPUT_KEYBOARD_TYPE_ALPHABETIC);
3776 
3777     mFakeEventHub->addKey(EVENTHUB_ID, KEY_A, 0, AKEYCODE_A, 0);
3778 
3779     const int32_t keyCodes[2] = { AKEYCODE_A, AKEYCODE_B };
3780     uint8_t flags[2] = { 0, 0 };
3781     ASSERT_TRUE(mapper.markSupportedKeyCodes(AINPUT_SOURCE_ANY, 1, keyCodes, flags));
3782     ASSERT_TRUE(flags[0]);
3783     ASSERT_FALSE(flags[1]);
3784 }
3785 
TEST_F(KeyboardInputMapperTest,Process_LockedKeysShouldToggleMetaStateAndLeds)3786 TEST_F(KeyboardInputMapperTest, Process_LockedKeysShouldToggleMetaStateAndLeds) {
3787     mFakeEventHub->addLed(EVENTHUB_ID, LED_CAPSL, true /*initially on*/);
3788     mFakeEventHub->addLed(EVENTHUB_ID, LED_NUML, false /*initially off*/);
3789     mFakeEventHub->addLed(EVENTHUB_ID, LED_SCROLLL, false /*initially off*/);
3790     mFakeEventHub->addKey(EVENTHUB_ID, KEY_CAPSLOCK, 0, AKEYCODE_CAPS_LOCK, 0);
3791     mFakeEventHub->addKey(EVENTHUB_ID, KEY_NUMLOCK, 0, AKEYCODE_NUM_LOCK, 0);
3792     mFakeEventHub->addKey(EVENTHUB_ID, KEY_SCROLLLOCK, 0, AKEYCODE_SCROLL_LOCK, 0);
3793 
3794     KeyboardInputMapper& mapper =
3795             addMapperAndConfigure<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD,
3796                                                        AINPUT_KEYBOARD_TYPE_ALPHABETIC);
3797     // Initial metastate is AMETA_NONE.
3798     ASSERT_EQ(AMETA_NONE, mapper.getMetaState());
3799 
3800     // Initialization should have turned all of the lights off.
3801     ASSERT_FALSE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_CAPSL));
3802     ASSERT_FALSE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_NUML));
3803     ASSERT_FALSE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_SCROLLL));
3804 
3805     // Toggle caps lock on.
3806     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_CAPSLOCK, 1);
3807     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_CAPSLOCK, 0);
3808     ASSERT_TRUE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_CAPSL));
3809     ASSERT_FALSE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_NUML));
3810     ASSERT_FALSE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_SCROLLL));
3811     ASSERT_EQ(AMETA_CAPS_LOCK_ON, mapper.getMetaState());
3812 
3813     // Toggle num lock on.
3814     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_NUMLOCK, 1);
3815     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_NUMLOCK, 0);
3816     ASSERT_TRUE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_CAPSL));
3817     ASSERT_TRUE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_NUML));
3818     ASSERT_FALSE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_SCROLLL));
3819     ASSERT_EQ(AMETA_CAPS_LOCK_ON | AMETA_NUM_LOCK_ON, mapper.getMetaState());
3820 
3821     // Toggle caps lock off.
3822     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_CAPSLOCK, 1);
3823     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_CAPSLOCK, 0);
3824     ASSERT_FALSE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_CAPSL));
3825     ASSERT_TRUE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_NUML));
3826     ASSERT_FALSE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_SCROLLL));
3827     ASSERT_EQ(AMETA_NUM_LOCK_ON, mapper.getMetaState());
3828 
3829     // Toggle scroll lock on.
3830     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_SCROLLLOCK, 1);
3831     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_SCROLLLOCK, 0);
3832     ASSERT_FALSE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_CAPSL));
3833     ASSERT_TRUE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_NUML));
3834     ASSERT_TRUE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_SCROLLL));
3835     ASSERT_EQ(AMETA_NUM_LOCK_ON | AMETA_SCROLL_LOCK_ON, mapper.getMetaState());
3836 
3837     // Toggle num lock off.
3838     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_NUMLOCK, 1);
3839     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_NUMLOCK, 0);
3840     ASSERT_FALSE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_CAPSL));
3841     ASSERT_FALSE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_NUML));
3842     ASSERT_TRUE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_SCROLLL));
3843     ASSERT_EQ(AMETA_SCROLL_LOCK_ON, mapper.getMetaState());
3844 
3845     // Toggle scroll lock off.
3846     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_SCROLLLOCK, 1);
3847     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_SCROLLLOCK, 0);
3848     ASSERT_FALSE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_CAPSL));
3849     ASSERT_FALSE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_NUML));
3850     ASSERT_FALSE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_SCROLLL));
3851     ASSERT_EQ(AMETA_NONE, mapper.getMetaState());
3852 }
3853 
TEST_F(KeyboardInputMapperTest,NoMetaStateWhenMetaKeysNotPresent)3854 TEST_F(KeyboardInputMapperTest, NoMetaStateWhenMetaKeysNotPresent) {
3855     mFakeEventHub->addKey(EVENTHUB_ID, BTN_A, 0, AKEYCODE_BUTTON_A, 0);
3856     mFakeEventHub->addKey(EVENTHUB_ID, BTN_B, 0, AKEYCODE_BUTTON_B, 0);
3857     mFakeEventHub->addKey(EVENTHUB_ID, BTN_X, 0, AKEYCODE_BUTTON_X, 0);
3858     mFakeEventHub->addKey(EVENTHUB_ID, BTN_Y, 0, AKEYCODE_BUTTON_Y, 0);
3859 
3860     KeyboardInputMapper& mapper =
3861             addMapperAndConfigure<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD,
3862                                                        AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC);
3863 
3864     // Meta state should be AMETA_NONE after reset
3865     mapper.reset(ARBITRARY_TIME);
3866     ASSERT_EQ(AMETA_NONE, mapper.getMetaState());
3867     // Meta state should be AMETA_NONE with update, as device doesn't have the keys.
3868     mapper.updateMetaState(AKEYCODE_NUM_LOCK);
3869     ASSERT_EQ(AMETA_NONE, mapper.getMetaState());
3870 
3871     NotifyKeyArgs args;
3872     // Press button "A"
3873     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, BTN_A, 1);
3874     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
3875     ASSERT_EQ(AMETA_NONE, args.metaState);
3876     ASSERT_EQ(AMETA_NONE, mapper.getMetaState());
3877     ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, args.action);
3878     ASSERT_EQ(AKEYCODE_BUTTON_A, args.keyCode);
3879 
3880     // Button up.
3881     process(mapper, ARBITRARY_TIME + 2, READ_TIME, EV_KEY, BTN_A, 0);
3882     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
3883     ASSERT_EQ(AMETA_NONE, args.metaState);
3884     ASSERT_EQ(AMETA_NONE, mapper.getMetaState());
3885     ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action);
3886     ASSERT_EQ(AKEYCODE_BUTTON_A, args.keyCode);
3887 }
3888 
TEST_F(KeyboardInputMapperTest,Configure_AssignsDisplayPort)3889 TEST_F(KeyboardInputMapperTest, Configure_AssignsDisplayPort) {
3890     // keyboard 1.
3891     mFakeEventHub->addKey(EVENTHUB_ID, KEY_UP, 0, AKEYCODE_DPAD_UP, 0);
3892     mFakeEventHub->addKey(EVENTHUB_ID, KEY_RIGHT, 0, AKEYCODE_DPAD_RIGHT, 0);
3893     mFakeEventHub->addKey(EVENTHUB_ID, KEY_DOWN, 0, AKEYCODE_DPAD_DOWN, 0);
3894     mFakeEventHub->addKey(EVENTHUB_ID, KEY_LEFT, 0, AKEYCODE_DPAD_LEFT, 0);
3895 
3896     // keyboard 2.
3897     const std::string USB2 = "USB2";
3898     const std::string DEVICE_NAME2 = "KEYBOARD2";
3899     constexpr int32_t SECOND_DEVICE_ID = DEVICE_ID + 1;
3900     constexpr int32_t SECOND_EVENTHUB_ID = EVENTHUB_ID + 1;
3901     std::shared_ptr<InputDevice> device2 =
3902             newDevice(SECOND_DEVICE_ID, DEVICE_NAME2, USB2, SECOND_EVENTHUB_ID,
3903                       ftl::Flags<InputDeviceClass>(0));
3904 
3905     mFakeEventHub->addKey(SECOND_EVENTHUB_ID, KEY_UP, 0, AKEYCODE_DPAD_UP, 0);
3906     mFakeEventHub->addKey(SECOND_EVENTHUB_ID, KEY_RIGHT, 0, AKEYCODE_DPAD_RIGHT, 0);
3907     mFakeEventHub->addKey(SECOND_EVENTHUB_ID, KEY_DOWN, 0, AKEYCODE_DPAD_DOWN, 0);
3908     mFakeEventHub->addKey(SECOND_EVENTHUB_ID, KEY_LEFT, 0, AKEYCODE_DPAD_LEFT, 0);
3909 
3910     KeyboardInputMapper& mapper =
3911             addMapperAndConfigure<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD,
3912                                                        AINPUT_KEYBOARD_TYPE_ALPHABETIC);
3913 
3914     KeyboardInputMapper& mapper2 =
3915             device2->addMapper<KeyboardInputMapper>(SECOND_EVENTHUB_ID, AINPUT_SOURCE_KEYBOARD,
3916                                                     AINPUT_KEYBOARD_TYPE_ALPHABETIC);
3917     device2->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), 0 /*changes*/);
3918     device2->reset(ARBITRARY_TIME);
3919 
3920     // Prepared displays and associated info.
3921     constexpr uint8_t hdmi1 = 0;
3922     constexpr uint8_t hdmi2 = 1;
3923     const std::string SECONDARY_UNIQUE_ID = "local:1";
3924 
3925     mFakePolicy->addInputPortAssociation(DEVICE_LOCATION, hdmi1);
3926     mFakePolicy->addInputPortAssociation(USB2, hdmi2);
3927 
3928     // No associated display viewport found, should disable the device.
3929     device2->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(),
3930                        InputReaderConfiguration::CHANGE_DISPLAY_INFO);
3931     ASSERT_FALSE(device2->isEnabled());
3932 
3933     // Prepare second display.
3934     constexpr int32_t newDisplayId = 2;
3935     setDisplayInfoAndReconfigure(DISPLAY_ID, DISPLAY_WIDTH, DISPLAY_HEIGHT, DISPLAY_ORIENTATION_0,
3936                                  UNIQUE_ID, hdmi1, ViewportType::INTERNAL);
3937     setDisplayInfoAndReconfigure(newDisplayId, DISPLAY_WIDTH, DISPLAY_HEIGHT, DISPLAY_ORIENTATION_0,
3938                                  SECONDARY_UNIQUE_ID, hdmi2, ViewportType::EXTERNAL);
3939     // Default device will reconfigure above, need additional reconfiguration for another device.
3940     device2->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(),
3941                        InputReaderConfiguration::CHANGE_DISPLAY_INFO);
3942 
3943     // Device should be enabled after the associated display is found.
3944     ASSERT_TRUE(mDevice->isEnabled());
3945     ASSERT_TRUE(device2->isEnabled());
3946 
3947     // Test pad key events
3948     ASSERT_NO_FATAL_FAILURE(
3949             testDPadKeyRotation(mapper, KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_UP, DISPLAY_ID));
3950     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, KEY_RIGHT, AKEYCODE_DPAD_RIGHT,
3951                                                 AKEYCODE_DPAD_RIGHT, DISPLAY_ID));
3952     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, KEY_DOWN, AKEYCODE_DPAD_DOWN,
3953                                                 AKEYCODE_DPAD_DOWN, DISPLAY_ID));
3954     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, KEY_LEFT, AKEYCODE_DPAD_LEFT,
3955                                                 AKEYCODE_DPAD_LEFT, DISPLAY_ID));
3956 
3957     ASSERT_NO_FATAL_FAILURE(
3958             testDPadKeyRotation(mapper2, KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_UP, newDisplayId));
3959     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper2, KEY_RIGHT, AKEYCODE_DPAD_RIGHT,
3960                                                 AKEYCODE_DPAD_RIGHT, newDisplayId));
3961     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper2, KEY_DOWN, AKEYCODE_DPAD_DOWN,
3962                                                 AKEYCODE_DPAD_DOWN, newDisplayId));
3963     ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper2, KEY_LEFT, AKEYCODE_DPAD_LEFT,
3964                                                 AKEYCODE_DPAD_LEFT, newDisplayId));
3965 }
3966 
TEST_F(KeyboardInputMapperTest,Process_LockedKeysShouldToggleAfterReattach)3967 TEST_F(KeyboardInputMapperTest, Process_LockedKeysShouldToggleAfterReattach) {
3968     mFakeEventHub->addLed(EVENTHUB_ID, LED_CAPSL, true /*initially on*/);
3969     mFakeEventHub->addLed(EVENTHUB_ID, LED_NUML, false /*initially off*/);
3970     mFakeEventHub->addLed(EVENTHUB_ID, LED_SCROLLL, false /*initially off*/);
3971     mFakeEventHub->addKey(EVENTHUB_ID, KEY_CAPSLOCK, 0, AKEYCODE_CAPS_LOCK, 0);
3972     mFakeEventHub->addKey(EVENTHUB_ID, KEY_NUMLOCK, 0, AKEYCODE_NUM_LOCK, 0);
3973     mFakeEventHub->addKey(EVENTHUB_ID, KEY_SCROLLLOCK, 0, AKEYCODE_SCROLL_LOCK, 0);
3974 
3975     KeyboardInputMapper& mapper =
3976             addMapperAndConfigure<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD,
3977                                                        AINPUT_KEYBOARD_TYPE_ALPHABETIC);
3978     // Initial metastate is AMETA_NONE.
3979     ASSERT_EQ(AMETA_NONE, mapper.getMetaState());
3980 
3981     // Initialization should have turned all of the lights off.
3982     ASSERT_FALSE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_CAPSL));
3983     ASSERT_FALSE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_NUML));
3984     ASSERT_FALSE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_SCROLLL));
3985 
3986     // Toggle caps lock on.
3987     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_CAPSLOCK, 1);
3988     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_CAPSLOCK, 0);
3989     ASSERT_TRUE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_CAPSL));
3990     ASSERT_EQ(AMETA_CAPS_LOCK_ON, mapper.getMetaState());
3991 
3992     // Toggle num lock on.
3993     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_NUMLOCK, 1);
3994     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_NUMLOCK, 0);
3995     ASSERT_TRUE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_NUML));
3996     ASSERT_EQ(AMETA_CAPS_LOCK_ON | AMETA_NUM_LOCK_ON, mapper.getMetaState());
3997 
3998     // Toggle scroll lock on.
3999     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_SCROLLLOCK, 1);
4000     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_SCROLLLOCK, 0);
4001     ASSERT_TRUE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_SCROLLL));
4002     ASSERT_EQ(AMETA_CAPS_LOCK_ON | AMETA_NUM_LOCK_ON | AMETA_SCROLL_LOCK_ON, mapper.getMetaState());
4003 
4004     mFakeEventHub->removeDevice(EVENTHUB_ID);
4005     mReader->loopOnce();
4006 
4007     // keyboard 2 should default toggle keys.
4008     const std::string USB2 = "USB2";
4009     const std::string DEVICE_NAME2 = "KEYBOARD2";
4010     constexpr int32_t SECOND_DEVICE_ID = DEVICE_ID + 1;
4011     constexpr int32_t SECOND_EVENTHUB_ID = EVENTHUB_ID + 1;
4012     std::shared_ptr<InputDevice> device2 =
4013             newDevice(SECOND_DEVICE_ID, DEVICE_NAME2, USB2, SECOND_EVENTHUB_ID,
4014                       ftl::Flags<InputDeviceClass>(0));
4015     mFakeEventHub->addLed(SECOND_EVENTHUB_ID, LED_CAPSL, true /*initially on*/);
4016     mFakeEventHub->addLed(SECOND_EVENTHUB_ID, LED_NUML, false /*initially off*/);
4017     mFakeEventHub->addLed(SECOND_EVENTHUB_ID, LED_SCROLLL, false /*initially off*/);
4018     mFakeEventHub->addKey(SECOND_EVENTHUB_ID, KEY_CAPSLOCK, 0, AKEYCODE_CAPS_LOCK, 0);
4019     mFakeEventHub->addKey(SECOND_EVENTHUB_ID, KEY_NUMLOCK, 0, AKEYCODE_NUM_LOCK, 0);
4020     mFakeEventHub->addKey(SECOND_EVENTHUB_ID, KEY_SCROLLLOCK, 0, AKEYCODE_SCROLL_LOCK, 0);
4021 
4022     KeyboardInputMapper& mapper2 =
4023             device2->addMapper<KeyboardInputMapper>(SECOND_EVENTHUB_ID, AINPUT_SOURCE_KEYBOARD,
4024                                                     AINPUT_KEYBOARD_TYPE_ALPHABETIC);
4025     device2->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), 0 /*changes*/);
4026     device2->reset(ARBITRARY_TIME);
4027 
4028     ASSERT_TRUE(mFakeEventHub->getLedState(SECOND_EVENTHUB_ID, LED_CAPSL));
4029     ASSERT_TRUE(mFakeEventHub->getLedState(SECOND_EVENTHUB_ID, LED_NUML));
4030     ASSERT_TRUE(mFakeEventHub->getLedState(SECOND_EVENTHUB_ID, LED_SCROLLL));
4031     ASSERT_EQ(AMETA_CAPS_LOCK_ON | AMETA_NUM_LOCK_ON | AMETA_SCROLL_LOCK_ON,
4032               mapper2.getMetaState());
4033 }
4034 
TEST_F(KeyboardInputMapperTest,Process_toggleCapsLockState)4035 TEST_F(KeyboardInputMapperTest, Process_toggleCapsLockState) {
4036     mFakeEventHub->addKey(EVENTHUB_ID, KEY_CAPSLOCK, 0, AKEYCODE_CAPS_LOCK, 0);
4037     mFakeEventHub->addKey(EVENTHUB_ID, KEY_NUMLOCK, 0, AKEYCODE_NUM_LOCK, 0);
4038     mFakeEventHub->addKey(EVENTHUB_ID, KEY_SCROLLLOCK, 0, AKEYCODE_SCROLL_LOCK, 0);
4039 
4040     // Suppose we have two mappers. (DPAD + KEYBOARD)
4041     addMapperAndConfigure<KeyboardInputMapper>(AINPUT_SOURCE_DPAD,
4042                                                AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC);
4043     KeyboardInputMapper& mapper =
4044             addMapperAndConfigure<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD,
4045                                                        AINPUT_KEYBOARD_TYPE_ALPHABETIC);
4046     // Initial metastate is AMETA_NONE.
4047     ASSERT_EQ(AMETA_NONE, mapper.getMetaState());
4048 
4049     mReader->toggleCapsLockState(DEVICE_ID);
4050     ASSERT_EQ(AMETA_CAPS_LOCK_ON, mapper.getMetaState());
4051 }
4052 
TEST_F(KeyboardInputMapperTest,Process_LockedKeysShouldToggleInMultiDevices)4053 TEST_F(KeyboardInputMapperTest, Process_LockedKeysShouldToggleInMultiDevices) {
4054     // keyboard 1.
4055     mFakeEventHub->addLed(EVENTHUB_ID, LED_CAPSL, true /*initially on*/);
4056     mFakeEventHub->addLed(EVENTHUB_ID, LED_NUML, false /*initially off*/);
4057     mFakeEventHub->addLed(EVENTHUB_ID, LED_SCROLLL, false /*initially off*/);
4058     mFakeEventHub->addKey(EVENTHUB_ID, KEY_CAPSLOCK, 0, AKEYCODE_CAPS_LOCK, 0);
4059     mFakeEventHub->addKey(EVENTHUB_ID, KEY_NUMLOCK, 0, AKEYCODE_NUM_LOCK, 0);
4060     mFakeEventHub->addKey(EVENTHUB_ID, KEY_SCROLLLOCK, 0, AKEYCODE_SCROLL_LOCK, 0);
4061 
4062     KeyboardInputMapper& mapper1 =
4063             addMapperAndConfigure<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD,
4064                                                        AINPUT_KEYBOARD_TYPE_ALPHABETIC);
4065 
4066     // keyboard 2.
4067     const std::string USB2 = "USB2";
4068     const std::string DEVICE_NAME2 = "KEYBOARD2";
4069     constexpr int32_t SECOND_DEVICE_ID = DEVICE_ID + 1;
4070     constexpr int32_t SECOND_EVENTHUB_ID = EVENTHUB_ID + 1;
4071     std::shared_ptr<InputDevice> device2 =
4072             newDevice(SECOND_DEVICE_ID, DEVICE_NAME2, USB2, SECOND_EVENTHUB_ID,
4073                       ftl::Flags<InputDeviceClass>(0));
4074     mFakeEventHub->addLed(SECOND_EVENTHUB_ID, LED_CAPSL, true /*initially on*/);
4075     mFakeEventHub->addLed(SECOND_EVENTHUB_ID, LED_NUML, false /*initially off*/);
4076     mFakeEventHub->addLed(SECOND_EVENTHUB_ID, LED_SCROLLL, false /*initially off*/);
4077     mFakeEventHub->addKey(SECOND_EVENTHUB_ID, KEY_CAPSLOCK, 0, AKEYCODE_CAPS_LOCK, 0);
4078     mFakeEventHub->addKey(SECOND_EVENTHUB_ID, KEY_NUMLOCK, 0, AKEYCODE_NUM_LOCK, 0);
4079     mFakeEventHub->addKey(SECOND_EVENTHUB_ID, KEY_SCROLLLOCK, 0, AKEYCODE_SCROLL_LOCK, 0);
4080 
4081     KeyboardInputMapper& mapper2 =
4082             device2->addMapper<KeyboardInputMapper>(SECOND_EVENTHUB_ID, AINPUT_SOURCE_KEYBOARD,
4083                                                     AINPUT_KEYBOARD_TYPE_ALPHABETIC);
4084     device2->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), 0 /*changes*/);
4085     device2->reset(ARBITRARY_TIME);
4086 
4087     // Initial metastate is AMETA_NONE.
4088     ASSERT_EQ(AMETA_NONE, mapper1.getMetaState());
4089     ASSERT_EQ(AMETA_NONE, mapper2.getMetaState());
4090 
4091     // Toggle num lock on and off.
4092     process(mapper1, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_NUMLOCK, 1);
4093     process(mapper1, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_NUMLOCK, 0);
4094     ASSERT_TRUE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_NUML));
4095     ASSERT_EQ(AMETA_NUM_LOCK_ON, mapper1.getMetaState());
4096     ASSERT_EQ(AMETA_NUM_LOCK_ON, mapper2.getMetaState());
4097 
4098     process(mapper1, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_NUMLOCK, 1);
4099     process(mapper1, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_NUMLOCK, 0);
4100     ASSERT_FALSE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_NUML));
4101     ASSERT_EQ(AMETA_NONE, mapper1.getMetaState());
4102     ASSERT_EQ(AMETA_NONE, mapper2.getMetaState());
4103 
4104     // Toggle caps lock on and off.
4105     process(mapper1, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_CAPSLOCK, 1);
4106     process(mapper1, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_CAPSLOCK, 0);
4107     ASSERT_TRUE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_CAPSL));
4108     ASSERT_EQ(AMETA_CAPS_LOCK_ON, mapper1.getMetaState());
4109     ASSERT_EQ(AMETA_CAPS_LOCK_ON, mapper2.getMetaState());
4110 
4111     process(mapper1, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_CAPSLOCK, 1);
4112     process(mapper1, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_CAPSLOCK, 0);
4113     ASSERT_FALSE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_CAPSL));
4114     ASSERT_EQ(AMETA_NONE, mapper1.getMetaState());
4115     ASSERT_EQ(AMETA_NONE, mapper2.getMetaState());
4116 
4117     // Toggle scroll lock on and off.
4118     process(mapper1, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_SCROLLLOCK, 1);
4119     process(mapper1, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_SCROLLLOCK, 0);
4120     ASSERT_TRUE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_SCROLLL));
4121     ASSERT_EQ(AMETA_SCROLL_LOCK_ON, mapper1.getMetaState());
4122     ASSERT_EQ(AMETA_SCROLL_LOCK_ON, mapper2.getMetaState());
4123 
4124     process(mapper1, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_SCROLLLOCK, 1);
4125     process(mapper1, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_SCROLLLOCK, 0);
4126     ASSERT_FALSE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_SCROLLL));
4127     ASSERT_EQ(AMETA_NONE, mapper1.getMetaState());
4128     ASSERT_EQ(AMETA_NONE, mapper2.getMetaState());
4129 }
4130 
4131 // --- KeyboardInputMapperTest_ExternalDevice ---
4132 
4133 class KeyboardInputMapperTest_ExternalDevice : public InputMapperTest {
4134 protected:
SetUp()4135     void SetUp() override { InputMapperTest::SetUp(DEVICE_CLASSES | InputDeviceClass::EXTERNAL); }
4136 };
4137 
TEST_F(KeyboardInputMapperTest_ExternalDevice,WakeBehavior)4138 TEST_F(KeyboardInputMapperTest_ExternalDevice, WakeBehavior) {
4139     // For external devices, non-media keys will trigger wake on key down. Media keys need to be
4140     // marked as WAKE in the keylayout file to trigger wake.
4141 
4142     mFakeEventHub->addKey(EVENTHUB_ID, KEY_HOME, 0, AKEYCODE_HOME, 0);
4143     mFakeEventHub->addKey(EVENTHUB_ID, KEY_PLAY, 0, AKEYCODE_MEDIA_PLAY, 0);
4144     mFakeEventHub->addKey(EVENTHUB_ID, KEY_PLAYPAUSE, 0, AKEYCODE_MEDIA_PLAY_PAUSE,
4145                           POLICY_FLAG_WAKE);
4146 
4147     KeyboardInputMapper& mapper =
4148             addMapperAndConfigure<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD,
4149                                                        AINPUT_KEYBOARD_TYPE_ALPHABETIC);
4150 
4151     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_HOME, 1);
4152     NotifyKeyArgs args;
4153     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
4154     ASSERT_EQ(POLICY_FLAG_WAKE, args.policyFlags);
4155 
4156     process(mapper, ARBITRARY_TIME + 1, READ_TIME, EV_KEY, KEY_HOME, 0);
4157     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
4158     ASSERT_EQ(uint32_t(0), args.policyFlags);
4159 
4160     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_PLAY, 1);
4161     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
4162     ASSERT_EQ(uint32_t(0), args.policyFlags);
4163 
4164     process(mapper, ARBITRARY_TIME + 1, READ_TIME, EV_KEY, KEY_PLAY, 0);
4165     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
4166     ASSERT_EQ(uint32_t(0), args.policyFlags);
4167 
4168     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_PLAYPAUSE, 1);
4169     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
4170     ASSERT_EQ(POLICY_FLAG_WAKE, args.policyFlags);
4171 
4172     process(mapper, ARBITRARY_TIME + 1, READ_TIME, EV_KEY, KEY_PLAYPAUSE, 0);
4173     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
4174     ASSERT_EQ(POLICY_FLAG_WAKE, args.policyFlags);
4175 }
4176 
TEST_F(KeyboardInputMapperTest_ExternalDevice,DoNotWakeByDefaultBehavior)4177 TEST_F(KeyboardInputMapperTest_ExternalDevice, DoNotWakeByDefaultBehavior) {
4178     // Tv Remote key's wake behavior is prescribed by the keylayout file.
4179 
4180     mFakeEventHub->addKey(EVENTHUB_ID, KEY_HOME, 0, AKEYCODE_HOME, POLICY_FLAG_WAKE);
4181     mFakeEventHub->addKey(EVENTHUB_ID, KEY_DOWN, 0, AKEYCODE_DPAD_DOWN, 0);
4182     mFakeEventHub->addKey(EVENTHUB_ID, KEY_PLAY, 0, AKEYCODE_MEDIA_PLAY, POLICY_FLAG_WAKE);
4183 
4184     addConfigurationProperty("keyboard.doNotWakeByDefault", "1");
4185     KeyboardInputMapper& mapper =
4186             addMapperAndConfigure<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD,
4187                                                        AINPUT_KEYBOARD_TYPE_ALPHABETIC);
4188 
4189     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_HOME, 1);
4190     NotifyKeyArgs args;
4191     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
4192     ASSERT_EQ(POLICY_FLAG_WAKE, args.policyFlags);
4193 
4194     process(mapper, ARBITRARY_TIME + 1, READ_TIME, EV_KEY, KEY_HOME, 0);
4195     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
4196     ASSERT_EQ(POLICY_FLAG_WAKE, args.policyFlags);
4197 
4198     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_DOWN, 1);
4199     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
4200     ASSERT_EQ(uint32_t(0), args.policyFlags);
4201 
4202     process(mapper, ARBITRARY_TIME + 1, READ_TIME, EV_KEY, KEY_DOWN, 0);
4203     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
4204     ASSERT_EQ(uint32_t(0), args.policyFlags);
4205 
4206     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_PLAY, 1);
4207     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
4208     ASSERT_EQ(POLICY_FLAG_WAKE, args.policyFlags);
4209 
4210     process(mapper, ARBITRARY_TIME + 1, READ_TIME, EV_KEY, KEY_PLAY, 0);
4211     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
4212     ASSERT_EQ(POLICY_FLAG_WAKE, args.policyFlags);
4213 }
4214 
4215 // --- CursorInputMapperTest ---
4216 
4217 class CursorInputMapperTest : public InputMapperTest {
4218 protected:
4219     static const int32_t TRACKBALL_MOVEMENT_THRESHOLD;
4220 
4221     std::shared_ptr<FakePointerController> mFakePointerController;
4222 
SetUp()4223     void SetUp() override {
4224         InputMapperTest::SetUp();
4225 
4226         mFakePointerController = std::make_shared<FakePointerController>();
4227         mFakePolicy->setPointerController(mFakePointerController);
4228     }
4229 
4230     void testMotionRotation(CursorInputMapper& mapper, int32_t originalX, int32_t originalY,
4231                             int32_t rotatedX, int32_t rotatedY);
4232 
prepareDisplay(int32_t orientation)4233     void prepareDisplay(int32_t orientation) {
4234         setDisplayInfoAndReconfigure(DISPLAY_ID, DISPLAY_WIDTH, DISPLAY_HEIGHT, orientation,
4235                                      DISPLAY_UNIQUE_ID, NO_PORT, ViewportType::INTERNAL);
4236     }
4237 
prepareSecondaryDisplay()4238     void prepareSecondaryDisplay() {
4239         setDisplayInfoAndReconfigure(SECONDARY_DISPLAY_ID, DISPLAY_WIDTH, DISPLAY_HEIGHT,
4240                                      DISPLAY_ORIENTATION_0, SECONDARY_DISPLAY_UNIQUE_ID, NO_PORT,
4241                                      ViewportType::EXTERNAL);
4242     }
4243 
assertCursorPointerCoords(const PointerCoords & coords,float x,float y,float pressure)4244     static void assertCursorPointerCoords(const PointerCoords& coords, float x, float y,
4245                                           float pressure) {
4246         ASSERT_NO_FATAL_FAILURE(assertPointerCoords(coords, x, y, pressure, 0.0f, 0.0f, 0.0f, 0.0f,
4247                                                     0.0f, 0.0f, 0.0f, EPSILON));
4248     }
4249 };
4250 
4251 const int32_t CursorInputMapperTest::TRACKBALL_MOVEMENT_THRESHOLD = 6;
4252 
testMotionRotation(CursorInputMapper & mapper,int32_t originalX,int32_t originalY,int32_t rotatedX,int32_t rotatedY)4253 void CursorInputMapperTest::testMotionRotation(CursorInputMapper& mapper, int32_t originalX,
4254                                                int32_t originalY, int32_t rotatedX,
4255                                                int32_t rotatedY) {
4256     NotifyMotionArgs args;
4257 
4258     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_X, originalX);
4259     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_Y, originalY);
4260     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
4261     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
4262     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
4263     ASSERT_NO_FATAL_FAILURE(
4264             assertCursorPointerCoords(args.pointerCoords[0],
4265                                       float(rotatedX) / TRACKBALL_MOVEMENT_THRESHOLD,
4266                                       float(rotatedY) / TRACKBALL_MOVEMENT_THRESHOLD, 0.0f));
4267 }
4268 
TEST_F(CursorInputMapperTest,WhenModeIsPointer_GetSources_ReturnsMouse)4269 TEST_F(CursorInputMapperTest, WhenModeIsPointer_GetSources_ReturnsMouse) {
4270     addConfigurationProperty("cursor.mode", "pointer");
4271     CursorInputMapper& mapper = addMapperAndConfigure<CursorInputMapper>();
4272 
4273     ASSERT_EQ(AINPUT_SOURCE_MOUSE, mapper.getSources());
4274 }
4275 
TEST_F(CursorInputMapperTest,WhenModeIsNavigation_GetSources_ReturnsTrackball)4276 TEST_F(CursorInputMapperTest, WhenModeIsNavigation_GetSources_ReturnsTrackball) {
4277     addConfigurationProperty("cursor.mode", "navigation");
4278     CursorInputMapper& mapper = addMapperAndConfigure<CursorInputMapper>();
4279 
4280     ASSERT_EQ(AINPUT_SOURCE_TRACKBALL, mapper.getSources());
4281 }
4282 
TEST_F(CursorInputMapperTest,WhenModeIsPointer_PopulateDeviceInfo_ReturnsRangeFromPointerController)4283 TEST_F(CursorInputMapperTest, WhenModeIsPointer_PopulateDeviceInfo_ReturnsRangeFromPointerController) {
4284     addConfigurationProperty("cursor.mode", "pointer");
4285     CursorInputMapper& mapper = addMapperAndConfigure<CursorInputMapper>();
4286 
4287     InputDeviceInfo info;
4288     mapper.populateDeviceInfo(&info);
4289 
4290     // Initially there may not be a valid motion range.
4291     ASSERT_EQ(nullptr, info.getMotionRange(AINPUT_MOTION_RANGE_X, AINPUT_SOURCE_MOUSE));
4292     ASSERT_EQ(nullptr, info.getMotionRange(AINPUT_MOTION_RANGE_Y, AINPUT_SOURCE_MOUSE));
4293     ASSERT_NO_FATAL_FAILURE(assertMotionRange(info,
4294             AINPUT_MOTION_RANGE_PRESSURE, AINPUT_SOURCE_MOUSE, 0.0f, 1.0f, 0.0f, 0.0f));
4295 
4296     // When the bounds are set, then there should be a valid motion range.
4297     mFakePointerController->setBounds(1, 2, 800 - 1, 480 - 1);
4298 
4299     InputDeviceInfo info2;
4300     mapper.populateDeviceInfo(&info2);
4301 
4302     ASSERT_NO_FATAL_FAILURE(assertMotionRange(info2,
4303             AINPUT_MOTION_RANGE_X, AINPUT_SOURCE_MOUSE,
4304             1, 800 - 1, 0.0f, 0.0f));
4305     ASSERT_NO_FATAL_FAILURE(assertMotionRange(info2,
4306             AINPUT_MOTION_RANGE_Y, AINPUT_SOURCE_MOUSE,
4307             2, 480 - 1, 0.0f, 0.0f));
4308     ASSERT_NO_FATAL_FAILURE(assertMotionRange(info2,
4309             AINPUT_MOTION_RANGE_PRESSURE, AINPUT_SOURCE_MOUSE,
4310             0.0f, 1.0f, 0.0f, 0.0f));
4311 }
4312 
TEST_F(CursorInputMapperTest,WhenModeIsNavigation_PopulateDeviceInfo_ReturnsScaledRange)4313 TEST_F(CursorInputMapperTest, WhenModeIsNavigation_PopulateDeviceInfo_ReturnsScaledRange) {
4314     addConfigurationProperty("cursor.mode", "navigation");
4315     CursorInputMapper& mapper = addMapperAndConfigure<CursorInputMapper>();
4316 
4317     InputDeviceInfo info;
4318     mapper.populateDeviceInfo(&info);
4319 
4320     ASSERT_NO_FATAL_FAILURE(assertMotionRange(info,
4321             AINPUT_MOTION_RANGE_X, AINPUT_SOURCE_TRACKBALL,
4322             -1.0f, 1.0f, 0.0f, 1.0f / TRACKBALL_MOVEMENT_THRESHOLD));
4323     ASSERT_NO_FATAL_FAILURE(assertMotionRange(info,
4324             AINPUT_MOTION_RANGE_Y, AINPUT_SOURCE_TRACKBALL,
4325             -1.0f, 1.0f, 0.0f, 1.0f / TRACKBALL_MOVEMENT_THRESHOLD));
4326     ASSERT_NO_FATAL_FAILURE(assertMotionRange(info,
4327             AINPUT_MOTION_RANGE_PRESSURE, AINPUT_SOURCE_TRACKBALL,
4328             0.0f, 1.0f, 0.0f, 0.0f));
4329 }
4330 
TEST_F(CursorInputMapperTest,Process_ShouldSetAllFieldsAndIncludeGlobalMetaState)4331 TEST_F(CursorInputMapperTest, Process_ShouldSetAllFieldsAndIncludeGlobalMetaState) {
4332     addConfigurationProperty("cursor.mode", "navigation");
4333     CursorInputMapper& mapper = addMapperAndConfigure<CursorInputMapper>();
4334 
4335     mReader->getContext()->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
4336 
4337     NotifyMotionArgs args;
4338 
4339     // Button press.
4340     // Mostly testing non x/y behavior here so we don't need to check again elsewhere.
4341     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, BTN_MOUSE, 1);
4342     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
4343     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
4344     ASSERT_EQ(ARBITRARY_TIME, args.eventTime);
4345     ASSERT_EQ(DEVICE_ID, args.deviceId);
4346     ASSERT_EQ(AINPUT_SOURCE_TRACKBALL, args.source);
4347     ASSERT_EQ(uint32_t(0), args.policyFlags);
4348     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action);
4349     ASSERT_EQ(0, args.flags);
4350     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
4351     ASSERT_EQ(AMOTION_EVENT_BUTTON_PRIMARY, args.buttonState);
4352     ASSERT_EQ(0, args.edgeFlags);
4353     ASSERT_EQ(uint32_t(1), args.pointerCount);
4354     ASSERT_EQ(0, args.pointerProperties[0].id);
4355     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_MOUSE, args.pointerProperties[0].toolType);
4356     ASSERT_NO_FATAL_FAILURE(assertCursorPointerCoords(args.pointerCoords[0], 0.0f, 0.0f, 1.0f));
4357     ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.xPrecision);
4358     ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.yPrecision);
4359     ASSERT_EQ(ARBITRARY_TIME, args.downTime);
4360 
4361     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
4362     ASSERT_EQ(ARBITRARY_TIME, args.eventTime);
4363     ASSERT_EQ(DEVICE_ID, args.deviceId);
4364     ASSERT_EQ(AINPUT_SOURCE_TRACKBALL, args.source);
4365     ASSERT_EQ(uint32_t(0), args.policyFlags);
4366     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, args.action);
4367     ASSERT_EQ(0, args.flags);
4368     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
4369     ASSERT_EQ(AMOTION_EVENT_BUTTON_PRIMARY, args.buttonState);
4370     ASSERT_EQ(0, args.edgeFlags);
4371     ASSERT_EQ(uint32_t(1), args.pointerCount);
4372     ASSERT_EQ(0, args.pointerProperties[0].id);
4373     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_MOUSE, args.pointerProperties[0].toolType);
4374     ASSERT_NO_FATAL_FAILURE(assertCursorPointerCoords(args.pointerCoords[0], 0.0f, 0.0f, 1.0f));
4375     ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.xPrecision);
4376     ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.yPrecision);
4377     ASSERT_EQ(ARBITRARY_TIME, args.downTime);
4378 
4379     // Button release.  Should have same down time.
4380     process(mapper, ARBITRARY_TIME + 1, READ_TIME, EV_KEY, BTN_MOUSE, 0);
4381     process(mapper, ARBITRARY_TIME + 1, READ_TIME, EV_SYN, SYN_REPORT, 0);
4382     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
4383     ASSERT_EQ(ARBITRARY_TIME + 1, args.eventTime);
4384     ASSERT_EQ(DEVICE_ID, args.deviceId);
4385     ASSERT_EQ(AINPUT_SOURCE_TRACKBALL, args.source);
4386     ASSERT_EQ(uint32_t(0), args.policyFlags);
4387     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, args.action);
4388     ASSERT_EQ(0, args.flags);
4389     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
4390     ASSERT_EQ(0, args.buttonState);
4391     ASSERT_EQ(0, args.edgeFlags);
4392     ASSERT_EQ(uint32_t(1), args.pointerCount);
4393     ASSERT_EQ(0, args.pointerProperties[0].id);
4394     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_MOUSE, args.pointerProperties[0].toolType);
4395     ASSERT_NO_FATAL_FAILURE(assertCursorPointerCoords(args.pointerCoords[0], 0.0f, 0.0f, 0.0f));
4396     ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.xPrecision);
4397     ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.yPrecision);
4398     ASSERT_EQ(ARBITRARY_TIME, args.downTime);
4399 
4400     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
4401     ASSERT_EQ(ARBITRARY_TIME + 1, args.eventTime);
4402     ASSERT_EQ(DEVICE_ID, args.deviceId);
4403     ASSERT_EQ(AINPUT_SOURCE_TRACKBALL, args.source);
4404     ASSERT_EQ(uint32_t(0), args.policyFlags);
4405     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, args.action);
4406     ASSERT_EQ(0, args.flags);
4407     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
4408     ASSERT_EQ(0, args.buttonState);
4409     ASSERT_EQ(0, args.edgeFlags);
4410     ASSERT_EQ(uint32_t(1), args.pointerCount);
4411     ASSERT_EQ(0, args.pointerProperties[0].id);
4412     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_MOUSE, args.pointerProperties[0].toolType);
4413     ASSERT_NO_FATAL_FAILURE(assertCursorPointerCoords(args.pointerCoords[0], 0.0f, 0.0f, 0.0f));
4414     ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.xPrecision);
4415     ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.yPrecision);
4416     ASSERT_EQ(ARBITRARY_TIME, args.downTime);
4417 }
4418 
TEST_F(CursorInputMapperTest,Process_ShouldHandleIndependentXYUpdates)4419 TEST_F(CursorInputMapperTest, Process_ShouldHandleIndependentXYUpdates) {
4420     addConfigurationProperty("cursor.mode", "navigation");
4421     CursorInputMapper& mapper = addMapperAndConfigure<CursorInputMapper>();
4422 
4423     NotifyMotionArgs args;
4424 
4425     // Motion in X but not Y.
4426     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_X, 1);
4427     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
4428     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
4429     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
4430     ASSERT_NO_FATAL_FAILURE(assertCursorPointerCoords(args.pointerCoords[0],
4431                                                       1.0f / TRACKBALL_MOVEMENT_THRESHOLD, 0.0f,
4432                                                       0.0f));
4433 
4434     // Motion in Y but not X.
4435     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_Y, -2);
4436     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
4437     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
4438     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
4439     ASSERT_NO_FATAL_FAILURE(assertCursorPointerCoords(args.pointerCoords[0], 0.0f,
4440                                                       -2.0f / TRACKBALL_MOVEMENT_THRESHOLD, 0.0f));
4441 }
4442 
TEST_F(CursorInputMapperTest,Process_ShouldHandleIndependentButtonUpdates)4443 TEST_F(CursorInputMapperTest, Process_ShouldHandleIndependentButtonUpdates) {
4444     addConfigurationProperty("cursor.mode", "navigation");
4445     CursorInputMapper& mapper = addMapperAndConfigure<CursorInputMapper>();
4446 
4447     NotifyMotionArgs args;
4448 
4449     // Button press.
4450     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, BTN_MOUSE, 1);
4451     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
4452     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
4453     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action);
4454     ASSERT_NO_FATAL_FAILURE(assertCursorPointerCoords(args.pointerCoords[0], 0.0f, 0.0f, 1.0f));
4455 
4456     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
4457     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, args.action);
4458     ASSERT_NO_FATAL_FAILURE(assertCursorPointerCoords(args.pointerCoords[0], 0.0f, 0.0f, 1.0f));
4459 
4460     // Button release.
4461     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, BTN_MOUSE, 0);
4462     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
4463     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
4464     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, args.action);
4465     ASSERT_NO_FATAL_FAILURE(assertCursorPointerCoords(args.pointerCoords[0], 0.0f, 0.0f, 0.0f));
4466 
4467     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
4468     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, args.action);
4469     ASSERT_NO_FATAL_FAILURE(assertCursorPointerCoords(args.pointerCoords[0], 0.0f, 0.0f, 0.0f));
4470 }
4471 
TEST_F(CursorInputMapperTest,Process_ShouldHandleCombinedXYAndButtonUpdates)4472 TEST_F(CursorInputMapperTest, Process_ShouldHandleCombinedXYAndButtonUpdates) {
4473     addConfigurationProperty("cursor.mode", "navigation");
4474     CursorInputMapper& mapper = addMapperAndConfigure<CursorInputMapper>();
4475 
4476     NotifyMotionArgs args;
4477 
4478     // Combined X, Y and Button.
4479     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_X, 1);
4480     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_Y, -2);
4481     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, BTN_MOUSE, 1);
4482     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
4483     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
4484     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action);
4485     ASSERT_NO_FATAL_FAILURE(assertCursorPointerCoords(args.pointerCoords[0],
4486                                                       1.0f / TRACKBALL_MOVEMENT_THRESHOLD,
4487                                                       -2.0f / TRACKBALL_MOVEMENT_THRESHOLD, 1.0f));
4488 
4489     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
4490     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, args.action);
4491     ASSERT_NO_FATAL_FAILURE(assertCursorPointerCoords(args.pointerCoords[0],
4492                                                       1.0f / TRACKBALL_MOVEMENT_THRESHOLD,
4493                                                       -2.0f / TRACKBALL_MOVEMENT_THRESHOLD, 1.0f));
4494 
4495     // Move X, Y a bit while pressed.
4496     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_X, 2);
4497     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_Y, 1);
4498     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
4499     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
4500     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
4501     ASSERT_NO_FATAL_FAILURE(assertCursorPointerCoords(args.pointerCoords[0],
4502                                                       2.0f / TRACKBALL_MOVEMENT_THRESHOLD,
4503                                                       1.0f / TRACKBALL_MOVEMENT_THRESHOLD, 1.0f));
4504 
4505     // Release Button.
4506     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, BTN_MOUSE, 0);
4507     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
4508     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
4509     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, args.action);
4510     ASSERT_NO_FATAL_FAILURE(assertCursorPointerCoords(args.pointerCoords[0], 0.0f, 0.0f, 0.0f));
4511 
4512     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
4513     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, args.action);
4514     ASSERT_NO_FATAL_FAILURE(assertCursorPointerCoords(args.pointerCoords[0], 0.0f, 0.0f, 0.0f));
4515 }
4516 
TEST_F(CursorInputMapperTest,Process_WhenOrientationAware_ShouldNotRotateMotions)4517 TEST_F(CursorInputMapperTest, Process_WhenOrientationAware_ShouldNotRotateMotions) {
4518     mFakePolicy->addInputUniqueIdAssociation(DEVICE_LOCATION, DISPLAY_UNIQUE_ID);
4519     addConfigurationProperty("cursor.mode", "navigation");
4520     // InputReader works in the un-rotated coordinate space, so orientation-aware devices do not
4521     // need to be rotated.
4522     addConfigurationProperty("cursor.orientationAware", "1");
4523     CursorInputMapper& mapper = addMapperAndConfigure<CursorInputMapper>();
4524 
4525     prepareDisplay(DISPLAY_ORIENTATION_90);
4526     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  0,  1,  0,  1));
4527     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1,  1,  1,  1));
4528     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1,  0,  1,  0));
4529     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1, -1,  1, -1));
4530     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  0, -1,  0, -1));
4531     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1, -1, -1));
4532     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1,  0, -1,  0));
4533     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1,  1, -1,  1));
4534 }
4535 
TEST_F(CursorInputMapperTest,Process_WhenNotOrientationAware_ShouldRotateMotions)4536 TEST_F(CursorInputMapperTest, Process_WhenNotOrientationAware_ShouldRotateMotions) {
4537     mFakePolicy->addInputUniqueIdAssociation(DEVICE_LOCATION, DISPLAY_UNIQUE_ID);
4538     addConfigurationProperty("cursor.mode", "navigation");
4539     // Since InputReader works in the un-rotated coordinate space, only devices that are not
4540     // orientation-aware are affected by display rotation.
4541     CursorInputMapper& mapper = addMapperAndConfigure<CursorInputMapper>();
4542 
4543     clearViewports();
4544     prepareDisplay(DISPLAY_ORIENTATION_0);
4545     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  0,  1,  0,  1));
4546     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1,  1,  1,  1));
4547     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1,  0,  1,  0));
4548     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1, -1,  1, -1));
4549     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  0, -1,  0, -1));
4550     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1, -1, -1));
4551     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1,  0, -1,  0));
4552     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1,  1, -1,  1));
4553 
4554     clearViewports();
4555     prepareDisplay(DISPLAY_ORIENTATION_90);
4556     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  0,  1, -1,  0));
4557     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1,  1, -1,  1));
4558     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1,  0,  0,  1));
4559     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1, -1,  1,  1));
4560     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  0, -1,  1,  0));
4561     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1,  1, -1));
4562     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1,  0,  0, -1));
4563     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1,  1, -1, -1));
4564 
4565     clearViewports();
4566     prepareDisplay(DISPLAY_ORIENTATION_180);
4567     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  0,  1,  0, -1));
4568     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1,  1, -1, -1));
4569     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1,  0, -1,  0));
4570     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1, -1, -1,  1));
4571     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  0, -1,  0,  1));
4572     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1,  1,  1));
4573     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1,  0,  1,  0));
4574     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1,  1,  1, -1));
4575 
4576     clearViewports();
4577     prepareDisplay(DISPLAY_ORIENTATION_270);
4578     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  0,  1,  1,  0));
4579     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1,  1,  1, -1));
4580     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1,  0,  0, -1));
4581     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  1, -1, -1, -1));
4582     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper,  0, -1, -1,  0));
4583     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1, -1,  1));
4584     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1,  0,  0,  1));
4585     ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1,  1,  1,  1));
4586 }
4587 
TEST_F(CursorInputMapperTest,Process_ShouldHandleAllButtons)4588 TEST_F(CursorInputMapperTest, Process_ShouldHandleAllButtons) {
4589     addConfigurationProperty("cursor.mode", "pointer");
4590     CursorInputMapper& mapper = addMapperAndConfigure<CursorInputMapper>();
4591 
4592     mFakePointerController->setBounds(0, 0, 800 - 1, 480 - 1);
4593     mFakePointerController->setPosition(100, 200);
4594     mFakePointerController->setButtonState(0);
4595 
4596     NotifyMotionArgs motionArgs;
4597     NotifyKeyArgs keyArgs;
4598 
4599     // press BTN_LEFT, release BTN_LEFT
4600     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, BTN_LEFT, 1);
4601     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
4602     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
4603     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
4604     ASSERT_EQ(AMOTION_EVENT_BUTTON_PRIMARY, motionArgs.buttonState);
4605     ASSERT_EQ(AMOTION_EVENT_BUTTON_PRIMARY, mFakePointerController->getButtonState());
4606     ASSERT_NO_FATAL_FAILURE(
4607             assertCursorPointerCoords(motionArgs.pointerCoords[0], 100.0f, 200.0f, 1.0f));
4608 
4609     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
4610     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, motionArgs.action);
4611     ASSERT_EQ(AMOTION_EVENT_BUTTON_PRIMARY, motionArgs.buttonState);
4612     ASSERT_EQ(AMOTION_EVENT_BUTTON_PRIMARY, mFakePointerController->getButtonState());
4613     ASSERT_NO_FATAL_FAILURE(
4614             assertCursorPointerCoords(motionArgs.pointerCoords[0], 100.0f, 200.0f, 1.0f));
4615 
4616     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, BTN_LEFT, 0);
4617     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
4618     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
4619     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, motionArgs.action);
4620     ASSERT_EQ(0, motionArgs.buttonState);
4621     ASSERT_EQ(0, mFakePointerController->getButtonState());
4622     ASSERT_NO_FATAL_FAILURE(
4623             assertCursorPointerCoords(motionArgs.pointerCoords[0], 100.0f, 200.0f, 0.0f));
4624 
4625     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
4626     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
4627     ASSERT_EQ(0, motionArgs.buttonState);
4628     ASSERT_EQ(0, mFakePointerController->getButtonState());
4629     ASSERT_NO_FATAL_FAILURE(
4630             assertCursorPointerCoords(motionArgs.pointerCoords[0], 100.0f, 200.0f, 0.0f));
4631 
4632     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
4633     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action);
4634     ASSERT_EQ(0, motionArgs.buttonState);
4635     ASSERT_EQ(0, mFakePointerController->getButtonState());
4636     ASSERT_NO_FATAL_FAILURE(
4637             assertCursorPointerCoords(motionArgs.pointerCoords[0], 100.0f, 200.0f, 0.0f));
4638 
4639     // press BTN_RIGHT + BTN_MIDDLE, release BTN_RIGHT, release BTN_MIDDLE
4640     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, BTN_RIGHT, 1);
4641     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, BTN_MIDDLE, 1);
4642     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
4643     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
4644     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
4645     ASSERT_EQ(AMOTION_EVENT_BUTTON_SECONDARY | AMOTION_EVENT_BUTTON_TERTIARY,
4646             motionArgs.buttonState);
4647     ASSERT_EQ(AMOTION_EVENT_BUTTON_SECONDARY | AMOTION_EVENT_BUTTON_TERTIARY,
4648             mFakePointerController->getButtonState());
4649     ASSERT_NO_FATAL_FAILURE(
4650             assertCursorPointerCoords(motionArgs.pointerCoords[0], 100.0f, 200.0f, 1.0f));
4651 
4652     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
4653     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, motionArgs.action);
4654     ASSERT_EQ(AMOTION_EVENT_BUTTON_TERTIARY, motionArgs.buttonState);
4655     ASSERT_EQ(AMOTION_EVENT_BUTTON_SECONDARY | AMOTION_EVENT_BUTTON_TERTIARY,
4656             mFakePointerController->getButtonState());
4657     ASSERT_NO_FATAL_FAILURE(
4658             assertCursorPointerCoords(motionArgs.pointerCoords[0], 100.0f, 200.0f, 1.0f));
4659 
4660     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
4661     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, motionArgs.action);
4662     ASSERT_EQ(AMOTION_EVENT_BUTTON_SECONDARY | AMOTION_EVENT_BUTTON_TERTIARY,
4663             motionArgs.buttonState);
4664     ASSERT_EQ(AMOTION_EVENT_BUTTON_SECONDARY | AMOTION_EVENT_BUTTON_TERTIARY,
4665             mFakePointerController->getButtonState());
4666     ASSERT_NO_FATAL_FAILURE(
4667             assertCursorPointerCoords(motionArgs.pointerCoords[0], 100.0f, 200.0f, 1.0f));
4668 
4669     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, BTN_RIGHT, 0);
4670     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
4671     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
4672     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, motionArgs.action);
4673     ASSERT_EQ(AMOTION_EVENT_BUTTON_TERTIARY, motionArgs.buttonState);
4674     ASSERT_EQ(AMOTION_EVENT_BUTTON_TERTIARY, mFakePointerController->getButtonState());
4675     ASSERT_NO_FATAL_FAILURE(
4676             assertCursorPointerCoords(motionArgs.pointerCoords[0], 100.0f, 200.0f, 1.0f));
4677 
4678     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
4679     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
4680     ASSERT_EQ(AMOTION_EVENT_BUTTON_TERTIARY, motionArgs.buttonState);
4681     ASSERT_EQ(AMOTION_EVENT_BUTTON_TERTIARY, mFakePointerController->getButtonState());
4682     ASSERT_NO_FATAL_FAILURE(
4683             assertCursorPointerCoords(motionArgs.pointerCoords[0], 100.0f, 200.0f, 1.0f));
4684 
4685     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, BTN_MIDDLE, 0);
4686     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
4687     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
4688     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, motionArgs.action);
4689     ASSERT_EQ(0, motionArgs.buttonState);
4690     ASSERT_EQ(0, mFakePointerController->getButtonState());
4691     ASSERT_NO_FATAL_FAILURE(
4692             assertCursorPointerCoords(motionArgs.pointerCoords[0], 100.0f, 200.0f, 0.0f));
4693     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, BTN_MIDDLE, 0);
4694     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
4695 
4696     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
4697     ASSERT_EQ(0, motionArgs.buttonState);
4698     ASSERT_EQ(0, mFakePointerController->getButtonState());
4699     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
4700     ASSERT_NO_FATAL_FAILURE(
4701             assertCursorPointerCoords(motionArgs.pointerCoords[0], 100.0f, 200.0f, 0.0f));
4702 
4703     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
4704     ASSERT_EQ(0, motionArgs.buttonState);
4705     ASSERT_EQ(0, mFakePointerController->getButtonState());
4706     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action);
4707     ASSERT_NO_FATAL_FAILURE(
4708             assertCursorPointerCoords(motionArgs.pointerCoords[0], 100.0f, 200.0f, 0.0f));
4709 
4710     // press BTN_BACK, release BTN_BACK
4711     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, BTN_BACK, 1);
4712     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
4713     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs));
4714     ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action);
4715     ASSERT_EQ(AKEYCODE_BACK, keyArgs.keyCode);
4716 
4717     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
4718     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action);
4719     ASSERT_EQ(AMOTION_EVENT_BUTTON_BACK, motionArgs.buttonState);
4720     ASSERT_EQ(AMOTION_EVENT_BUTTON_BACK, mFakePointerController->getButtonState());
4721     ASSERT_NO_FATAL_FAILURE(
4722             assertCursorPointerCoords(motionArgs.pointerCoords[0], 100.0f, 200.0f, 0.0f));
4723 
4724     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
4725     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, motionArgs.action);
4726     ASSERT_EQ(AMOTION_EVENT_BUTTON_BACK, motionArgs.buttonState);
4727     ASSERT_EQ(AMOTION_EVENT_BUTTON_BACK, mFakePointerController->getButtonState());
4728     ASSERT_NO_FATAL_FAILURE(
4729             assertCursorPointerCoords(motionArgs.pointerCoords[0], 100.0f, 200.0f, 0.0f));
4730 
4731     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, BTN_BACK, 0);
4732     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
4733     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
4734     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, motionArgs.action);
4735     ASSERT_EQ(0, motionArgs.buttonState);
4736     ASSERT_EQ(0, mFakePointerController->getButtonState());
4737     ASSERT_NO_FATAL_FAILURE(
4738             assertCursorPointerCoords(motionArgs.pointerCoords[0], 100.0f, 200.0f, 0.0f));
4739 
4740     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
4741     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action);
4742     ASSERT_EQ(0, motionArgs.buttonState);
4743     ASSERT_EQ(0, mFakePointerController->getButtonState());
4744 
4745     ASSERT_NO_FATAL_FAILURE(
4746             assertCursorPointerCoords(motionArgs.pointerCoords[0], 100.0f, 200.0f, 0.0f));
4747     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs));
4748     ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action);
4749     ASSERT_EQ(AKEYCODE_BACK, keyArgs.keyCode);
4750 
4751     // press BTN_SIDE, release BTN_SIDE
4752     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, BTN_SIDE, 1);
4753     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
4754     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs));
4755     ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action);
4756     ASSERT_EQ(AKEYCODE_BACK, keyArgs.keyCode);
4757 
4758     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
4759     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action);
4760     ASSERT_EQ(AMOTION_EVENT_BUTTON_BACK, motionArgs.buttonState);
4761     ASSERT_EQ(AMOTION_EVENT_BUTTON_BACK, mFakePointerController->getButtonState());
4762     ASSERT_NO_FATAL_FAILURE(
4763             assertCursorPointerCoords(motionArgs.pointerCoords[0], 100.0f, 200.0f, 0.0f));
4764 
4765     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
4766     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, motionArgs.action);
4767     ASSERT_EQ(AMOTION_EVENT_BUTTON_BACK, motionArgs.buttonState);
4768     ASSERT_EQ(AMOTION_EVENT_BUTTON_BACK, mFakePointerController->getButtonState());
4769     ASSERT_NO_FATAL_FAILURE(
4770             assertCursorPointerCoords(motionArgs.pointerCoords[0], 100.0f, 200.0f, 0.0f));
4771 
4772     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, BTN_SIDE, 0);
4773     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
4774     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
4775     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, motionArgs.action);
4776     ASSERT_EQ(0, motionArgs.buttonState);
4777     ASSERT_EQ(0, mFakePointerController->getButtonState());
4778     ASSERT_NO_FATAL_FAILURE(
4779             assertCursorPointerCoords(motionArgs.pointerCoords[0], 100.0f, 200.0f, 0.0f));
4780 
4781     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
4782     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action);
4783     ASSERT_EQ(0, motionArgs.buttonState);
4784     ASSERT_EQ(0, mFakePointerController->getButtonState());
4785     ASSERT_NO_FATAL_FAILURE(
4786             assertCursorPointerCoords(motionArgs.pointerCoords[0], 100.0f, 200.0f, 0.0f));
4787 
4788     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs));
4789     ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action);
4790     ASSERT_EQ(AKEYCODE_BACK, keyArgs.keyCode);
4791 
4792     // press BTN_FORWARD, release BTN_FORWARD
4793     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, BTN_FORWARD, 1);
4794     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
4795     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs));
4796     ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action);
4797     ASSERT_EQ(AKEYCODE_FORWARD, keyArgs.keyCode);
4798 
4799     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
4800     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action);
4801     ASSERT_EQ(AMOTION_EVENT_BUTTON_FORWARD, motionArgs.buttonState);
4802     ASSERT_EQ(AMOTION_EVENT_BUTTON_FORWARD, mFakePointerController->getButtonState());
4803     ASSERT_NO_FATAL_FAILURE(
4804             assertCursorPointerCoords(motionArgs.pointerCoords[0], 100.0f, 200.0f, 0.0f));
4805 
4806     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
4807     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, motionArgs.action);
4808     ASSERT_EQ(AMOTION_EVENT_BUTTON_FORWARD, motionArgs.buttonState);
4809     ASSERT_EQ(AMOTION_EVENT_BUTTON_FORWARD, mFakePointerController->getButtonState());
4810     ASSERT_NO_FATAL_FAILURE(
4811             assertCursorPointerCoords(motionArgs.pointerCoords[0], 100.0f, 200.0f, 0.0f));
4812 
4813     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, BTN_FORWARD, 0);
4814     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
4815     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
4816     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, motionArgs.action);
4817     ASSERT_EQ(0, motionArgs.buttonState);
4818     ASSERT_EQ(0, mFakePointerController->getButtonState());
4819     ASSERT_NO_FATAL_FAILURE(
4820             assertCursorPointerCoords(motionArgs.pointerCoords[0], 100.0f, 200.0f, 0.0f));
4821 
4822     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
4823     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action);
4824     ASSERT_EQ(0, motionArgs.buttonState);
4825     ASSERT_EQ(0, mFakePointerController->getButtonState());
4826     ASSERT_NO_FATAL_FAILURE(
4827             assertCursorPointerCoords(motionArgs.pointerCoords[0], 100.0f, 200.0f, 0.0f));
4828 
4829     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs));
4830     ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action);
4831     ASSERT_EQ(AKEYCODE_FORWARD, keyArgs.keyCode);
4832 
4833     // press BTN_EXTRA, release BTN_EXTRA
4834     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, BTN_EXTRA, 1);
4835     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
4836     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs));
4837     ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action);
4838     ASSERT_EQ(AKEYCODE_FORWARD, keyArgs.keyCode);
4839 
4840     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
4841     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action);
4842     ASSERT_EQ(AMOTION_EVENT_BUTTON_FORWARD, motionArgs.buttonState);
4843     ASSERT_EQ(AMOTION_EVENT_BUTTON_FORWARD, mFakePointerController->getButtonState());
4844     ASSERT_NO_FATAL_FAILURE(
4845             assertCursorPointerCoords(motionArgs.pointerCoords[0], 100.0f, 200.0f, 0.0f));
4846 
4847     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
4848     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, motionArgs.action);
4849     ASSERT_EQ(AMOTION_EVENT_BUTTON_FORWARD, motionArgs.buttonState);
4850     ASSERT_EQ(AMOTION_EVENT_BUTTON_FORWARD, mFakePointerController->getButtonState());
4851     ASSERT_NO_FATAL_FAILURE(
4852             assertCursorPointerCoords(motionArgs.pointerCoords[0], 100.0f, 200.0f, 0.0f));
4853 
4854     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, BTN_EXTRA, 0);
4855     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
4856     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
4857     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, motionArgs.action);
4858     ASSERT_EQ(0, motionArgs.buttonState);
4859     ASSERT_EQ(0, mFakePointerController->getButtonState());
4860     ASSERT_NO_FATAL_FAILURE(
4861             assertCursorPointerCoords(motionArgs.pointerCoords[0], 100.0f, 200.0f, 0.0f));
4862 
4863     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
4864     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action);
4865     ASSERT_EQ(0, motionArgs.buttonState);
4866     ASSERT_EQ(0, mFakePointerController->getButtonState());
4867     ASSERT_NO_FATAL_FAILURE(
4868             assertCursorPointerCoords(motionArgs.pointerCoords[0], 100.0f, 200.0f, 0.0f));
4869 
4870     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs));
4871     ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action);
4872     ASSERT_EQ(AKEYCODE_FORWARD, keyArgs.keyCode);
4873 }
4874 
TEST_F(CursorInputMapperTest,Process_WhenModeIsPointer_ShouldMoveThePointerAround)4875 TEST_F(CursorInputMapperTest, Process_WhenModeIsPointer_ShouldMoveThePointerAround) {
4876     addConfigurationProperty("cursor.mode", "pointer");
4877     CursorInputMapper& mapper = addMapperAndConfigure<CursorInputMapper>();
4878 
4879     mFakePointerController->setBounds(0, 0, 800 - 1, 480 - 1);
4880     mFakePointerController->setPosition(100, 200);
4881     mFakePointerController->setButtonState(0);
4882 
4883     NotifyMotionArgs args;
4884 
4885     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_X, 10);
4886     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_Y, 20);
4887     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
4888     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
4889     ASSERT_EQ(AINPUT_SOURCE_MOUSE, args.source);
4890     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, args.action);
4891     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
4892             110.0f, 220.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
4893     ASSERT_NO_FATAL_FAILURE(assertPosition(*mFakePointerController, 110.0f, 220.0f));
4894 }
4895 
TEST_F(CursorInputMapperTest,Process_PointerCapture)4896 TEST_F(CursorInputMapperTest, Process_PointerCapture) {
4897     addConfigurationProperty("cursor.mode", "pointer");
4898     mFakePolicy->setPointerCapture(true);
4899     CursorInputMapper& mapper = addMapperAndConfigure<CursorInputMapper>();
4900 
4901     NotifyDeviceResetArgs resetArgs;
4902     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled(&resetArgs));
4903     ASSERT_EQ(ARBITRARY_TIME, resetArgs.eventTime);
4904     ASSERT_EQ(DEVICE_ID, resetArgs.deviceId);
4905 
4906     mFakePointerController->setBounds(0, 0, 800 - 1, 480 - 1);
4907     mFakePointerController->setPosition(100, 200);
4908     mFakePointerController->setButtonState(0);
4909 
4910     NotifyMotionArgs args;
4911 
4912     // Move.
4913     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_X, 10);
4914     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_Y, 20);
4915     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
4916     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
4917     ASSERT_EQ(AINPUT_SOURCE_MOUSE_RELATIVE, args.source);
4918     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
4919     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
4920             10.0f, 20.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
4921     ASSERT_NO_FATAL_FAILURE(assertPosition(*mFakePointerController, 100.0f, 200.0f));
4922 
4923     // Button press.
4924     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, BTN_MOUSE, 1);
4925     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
4926     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
4927     ASSERT_EQ(AINPUT_SOURCE_MOUSE_RELATIVE, args.source);
4928     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action);
4929     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
4930             0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
4931     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
4932     ASSERT_EQ(AINPUT_SOURCE_MOUSE_RELATIVE, args.source);
4933     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, args.action);
4934     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
4935             0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
4936 
4937     // Button release.
4938     process(mapper, ARBITRARY_TIME + 2, READ_TIME, EV_KEY, BTN_MOUSE, 0);
4939     process(mapper, ARBITRARY_TIME + 2, READ_TIME, EV_SYN, SYN_REPORT, 0);
4940     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
4941     ASSERT_EQ(AINPUT_SOURCE_MOUSE_RELATIVE, args.source);
4942     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, args.action);
4943     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
4944             0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
4945     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
4946     ASSERT_EQ(AINPUT_SOURCE_MOUSE_RELATIVE, args.source);
4947     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, args.action);
4948     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
4949             0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
4950 
4951     // Another move.
4952     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_X, 30);
4953     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_Y, 40);
4954     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
4955     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
4956     ASSERT_EQ(AINPUT_SOURCE_MOUSE_RELATIVE, args.source);
4957     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
4958     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
4959             30.0f, 40.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
4960     ASSERT_NO_FATAL_FAILURE(assertPosition(*mFakePointerController, 100.0f, 200.0f));
4961 
4962     // Disable pointer capture and check that the device generation got bumped
4963     // and events are generated the usual way.
4964     const uint32_t generation = mReader->getContext()->getGeneration();
4965     mFakePolicy->setPointerCapture(false);
4966     configureDevice(InputReaderConfiguration::CHANGE_POINTER_CAPTURE);
4967     ASSERT_TRUE(mReader->getContext()->getGeneration() != generation);
4968 
4969     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled(&resetArgs));
4970     ASSERT_EQ(DEVICE_ID, resetArgs.deviceId);
4971 
4972     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_X, 10);
4973     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_Y, 20);
4974     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
4975     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
4976     ASSERT_EQ(AINPUT_SOURCE_MOUSE, args.source);
4977     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, args.action);
4978     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
4979             110.0f, 220.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
4980     ASSERT_NO_FATAL_FAILURE(assertPosition(*mFakePointerController, 110.0f, 220.0f));
4981 }
4982 
4983 /**
4984  * When Pointer Capture is enabled, we expect to report unprocessed relative movements, so any
4985  * pointer acceleration or speed processing should not be applied.
4986  */
TEST_F(CursorInputMapperTest,PointerCaptureDisablesVelocityProcessing)4987 TEST_F(CursorInputMapperTest, PointerCaptureDisablesVelocityProcessing) {
4988     addConfigurationProperty("cursor.mode", "pointer");
4989     const VelocityControlParameters testParams(5.f /*scale*/, 0.f /*low threshold*/,
4990                                                100.f /*high threshold*/, 10.f /*acceleration*/);
4991     mFakePolicy->setVelocityControlParams(testParams);
4992     CursorInputMapper& mapper = addMapperAndConfigure<CursorInputMapper>();
4993 
4994     NotifyDeviceResetArgs resetArgs;
4995     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled(&resetArgs));
4996     ASSERT_EQ(ARBITRARY_TIME, resetArgs.eventTime);
4997     ASSERT_EQ(DEVICE_ID, resetArgs.deviceId);
4998 
4999     NotifyMotionArgs args;
5000 
5001     // Move and verify scale is applied.
5002     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_X, 10);
5003     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_Y, 20);
5004     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
5005     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
5006     ASSERT_EQ(AINPUT_SOURCE_MOUSE, args.source);
5007     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, args.action);
5008     const float relX = args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X);
5009     const float relY = args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y);
5010     ASSERT_GT(relX, 10);
5011     ASSERT_GT(relY, 20);
5012 
5013     // Enable Pointer Capture
5014     mFakePolicy->setPointerCapture(true);
5015     configureDevice(InputReaderConfiguration::CHANGE_POINTER_CAPTURE);
5016     NotifyPointerCaptureChangedArgs captureArgs;
5017     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyCaptureWasCalled(&captureArgs));
5018     ASSERT_TRUE(captureArgs.request.enable);
5019 
5020     // Move and verify scale is not applied.
5021     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_X, 10);
5022     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_Y, 20);
5023     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
5024     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
5025     ASSERT_EQ(AINPUT_SOURCE_MOUSE_RELATIVE, args.source);
5026     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
5027     ASSERT_EQ(10, args.pointerCoords[0].getX());
5028     ASSERT_EQ(20, args.pointerCoords[0].getY());
5029 }
5030 
TEST_F(CursorInputMapperTest,PointerCaptureDisablesOrientationChanges)5031 TEST_F(CursorInputMapperTest, PointerCaptureDisablesOrientationChanges) {
5032     addConfigurationProperty("cursor.mode", "pointer");
5033     CursorInputMapper& mapper = addMapperAndConfigure<CursorInputMapper>();
5034 
5035     NotifyDeviceResetArgs resetArgs;
5036     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled(&resetArgs));
5037     ASSERT_EQ(ARBITRARY_TIME, resetArgs.eventTime);
5038     ASSERT_EQ(DEVICE_ID, resetArgs.deviceId);
5039 
5040     // Ensure the display is rotated.
5041     prepareDisplay(DISPLAY_ORIENTATION_90);
5042 
5043     NotifyMotionArgs args;
5044 
5045     // Verify that the coordinates are rotated.
5046     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_X, 10);
5047     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_Y, 20);
5048     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
5049     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
5050     ASSERT_EQ(AINPUT_SOURCE_MOUSE, args.source);
5051     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, args.action);
5052     ASSERT_EQ(-20, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X));
5053     ASSERT_EQ(10, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y));
5054 
5055     // Enable Pointer Capture.
5056     mFakePolicy->setPointerCapture(true);
5057     configureDevice(InputReaderConfiguration::CHANGE_POINTER_CAPTURE);
5058     NotifyPointerCaptureChangedArgs captureArgs;
5059     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyCaptureWasCalled(&captureArgs));
5060     ASSERT_TRUE(captureArgs.request.enable);
5061 
5062     // Move and verify rotation is not applied.
5063     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_X, 10);
5064     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_Y, 20);
5065     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
5066     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
5067     ASSERT_EQ(AINPUT_SOURCE_MOUSE_RELATIVE, args.source);
5068     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
5069     ASSERT_EQ(10, args.pointerCoords[0].getX());
5070     ASSERT_EQ(20, args.pointerCoords[0].getY());
5071 }
5072 
TEST_F(CursorInputMapperTest,ConfigureDisplayId_NoAssociatedViewport)5073 TEST_F(CursorInputMapperTest, ConfigureDisplayId_NoAssociatedViewport) {
5074     CursorInputMapper& mapper = addMapperAndConfigure<CursorInputMapper>();
5075 
5076     // Set up the default display.
5077     prepareDisplay(DISPLAY_ORIENTATION_90);
5078 
5079     // Set up the secondary display as the display on which the pointer should be shown.
5080     // The InputDevice is not associated with any display.
5081     prepareSecondaryDisplay();
5082     mFakePolicy->setDefaultPointerDisplayId(SECONDARY_DISPLAY_ID);
5083     configureDevice(InputReaderConfiguration::CHANGE_DISPLAY_INFO);
5084 
5085     mFakePointerController->setBounds(0, 0, DISPLAY_WIDTH - 1, DISPLAY_HEIGHT - 1);
5086     mFakePointerController->setPosition(100, 200);
5087     mFakePointerController->setButtonState(0);
5088 
5089     // Ensure input events are generated for the secondary display.
5090     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_X, 10);
5091     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_Y, 20);
5092     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
5093     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(
5094             AllOf(WithAction(AMOTION_EVENT_ACTION_HOVER_MOVE), WithSource(AINPUT_SOURCE_MOUSE),
5095                   WithDisplayId(SECONDARY_DISPLAY_ID), WithCoords(110.0f, 220.0f))));
5096     ASSERT_NO_FATAL_FAILURE(assertPosition(*mFakePointerController, 110.0f, 220.0f));
5097 }
5098 
TEST_F(CursorInputMapperTest,ConfigureDisplayId_WithAssociatedViewport)5099 TEST_F(CursorInputMapperTest, ConfigureDisplayId_WithAssociatedViewport) {
5100     CursorInputMapper& mapper = addMapperAndConfigure<CursorInputMapper>();
5101 
5102     // Set up the default display.
5103     prepareDisplay(DISPLAY_ORIENTATION_90);
5104 
5105     // Set up the secondary display as the display on which the pointer should be shown,
5106     // and associate the InputDevice with the secondary display.
5107     prepareSecondaryDisplay();
5108     mFakePolicy->setDefaultPointerDisplayId(SECONDARY_DISPLAY_ID);
5109     mFakePolicy->addInputUniqueIdAssociation(DEVICE_LOCATION, SECONDARY_DISPLAY_UNIQUE_ID);
5110     configureDevice(InputReaderConfiguration::CHANGE_DISPLAY_INFO);
5111 
5112     mFakePointerController->setBounds(0, 0, DISPLAY_WIDTH - 1, DISPLAY_HEIGHT - 1);
5113     mFakePointerController->setPosition(100, 200);
5114     mFakePointerController->setButtonState(0);
5115 
5116     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_X, 10);
5117     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_Y, 20);
5118     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
5119     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(
5120             AllOf(WithAction(AMOTION_EVENT_ACTION_HOVER_MOVE), WithSource(AINPUT_SOURCE_MOUSE),
5121                   WithDisplayId(SECONDARY_DISPLAY_ID), WithCoords(110.0f, 220.0f))));
5122     ASSERT_NO_FATAL_FAILURE(assertPosition(*mFakePointerController, 110.0f, 220.0f));
5123 }
5124 
TEST_F(CursorInputMapperTest,ConfigureDisplayId_IgnoresEventsForMismatchedPointerDisplay)5125 TEST_F(CursorInputMapperTest, ConfigureDisplayId_IgnoresEventsForMismatchedPointerDisplay) {
5126     CursorInputMapper& mapper = addMapperAndConfigure<CursorInputMapper>();
5127 
5128     // Set up the default display as the display on which the pointer should be shown.
5129     prepareDisplay(DISPLAY_ORIENTATION_90);
5130     mFakePolicy->setDefaultPointerDisplayId(DISPLAY_ID);
5131 
5132     // Associate the InputDevice with the secondary display.
5133     prepareSecondaryDisplay();
5134     mFakePolicy->addInputUniqueIdAssociation(DEVICE_LOCATION, SECONDARY_DISPLAY_UNIQUE_ID);
5135     configureDevice(InputReaderConfiguration::CHANGE_DISPLAY_INFO);
5136 
5137     // The mapper should not generate any events because it is associated with a display that is
5138     // different from the pointer display.
5139     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_X, 10);
5140     process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_Y, 20);
5141     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
5142     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());
5143 }
5144 
5145 // --- TouchInputMapperTest ---
5146 
5147 class TouchInputMapperTest : public InputMapperTest {
5148 protected:
5149     static const int32_t RAW_X_MIN;
5150     static const int32_t RAW_X_MAX;
5151     static const int32_t RAW_Y_MIN;
5152     static const int32_t RAW_Y_MAX;
5153     static const int32_t RAW_TOUCH_MIN;
5154     static const int32_t RAW_TOUCH_MAX;
5155     static const int32_t RAW_TOOL_MIN;
5156     static const int32_t RAW_TOOL_MAX;
5157     static const int32_t RAW_PRESSURE_MIN;
5158     static const int32_t RAW_PRESSURE_MAX;
5159     static const int32_t RAW_ORIENTATION_MIN;
5160     static const int32_t RAW_ORIENTATION_MAX;
5161     static const int32_t RAW_DISTANCE_MIN;
5162     static const int32_t RAW_DISTANCE_MAX;
5163     static const int32_t RAW_TILT_MIN;
5164     static const int32_t RAW_TILT_MAX;
5165     static const int32_t RAW_ID_MIN;
5166     static const int32_t RAW_ID_MAX;
5167     static const int32_t RAW_SLOT_MIN;
5168     static const int32_t RAW_SLOT_MAX;
5169     static const float X_PRECISION;
5170     static const float Y_PRECISION;
5171     static const float X_PRECISION_VIRTUAL;
5172     static const float Y_PRECISION_VIRTUAL;
5173 
5174     static const float GEOMETRIC_SCALE;
5175     static const TouchAffineTransformation AFFINE_TRANSFORM;
5176 
5177     static const VirtualKeyDefinition VIRTUAL_KEYS[2];
5178 
5179     const std::string UNIQUE_ID = "local:0";
5180     const std::string SECONDARY_UNIQUE_ID = "local:1";
5181 
5182     enum Axes {
5183         POSITION = 1 << 0,
5184         TOUCH = 1 << 1,
5185         TOOL = 1 << 2,
5186         PRESSURE = 1 << 3,
5187         ORIENTATION = 1 << 4,
5188         MINOR = 1 << 5,
5189         ID = 1 << 6,
5190         DISTANCE = 1 << 7,
5191         TILT = 1 << 8,
5192         SLOT = 1 << 9,
5193         TOOL_TYPE = 1 << 10,
5194     };
5195 
5196     void prepareDisplay(int32_t orientation, std::optional<uint8_t> port = NO_PORT);
5197     void prepareSecondaryDisplay(ViewportType type, std::optional<uint8_t> port = NO_PORT);
5198     void prepareVirtualDisplay(int32_t orientation);
5199     void prepareVirtualKeys();
5200     void prepareLocationCalibration();
5201     int32_t toRawX(float displayX);
5202     int32_t toRawY(float displayY);
5203     int32_t toRotatedRawX(float displayX);
5204     int32_t toRotatedRawY(float displayY);
5205     float toCookedX(float rawX, float rawY);
5206     float toCookedY(float rawX, float rawY);
5207     float toDisplayX(int32_t rawX);
5208     float toDisplayX(int32_t rawX, int32_t displayWidth);
5209     float toDisplayY(int32_t rawY);
5210     float toDisplayY(int32_t rawY, int32_t displayHeight);
5211 
5212 };
5213 
5214 const int32_t TouchInputMapperTest::RAW_X_MIN = 25;
5215 const int32_t TouchInputMapperTest::RAW_X_MAX = 1019;
5216 const int32_t TouchInputMapperTest::RAW_Y_MIN = 30;
5217 const int32_t TouchInputMapperTest::RAW_Y_MAX = 1009;
5218 const int32_t TouchInputMapperTest::RAW_TOUCH_MIN = 0;
5219 const int32_t TouchInputMapperTest::RAW_TOUCH_MAX = 31;
5220 const int32_t TouchInputMapperTest::RAW_TOOL_MIN = 0;
5221 const int32_t TouchInputMapperTest::RAW_TOOL_MAX = 15;
5222 const int32_t TouchInputMapperTest::RAW_PRESSURE_MIN = 0;
5223 const int32_t TouchInputMapperTest::RAW_PRESSURE_MAX = 255;
5224 const int32_t TouchInputMapperTest::RAW_ORIENTATION_MIN = -7;
5225 const int32_t TouchInputMapperTest::RAW_ORIENTATION_MAX = 7;
5226 const int32_t TouchInputMapperTest::RAW_DISTANCE_MIN = 0;
5227 const int32_t TouchInputMapperTest::RAW_DISTANCE_MAX = 7;
5228 const int32_t TouchInputMapperTest::RAW_TILT_MIN = 0;
5229 const int32_t TouchInputMapperTest::RAW_TILT_MAX = 150;
5230 const int32_t TouchInputMapperTest::RAW_ID_MIN = 0;
5231 const int32_t TouchInputMapperTest::RAW_ID_MAX = 9;
5232 const int32_t TouchInputMapperTest::RAW_SLOT_MIN = 0;
5233 const int32_t TouchInputMapperTest::RAW_SLOT_MAX = 9;
5234 const float TouchInputMapperTest::X_PRECISION = float(RAW_X_MAX - RAW_X_MIN + 1) / DISPLAY_WIDTH;
5235 const float TouchInputMapperTest::Y_PRECISION = float(RAW_Y_MAX - RAW_Y_MIN + 1) / DISPLAY_HEIGHT;
5236 const float TouchInputMapperTest::X_PRECISION_VIRTUAL =
5237         float(RAW_X_MAX - RAW_X_MIN + 1) / VIRTUAL_DISPLAY_WIDTH;
5238 const float TouchInputMapperTest::Y_PRECISION_VIRTUAL =
5239         float(RAW_Y_MAX - RAW_Y_MIN + 1) / VIRTUAL_DISPLAY_HEIGHT;
5240 const TouchAffineTransformation TouchInputMapperTest::AFFINE_TRANSFORM =
5241         TouchAffineTransformation(1, -2, 3, -4, 5, -6);
5242 
5243 const float TouchInputMapperTest::GEOMETRIC_SCALE =
5244         avg(float(DISPLAY_WIDTH) / (RAW_X_MAX - RAW_X_MIN + 1),
5245                 float(DISPLAY_HEIGHT) / (RAW_Y_MAX - RAW_Y_MIN + 1));
5246 
5247 const VirtualKeyDefinition TouchInputMapperTest::VIRTUAL_KEYS[2] = {
5248         { KEY_HOME, 60, DISPLAY_HEIGHT + 15, 20, 20 },
5249         { KEY_MENU, DISPLAY_HEIGHT - 60, DISPLAY_WIDTH + 15, 20, 20 },
5250 };
5251 
prepareDisplay(int32_t orientation,std::optional<uint8_t> port)5252 void TouchInputMapperTest::prepareDisplay(int32_t orientation, std::optional<uint8_t> port) {
5253     setDisplayInfoAndReconfigure(DISPLAY_ID, DISPLAY_WIDTH, DISPLAY_HEIGHT, orientation, UNIQUE_ID,
5254                                  port, ViewportType::INTERNAL);
5255 }
5256 
prepareSecondaryDisplay(ViewportType type,std::optional<uint8_t> port)5257 void TouchInputMapperTest::prepareSecondaryDisplay(ViewportType type, std::optional<uint8_t> port) {
5258     setDisplayInfoAndReconfigure(SECONDARY_DISPLAY_ID, DISPLAY_WIDTH, DISPLAY_HEIGHT,
5259             DISPLAY_ORIENTATION_0, SECONDARY_UNIQUE_ID, port, type);
5260 }
5261 
prepareVirtualDisplay(int32_t orientation)5262 void TouchInputMapperTest::prepareVirtualDisplay(int32_t orientation) {
5263     setDisplayInfoAndReconfigure(VIRTUAL_DISPLAY_ID, VIRTUAL_DISPLAY_WIDTH, VIRTUAL_DISPLAY_HEIGHT,
5264                                  orientation, VIRTUAL_DISPLAY_UNIQUE_ID, NO_PORT,
5265                                  ViewportType::VIRTUAL);
5266 }
5267 
prepareVirtualKeys()5268 void TouchInputMapperTest::prepareVirtualKeys() {
5269     mFakeEventHub->addVirtualKeyDefinition(EVENTHUB_ID, VIRTUAL_KEYS[0]);
5270     mFakeEventHub->addVirtualKeyDefinition(EVENTHUB_ID, VIRTUAL_KEYS[1]);
5271     mFakeEventHub->addKey(EVENTHUB_ID, KEY_HOME, 0, AKEYCODE_HOME, POLICY_FLAG_WAKE);
5272     mFakeEventHub->addKey(EVENTHUB_ID, KEY_MENU, 0, AKEYCODE_MENU, POLICY_FLAG_WAKE);
5273 }
5274 
prepareLocationCalibration()5275 void TouchInputMapperTest::prepareLocationCalibration() {
5276     mFakePolicy->setTouchAffineTransformation(AFFINE_TRANSFORM);
5277 }
5278 
toRawX(float displayX)5279 int32_t TouchInputMapperTest::toRawX(float displayX) {
5280     return int32_t(displayX * (RAW_X_MAX - RAW_X_MIN + 1) / DISPLAY_WIDTH + RAW_X_MIN);
5281 }
5282 
toRawY(float displayY)5283 int32_t TouchInputMapperTest::toRawY(float displayY) {
5284     return int32_t(displayY * (RAW_Y_MAX - RAW_Y_MIN + 1) / DISPLAY_HEIGHT + RAW_Y_MIN);
5285 }
5286 
toRotatedRawX(float displayX)5287 int32_t TouchInputMapperTest::toRotatedRawX(float displayX) {
5288     return int32_t(displayX * (RAW_X_MAX - RAW_X_MIN + 1) / DISPLAY_HEIGHT + RAW_X_MIN);
5289 }
5290 
toRotatedRawY(float displayY)5291 int32_t TouchInputMapperTest::toRotatedRawY(float displayY) {
5292     return int32_t(displayY * (RAW_Y_MAX - RAW_Y_MIN + 1) / DISPLAY_WIDTH + RAW_Y_MIN);
5293 }
5294 
toCookedX(float rawX,float rawY)5295 float TouchInputMapperTest::toCookedX(float rawX, float rawY) {
5296     AFFINE_TRANSFORM.applyTo(rawX, rawY);
5297     return rawX;
5298 }
5299 
toCookedY(float rawX,float rawY)5300 float TouchInputMapperTest::toCookedY(float rawX, float rawY) {
5301     AFFINE_TRANSFORM.applyTo(rawX, rawY);
5302     return rawY;
5303 }
5304 
toDisplayX(int32_t rawX)5305 float TouchInputMapperTest::toDisplayX(int32_t rawX) {
5306     return toDisplayX(rawX, DISPLAY_WIDTH);
5307 }
5308 
toDisplayX(int32_t rawX,int32_t displayWidth)5309 float TouchInputMapperTest::toDisplayX(int32_t rawX, int32_t displayWidth) {
5310     return float(rawX - RAW_X_MIN) * displayWidth / (RAW_X_MAX - RAW_X_MIN + 1);
5311 }
5312 
toDisplayY(int32_t rawY)5313 float TouchInputMapperTest::toDisplayY(int32_t rawY) {
5314     return toDisplayY(rawY, DISPLAY_HEIGHT);
5315 }
5316 
toDisplayY(int32_t rawY,int32_t displayHeight)5317 float TouchInputMapperTest::toDisplayY(int32_t rawY, int32_t displayHeight) {
5318     return float(rawY - RAW_Y_MIN) * displayHeight / (RAW_Y_MAX - RAW_Y_MIN + 1);
5319 }
5320 
5321 
5322 // --- SingleTouchInputMapperTest ---
5323 
5324 class SingleTouchInputMapperTest : public TouchInputMapperTest {
5325 protected:
5326     void prepareButtons();
5327     void prepareAxes(int axes);
5328 
5329     void processDown(SingleTouchInputMapper& mapper, int32_t x, int32_t y);
5330     void processMove(SingleTouchInputMapper& mapper, int32_t x, int32_t y);
5331     void processUp(SingleTouchInputMapper& mappery);
5332     void processPressure(SingleTouchInputMapper& mapper, int32_t pressure);
5333     void processToolMajor(SingleTouchInputMapper& mapper, int32_t toolMajor);
5334     void processDistance(SingleTouchInputMapper& mapper, int32_t distance);
5335     void processTilt(SingleTouchInputMapper& mapper, int32_t tiltX, int32_t tiltY);
5336     void processKey(SingleTouchInputMapper& mapper, int32_t code, int32_t value);
5337     void processSync(SingleTouchInputMapper& mapper);
5338 };
5339 
prepareButtons()5340 void SingleTouchInputMapperTest::prepareButtons() {
5341     mFakeEventHub->addKey(EVENTHUB_ID, BTN_TOUCH, 0, AKEYCODE_UNKNOWN, 0);
5342 }
5343 
prepareAxes(int axes)5344 void SingleTouchInputMapperTest::prepareAxes(int axes) {
5345     if (axes & POSITION) {
5346         mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_X, RAW_X_MIN, RAW_X_MAX, 0, 0);
5347         mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_Y, RAW_Y_MIN, RAW_Y_MAX, 0, 0);
5348     }
5349     if (axes & PRESSURE) {
5350         mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_PRESSURE, RAW_PRESSURE_MIN,
5351                                        RAW_PRESSURE_MAX, 0, 0);
5352     }
5353     if (axes & TOOL) {
5354         mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_TOOL_WIDTH, RAW_TOOL_MIN, RAW_TOOL_MAX, 0,
5355                                        0);
5356     }
5357     if (axes & DISTANCE) {
5358         mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_DISTANCE, RAW_DISTANCE_MIN,
5359                                        RAW_DISTANCE_MAX, 0, 0);
5360     }
5361     if (axes & TILT) {
5362         mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_TILT_X, RAW_TILT_MIN, RAW_TILT_MAX, 0, 0);
5363         mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_TILT_Y, RAW_TILT_MIN, RAW_TILT_MAX, 0, 0);
5364     }
5365 }
5366 
processDown(SingleTouchInputMapper & mapper,int32_t x,int32_t y)5367 void SingleTouchInputMapperTest::processDown(SingleTouchInputMapper& mapper, int32_t x, int32_t y) {
5368     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, BTN_TOUCH, 1);
5369     process(mapper, ARBITRARY_TIME, READ_TIME, EV_ABS, ABS_X, x);
5370     process(mapper, ARBITRARY_TIME, READ_TIME, EV_ABS, ABS_Y, y);
5371 }
5372 
processMove(SingleTouchInputMapper & mapper,int32_t x,int32_t y)5373 void SingleTouchInputMapperTest::processMove(SingleTouchInputMapper& mapper, int32_t x, int32_t y) {
5374     process(mapper, ARBITRARY_TIME, READ_TIME, EV_ABS, ABS_X, x);
5375     process(mapper, ARBITRARY_TIME, READ_TIME, EV_ABS, ABS_Y, y);
5376 }
5377 
processUp(SingleTouchInputMapper & mapper)5378 void SingleTouchInputMapperTest::processUp(SingleTouchInputMapper& mapper) {
5379     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, BTN_TOUCH, 0);
5380 }
5381 
processPressure(SingleTouchInputMapper & mapper,int32_t pressure)5382 void SingleTouchInputMapperTest::processPressure(SingleTouchInputMapper& mapper, int32_t pressure) {
5383     process(mapper, ARBITRARY_TIME, READ_TIME, EV_ABS, ABS_PRESSURE, pressure);
5384 }
5385 
processToolMajor(SingleTouchInputMapper & mapper,int32_t toolMajor)5386 void SingleTouchInputMapperTest::processToolMajor(SingleTouchInputMapper& mapper,
5387                                                   int32_t toolMajor) {
5388     process(mapper, ARBITRARY_TIME, READ_TIME, EV_ABS, ABS_TOOL_WIDTH, toolMajor);
5389 }
5390 
processDistance(SingleTouchInputMapper & mapper,int32_t distance)5391 void SingleTouchInputMapperTest::processDistance(SingleTouchInputMapper& mapper, int32_t distance) {
5392     process(mapper, ARBITRARY_TIME, READ_TIME, EV_ABS, ABS_DISTANCE, distance);
5393 }
5394 
processTilt(SingleTouchInputMapper & mapper,int32_t tiltX,int32_t tiltY)5395 void SingleTouchInputMapperTest::processTilt(SingleTouchInputMapper& mapper, int32_t tiltX,
5396                                              int32_t tiltY) {
5397     process(mapper, ARBITRARY_TIME, READ_TIME, EV_ABS, ABS_TILT_X, tiltX);
5398     process(mapper, ARBITRARY_TIME, READ_TIME, EV_ABS, ABS_TILT_Y, tiltY);
5399 }
5400 
processKey(SingleTouchInputMapper & mapper,int32_t code,int32_t value)5401 void SingleTouchInputMapperTest::processKey(SingleTouchInputMapper& mapper, int32_t code,
5402                                             int32_t value) {
5403     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, code, value);
5404 }
5405 
processSync(SingleTouchInputMapper & mapper)5406 void SingleTouchInputMapperTest::processSync(SingleTouchInputMapper& mapper) {
5407     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
5408 }
5409 
TEST_F(SingleTouchInputMapperTest,GetSources_WhenDeviceTypeIsNotSpecifiedAndNotACursor_ReturnsPointer)5410 TEST_F(SingleTouchInputMapperTest, GetSources_WhenDeviceTypeIsNotSpecifiedAndNotACursor_ReturnsPointer) {
5411     prepareButtons();
5412     prepareAxes(POSITION);
5413     SingleTouchInputMapper& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
5414 
5415     ASSERT_EQ(AINPUT_SOURCE_MOUSE, mapper.getSources());
5416 }
5417 
TEST_F(SingleTouchInputMapperTest,GetSources_WhenDeviceTypeIsNotSpecifiedAndIsACursor_ReturnsTouchPad)5418 TEST_F(SingleTouchInputMapperTest, GetSources_WhenDeviceTypeIsNotSpecifiedAndIsACursor_ReturnsTouchPad) {
5419     mFakeEventHub->addRelativeAxis(EVENTHUB_ID, REL_X);
5420     mFakeEventHub->addRelativeAxis(EVENTHUB_ID, REL_Y);
5421     prepareButtons();
5422     prepareAxes(POSITION);
5423     SingleTouchInputMapper& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
5424 
5425     ASSERT_EQ(AINPUT_SOURCE_TOUCHPAD, mapper.getSources());
5426 }
5427 
TEST_F(SingleTouchInputMapperTest,GetSources_WhenDeviceTypeIsTouchPad_ReturnsTouchPad)5428 TEST_F(SingleTouchInputMapperTest, GetSources_WhenDeviceTypeIsTouchPad_ReturnsTouchPad) {
5429     prepareButtons();
5430     prepareAxes(POSITION);
5431     addConfigurationProperty("touch.deviceType", "touchPad");
5432     SingleTouchInputMapper& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
5433 
5434     ASSERT_EQ(AINPUT_SOURCE_TOUCHPAD, mapper.getSources());
5435 }
5436 
TEST_F(SingleTouchInputMapperTest,GetSources_WhenDeviceTypeIsTouchScreen_ReturnsTouchScreen)5437 TEST_F(SingleTouchInputMapperTest, GetSources_WhenDeviceTypeIsTouchScreen_ReturnsTouchScreen) {
5438     prepareButtons();
5439     prepareAxes(POSITION);
5440     addConfigurationProperty("touch.deviceType", "touchScreen");
5441     SingleTouchInputMapper& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
5442 
5443     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, mapper.getSources());
5444 }
5445 
TEST_F(SingleTouchInputMapperTest,GetKeyCodeState)5446 TEST_F(SingleTouchInputMapperTest, GetKeyCodeState) {
5447     addConfigurationProperty("touch.deviceType", "touchScreen");
5448     prepareDisplay(DISPLAY_ORIENTATION_0);
5449     prepareButtons();
5450     prepareAxes(POSITION);
5451     prepareVirtualKeys();
5452     SingleTouchInputMapper& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
5453 
5454     // Unknown key.
5455     ASSERT_EQ(AKEY_STATE_UNKNOWN, mapper.getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_A));
5456 
5457     // Virtual key is down.
5458     int32_t x = toRawX(VIRTUAL_KEYS[0].centerX);
5459     int32_t y = toRawY(VIRTUAL_KEYS[0].centerY);
5460     processDown(mapper, x, y);
5461     processSync(mapper);
5462     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled());
5463 
5464     ASSERT_EQ(AKEY_STATE_VIRTUAL, mapper.getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_HOME));
5465 
5466     // Virtual key is up.
5467     processUp(mapper);
5468     processSync(mapper);
5469     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled());
5470 
5471     ASSERT_EQ(AKEY_STATE_UP, mapper.getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_HOME));
5472 }
5473 
TEST_F(SingleTouchInputMapperTest,GetScanCodeState)5474 TEST_F(SingleTouchInputMapperTest, GetScanCodeState) {
5475     addConfigurationProperty("touch.deviceType", "touchScreen");
5476     prepareDisplay(DISPLAY_ORIENTATION_0);
5477     prepareButtons();
5478     prepareAxes(POSITION);
5479     prepareVirtualKeys();
5480     SingleTouchInputMapper& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
5481 
5482     // Unknown key.
5483     ASSERT_EQ(AKEY_STATE_UNKNOWN, mapper.getScanCodeState(AINPUT_SOURCE_ANY, KEY_A));
5484 
5485     // Virtual key is down.
5486     int32_t x = toRawX(VIRTUAL_KEYS[0].centerX);
5487     int32_t y = toRawY(VIRTUAL_KEYS[0].centerY);
5488     processDown(mapper, x, y);
5489     processSync(mapper);
5490     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled());
5491 
5492     ASSERT_EQ(AKEY_STATE_VIRTUAL, mapper.getScanCodeState(AINPUT_SOURCE_ANY, KEY_HOME));
5493 
5494     // Virtual key is up.
5495     processUp(mapper);
5496     processSync(mapper);
5497     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled());
5498 
5499     ASSERT_EQ(AKEY_STATE_UP, mapper.getScanCodeState(AINPUT_SOURCE_ANY, KEY_HOME));
5500 }
5501 
TEST_F(SingleTouchInputMapperTest,MarkSupportedKeyCodes)5502 TEST_F(SingleTouchInputMapperTest, MarkSupportedKeyCodes) {
5503     addConfigurationProperty("touch.deviceType", "touchScreen");
5504     prepareDisplay(DISPLAY_ORIENTATION_0);
5505     prepareButtons();
5506     prepareAxes(POSITION);
5507     prepareVirtualKeys();
5508     SingleTouchInputMapper& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
5509 
5510     const int32_t keys[2] = { AKEYCODE_HOME, AKEYCODE_A };
5511     uint8_t flags[2] = { 0, 0 };
5512     ASSERT_TRUE(mapper.markSupportedKeyCodes(AINPUT_SOURCE_ANY, 2, keys, flags));
5513     ASSERT_TRUE(flags[0]);
5514     ASSERT_FALSE(flags[1]);
5515 }
5516 
TEST_F(SingleTouchInputMapperTest,Process_WhenVirtualKeyIsPressedAndReleasedNormally_SendsKeyDownAndKeyUp)5517 TEST_F(SingleTouchInputMapperTest, Process_WhenVirtualKeyIsPressedAndReleasedNormally_SendsKeyDownAndKeyUp) {
5518     addConfigurationProperty("touch.deviceType", "touchScreen");
5519     prepareDisplay(DISPLAY_ORIENTATION_0);
5520     prepareButtons();
5521     prepareAxes(POSITION);
5522     prepareVirtualKeys();
5523     SingleTouchInputMapper& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
5524 
5525     mReader->getContext()->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
5526 
5527     NotifyKeyArgs args;
5528 
5529     // Press virtual key.
5530     int32_t x = toRawX(VIRTUAL_KEYS[0].centerX);
5531     int32_t y = toRawY(VIRTUAL_KEYS[0].centerY);
5532     processDown(mapper, x, y);
5533     processSync(mapper);
5534 
5535     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
5536     ASSERT_EQ(ARBITRARY_TIME, args.eventTime);
5537     ASSERT_EQ(DEVICE_ID, args.deviceId);
5538     ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source);
5539     ASSERT_EQ(POLICY_FLAG_VIRTUAL, args.policyFlags);
5540     ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, args.action);
5541     ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY, args.flags);
5542     ASSERT_EQ(AKEYCODE_HOME, args.keyCode);
5543     ASSERT_EQ(KEY_HOME, args.scanCode);
5544     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
5545     ASSERT_EQ(ARBITRARY_TIME, args.downTime);
5546 
5547     // Release virtual key.
5548     processUp(mapper);
5549     processSync(mapper);
5550 
5551     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&args));
5552     ASSERT_EQ(ARBITRARY_TIME, args.eventTime);
5553     ASSERT_EQ(DEVICE_ID, args.deviceId);
5554     ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source);
5555     ASSERT_EQ(POLICY_FLAG_VIRTUAL, args.policyFlags);
5556     ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action);
5557     ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY, args.flags);
5558     ASSERT_EQ(AKEYCODE_HOME, args.keyCode);
5559     ASSERT_EQ(KEY_HOME, args.scanCode);
5560     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
5561     ASSERT_EQ(ARBITRARY_TIME, args.downTime);
5562 
5563     // Should not have sent any motions.
5564     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasNotCalled());
5565 }
5566 
TEST_F(SingleTouchInputMapperTest,Process_WhenVirtualKeyIsPressedAndMovedOutOfBounds_SendsKeyDownAndKeyCancel)5567 TEST_F(SingleTouchInputMapperTest, Process_WhenVirtualKeyIsPressedAndMovedOutOfBounds_SendsKeyDownAndKeyCancel) {
5568     addConfigurationProperty("touch.deviceType", "touchScreen");
5569     prepareDisplay(DISPLAY_ORIENTATION_0);
5570     prepareButtons();
5571     prepareAxes(POSITION);
5572     prepareVirtualKeys();
5573     SingleTouchInputMapper& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
5574 
5575     mReader->getContext()->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
5576 
5577     NotifyKeyArgs keyArgs;
5578 
5579     // Press virtual key.
5580     int32_t x = toRawX(VIRTUAL_KEYS[0].centerX);
5581     int32_t y = toRawY(VIRTUAL_KEYS[0].centerY);
5582     processDown(mapper, x, y);
5583     processSync(mapper);
5584 
5585     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs));
5586     ASSERT_EQ(ARBITRARY_TIME, keyArgs.eventTime);
5587     ASSERT_EQ(DEVICE_ID, keyArgs.deviceId);
5588     ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, keyArgs.source);
5589     ASSERT_EQ(POLICY_FLAG_VIRTUAL, keyArgs.policyFlags);
5590     ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action);
5591     ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY, keyArgs.flags);
5592     ASSERT_EQ(AKEYCODE_HOME, keyArgs.keyCode);
5593     ASSERT_EQ(KEY_HOME, keyArgs.scanCode);
5594     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, keyArgs.metaState);
5595     ASSERT_EQ(ARBITRARY_TIME, keyArgs.downTime);
5596 
5597     // Move out of bounds.  This should generate a cancel and a pointer down since we moved
5598     // into the display area.
5599     y -= 100;
5600     processMove(mapper, x, y);
5601     processSync(mapper);
5602 
5603     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs));
5604     ASSERT_EQ(ARBITRARY_TIME, keyArgs.eventTime);
5605     ASSERT_EQ(DEVICE_ID, keyArgs.deviceId);
5606     ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, keyArgs.source);
5607     ASSERT_EQ(POLICY_FLAG_VIRTUAL, keyArgs.policyFlags);
5608     ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action);
5609     ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY
5610             | AKEY_EVENT_FLAG_CANCELED, keyArgs.flags);
5611     ASSERT_EQ(AKEYCODE_HOME, keyArgs.keyCode);
5612     ASSERT_EQ(KEY_HOME, keyArgs.scanCode);
5613     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, keyArgs.metaState);
5614     ASSERT_EQ(ARBITRARY_TIME, keyArgs.downTime);
5615 
5616     NotifyMotionArgs motionArgs;
5617     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
5618     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
5619     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
5620     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
5621     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
5622     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
5623     ASSERT_EQ(0, motionArgs.flags);
5624     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
5625     ASSERT_EQ(0, motionArgs.buttonState);
5626     ASSERT_EQ(0, motionArgs.edgeFlags);
5627     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
5628     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
5629     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
5630     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
5631             toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0, 0));
5632     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
5633     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
5634     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
5635 
5636     // Keep moving out of bounds.  Should generate a pointer move.
5637     y -= 50;
5638     processMove(mapper, x, y);
5639     processSync(mapper);
5640 
5641     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
5642     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
5643     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
5644     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
5645     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
5646     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
5647     ASSERT_EQ(0, motionArgs.flags);
5648     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
5649     ASSERT_EQ(0, motionArgs.buttonState);
5650     ASSERT_EQ(0, motionArgs.edgeFlags);
5651     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
5652     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
5653     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
5654     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
5655             toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0, 0));
5656     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
5657     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
5658     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
5659 
5660     // Release out of bounds.  Should generate a pointer up.
5661     processUp(mapper);
5662     processSync(mapper);
5663 
5664     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
5665     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
5666     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
5667     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
5668     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
5669     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
5670     ASSERT_EQ(0, motionArgs.flags);
5671     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
5672     ASSERT_EQ(0, motionArgs.buttonState);
5673     ASSERT_EQ(0, motionArgs.edgeFlags);
5674     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
5675     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
5676     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
5677     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
5678             toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0, 0));
5679     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
5680     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
5681     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
5682 
5683     // Should not have sent any more keys or motions.
5684     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasNotCalled());
5685     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());
5686 }
5687 
TEST_F(SingleTouchInputMapperTest,Process_WhenTouchStartsOutsideDisplayAndMovesIn_SendsDownAsTouchEntersDisplay)5688 TEST_F(SingleTouchInputMapperTest, Process_WhenTouchStartsOutsideDisplayAndMovesIn_SendsDownAsTouchEntersDisplay) {
5689     addConfigurationProperty("touch.deviceType", "touchScreen");
5690     prepareDisplay(DISPLAY_ORIENTATION_0);
5691     prepareButtons();
5692     prepareAxes(POSITION);
5693     prepareVirtualKeys();
5694     SingleTouchInputMapper& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
5695 
5696     mReader->getContext()->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
5697 
5698     NotifyMotionArgs motionArgs;
5699 
5700     // Initially go down out of bounds.
5701     int32_t x = -10;
5702     int32_t y = -10;
5703     processDown(mapper, x, y);
5704     processSync(mapper);
5705 
5706     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());
5707 
5708     // Move into the display area.  Should generate a pointer down.
5709     x = 50;
5710     y = 75;
5711     processMove(mapper, x, y);
5712     processSync(mapper);
5713 
5714     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
5715     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
5716     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
5717     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
5718     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
5719     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
5720     ASSERT_EQ(0, motionArgs.flags);
5721     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
5722     ASSERT_EQ(0, motionArgs.buttonState);
5723     ASSERT_EQ(0, motionArgs.edgeFlags);
5724     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
5725     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
5726     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
5727     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
5728             toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0, 0));
5729     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
5730     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
5731     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
5732 
5733     // Release.  Should generate a pointer up.
5734     processUp(mapper);
5735     processSync(mapper);
5736 
5737     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
5738     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
5739     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
5740     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
5741     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
5742     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
5743     ASSERT_EQ(0, motionArgs.flags);
5744     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
5745     ASSERT_EQ(0, motionArgs.buttonState);
5746     ASSERT_EQ(0, motionArgs.edgeFlags);
5747     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
5748     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
5749     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
5750     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
5751             toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0, 0));
5752     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
5753     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
5754     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
5755 
5756     // Should not have sent any more keys or motions.
5757     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasNotCalled());
5758     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());
5759 }
5760 
TEST_F(SingleTouchInputMapperTest,Process_NormalSingleTouchGesture_VirtualDisplay)5761 TEST_F(SingleTouchInputMapperTest, Process_NormalSingleTouchGesture_VirtualDisplay) {
5762     addConfigurationProperty("touch.deviceType", "touchScreen");
5763     addConfigurationProperty("touch.displayId", VIRTUAL_DISPLAY_UNIQUE_ID);
5764 
5765     prepareVirtualDisplay(DISPLAY_ORIENTATION_0);
5766     prepareButtons();
5767     prepareAxes(POSITION);
5768     prepareVirtualKeys();
5769     SingleTouchInputMapper& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
5770 
5771     mReader->getContext()->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
5772 
5773     NotifyMotionArgs motionArgs;
5774 
5775     // Down.
5776     int32_t x = 100;
5777     int32_t y = 125;
5778     processDown(mapper, x, y);
5779     processSync(mapper);
5780 
5781     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
5782     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
5783     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
5784     ASSERT_EQ(VIRTUAL_DISPLAY_ID, motionArgs.displayId);
5785     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
5786     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
5787     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
5788     ASSERT_EQ(0, motionArgs.flags);
5789     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
5790     ASSERT_EQ(0, motionArgs.buttonState);
5791     ASSERT_EQ(0, motionArgs.edgeFlags);
5792     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
5793     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
5794     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
5795     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
5796             toDisplayX(x, VIRTUAL_DISPLAY_WIDTH), toDisplayY(y, VIRTUAL_DISPLAY_HEIGHT),
5797             1, 0, 0, 0, 0, 0, 0, 0));
5798     ASSERT_NEAR(X_PRECISION_VIRTUAL, motionArgs.xPrecision, EPSILON);
5799     ASSERT_NEAR(Y_PRECISION_VIRTUAL, motionArgs.yPrecision, EPSILON);
5800     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
5801 
5802     // Move.
5803     x += 50;
5804     y += 75;
5805     processMove(mapper, x, y);
5806     processSync(mapper);
5807 
5808     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
5809     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
5810     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
5811     ASSERT_EQ(VIRTUAL_DISPLAY_ID, motionArgs.displayId);
5812     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
5813     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
5814     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
5815     ASSERT_EQ(0, motionArgs.flags);
5816     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
5817     ASSERT_EQ(0, motionArgs.buttonState);
5818     ASSERT_EQ(0, motionArgs.edgeFlags);
5819     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
5820     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
5821     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
5822     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
5823             toDisplayX(x, VIRTUAL_DISPLAY_WIDTH), toDisplayY(y, VIRTUAL_DISPLAY_HEIGHT),
5824             1, 0, 0, 0, 0, 0, 0, 0));
5825     ASSERT_NEAR(X_PRECISION_VIRTUAL, motionArgs.xPrecision, EPSILON);
5826     ASSERT_NEAR(Y_PRECISION_VIRTUAL, motionArgs.yPrecision, EPSILON);
5827     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
5828 
5829     // Up.
5830     processUp(mapper);
5831     processSync(mapper);
5832 
5833     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
5834     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
5835     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
5836     ASSERT_EQ(VIRTUAL_DISPLAY_ID, motionArgs.displayId);
5837     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
5838     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
5839     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
5840     ASSERT_EQ(0, motionArgs.flags);
5841     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
5842     ASSERT_EQ(0, motionArgs.buttonState);
5843     ASSERT_EQ(0, motionArgs.edgeFlags);
5844     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
5845     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
5846     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
5847     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
5848             toDisplayX(x, VIRTUAL_DISPLAY_WIDTH), toDisplayY(y, VIRTUAL_DISPLAY_HEIGHT),
5849             1, 0, 0, 0, 0, 0, 0, 0));
5850     ASSERT_NEAR(X_PRECISION_VIRTUAL, motionArgs.xPrecision, EPSILON);
5851     ASSERT_NEAR(Y_PRECISION_VIRTUAL, motionArgs.yPrecision, EPSILON);
5852     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
5853 
5854     // Should not have sent any more keys or motions.
5855     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasNotCalled());
5856     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());
5857 }
5858 
TEST_F(SingleTouchInputMapperTest,Process_NormalSingleTouchGesture)5859 TEST_F(SingleTouchInputMapperTest, Process_NormalSingleTouchGesture) {
5860     addConfigurationProperty("touch.deviceType", "touchScreen");
5861     prepareDisplay(DISPLAY_ORIENTATION_0);
5862     prepareButtons();
5863     prepareAxes(POSITION);
5864     prepareVirtualKeys();
5865     SingleTouchInputMapper& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
5866 
5867     mReader->getContext()->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
5868 
5869     NotifyMotionArgs motionArgs;
5870 
5871     // Down.
5872     int32_t x = 100;
5873     int32_t y = 125;
5874     processDown(mapper, x, y);
5875     processSync(mapper);
5876 
5877     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
5878     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
5879     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
5880     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
5881     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
5882     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
5883     ASSERT_EQ(0, motionArgs.flags);
5884     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
5885     ASSERT_EQ(0, motionArgs.buttonState);
5886     ASSERT_EQ(0, motionArgs.edgeFlags);
5887     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
5888     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
5889     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
5890     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
5891             toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0, 0));
5892     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
5893     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
5894     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
5895 
5896     // Move.
5897     x += 50;
5898     y += 75;
5899     processMove(mapper, x, y);
5900     processSync(mapper);
5901 
5902     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
5903     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
5904     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
5905     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
5906     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
5907     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
5908     ASSERT_EQ(0, motionArgs.flags);
5909     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
5910     ASSERT_EQ(0, motionArgs.buttonState);
5911     ASSERT_EQ(0, motionArgs.edgeFlags);
5912     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
5913     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
5914     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
5915     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
5916             toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0, 0));
5917     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
5918     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
5919     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
5920 
5921     // Up.
5922     processUp(mapper);
5923     processSync(mapper);
5924 
5925     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
5926     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
5927     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
5928     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
5929     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
5930     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
5931     ASSERT_EQ(0, motionArgs.flags);
5932     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
5933     ASSERT_EQ(0, motionArgs.buttonState);
5934     ASSERT_EQ(0, motionArgs.edgeFlags);
5935     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
5936     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
5937     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
5938     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
5939             toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0, 0));
5940     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
5941     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
5942     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
5943 
5944     // Should not have sent any more keys or motions.
5945     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasNotCalled());
5946     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());
5947 }
5948 
TEST_F(SingleTouchInputMapperTest,Process_WhenOrientationAware_DoesNotRotateMotions)5949 TEST_F(SingleTouchInputMapperTest, Process_WhenOrientationAware_DoesNotRotateMotions) {
5950     addConfigurationProperty("touch.deviceType", "touchScreen");
5951     prepareButtons();
5952     prepareAxes(POSITION);
5953     // InputReader works in the un-rotated coordinate space, so orientation-aware devices do not
5954     // need to be rotated. Touchscreens are orientation-aware by default.
5955     SingleTouchInputMapper& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
5956 
5957     NotifyMotionArgs args;
5958 
5959     // Rotation 90.
5960     prepareDisplay(DISPLAY_ORIENTATION_90);
5961     processDown(mapper, toRawX(50), toRawY(75));
5962     processSync(mapper);
5963 
5964     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
5965     ASSERT_NEAR(50, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X), 1);
5966     ASSERT_NEAR(75, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y), 1);
5967 
5968     processUp(mapper);
5969     processSync(mapper);
5970     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled());
5971 }
5972 
TEST_F(SingleTouchInputMapperTest,Process_WhenNotOrientationAware_RotatesMotions)5973 TEST_F(SingleTouchInputMapperTest, Process_WhenNotOrientationAware_RotatesMotions) {
5974     addConfigurationProperty("touch.deviceType", "touchScreen");
5975     prepareButtons();
5976     prepareAxes(POSITION);
5977     // Since InputReader works in the un-rotated coordinate space, only devices that are not
5978     // orientation-aware are affected by display rotation.
5979     addConfigurationProperty("touch.orientationAware", "0");
5980     SingleTouchInputMapper& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
5981 
5982     NotifyMotionArgs args;
5983 
5984     // Rotation 0.
5985     clearViewports();
5986     prepareDisplay(DISPLAY_ORIENTATION_0);
5987     processDown(mapper, toRawX(50), toRawY(75));
5988     processSync(mapper);
5989 
5990     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
5991     ASSERT_NEAR(50, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X), 1);
5992     ASSERT_NEAR(75, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y), 1);
5993 
5994     processUp(mapper);
5995     processSync(mapper);
5996     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled());
5997 
5998     // Rotation 90.
5999     clearViewports();
6000     prepareDisplay(DISPLAY_ORIENTATION_90);
6001     processDown(mapper, toRawX(75), RAW_Y_MAX - toRawY(50) + RAW_Y_MIN);
6002     processSync(mapper);
6003 
6004     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
6005     ASSERT_NEAR(50, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X), 1);
6006     ASSERT_NEAR(75, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y), 1);
6007 
6008     processUp(mapper);
6009     processSync(mapper);
6010     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled());
6011 
6012     // Rotation 180.
6013     clearViewports();
6014     prepareDisplay(DISPLAY_ORIENTATION_180);
6015     processDown(mapper, RAW_X_MAX - toRawX(50) + RAW_X_MIN, RAW_Y_MAX - toRawY(75) + RAW_Y_MIN);
6016     processSync(mapper);
6017 
6018     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
6019     ASSERT_NEAR(50, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X), 1);
6020     ASSERT_NEAR(75, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y), 1);
6021 
6022     processUp(mapper);
6023     processSync(mapper);
6024     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled());
6025 
6026     // Rotation 270.
6027     clearViewports();
6028     prepareDisplay(DISPLAY_ORIENTATION_270);
6029     processDown(mapper, RAW_X_MAX - toRawX(75) + RAW_X_MIN, toRawY(50));
6030     processSync(mapper);
6031 
6032     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
6033     ASSERT_NEAR(50, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X), 1);
6034     ASSERT_NEAR(75, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y), 1);
6035 
6036     processUp(mapper);
6037     processSync(mapper);
6038     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled());
6039 }
6040 
TEST_F(SingleTouchInputMapperTest,Process_WhenOrientation0_RotatesMotions)6041 TEST_F(SingleTouchInputMapperTest, Process_WhenOrientation0_RotatesMotions) {
6042     addConfigurationProperty("touch.deviceType", "touchScreen");
6043     prepareButtons();
6044     prepareAxes(POSITION);
6045     addConfigurationProperty("touch.orientationAware", "1");
6046     addConfigurationProperty("touch.orientation", "ORIENTATION_0");
6047     clearViewports();
6048     prepareDisplay(DISPLAY_ORIENTATION_0);
6049     auto& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
6050     NotifyMotionArgs args;
6051 
6052     // Orientation 0.
6053     processDown(mapper, toRawX(50), toRawY(75));
6054     processSync(mapper);
6055 
6056     EXPECT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
6057     EXPECT_NEAR(50, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X), 1);
6058     EXPECT_NEAR(75, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y), 1);
6059 
6060     processUp(mapper);
6061     processSync(mapper);
6062     EXPECT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled());
6063 }
6064 
TEST_F(SingleTouchInputMapperTest,Process_WhenOrientation90_RotatesMotions)6065 TEST_F(SingleTouchInputMapperTest, Process_WhenOrientation90_RotatesMotions) {
6066     addConfigurationProperty("touch.deviceType", "touchScreen");
6067     prepareButtons();
6068     prepareAxes(POSITION);
6069     addConfigurationProperty("touch.orientationAware", "1");
6070     addConfigurationProperty("touch.orientation", "ORIENTATION_90");
6071     clearViewports();
6072     prepareDisplay(DISPLAY_ORIENTATION_0);
6073     auto& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
6074     NotifyMotionArgs args;
6075 
6076     // Orientation 90.
6077     processDown(mapper, RAW_X_MAX - toRotatedRawX(75) + RAW_X_MIN, toRotatedRawY(50));
6078     processSync(mapper);
6079 
6080     EXPECT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
6081     EXPECT_NEAR(50, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X), 1);
6082     EXPECT_NEAR(75, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y), 1);
6083 
6084     processUp(mapper);
6085     processSync(mapper);
6086     EXPECT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled());
6087 }
6088 
TEST_F(SingleTouchInputMapperTest,Process_WhenOrientation180_RotatesMotions)6089 TEST_F(SingleTouchInputMapperTest, Process_WhenOrientation180_RotatesMotions) {
6090     addConfigurationProperty("touch.deviceType", "touchScreen");
6091     prepareButtons();
6092     prepareAxes(POSITION);
6093     addConfigurationProperty("touch.orientationAware", "1");
6094     addConfigurationProperty("touch.orientation", "ORIENTATION_180");
6095     clearViewports();
6096     prepareDisplay(DISPLAY_ORIENTATION_0);
6097     auto& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
6098     NotifyMotionArgs args;
6099 
6100     // Orientation 180.
6101     processDown(mapper, RAW_X_MAX - toRawX(50) + RAW_X_MIN, RAW_Y_MAX - toRawY(75) + RAW_Y_MIN);
6102     processSync(mapper);
6103 
6104     EXPECT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
6105     EXPECT_NEAR(50, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X), 1);
6106     EXPECT_NEAR(75, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y), 1);
6107 
6108     processUp(mapper);
6109     processSync(mapper);
6110     EXPECT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled());
6111 }
6112 
TEST_F(SingleTouchInputMapperTest,Process_WhenOrientation270_RotatesMotions)6113 TEST_F(SingleTouchInputMapperTest, Process_WhenOrientation270_RotatesMotions) {
6114     addConfigurationProperty("touch.deviceType", "touchScreen");
6115     prepareButtons();
6116     prepareAxes(POSITION);
6117     addConfigurationProperty("touch.orientationAware", "1");
6118     addConfigurationProperty("touch.orientation", "ORIENTATION_270");
6119     clearViewports();
6120     prepareDisplay(DISPLAY_ORIENTATION_0);
6121     auto& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
6122     NotifyMotionArgs args;
6123 
6124     // Orientation 270.
6125     processDown(mapper, toRotatedRawX(75), RAW_Y_MAX - toRotatedRawY(50) + RAW_Y_MIN);
6126     processSync(mapper);
6127 
6128     EXPECT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
6129     EXPECT_NEAR(50, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X), 1);
6130     EXPECT_NEAR(75, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y), 1);
6131 
6132     processUp(mapper);
6133     processSync(mapper);
6134     EXPECT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled());
6135 }
6136 
TEST_F(SingleTouchInputMapperTest,Process_WhenOrientationSpecified_RotatesMotionWithDisplay)6137 TEST_F(SingleTouchInputMapperTest, Process_WhenOrientationSpecified_RotatesMotionWithDisplay) {
6138     addConfigurationProperty("touch.deviceType", "touchScreen");
6139     prepareButtons();
6140     prepareAxes(POSITION);
6141     // Since InputReader works in the un-rotated coordinate space, only devices that are not
6142     // orientation-aware are affected by display rotation.
6143     addConfigurationProperty("touch.orientationAware", "0");
6144     addConfigurationProperty("touch.orientation", "ORIENTATION_90");
6145     auto& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
6146 
6147     NotifyMotionArgs args;
6148 
6149     // Orientation 90, Rotation 0.
6150     clearViewports();
6151     prepareDisplay(DISPLAY_ORIENTATION_0);
6152     processDown(mapper, RAW_X_MAX - toRotatedRawX(75) + RAW_X_MIN, toRotatedRawY(50));
6153     processSync(mapper);
6154 
6155     EXPECT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
6156     EXPECT_NEAR(50, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X), 1);
6157     EXPECT_NEAR(75, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y), 1);
6158 
6159     processUp(mapper);
6160     processSync(mapper);
6161     EXPECT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled());
6162 
6163     // Orientation 90, Rotation 90.
6164     clearViewports();
6165     prepareDisplay(DISPLAY_ORIENTATION_90);
6166     processDown(mapper, toRotatedRawX(50), toRotatedRawY(75));
6167     processSync(mapper);
6168 
6169     EXPECT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
6170     EXPECT_NEAR(50, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X), 1);
6171     EXPECT_NEAR(75, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y), 1);
6172 
6173     processUp(mapper);
6174     processSync(mapper);
6175     EXPECT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled());
6176 
6177     // Orientation 90, Rotation 180.
6178     clearViewports();
6179     prepareDisplay(DISPLAY_ORIENTATION_180);
6180     processDown(mapper, toRotatedRawX(75), RAW_Y_MAX - toRotatedRawY(50) + RAW_Y_MIN);
6181     processSync(mapper);
6182 
6183     EXPECT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
6184     EXPECT_NEAR(50, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X), 1);
6185     EXPECT_NEAR(75, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y), 1);
6186 
6187     processUp(mapper);
6188     processSync(mapper);
6189     EXPECT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled());
6190 
6191     // Orientation 90, Rotation 270.
6192     clearViewports();
6193     prepareDisplay(DISPLAY_ORIENTATION_270);
6194     processDown(mapper, RAW_X_MAX - toRotatedRawX(50) + RAW_X_MIN,
6195                 RAW_Y_MAX - toRotatedRawY(75) + RAW_Y_MIN);
6196     processSync(mapper);
6197 
6198     EXPECT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
6199     EXPECT_NEAR(50, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X), 1);
6200     EXPECT_NEAR(75, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y), 1);
6201 
6202     processUp(mapper);
6203     processSync(mapper);
6204     EXPECT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled());
6205 }
6206 
TEST_F(SingleTouchInputMapperTest,Process_AllAxes_DefaultCalibration)6207 TEST_F(SingleTouchInputMapperTest, Process_AllAxes_DefaultCalibration) {
6208     addConfigurationProperty("touch.deviceType", "touchScreen");
6209     prepareDisplay(DISPLAY_ORIENTATION_0);
6210     prepareButtons();
6211     prepareAxes(POSITION | PRESSURE | TOOL | DISTANCE | TILT);
6212     SingleTouchInputMapper& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
6213 
6214     // These calculations are based on the input device calibration documentation.
6215     int32_t rawX = 100;
6216     int32_t rawY = 200;
6217     int32_t rawPressure = 10;
6218     int32_t rawToolMajor = 12;
6219     int32_t rawDistance = 2;
6220     int32_t rawTiltX = 30;
6221     int32_t rawTiltY = 110;
6222 
6223     float x = toDisplayX(rawX);
6224     float y = toDisplayY(rawY);
6225     float pressure = float(rawPressure) / RAW_PRESSURE_MAX;
6226     float size = float(rawToolMajor) / RAW_TOOL_MAX;
6227     float tool = float(rawToolMajor) * GEOMETRIC_SCALE;
6228     float distance = float(rawDistance);
6229 
6230     float tiltCenter = (RAW_TILT_MAX + RAW_TILT_MIN) * 0.5f;
6231     float tiltScale = M_PI / 180;
6232     float tiltXAngle = (rawTiltX - tiltCenter) * tiltScale;
6233     float tiltYAngle = (rawTiltY - tiltCenter) * tiltScale;
6234     float orientation = atan2f(-sinf(tiltXAngle), sinf(tiltYAngle));
6235     float tilt = acosf(cosf(tiltXAngle) * cosf(tiltYAngle));
6236 
6237     processDown(mapper, rawX, rawY);
6238     processPressure(mapper, rawPressure);
6239     processToolMajor(mapper, rawToolMajor);
6240     processDistance(mapper, rawDistance);
6241     processTilt(mapper, rawTiltX, rawTiltY);
6242     processSync(mapper);
6243 
6244     NotifyMotionArgs args;
6245     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
6246     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
6247             x, y, pressure, size, tool, tool, tool, tool, orientation, distance));
6248     ASSERT_EQ(tilt, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_TILT));
6249 }
6250 
TEST_F(SingleTouchInputMapperTest,Process_XYAxes_AffineCalibration)6251 TEST_F(SingleTouchInputMapperTest, Process_XYAxes_AffineCalibration) {
6252     addConfigurationProperty("touch.deviceType", "touchScreen");
6253     prepareDisplay(DISPLAY_ORIENTATION_0);
6254     prepareLocationCalibration();
6255     prepareButtons();
6256     prepareAxes(POSITION);
6257     SingleTouchInputMapper& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
6258 
6259     int32_t rawX = 100;
6260     int32_t rawY = 200;
6261 
6262     float x = toDisplayX(toCookedX(rawX, rawY));
6263     float y = toDisplayY(toCookedY(rawX, rawY));
6264 
6265     processDown(mapper, rawX, rawY);
6266     processSync(mapper);
6267 
6268     NotifyMotionArgs args;
6269     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
6270     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
6271             x, y, 1, 0, 0, 0, 0, 0, 0, 0));
6272 }
6273 
TEST_F(SingleTouchInputMapperTest,Process_ShouldHandleAllButtons)6274 TEST_F(SingleTouchInputMapperTest, Process_ShouldHandleAllButtons) {
6275     addConfigurationProperty("touch.deviceType", "touchScreen");
6276     prepareDisplay(DISPLAY_ORIENTATION_0);
6277     prepareButtons();
6278     prepareAxes(POSITION);
6279     SingleTouchInputMapper& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
6280 
6281     NotifyMotionArgs motionArgs;
6282     NotifyKeyArgs keyArgs;
6283 
6284     processDown(mapper, 100, 200);
6285     processSync(mapper);
6286     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6287     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
6288     ASSERT_EQ(0, motionArgs.buttonState);
6289 
6290     // press BTN_LEFT, release BTN_LEFT
6291     processKey(mapper, BTN_LEFT, 1);
6292     processSync(mapper);
6293     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6294     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6295     ASSERT_EQ(AMOTION_EVENT_BUTTON_PRIMARY, motionArgs.buttonState);
6296 
6297     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6298     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, motionArgs.action);
6299     ASSERT_EQ(AMOTION_EVENT_BUTTON_PRIMARY, motionArgs.buttonState);
6300 
6301     processKey(mapper, BTN_LEFT, 0);
6302     processSync(mapper);
6303     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6304     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, motionArgs.action);
6305     ASSERT_EQ(0, motionArgs.buttonState);
6306 
6307     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6308     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6309     ASSERT_EQ(0, motionArgs.buttonState);
6310 
6311     // press BTN_RIGHT + BTN_MIDDLE, release BTN_RIGHT, release BTN_MIDDLE
6312     processKey(mapper, BTN_RIGHT, 1);
6313     processKey(mapper, BTN_MIDDLE, 1);
6314     processSync(mapper);
6315     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6316     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6317     ASSERT_EQ(AMOTION_EVENT_BUTTON_SECONDARY | AMOTION_EVENT_BUTTON_TERTIARY,
6318             motionArgs.buttonState);
6319 
6320     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6321     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, motionArgs.action);
6322     ASSERT_EQ(AMOTION_EVENT_BUTTON_TERTIARY, motionArgs.buttonState);
6323 
6324     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6325     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, motionArgs.action);
6326     ASSERT_EQ(AMOTION_EVENT_BUTTON_SECONDARY | AMOTION_EVENT_BUTTON_TERTIARY,
6327             motionArgs.buttonState);
6328 
6329     processKey(mapper, BTN_RIGHT, 0);
6330     processSync(mapper);
6331     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6332     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, motionArgs.action);
6333     ASSERT_EQ(AMOTION_EVENT_BUTTON_TERTIARY, motionArgs.buttonState);
6334 
6335     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6336     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6337     ASSERT_EQ(AMOTION_EVENT_BUTTON_TERTIARY, motionArgs.buttonState);
6338 
6339     processKey(mapper, BTN_MIDDLE, 0);
6340     processSync(mapper);
6341     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6342     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, motionArgs.action);
6343     ASSERT_EQ(0, motionArgs.buttonState);
6344 
6345     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6346     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6347     ASSERT_EQ(0, motionArgs.buttonState);
6348 
6349     // press BTN_BACK, release BTN_BACK
6350     processKey(mapper, BTN_BACK, 1);
6351     processSync(mapper);
6352     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs));
6353     ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action);
6354     ASSERT_EQ(AKEYCODE_BACK, keyArgs.keyCode);
6355 
6356     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6357     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6358     ASSERT_EQ(AMOTION_EVENT_BUTTON_BACK, motionArgs.buttonState);
6359 
6360     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6361     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, motionArgs.action);
6362     ASSERT_EQ(AMOTION_EVENT_BUTTON_BACK, motionArgs.buttonState);
6363 
6364     processKey(mapper, BTN_BACK, 0);
6365     processSync(mapper);
6366     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6367     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, motionArgs.action);
6368     ASSERT_EQ(0, motionArgs.buttonState);
6369 
6370     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6371     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6372     ASSERT_EQ(0, motionArgs.buttonState);
6373 
6374     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs));
6375     ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action);
6376     ASSERT_EQ(AKEYCODE_BACK, keyArgs.keyCode);
6377 
6378     // press BTN_SIDE, release BTN_SIDE
6379     processKey(mapper, BTN_SIDE, 1);
6380     processSync(mapper);
6381     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs));
6382     ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action);
6383     ASSERT_EQ(AKEYCODE_BACK, keyArgs.keyCode);
6384 
6385     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6386     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6387     ASSERT_EQ(AMOTION_EVENT_BUTTON_BACK, motionArgs.buttonState);
6388 
6389     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6390     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, motionArgs.action);
6391     ASSERT_EQ(AMOTION_EVENT_BUTTON_BACK, motionArgs.buttonState);
6392 
6393     processKey(mapper, BTN_SIDE, 0);
6394     processSync(mapper);
6395     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6396     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, motionArgs.action);
6397     ASSERT_EQ(0, motionArgs.buttonState);
6398 
6399     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6400     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6401     ASSERT_EQ(0, motionArgs.buttonState);
6402 
6403     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs));
6404     ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action);
6405     ASSERT_EQ(AKEYCODE_BACK, keyArgs.keyCode);
6406 
6407     // press BTN_FORWARD, release BTN_FORWARD
6408     processKey(mapper, BTN_FORWARD, 1);
6409     processSync(mapper);
6410     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs));
6411     ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action);
6412     ASSERT_EQ(AKEYCODE_FORWARD, keyArgs.keyCode);
6413 
6414     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6415     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6416     ASSERT_EQ(AMOTION_EVENT_BUTTON_FORWARD, motionArgs.buttonState);
6417 
6418     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6419     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, motionArgs.action);
6420     ASSERT_EQ(AMOTION_EVENT_BUTTON_FORWARD, motionArgs.buttonState);
6421 
6422     processKey(mapper, BTN_FORWARD, 0);
6423     processSync(mapper);
6424     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6425     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, motionArgs.action);
6426     ASSERT_EQ(0, motionArgs.buttonState);
6427 
6428     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6429     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6430     ASSERT_EQ(0, motionArgs.buttonState);
6431 
6432     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs));
6433     ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action);
6434     ASSERT_EQ(AKEYCODE_FORWARD, keyArgs.keyCode);
6435 
6436     // press BTN_EXTRA, release BTN_EXTRA
6437     processKey(mapper, BTN_EXTRA, 1);
6438     processSync(mapper);
6439     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs));
6440     ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action);
6441     ASSERT_EQ(AKEYCODE_FORWARD, keyArgs.keyCode);
6442 
6443     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6444     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6445     ASSERT_EQ(AMOTION_EVENT_BUTTON_FORWARD, motionArgs.buttonState);
6446 
6447     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6448     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, motionArgs.action);
6449     ASSERT_EQ(AMOTION_EVENT_BUTTON_FORWARD, motionArgs.buttonState);
6450 
6451     processKey(mapper, BTN_EXTRA, 0);
6452     processSync(mapper);
6453     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6454     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, motionArgs.action);
6455     ASSERT_EQ(0, motionArgs.buttonState);
6456 
6457     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6458     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6459     ASSERT_EQ(0, motionArgs.buttonState);
6460 
6461     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs));
6462     ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action);
6463     ASSERT_EQ(AKEYCODE_FORWARD, keyArgs.keyCode);
6464 
6465     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasNotCalled());
6466 
6467     // press BTN_STYLUS, release BTN_STYLUS
6468     processKey(mapper, BTN_STYLUS, 1);
6469     processSync(mapper);
6470     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6471     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6472     ASSERT_EQ(AMOTION_EVENT_BUTTON_STYLUS_PRIMARY, motionArgs.buttonState);
6473 
6474     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6475     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, motionArgs.action);
6476     ASSERT_EQ(AMOTION_EVENT_BUTTON_STYLUS_PRIMARY, motionArgs.buttonState);
6477 
6478     processKey(mapper, BTN_STYLUS, 0);
6479     processSync(mapper);
6480     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6481     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, motionArgs.action);
6482     ASSERT_EQ(0, motionArgs.buttonState);
6483 
6484     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6485     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6486     ASSERT_EQ(0, motionArgs.buttonState);
6487 
6488     // press BTN_STYLUS2, release BTN_STYLUS2
6489     processKey(mapper, BTN_STYLUS2, 1);
6490     processSync(mapper);
6491     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6492     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6493     ASSERT_EQ(AMOTION_EVENT_BUTTON_STYLUS_SECONDARY, motionArgs.buttonState);
6494 
6495     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6496     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, motionArgs.action);
6497     ASSERT_EQ(AMOTION_EVENT_BUTTON_STYLUS_SECONDARY, motionArgs.buttonState);
6498 
6499     processKey(mapper, BTN_STYLUS2, 0);
6500     processSync(mapper);
6501     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6502     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, motionArgs.action);
6503     ASSERT_EQ(0, motionArgs.buttonState);
6504 
6505     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6506     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6507     ASSERT_EQ(0, motionArgs.buttonState);
6508 
6509     // release touch
6510     processUp(mapper);
6511     processSync(mapper);
6512     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6513     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
6514     ASSERT_EQ(0, motionArgs.buttonState);
6515 }
6516 
TEST_F(SingleTouchInputMapperTest,Process_ShouldHandleAllToolTypes)6517 TEST_F(SingleTouchInputMapperTest, Process_ShouldHandleAllToolTypes) {
6518     addConfigurationProperty("touch.deviceType", "touchScreen");
6519     prepareDisplay(DISPLAY_ORIENTATION_0);
6520     prepareButtons();
6521     prepareAxes(POSITION);
6522     SingleTouchInputMapper& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
6523 
6524     NotifyMotionArgs motionArgs;
6525 
6526     // default tool type is finger
6527     processDown(mapper, 100, 200);
6528     processSync(mapper);
6529     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6530     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
6531     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
6532 
6533     // eraser
6534     processKey(mapper, BTN_TOOL_RUBBER, 1);
6535     processSync(mapper);
6536     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6537     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6538     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_ERASER, motionArgs.pointerProperties[0].toolType);
6539 
6540     // stylus
6541     processKey(mapper, BTN_TOOL_RUBBER, 0);
6542     processKey(mapper, BTN_TOOL_PEN, 1);
6543     processSync(mapper);
6544     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6545     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6546     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_STYLUS, motionArgs.pointerProperties[0].toolType);
6547 
6548     // brush
6549     processKey(mapper, BTN_TOOL_PEN, 0);
6550     processKey(mapper, BTN_TOOL_BRUSH, 1);
6551     processSync(mapper);
6552     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6553     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6554     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_STYLUS, motionArgs.pointerProperties[0].toolType);
6555 
6556     // pencil
6557     processKey(mapper, BTN_TOOL_BRUSH, 0);
6558     processKey(mapper, BTN_TOOL_PENCIL, 1);
6559     processSync(mapper);
6560     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6561     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6562     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_STYLUS, motionArgs.pointerProperties[0].toolType);
6563 
6564     // air-brush
6565     processKey(mapper, BTN_TOOL_PENCIL, 0);
6566     processKey(mapper, BTN_TOOL_AIRBRUSH, 1);
6567     processSync(mapper);
6568     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6569     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6570     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_STYLUS, motionArgs.pointerProperties[0].toolType);
6571 
6572     // mouse
6573     processKey(mapper, BTN_TOOL_AIRBRUSH, 0);
6574     processKey(mapper, BTN_TOOL_MOUSE, 1);
6575     processSync(mapper);
6576     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6577     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6578     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_MOUSE, motionArgs.pointerProperties[0].toolType);
6579 
6580     // lens
6581     processKey(mapper, BTN_TOOL_MOUSE, 0);
6582     processKey(mapper, BTN_TOOL_LENS, 1);
6583     processSync(mapper);
6584     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6585     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6586     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_MOUSE, motionArgs.pointerProperties[0].toolType);
6587 
6588     // double-tap
6589     processKey(mapper, BTN_TOOL_LENS, 0);
6590     processKey(mapper, BTN_TOOL_DOUBLETAP, 1);
6591     processSync(mapper);
6592     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6593     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6594     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
6595 
6596     // triple-tap
6597     processKey(mapper, BTN_TOOL_DOUBLETAP, 0);
6598     processKey(mapper, BTN_TOOL_TRIPLETAP, 1);
6599     processSync(mapper);
6600     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6601     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6602     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
6603 
6604     // quad-tap
6605     processKey(mapper, BTN_TOOL_TRIPLETAP, 0);
6606     processKey(mapper, BTN_TOOL_QUADTAP, 1);
6607     processSync(mapper);
6608     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6609     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6610     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
6611 
6612     // finger
6613     processKey(mapper, BTN_TOOL_QUADTAP, 0);
6614     processKey(mapper, BTN_TOOL_FINGER, 1);
6615     processSync(mapper);
6616     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6617     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6618     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
6619 
6620     // stylus trumps finger
6621     processKey(mapper, BTN_TOOL_PEN, 1);
6622     processSync(mapper);
6623     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6624     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6625     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_STYLUS, motionArgs.pointerProperties[0].toolType);
6626 
6627     // eraser trumps stylus
6628     processKey(mapper, BTN_TOOL_RUBBER, 1);
6629     processSync(mapper);
6630     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6631     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6632     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_ERASER, motionArgs.pointerProperties[0].toolType);
6633 
6634     // mouse trumps eraser
6635     processKey(mapper, BTN_TOOL_MOUSE, 1);
6636     processSync(mapper);
6637     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6638     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6639     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_MOUSE, motionArgs.pointerProperties[0].toolType);
6640 
6641     // back to default tool type
6642     processKey(mapper, BTN_TOOL_MOUSE, 0);
6643     processKey(mapper, BTN_TOOL_RUBBER, 0);
6644     processKey(mapper, BTN_TOOL_PEN, 0);
6645     processKey(mapper, BTN_TOOL_FINGER, 0);
6646     processSync(mapper);
6647     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6648     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
6649     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
6650 }
6651 
TEST_F(SingleTouchInputMapperTest,Process_WhenBtnTouchPresent_HoversIfItsValueIsZero)6652 TEST_F(SingleTouchInputMapperTest, Process_WhenBtnTouchPresent_HoversIfItsValueIsZero) {
6653     addConfigurationProperty("touch.deviceType", "touchScreen");
6654     prepareDisplay(DISPLAY_ORIENTATION_0);
6655     prepareButtons();
6656     prepareAxes(POSITION);
6657     mFakeEventHub->addKey(EVENTHUB_ID, BTN_TOOL_FINGER, 0, AKEYCODE_UNKNOWN, 0);
6658     SingleTouchInputMapper& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
6659 
6660     NotifyMotionArgs motionArgs;
6661 
6662     // initially hovering because BTN_TOUCH not sent yet, pressure defaults to 0
6663     processKey(mapper, BTN_TOOL_FINGER, 1);
6664     processMove(mapper, 100, 200);
6665     processSync(mapper);
6666     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6667     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_ENTER, motionArgs.action);
6668     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
6669             toDisplayX(100), toDisplayY(200), 0, 0, 0, 0, 0, 0, 0, 0));
6670 
6671     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6672     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action);
6673     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
6674             toDisplayX(100), toDisplayY(200), 0, 0, 0, 0, 0, 0, 0, 0));
6675 
6676     // move a little
6677     processMove(mapper, 150, 250);
6678     processSync(mapper);
6679     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6680     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action);
6681     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
6682             toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0));
6683 
6684     // down when BTN_TOUCH is pressed, pressure defaults to 1
6685     processKey(mapper, BTN_TOUCH, 1);
6686     processSync(mapper);
6687     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6688     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_EXIT, motionArgs.action);
6689     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
6690             toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0));
6691 
6692     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6693     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
6694     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
6695             toDisplayX(150), toDisplayY(250), 1, 0, 0, 0, 0, 0, 0, 0));
6696 
6697     // up when BTN_TOUCH is released, hover restored
6698     processKey(mapper, BTN_TOUCH, 0);
6699     processSync(mapper);
6700     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6701     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
6702     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
6703             toDisplayX(150), toDisplayY(250), 1, 0, 0, 0, 0, 0, 0, 0));
6704 
6705     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6706     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_ENTER, motionArgs.action);
6707     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
6708             toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0));
6709 
6710     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6711     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action);
6712     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
6713             toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0));
6714 
6715     // exit hover when pointer goes away
6716     processKey(mapper, BTN_TOOL_FINGER, 0);
6717     processSync(mapper);
6718     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6719     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_EXIT, motionArgs.action);
6720     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
6721             toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0));
6722 }
6723 
TEST_F(SingleTouchInputMapperTest,Process_WhenAbsPressureIsPresent_HoversIfItsValueIsZero)6724 TEST_F(SingleTouchInputMapperTest, Process_WhenAbsPressureIsPresent_HoversIfItsValueIsZero) {
6725     addConfigurationProperty("touch.deviceType", "touchScreen");
6726     prepareDisplay(DISPLAY_ORIENTATION_0);
6727     prepareButtons();
6728     prepareAxes(POSITION | PRESSURE);
6729     SingleTouchInputMapper& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
6730 
6731     NotifyMotionArgs motionArgs;
6732 
6733     // initially hovering because pressure is 0
6734     processDown(mapper, 100, 200);
6735     processPressure(mapper, 0);
6736     processSync(mapper);
6737     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6738     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_ENTER, motionArgs.action);
6739     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
6740             toDisplayX(100), toDisplayY(200), 0, 0, 0, 0, 0, 0, 0, 0));
6741 
6742     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6743     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action);
6744     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
6745             toDisplayX(100), toDisplayY(200), 0, 0, 0, 0, 0, 0, 0, 0));
6746 
6747     // move a little
6748     processMove(mapper, 150, 250);
6749     processSync(mapper);
6750     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6751     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action);
6752     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
6753             toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0));
6754 
6755     // down when pressure is non-zero
6756     processPressure(mapper, RAW_PRESSURE_MAX);
6757     processSync(mapper);
6758     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6759     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_EXIT, motionArgs.action);
6760     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
6761             toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0));
6762 
6763     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6764     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
6765     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
6766             toDisplayX(150), toDisplayY(250), 1, 0, 0, 0, 0, 0, 0, 0));
6767 
6768     // up when pressure becomes 0, hover restored
6769     processPressure(mapper, 0);
6770     processSync(mapper);
6771     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6772     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
6773     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
6774             toDisplayX(150), toDisplayY(250), 1, 0, 0, 0, 0, 0, 0, 0));
6775 
6776     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6777     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_ENTER, motionArgs.action);
6778     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
6779             toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0));
6780 
6781     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6782     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action);
6783     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
6784             toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0));
6785 
6786     // exit hover when pointer goes away
6787     processUp(mapper);
6788     processSync(mapper);
6789     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6790     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_EXIT, motionArgs.action);
6791     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
6792             toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0));
6793 }
6794 
TEST_F(SingleTouchInputMapperTest,Reset_RecreatesTouchState)6795 TEST_F(SingleTouchInputMapperTest, Reset_RecreatesTouchState) {
6796     addConfigurationProperty("touch.deviceType", "touchScreen");
6797     prepareDisplay(DISPLAY_ORIENTATION_0);
6798     prepareButtons();
6799     prepareAxes(POSITION | PRESSURE);
6800     SingleTouchInputMapper& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
6801     NotifyMotionArgs motionArgs;
6802 
6803     // Set the initial state for the touch pointer.
6804     mFakeEventHub->setAbsoluteAxisValue(EVENTHUB_ID, ABS_X, 100);
6805     mFakeEventHub->setAbsoluteAxisValue(EVENTHUB_ID, ABS_Y, 200);
6806     mFakeEventHub->setAbsoluteAxisValue(EVENTHUB_ID, ABS_PRESSURE, RAW_PRESSURE_MAX);
6807     mFakeEventHub->setScanCodeState(EVENTHUB_ID, BTN_TOUCH, 1);
6808 
6809     // Reset the mapper. When the mapper is reset, we expect it to attempt to recreate the touch
6810     // state by reading the current axis values.
6811     mapper.reset(ARBITRARY_TIME);
6812 
6813     // Send a sync to simulate an empty touch frame where nothing changes. The mapper should use
6814     // the recreated touch state to generate a down event.
6815     processSync(mapper);
6816     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6817     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
6818 
6819     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());
6820 }
6821 
TEST_F(SingleTouchInputMapperTest,WhenViewportActiveStatusChanged_PointerGestureIsReset)6822 TEST_F(SingleTouchInputMapperTest, WhenViewportActiveStatusChanged_PointerGestureIsReset) {
6823     std::shared_ptr<FakePointerController> fakePointerController =
6824             std::make_shared<FakePointerController>();
6825     fakePointerController->setBounds(0, 0, DISPLAY_WIDTH - 1, DISPLAY_HEIGHT - 1);
6826     fakePointerController->setPosition(100, 200);
6827     fakePointerController->setButtonState(0);
6828     mFakePolicy->setPointerController(fakePointerController);
6829 
6830     addConfigurationProperty("touch.deviceType", "pointer");
6831     prepareDisplay(DISPLAY_ORIENTATION_0);
6832     prepareButtons();
6833     mFakeEventHub->addKey(EVENTHUB_ID, BTN_TOOL_PEN, 0, AKEYCODE_UNKNOWN, 0);
6834     prepareAxes(POSITION);
6835     SingleTouchInputMapper& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
6836     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled());
6837 
6838     // Start a stylus gesture.
6839     processKey(mapper, BTN_TOOL_PEN, 1);
6840     processDown(mapper, 100, 200);
6841     processSync(mapper);
6842     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(
6843             AllOf(WithAction(AMOTION_EVENT_ACTION_DOWN),
6844                   WithSource(AINPUT_SOURCE_MOUSE | AINPUT_SOURCE_STYLUS),
6845                   WithToolType(AMOTION_EVENT_TOOL_TYPE_STYLUS))));
6846     // TODO(b/257078296): Pointer mode generates extra event.
6847     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(
6848             AllOf(WithAction(AMOTION_EVENT_ACTION_MOVE),
6849                   WithSource(AINPUT_SOURCE_MOUSE | AINPUT_SOURCE_STYLUS),
6850                   WithToolType(AMOTION_EVENT_TOOL_TYPE_STYLUS))));
6851     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());
6852 
6853     // Make the viewport inactive. This will put the device in disabled mode, and the ongoing stylus
6854     // gesture should be disabled.
6855     auto viewport = mFakePolicy->getDisplayViewportByType(ViewportType::INTERNAL);
6856     viewport->isActive = false;
6857     mFakePolicy->updateViewport(*viewport);
6858     configureDevice(InputReaderConfiguration::CHANGE_DISPLAY_INFO);
6859     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(
6860             AllOf(WithAction(AMOTION_EVENT_ACTION_CANCEL),
6861                   WithSource(AINPUT_SOURCE_MOUSE | AINPUT_SOURCE_STYLUS),
6862                   WithToolType(AMOTION_EVENT_TOOL_TYPE_STYLUS))));
6863     // TODO(b/257078296): Pointer mode generates extra event.
6864     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(
6865             AllOf(WithAction(AMOTION_EVENT_ACTION_CANCEL),
6866                   WithSource(AINPUT_SOURCE_MOUSE | AINPUT_SOURCE_STYLUS),
6867                   WithToolType(AMOTION_EVENT_TOOL_TYPE_STYLUS))));
6868     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());
6869 }
6870 
TEST_F(SingleTouchInputMapperTest,Process_WhenViewportDisplayIdChanged_TouchIsCanceledAndDeviceIsReset)6871 TEST_F(SingleTouchInputMapperTest,
6872        Process_WhenViewportDisplayIdChanged_TouchIsCanceledAndDeviceIsReset) {
6873     addConfigurationProperty("touch.deviceType", "touchScreen");
6874     prepareDisplay(DISPLAY_ORIENTATION_0);
6875     prepareButtons();
6876     prepareAxes(POSITION);
6877     SingleTouchInputMapper& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
6878     NotifyMotionArgs motionArgs;
6879 
6880     // Down.
6881     processDown(mapper, 100, 200);
6882     processSync(mapper);
6883 
6884     // We should receive a down event
6885     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6886     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
6887 
6888     // Change display id
6889     clearViewports();
6890     prepareSecondaryDisplay(ViewportType::INTERNAL);
6891 
6892     // We should receive a cancel event
6893     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6894     ASSERT_EQ(AMOTION_EVENT_ACTION_CANCEL, motionArgs.action);
6895     // Then receive reset called
6896     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled());
6897 }
6898 
TEST_F(SingleTouchInputMapperTest,Process_WhenViewportActiveStatusChanged_TouchIsCanceledAndDeviceIsReset)6899 TEST_F(SingleTouchInputMapperTest,
6900        Process_WhenViewportActiveStatusChanged_TouchIsCanceledAndDeviceIsReset) {
6901     addConfigurationProperty("touch.deviceType", "touchScreen");
6902     prepareDisplay(DISPLAY_ORIENTATION_0);
6903     prepareButtons();
6904     prepareAxes(POSITION);
6905     SingleTouchInputMapper& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
6906     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled());
6907     NotifyMotionArgs motionArgs;
6908 
6909     // Start a new gesture.
6910     processDown(mapper, 100, 200);
6911     processSync(mapper);
6912     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6913     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
6914 
6915     // Make the viewport inactive. This will put the device in disabled mode.
6916     auto viewport = mFakePolicy->getDisplayViewportByType(ViewportType::INTERNAL);
6917     viewport->isActive = false;
6918     mFakePolicy->updateViewport(*viewport);
6919     configureDevice(InputReaderConfiguration::CHANGE_DISPLAY_INFO);
6920 
6921     // We should receive a cancel event for the ongoing gesture.
6922     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6923     ASSERT_EQ(AMOTION_EVENT_ACTION_CANCEL, motionArgs.action);
6924     // Then we should be notified that the device was reset.
6925     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled());
6926 
6927     // No events are generated while the viewport is inactive.
6928     processMove(mapper, 101, 201);
6929     processSync(mapper);
6930     processUp(mapper);
6931     processSync(mapper);
6932     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());
6933 
6934     // Start a new gesture while the viewport is still inactive.
6935     processDown(mapper, 300, 400);
6936     mFakeEventHub->setAbsoluteAxisValue(EVENTHUB_ID, ABS_X, 300);
6937     mFakeEventHub->setAbsoluteAxisValue(EVENTHUB_ID, ABS_Y, 400);
6938     mFakeEventHub->setScanCodeState(EVENTHUB_ID, BTN_TOUCH, 1);
6939     processSync(mapper);
6940 
6941     // Make the viewport active again. The device should resume processing events.
6942     viewport->isActive = true;
6943     mFakePolicy->updateViewport(*viewport);
6944     configureDevice(InputReaderConfiguration::CHANGE_DISPLAY_INFO);
6945 
6946     // The device is reset because it changes back to direct mode, without generating any events.
6947     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled());
6948     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());
6949 
6950     // In the next sync, the touch state that was recreated when the device was reset is reported.
6951     processSync(mapper);
6952     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
6953     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
6954 
6955     // No more events.
6956     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());
6957     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasNotCalled());
6958 }
6959 
6960 // --- TouchDisplayProjectionTest ---
6961 
6962 class TouchDisplayProjectionTest : public SingleTouchInputMapperTest {
6963 public:
6964     // The values inside DisplayViewport are expected to be pre-rotated. This updates the current
6965     // DisplayViewport to pre-rotate the values. The viewport's physical display will be set to the
6966     // rotated equivalent of the given un-rotated physical display bounds.
configurePhysicalDisplay(int32_t orientation,Rect naturalPhysicalDisplay)6967     void configurePhysicalDisplay(int32_t orientation, Rect naturalPhysicalDisplay) {
6968         uint32_t inverseRotationFlags;
6969         auto width = DISPLAY_WIDTH;
6970         auto height = DISPLAY_HEIGHT;
6971         switch (orientation) {
6972             case DISPLAY_ORIENTATION_90:
6973                 inverseRotationFlags = ui::Transform::ROT_270;
6974                 std::swap(width, height);
6975                 break;
6976             case DISPLAY_ORIENTATION_180:
6977                 inverseRotationFlags = ui::Transform::ROT_180;
6978                 break;
6979             case DISPLAY_ORIENTATION_270:
6980                 inverseRotationFlags = ui::Transform::ROT_90;
6981                 std::swap(width, height);
6982                 break;
6983             case DISPLAY_ORIENTATION_0:
6984                 inverseRotationFlags = ui::Transform::ROT_0;
6985                 break;
6986             default:
6987                 FAIL() << "Invalid orientation: " << orientation;
6988         }
6989 
6990         const ui::Transform rotation(inverseRotationFlags, width, height);
6991         const Rect rotatedPhysicalDisplay = rotation.transform(naturalPhysicalDisplay);
6992 
6993         std::optional<DisplayViewport> internalViewport =
6994                 *mFakePolicy->getDisplayViewportByType(ViewportType::INTERNAL);
6995         DisplayViewport& v = *internalViewport;
6996         v.displayId = DISPLAY_ID;
6997         v.orientation = orientation;
6998 
6999         v.logicalLeft = 0;
7000         v.logicalTop = 0;
7001         v.logicalRight = 100;
7002         v.logicalBottom = 100;
7003 
7004         v.physicalLeft = rotatedPhysicalDisplay.left;
7005         v.physicalTop = rotatedPhysicalDisplay.top;
7006         v.physicalRight = rotatedPhysicalDisplay.right;
7007         v.physicalBottom = rotatedPhysicalDisplay.bottom;
7008 
7009         v.deviceWidth = width;
7010         v.deviceHeight = height;
7011 
7012         v.isActive = true;
7013         v.uniqueId = UNIQUE_ID;
7014         v.type = ViewportType::INTERNAL;
7015         mFakePolicy->updateViewport(v);
7016         configureDevice(InputReaderConfiguration::CHANGE_DISPLAY_INFO);
7017     }
7018 
assertReceivedMove(const Point & point)7019     void assertReceivedMove(const Point& point) {
7020         NotifyMotionArgs motionArgs;
7021         ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7022         ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
7023         ASSERT_EQ(size_t(1), motionArgs.pointerCount);
7024         ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], point.x, point.y,
7025                                                     1, 0, 0, 0, 0, 0, 0, 0));
7026     }
7027 };
7028 
TEST_F(TouchDisplayProjectionTest,IgnoresTouchesOutsidePhysicalDisplay)7029 TEST_F(TouchDisplayProjectionTest, IgnoresTouchesOutsidePhysicalDisplay) {
7030     addConfigurationProperty("touch.deviceType", "touchScreen");
7031     prepareDisplay(DISPLAY_ORIENTATION_0);
7032 
7033     prepareButtons();
7034     prepareAxes(POSITION);
7035     SingleTouchInputMapper& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
7036 
7037     NotifyMotionArgs motionArgs;
7038 
7039     // Configure the DisplayViewport such that the logical display maps to a subsection of
7040     // the display panel called the physical display. Here, the physical display is bounded by the
7041     // points (10, 20) and (70, 160) inside the display space, which is of the size 400 x 800.
7042     static const Rect kPhysicalDisplay{10, 20, 70, 160};
7043     static const std::array<Point, 6> kPointsOutsidePhysicalDisplay{
7044             {{-10, -10}, {0, 0}, {5, 100}, {50, 15}, {75, 100}, {50, 165}}};
7045 
7046     for (auto orientation : {DISPLAY_ORIENTATION_0, DISPLAY_ORIENTATION_90, DISPLAY_ORIENTATION_180,
7047                              DISPLAY_ORIENTATION_270}) {
7048         configurePhysicalDisplay(orientation, kPhysicalDisplay);
7049 
7050         // Touches outside the physical display should be ignored, and should not generate any
7051         // events. Ensure touches at the following points that lie outside of the physical display
7052         // area do not generate any events.
7053         for (const auto& point : kPointsOutsidePhysicalDisplay) {
7054             processDown(mapper, toRawX(point.x), toRawY(point.y));
7055             processSync(mapper);
7056             processUp(mapper);
7057             processSync(mapper);
7058             ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled())
7059                     << "Unexpected event generated for touch outside physical display at point: "
7060                     << point.x << ", " << point.y;
7061         }
7062     }
7063 }
7064 
TEST_F(TouchDisplayProjectionTest,EmitsTouchDownAfterEnteringPhysicalDisplay)7065 TEST_F(TouchDisplayProjectionTest, EmitsTouchDownAfterEnteringPhysicalDisplay) {
7066     addConfigurationProperty("touch.deviceType", "touchScreen");
7067     prepareDisplay(DISPLAY_ORIENTATION_0);
7068 
7069     prepareButtons();
7070     prepareAxes(POSITION);
7071     SingleTouchInputMapper& mapper = addMapperAndConfigure<SingleTouchInputMapper>();
7072 
7073     NotifyMotionArgs motionArgs;
7074 
7075     // Configure the DisplayViewport such that the logical display maps to a subsection of
7076     // the display panel called the physical display. Here, the physical display is bounded by the
7077     // points (10, 20) and (70, 160) inside the display space, which is of the size 400 x 800.
7078     static const Rect kPhysicalDisplay{10, 20, 70, 160};
7079 
7080     for (auto orientation : {DISPLAY_ORIENTATION_0, DISPLAY_ORIENTATION_90, DISPLAY_ORIENTATION_180,
7081                              DISPLAY_ORIENTATION_270}) {
7082         configurePhysicalDisplay(orientation, kPhysicalDisplay);
7083 
7084         // Touches that start outside the physical display should be ignored until it enters the
7085         // physical display bounds, at which point it should generate a down event. Start a touch at
7086         // the point (5, 100), which is outside the physical display bounds.
7087         static const Point kOutsidePoint{5, 100};
7088         processDown(mapper, toRawX(kOutsidePoint.x), toRawY(kOutsidePoint.y));
7089         processSync(mapper);
7090         ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());
7091 
7092         // Move the touch into the physical display area. This should generate a pointer down.
7093         processMove(mapper, toRawX(11), toRawY(21));
7094         processSync(mapper);
7095         ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7096         ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
7097         ASSERT_EQ(size_t(1), motionArgs.pointerCount);
7098         ASSERT_NO_FATAL_FAILURE(
7099                 assertPointerCoords(motionArgs.pointerCoords[0], 11, 21, 1, 0, 0, 0, 0, 0, 0, 0));
7100 
7101         // Move the touch inside the physical display area. This should generate a pointer move.
7102         processMove(mapper, toRawX(69), toRawY(159));
7103         processSync(mapper);
7104         assertReceivedMove({69, 159});
7105 
7106         // Move outside the physical display area. Since the pointer is already down, this should
7107         // now continue generating events.
7108         processMove(mapper, toRawX(kOutsidePoint.x), toRawY(kOutsidePoint.y));
7109         processSync(mapper);
7110         assertReceivedMove(kOutsidePoint);
7111 
7112         // Release. This should generate a pointer up.
7113         processUp(mapper);
7114         processSync(mapper);
7115         ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7116         ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
7117         ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0], kOutsidePoint.x,
7118                                                     kOutsidePoint.y, 1, 0, 0, 0, 0, 0, 0, 0));
7119 
7120         // Ensure no more events were generated.
7121         ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasNotCalled());
7122         ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());
7123     }
7124 }
7125 
7126 // --- MultiTouchInputMapperTest ---
7127 
7128 class MultiTouchInputMapperTest : public TouchInputMapperTest {
7129 protected:
7130     void prepareAxes(int axes);
7131 
7132     void processPosition(MultiTouchInputMapper& mapper, int32_t x, int32_t y);
7133     void processTouchMajor(MultiTouchInputMapper& mapper, int32_t touchMajor);
7134     void processTouchMinor(MultiTouchInputMapper& mapper, int32_t touchMinor);
7135     void processToolMajor(MultiTouchInputMapper& mapper, int32_t toolMajor);
7136     void processToolMinor(MultiTouchInputMapper& mapper, int32_t toolMinor);
7137     void processOrientation(MultiTouchInputMapper& mapper, int32_t orientation);
7138     void processPressure(MultiTouchInputMapper& mapper, int32_t pressure);
7139     void processDistance(MultiTouchInputMapper& mapper, int32_t distance);
7140     void processId(MultiTouchInputMapper& mapper, int32_t id);
7141     void processSlot(MultiTouchInputMapper& mapper, int32_t slot);
7142     void processToolType(MultiTouchInputMapper& mapper, int32_t toolType);
7143     void processKey(MultiTouchInputMapper& mapper, int32_t code, int32_t value);
7144     void processMTSync(MultiTouchInputMapper& mapper);
7145     void processSync(MultiTouchInputMapper& mapper);
7146 };
7147 
prepareAxes(int axes)7148 void MultiTouchInputMapperTest::prepareAxes(int axes) {
7149     if (axes & POSITION) {
7150         mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_MT_POSITION_X, RAW_X_MIN, RAW_X_MAX, 0, 0);
7151         mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_MT_POSITION_Y, RAW_Y_MIN, RAW_Y_MAX, 0, 0);
7152     }
7153     if (axes & TOUCH) {
7154         mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_MT_TOUCH_MAJOR, RAW_TOUCH_MIN,
7155                                        RAW_TOUCH_MAX, 0, 0);
7156         if (axes & MINOR) {
7157             mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_MT_TOUCH_MINOR, RAW_TOUCH_MIN,
7158                                            RAW_TOUCH_MAX, 0, 0);
7159         }
7160     }
7161     if (axes & TOOL) {
7162         mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_MT_WIDTH_MAJOR, RAW_TOOL_MIN, RAW_TOOL_MAX,
7163                                        0, 0);
7164         if (axes & MINOR) {
7165             mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_MT_WIDTH_MINOR, RAW_TOOL_MIN,
7166                                            RAW_TOOL_MAX, 0, 0);
7167         }
7168     }
7169     if (axes & ORIENTATION) {
7170         mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_MT_ORIENTATION, RAW_ORIENTATION_MIN,
7171                                        RAW_ORIENTATION_MAX, 0, 0);
7172     }
7173     if (axes & PRESSURE) {
7174         mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_MT_PRESSURE, RAW_PRESSURE_MIN,
7175                                        RAW_PRESSURE_MAX, 0, 0);
7176     }
7177     if (axes & DISTANCE) {
7178         mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_MT_DISTANCE, RAW_DISTANCE_MIN,
7179                                        RAW_DISTANCE_MAX, 0, 0);
7180     }
7181     if (axes & ID) {
7182         mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_MT_TRACKING_ID, RAW_ID_MIN, RAW_ID_MAX, 0,
7183                                        0);
7184     }
7185     if (axes & SLOT) {
7186         mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_MT_SLOT, RAW_SLOT_MIN, RAW_SLOT_MAX, 0, 0);
7187         mFakeEventHub->setAbsoluteAxisValue(EVENTHUB_ID, ABS_MT_SLOT, 0);
7188     }
7189     if (axes & TOOL_TYPE) {
7190         mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_MT_TOOL_TYPE, 0, MT_TOOL_MAX, 0, 0);
7191     }
7192 }
7193 
processPosition(MultiTouchInputMapper & mapper,int32_t x,int32_t y)7194 void MultiTouchInputMapperTest::processPosition(MultiTouchInputMapper& mapper, int32_t x,
7195                                                 int32_t y) {
7196     process(mapper, ARBITRARY_TIME, READ_TIME, EV_ABS, ABS_MT_POSITION_X, x);
7197     process(mapper, ARBITRARY_TIME, READ_TIME, EV_ABS, ABS_MT_POSITION_Y, y);
7198 }
7199 
processTouchMajor(MultiTouchInputMapper & mapper,int32_t touchMajor)7200 void MultiTouchInputMapperTest::processTouchMajor(MultiTouchInputMapper& mapper,
7201                                                   int32_t touchMajor) {
7202     process(mapper, ARBITRARY_TIME, READ_TIME, EV_ABS, ABS_MT_TOUCH_MAJOR, touchMajor);
7203 }
7204 
processTouchMinor(MultiTouchInputMapper & mapper,int32_t touchMinor)7205 void MultiTouchInputMapperTest::processTouchMinor(MultiTouchInputMapper& mapper,
7206                                                   int32_t touchMinor) {
7207     process(mapper, ARBITRARY_TIME, READ_TIME, EV_ABS, ABS_MT_TOUCH_MINOR, touchMinor);
7208 }
7209 
processToolMajor(MultiTouchInputMapper & mapper,int32_t toolMajor)7210 void MultiTouchInputMapperTest::processToolMajor(MultiTouchInputMapper& mapper, int32_t toolMajor) {
7211     process(mapper, ARBITRARY_TIME, READ_TIME, EV_ABS, ABS_MT_WIDTH_MAJOR, toolMajor);
7212 }
7213 
processToolMinor(MultiTouchInputMapper & mapper,int32_t toolMinor)7214 void MultiTouchInputMapperTest::processToolMinor(MultiTouchInputMapper& mapper, int32_t toolMinor) {
7215     process(mapper, ARBITRARY_TIME, READ_TIME, EV_ABS, ABS_MT_WIDTH_MINOR, toolMinor);
7216 }
7217 
processOrientation(MultiTouchInputMapper & mapper,int32_t orientation)7218 void MultiTouchInputMapperTest::processOrientation(MultiTouchInputMapper& mapper,
7219                                                    int32_t orientation) {
7220     process(mapper, ARBITRARY_TIME, READ_TIME, EV_ABS, ABS_MT_ORIENTATION, orientation);
7221 }
7222 
processPressure(MultiTouchInputMapper & mapper,int32_t pressure)7223 void MultiTouchInputMapperTest::processPressure(MultiTouchInputMapper& mapper, int32_t pressure) {
7224     process(mapper, ARBITRARY_TIME, READ_TIME, EV_ABS, ABS_MT_PRESSURE, pressure);
7225 }
7226 
processDistance(MultiTouchInputMapper & mapper,int32_t distance)7227 void MultiTouchInputMapperTest::processDistance(MultiTouchInputMapper& mapper, int32_t distance) {
7228     process(mapper, ARBITRARY_TIME, READ_TIME, EV_ABS, ABS_MT_DISTANCE, distance);
7229 }
7230 
processId(MultiTouchInputMapper & mapper,int32_t id)7231 void MultiTouchInputMapperTest::processId(MultiTouchInputMapper& mapper, int32_t id) {
7232     process(mapper, ARBITRARY_TIME, READ_TIME, EV_ABS, ABS_MT_TRACKING_ID, id);
7233 }
7234 
processSlot(MultiTouchInputMapper & mapper,int32_t slot)7235 void MultiTouchInputMapperTest::processSlot(MultiTouchInputMapper& mapper, int32_t slot) {
7236     process(mapper, ARBITRARY_TIME, READ_TIME, EV_ABS, ABS_MT_SLOT, slot);
7237 }
7238 
processToolType(MultiTouchInputMapper & mapper,int32_t toolType)7239 void MultiTouchInputMapperTest::processToolType(MultiTouchInputMapper& mapper, int32_t toolType) {
7240     process(mapper, ARBITRARY_TIME, READ_TIME, EV_ABS, ABS_MT_TOOL_TYPE, toolType);
7241 }
7242 
processKey(MultiTouchInputMapper & mapper,int32_t code,int32_t value)7243 void MultiTouchInputMapperTest::processKey(MultiTouchInputMapper& mapper, int32_t code,
7244                                            int32_t value) {
7245     process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, code, value);
7246 }
7247 
processMTSync(MultiTouchInputMapper & mapper)7248 void MultiTouchInputMapperTest::processMTSync(MultiTouchInputMapper& mapper) {
7249     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_MT_REPORT, 0);
7250 }
7251 
processSync(MultiTouchInputMapper & mapper)7252 void MultiTouchInputMapperTest::processSync(MultiTouchInputMapper& mapper) {
7253     process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
7254 }
7255 
TEST_F(MultiTouchInputMapperTest,Process_NormalMultiTouchGesture_WithoutTrackingIds)7256 TEST_F(MultiTouchInputMapperTest, Process_NormalMultiTouchGesture_WithoutTrackingIds) {
7257     addConfigurationProperty("touch.deviceType", "touchScreen");
7258     prepareDisplay(DISPLAY_ORIENTATION_0);
7259     prepareAxes(POSITION);
7260     prepareVirtualKeys();
7261     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
7262 
7263     mReader->getContext()->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
7264 
7265     NotifyMotionArgs motionArgs;
7266 
7267     // Two fingers down at once.
7268     int32_t x1 = 100, y1 = 125, x2 = 300, y2 = 500;
7269     processPosition(mapper, x1, y1);
7270     processMTSync(mapper);
7271     processPosition(mapper, x2, y2);
7272     processMTSync(mapper);
7273     processSync(mapper);
7274 
7275     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7276     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
7277     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
7278     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
7279     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
7280     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
7281     ASSERT_EQ(0, motionArgs.flags);
7282     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
7283     ASSERT_EQ(0, motionArgs.buttonState);
7284     ASSERT_EQ(0, motionArgs.edgeFlags);
7285     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
7286     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
7287     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7288     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7289             toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0, 0));
7290     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
7291     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
7292     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
7293 
7294     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7295     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
7296     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
7297     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
7298     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
7299     ASSERT_EQ(ACTION_POINTER_1_DOWN, motionArgs.action);
7300     ASSERT_EQ(0, motionArgs.flags);
7301     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
7302     ASSERT_EQ(0, motionArgs.buttonState);
7303     ASSERT_EQ(0, motionArgs.edgeFlags);
7304     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
7305     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
7306     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7307     ASSERT_EQ(1, motionArgs.pointerProperties[1].id);
7308     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType);
7309     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7310             toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0, 0));
7311     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
7312             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0));
7313     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
7314     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
7315     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
7316 
7317     // Move.
7318     x1 += 10; y1 += 15; x2 += 5; y2 -= 10;
7319     processPosition(mapper, x1, y1);
7320     processMTSync(mapper);
7321     processPosition(mapper, x2, y2);
7322     processMTSync(mapper);
7323     processSync(mapper);
7324 
7325     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7326     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
7327     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
7328     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
7329     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
7330     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
7331     ASSERT_EQ(0, motionArgs.flags);
7332     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
7333     ASSERT_EQ(0, motionArgs.buttonState);
7334     ASSERT_EQ(0, motionArgs.edgeFlags);
7335     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
7336     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
7337     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7338     ASSERT_EQ(1, motionArgs.pointerProperties[1].id);
7339     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType);
7340     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7341             toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0, 0));
7342     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
7343             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0));
7344     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
7345     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
7346     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
7347 
7348     // First finger up.
7349     x2 += 15; y2 -= 20;
7350     processPosition(mapper, x2, y2);
7351     processMTSync(mapper);
7352     processSync(mapper);
7353 
7354     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7355     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
7356     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
7357     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
7358     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
7359     ASSERT_EQ(ACTION_POINTER_0_UP, motionArgs.action);
7360     ASSERT_EQ(0, motionArgs.flags);
7361     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
7362     ASSERT_EQ(0, motionArgs.buttonState);
7363     ASSERT_EQ(0, motionArgs.edgeFlags);
7364     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
7365     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
7366     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7367     ASSERT_EQ(1, motionArgs.pointerProperties[1].id);
7368     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType);
7369     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7370             toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0, 0));
7371     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
7372             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0));
7373     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
7374     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
7375     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
7376 
7377     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7378     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
7379     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
7380     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
7381     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
7382     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
7383     ASSERT_EQ(0, motionArgs.flags);
7384     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
7385     ASSERT_EQ(0, motionArgs.buttonState);
7386     ASSERT_EQ(0, motionArgs.edgeFlags);
7387     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
7388     ASSERT_EQ(1, motionArgs.pointerProperties[0].id);
7389     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7390     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7391             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0));
7392     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
7393     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
7394     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
7395 
7396     // Move.
7397     x2 += 20; y2 -= 25;
7398     processPosition(mapper, x2, y2);
7399     processMTSync(mapper);
7400     processSync(mapper);
7401 
7402     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7403     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
7404     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
7405     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
7406     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
7407     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
7408     ASSERT_EQ(0, motionArgs.flags);
7409     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
7410     ASSERT_EQ(0, motionArgs.buttonState);
7411     ASSERT_EQ(0, motionArgs.edgeFlags);
7412     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
7413     ASSERT_EQ(1, motionArgs.pointerProperties[0].id);
7414     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7415     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7416             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0));
7417     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
7418     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
7419     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
7420 
7421     // New finger down.
7422     int32_t x3 = 700, y3 = 300;
7423     processPosition(mapper, x2, y2);
7424     processMTSync(mapper);
7425     processPosition(mapper, x3, y3);
7426     processMTSync(mapper);
7427     processSync(mapper);
7428 
7429     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7430     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
7431     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
7432     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
7433     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
7434     ASSERT_EQ(ACTION_POINTER_0_DOWN, motionArgs.action);
7435     ASSERT_EQ(0, motionArgs.flags);
7436     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
7437     ASSERT_EQ(0, motionArgs.buttonState);
7438     ASSERT_EQ(0, motionArgs.edgeFlags);
7439     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
7440     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
7441     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7442     ASSERT_EQ(1, motionArgs.pointerProperties[1].id);
7443     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType);
7444     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7445             toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0, 0));
7446     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
7447             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0));
7448     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
7449     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
7450     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
7451 
7452     // Second finger up.
7453     x3 += 30; y3 -= 20;
7454     processPosition(mapper, x3, y3);
7455     processMTSync(mapper);
7456     processSync(mapper);
7457 
7458     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7459     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
7460     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
7461     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
7462     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
7463     ASSERT_EQ(ACTION_POINTER_1_UP, motionArgs.action);
7464     ASSERT_EQ(0, motionArgs.flags);
7465     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
7466     ASSERT_EQ(0, motionArgs.buttonState);
7467     ASSERT_EQ(0, motionArgs.edgeFlags);
7468     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
7469     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
7470     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7471     ASSERT_EQ(1, motionArgs.pointerProperties[1].id);
7472     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType);
7473     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7474             toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0, 0));
7475     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
7476             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0));
7477     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
7478     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
7479     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
7480 
7481     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7482     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
7483     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
7484     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
7485     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
7486     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
7487     ASSERT_EQ(0, motionArgs.flags);
7488     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
7489     ASSERT_EQ(0, motionArgs.buttonState);
7490     ASSERT_EQ(0, motionArgs.edgeFlags);
7491     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
7492     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
7493     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7494     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7495             toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0, 0));
7496     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
7497     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
7498     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
7499 
7500     // Last finger up.
7501     processMTSync(mapper);
7502     processSync(mapper);
7503 
7504     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7505     ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
7506     ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
7507     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
7508     ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
7509     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
7510     ASSERT_EQ(0, motionArgs.flags);
7511     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
7512     ASSERT_EQ(0, motionArgs.buttonState);
7513     ASSERT_EQ(0, motionArgs.edgeFlags);
7514     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
7515     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
7516     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7517     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7518             toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0, 0));
7519     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
7520     ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
7521     ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
7522 
7523     // Should not have sent any more keys or motions.
7524     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasNotCalled());
7525     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());
7526 }
7527 
TEST_F(MultiTouchInputMapperTest,AxisResolution_IsPopulated)7528 TEST_F(MultiTouchInputMapperTest, AxisResolution_IsPopulated) {
7529     addConfigurationProperty("touch.deviceType", "touchScreen");
7530     prepareDisplay(DISPLAY_ORIENTATION_0);
7531 
7532     mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_MT_POSITION_X, RAW_X_MIN, RAW_X_MAX, /*flat*/ 0,
7533                                    /*fuzz*/ 0, /*resolution*/ 10);
7534     mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_MT_POSITION_Y, RAW_Y_MIN, RAW_Y_MAX, /*flat*/ 0,
7535                                    /*fuzz*/ 0, /*resolution*/ 11);
7536     mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_MT_TOUCH_MAJOR, RAW_TOUCH_MIN, RAW_TOUCH_MAX,
7537                                    /*flat*/ 0, /*fuzz*/ 0, /*resolution*/ 12);
7538     mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_MT_TOUCH_MINOR, RAW_TOUCH_MIN, RAW_TOUCH_MAX,
7539                                    /*flat*/ 0, /*fuzz*/ 0, /*resolution*/ 13);
7540     mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_MT_WIDTH_MAJOR, RAW_TOOL_MIN, RAW_TOOL_MAX,
7541                                    /*flat*/ 0, /*flat*/ 0, /*resolution*/ 14);
7542     mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_MT_WIDTH_MINOR, RAW_TOOL_MIN, RAW_TOOL_MAX,
7543                                    /*flat*/ 0, /*flat*/ 0, /*resolution*/ 15);
7544 
7545     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
7546 
7547     // X and Y axes
7548     assertAxisResolution(mapper, AMOTION_EVENT_AXIS_X, 10 / X_PRECISION);
7549     assertAxisResolution(mapper, AMOTION_EVENT_AXIS_Y, 11 / Y_PRECISION);
7550     // Touch major and minor
7551     assertAxisResolution(mapper, AMOTION_EVENT_AXIS_TOUCH_MAJOR, 12 * GEOMETRIC_SCALE);
7552     assertAxisResolution(mapper, AMOTION_EVENT_AXIS_TOUCH_MINOR, 13 * GEOMETRIC_SCALE);
7553     // Tool major and minor
7554     assertAxisResolution(mapper, AMOTION_EVENT_AXIS_TOOL_MAJOR, 14 * GEOMETRIC_SCALE);
7555     assertAxisResolution(mapper, AMOTION_EVENT_AXIS_TOOL_MINOR, 15 * GEOMETRIC_SCALE);
7556 }
7557 
TEST_F(MultiTouchInputMapperTest,TouchMajorAndMinorAxes_DoNotAppearIfNotSupported)7558 TEST_F(MultiTouchInputMapperTest, TouchMajorAndMinorAxes_DoNotAppearIfNotSupported) {
7559     addConfigurationProperty("touch.deviceType", "touchScreen");
7560     prepareDisplay(DISPLAY_ORIENTATION_0);
7561 
7562     mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_MT_POSITION_X, RAW_X_MIN, RAW_X_MAX, /*flat*/ 0,
7563                                    /*fuzz*/ 0, /*resolution*/ 10);
7564     mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_MT_POSITION_Y, RAW_Y_MIN, RAW_Y_MAX, /*flat*/ 0,
7565                                    /*fuzz*/ 0, /*resolution*/ 11);
7566 
7567     // We do not add ABS_MT_TOUCH_MAJOR / MINOR or ABS_MT_WIDTH_MAJOR / MINOR axes
7568 
7569     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
7570 
7571     // Touch major and minor
7572     assertAxisNotPresent(mapper, AMOTION_EVENT_AXIS_TOUCH_MAJOR);
7573     assertAxisNotPresent(mapper, AMOTION_EVENT_AXIS_TOUCH_MINOR);
7574     // Tool major and minor
7575     assertAxisNotPresent(mapper, AMOTION_EVENT_AXIS_TOOL_MAJOR);
7576     assertAxisNotPresent(mapper, AMOTION_EVENT_AXIS_TOOL_MINOR);
7577 }
7578 
TEST_F(MultiTouchInputMapperTest,Process_NormalMultiTouchGesture_WithTrackingIds)7579 TEST_F(MultiTouchInputMapperTest, Process_NormalMultiTouchGesture_WithTrackingIds) {
7580     addConfigurationProperty("touch.deviceType", "touchScreen");
7581     prepareDisplay(DISPLAY_ORIENTATION_0);
7582     prepareAxes(POSITION | ID);
7583     prepareVirtualKeys();
7584     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
7585 
7586     mReader->getContext()->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
7587 
7588     NotifyMotionArgs motionArgs;
7589 
7590     // Two fingers down at once.
7591     int32_t x1 = 100, y1 = 125, x2 = 300, y2 = 500;
7592     processPosition(mapper, x1, y1);
7593     processId(mapper, 1);
7594     processMTSync(mapper);
7595     processPosition(mapper, x2, y2);
7596     processId(mapper, 2);
7597     processMTSync(mapper);
7598     processSync(mapper);
7599 
7600     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7601     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
7602     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
7603     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
7604     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7605     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7606             toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0, 0));
7607 
7608     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7609     ASSERT_EQ(ACTION_POINTER_1_DOWN, motionArgs.action);
7610     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
7611     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
7612     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7613     ASSERT_EQ(1, motionArgs.pointerProperties[1].id);
7614     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType);
7615     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7616             toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0, 0));
7617     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
7618             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0));
7619 
7620     // Move.
7621     x1 += 10; y1 += 15; x2 += 5; y2 -= 10;
7622     processPosition(mapper, x1, y1);
7623     processId(mapper, 1);
7624     processMTSync(mapper);
7625     processPosition(mapper, x2, y2);
7626     processId(mapper, 2);
7627     processMTSync(mapper);
7628     processSync(mapper);
7629 
7630     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7631     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
7632     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
7633     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
7634     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7635     ASSERT_EQ(1, motionArgs.pointerProperties[1].id);
7636     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType);
7637     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7638             toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0, 0));
7639     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
7640             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0));
7641 
7642     // First finger up.
7643     x2 += 15; y2 -= 20;
7644     processPosition(mapper, x2, y2);
7645     processId(mapper, 2);
7646     processMTSync(mapper);
7647     processSync(mapper);
7648 
7649     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7650     ASSERT_EQ(ACTION_POINTER_0_UP, motionArgs.action);
7651     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
7652     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
7653     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7654     ASSERT_EQ(1, motionArgs.pointerProperties[1].id);
7655     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType);
7656     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7657             toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0, 0));
7658     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
7659             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0));
7660 
7661     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7662     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
7663     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
7664     ASSERT_EQ(1, motionArgs.pointerProperties[0].id);
7665     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7666     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7667             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0));
7668 
7669     // Move.
7670     x2 += 20; y2 -= 25;
7671     processPosition(mapper, x2, y2);
7672     processId(mapper, 2);
7673     processMTSync(mapper);
7674     processSync(mapper);
7675 
7676     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7677     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
7678     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
7679     ASSERT_EQ(1, motionArgs.pointerProperties[0].id);
7680     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7681     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7682             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0));
7683 
7684     // New finger down.
7685     int32_t x3 = 700, y3 = 300;
7686     processPosition(mapper, x2, y2);
7687     processId(mapper, 2);
7688     processMTSync(mapper);
7689     processPosition(mapper, x3, y3);
7690     processId(mapper, 3);
7691     processMTSync(mapper);
7692     processSync(mapper);
7693 
7694     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7695     ASSERT_EQ(ACTION_POINTER_0_DOWN, motionArgs.action);
7696     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
7697     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
7698     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7699     ASSERT_EQ(1, motionArgs.pointerProperties[1].id);
7700     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType);
7701     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7702             toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0, 0));
7703     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
7704             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0));
7705 
7706     // Second finger up.
7707     x3 += 30; y3 -= 20;
7708     processPosition(mapper, x3, y3);
7709     processId(mapper, 3);
7710     processMTSync(mapper);
7711     processSync(mapper);
7712 
7713     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7714     ASSERT_EQ(ACTION_POINTER_1_UP, motionArgs.action);
7715     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
7716     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
7717     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7718     ASSERT_EQ(1, motionArgs.pointerProperties[1].id);
7719     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType);
7720     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7721             toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0, 0));
7722     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
7723             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0));
7724 
7725     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7726     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
7727     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
7728     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
7729     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7730     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7731             toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0, 0));
7732 
7733     // Last finger up.
7734     processMTSync(mapper);
7735     processSync(mapper);
7736 
7737     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7738     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
7739     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
7740     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
7741     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7742     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7743             toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0, 0));
7744 
7745     // Should not have sent any more keys or motions.
7746     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasNotCalled());
7747     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());
7748 }
7749 
TEST_F(MultiTouchInputMapperTest,Process_NormalMultiTouchGesture_WithSlots)7750 TEST_F(MultiTouchInputMapperTest, Process_NormalMultiTouchGesture_WithSlots) {
7751     addConfigurationProperty("touch.deviceType", "touchScreen");
7752     prepareDisplay(DISPLAY_ORIENTATION_0);
7753     prepareAxes(POSITION | ID | SLOT);
7754     prepareVirtualKeys();
7755     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
7756 
7757     mReader->getContext()->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
7758 
7759     NotifyMotionArgs motionArgs;
7760 
7761     // Two fingers down at once.
7762     int32_t x1 = 100, y1 = 125, x2 = 300, y2 = 500;
7763     processPosition(mapper, x1, y1);
7764     processId(mapper, 1);
7765     processSlot(mapper, 1);
7766     processPosition(mapper, x2, y2);
7767     processId(mapper, 2);
7768     processSync(mapper);
7769 
7770     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7771     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
7772     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
7773     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
7774     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7775     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7776             toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0, 0));
7777 
7778     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7779     ASSERT_EQ(ACTION_POINTER_1_DOWN, motionArgs.action);
7780     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
7781     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
7782     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7783     ASSERT_EQ(1, motionArgs.pointerProperties[1].id);
7784     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType);
7785     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7786             toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0, 0));
7787     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
7788             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0));
7789 
7790     // Move.
7791     x1 += 10; y1 += 15; x2 += 5; y2 -= 10;
7792     processSlot(mapper, 0);
7793     processPosition(mapper, x1, y1);
7794     processSlot(mapper, 1);
7795     processPosition(mapper, x2, y2);
7796     processSync(mapper);
7797 
7798     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7799     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
7800     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
7801     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
7802     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7803     ASSERT_EQ(1, motionArgs.pointerProperties[1].id);
7804     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType);
7805     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7806             toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0, 0));
7807     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
7808             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0));
7809 
7810     // First finger up.
7811     x2 += 15; y2 -= 20;
7812     processSlot(mapper, 0);
7813     processId(mapper, -1);
7814     processSlot(mapper, 1);
7815     processPosition(mapper, x2, y2);
7816     processSync(mapper);
7817 
7818     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7819     ASSERT_EQ(ACTION_POINTER_0_UP, motionArgs.action);
7820     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
7821     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
7822     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7823     ASSERT_EQ(1, motionArgs.pointerProperties[1].id);
7824     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType);
7825     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7826             toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0, 0));
7827     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
7828             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0));
7829 
7830     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7831     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
7832     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
7833     ASSERT_EQ(1, motionArgs.pointerProperties[0].id);
7834     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7835     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7836             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0));
7837 
7838     // Move.
7839     x2 += 20; y2 -= 25;
7840     processPosition(mapper, x2, y2);
7841     processSync(mapper);
7842 
7843     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7844     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
7845     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
7846     ASSERT_EQ(1, motionArgs.pointerProperties[0].id);
7847     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7848     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7849             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0));
7850 
7851     // New finger down.
7852     int32_t x3 = 700, y3 = 300;
7853     processPosition(mapper, x2, y2);
7854     processSlot(mapper, 0);
7855     processId(mapper, 3);
7856     processPosition(mapper, x3, y3);
7857     processSync(mapper);
7858 
7859     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7860     ASSERT_EQ(ACTION_POINTER_0_DOWN, motionArgs.action);
7861     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
7862     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
7863     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7864     ASSERT_EQ(1, motionArgs.pointerProperties[1].id);
7865     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType);
7866     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7867             toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0, 0));
7868     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
7869             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0));
7870 
7871     // Second finger up.
7872     x3 += 30; y3 -= 20;
7873     processSlot(mapper, 1);
7874     processId(mapper, -1);
7875     processSlot(mapper, 0);
7876     processPosition(mapper, x3, y3);
7877     processSync(mapper);
7878 
7879     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7880     ASSERT_EQ(ACTION_POINTER_1_UP, motionArgs.action);
7881     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
7882     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
7883     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7884     ASSERT_EQ(1, motionArgs.pointerProperties[1].id);
7885     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType);
7886     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7887             toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0, 0));
7888     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
7889             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0, 0));
7890 
7891     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7892     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
7893     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
7894     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
7895     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7896     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7897             toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0, 0));
7898 
7899     // Last finger up.
7900     processId(mapper, -1);
7901     processSync(mapper);
7902 
7903     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
7904     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
7905     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
7906     ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
7907     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
7908     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
7909             toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0, 0));
7910 
7911     // Should not have sent any more keys or motions.
7912     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasNotCalled());
7913     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());
7914 }
7915 
TEST_F(MultiTouchInputMapperTest,Process_AllAxes_WithDefaultCalibration)7916 TEST_F(MultiTouchInputMapperTest, Process_AllAxes_WithDefaultCalibration) {
7917     addConfigurationProperty("touch.deviceType", "touchScreen");
7918     prepareDisplay(DISPLAY_ORIENTATION_0);
7919     prepareAxes(POSITION | TOUCH | TOOL | PRESSURE | ORIENTATION | ID | MINOR | DISTANCE);
7920     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
7921 
7922     // These calculations are based on the input device calibration documentation.
7923     int32_t rawX = 100;
7924     int32_t rawY = 200;
7925     int32_t rawTouchMajor = 7;
7926     int32_t rawTouchMinor = 6;
7927     int32_t rawToolMajor = 9;
7928     int32_t rawToolMinor = 8;
7929     int32_t rawPressure = 11;
7930     int32_t rawDistance = 0;
7931     int32_t rawOrientation = 3;
7932     int32_t id = 5;
7933 
7934     float x = toDisplayX(rawX);
7935     float y = toDisplayY(rawY);
7936     float pressure = float(rawPressure) / RAW_PRESSURE_MAX;
7937     float size = avg(rawTouchMajor, rawTouchMinor) / RAW_TOUCH_MAX;
7938     float toolMajor = float(rawToolMajor) * GEOMETRIC_SCALE;
7939     float toolMinor = float(rawToolMinor) * GEOMETRIC_SCALE;
7940     float touchMajor = float(rawTouchMajor) * GEOMETRIC_SCALE;
7941     float touchMinor = float(rawTouchMinor) * GEOMETRIC_SCALE;
7942     float orientation = float(rawOrientation) / RAW_ORIENTATION_MAX * M_PI_2;
7943     float distance = float(rawDistance);
7944 
7945     processPosition(mapper, rawX, rawY);
7946     processTouchMajor(mapper, rawTouchMajor);
7947     processTouchMinor(mapper, rawTouchMinor);
7948     processToolMajor(mapper, rawToolMajor);
7949     processToolMinor(mapper, rawToolMinor);
7950     processPressure(mapper, rawPressure);
7951     processOrientation(mapper, rawOrientation);
7952     processDistance(mapper, rawDistance);
7953     processId(mapper, id);
7954     processMTSync(mapper);
7955     processSync(mapper);
7956 
7957     NotifyMotionArgs args;
7958     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
7959     ASSERT_EQ(0, args.pointerProperties[0].id);
7960     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
7961             x, y, pressure, size, touchMajor, touchMinor, toolMajor, toolMinor,
7962             orientation, distance));
7963 }
7964 
TEST_F(MultiTouchInputMapperTest,Process_TouchAndToolAxes_GeometricCalibration)7965 TEST_F(MultiTouchInputMapperTest, Process_TouchAndToolAxes_GeometricCalibration) {
7966     addConfigurationProperty("touch.deviceType", "touchScreen");
7967     prepareDisplay(DISPLAY_ORIENTATION_0);
7968     prepareAxes(POSITION | TOUCH | TOOL | MINOR);
7969     addConfigurationProperty("touch.size.calibration", "geometric");
7970     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
7971 
7972     // These calculations are based on the input device calibration documentation.
7973     int32_t rawX = 100;
7974     int32_t rawY = 200;
7975     int32_t rawTouchMajor = 140;
7976     int32_t rawTouchMinor = 120;
7977     int32_t rawToolMajor = 180;
7978     int32_t rawToolMinor = 160;
7979 
7980     float x = toDisplayX(rawX);
7981     float y = toDisplayY(rawY);
7982     float size = avg(rawTouchMajor, rawTouchMinor) / RAW_TOUCH_MAX;
7983     float toolMajor = float(rawToolMajor) * GEOMETRIC_SCALE;
7984     float toolMinor = float(rawToolMinor) * GEOMETRIC_SCALE;
7985     float touchMajor = float(rawTouchMajor) * GEOMETRIC_SCALE;
7986     float touchMinor = float(rawTouchMinor) * GEOMETRIC_SCALE;
7987 
7988     processPosition(mapper, rawX, rawY);
7989     processTouchMajor(mapper, rawTouchMajor);
7990     processTouchMinor(mapper, rawTouchMinor);
7991     processToolMajor(mapper, rawToolMajor);
7992     processToolMinor(mapper, rawToolMinor);
7993     processMTSync(mapper);
7994     processSync(mapper);
7995 
7996     NotifyMotionArgs args;
7997     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
7998     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
7999             x, y, 1.0f, size, touchMajor, touchMinor, toolMajor, toolMinor, 0, 0));
8000 }
8001 
TEST_F(MultiTouchInputMapperTest,Process_TouchAndToolAxes_SummedLinearCalibration)8002 TEST_F(MultiTouchInputMapperTest, Process_TouchAndToolAxes_SummedLinearCalibration) {
8003     addConfigurationProperty("touch.deviceType", "touchScreen");
8004     prepareDisplay(DISPLAY_ORIENTATION_0);
8005     prepareAxes(POSITION | TOUCH | TOOL);
8006     addConfigurationProperty("touch.size.calibration", "diameter");
8007     addConfigurationProperty("touch.size.scale", "10");
8008     addConfigurationProperty("touch.size.bias", "160");
8009     addConfigurationProperty("touch.size.isSummed", "1");
8010     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
8011 
8012     // These calculations are based on the input device calibration documentation.
8013     // Note: We only provide a single common touch/tool value because the device is assumed
8014     //       not to emit separate values for each pointer (isSummed = 1).
8015     int32_t rawX = 100;
8016     int32_t rawY = 200;
8017     int32_t rawX2 = 150;
8018     int32_t rawY2 = 250;
8019     int32_t rawTouchMajor = 5;
8020     int32_t rawToolMajor = 8;
8021 
8022     float x = toDisplayX(rawX);
8023     float y = toDisplayY(rawY);
8024     float x2 = toDisplayX(rawX2);
8025     float y2 = toDisplayY(rawY2);
8026     float size = float(rawTouchMajor) / 2 / RAW_TOUCH_MAX;
8027     float touch = float(rawTouchMajor) / 2 * 10.0f + 160.0f;
8028     float tool = float(rawToolMajor) / 2 * 10.0f + 160.0f;
8029 
8030     processPosition(mapper, rawX, rawY);
8031     processTouchMajor(mapper, rawTouchMajor);
8032     processToolMajor(mapper, rawToolMajor);
8033     processMTSync(mapper);
8034     processPosition(mapper, rawX2, rawY2);
8035     processTouchMajor(mapper, rawTouchMajor);
8036     processToolMajor(mapper, rawToolMajor);
8037     processMTSync(mapper);
8038     processSync(mapper);
8039 
8040     NotifyMotionArgs args;
8041     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
8042     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action);
8043 
8044     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
8045     ASSERT_EQ(ACTION_POINTER_1_DOWN, args.action);
8046     ASSERT_EQ(size_t(2), args.pointerCount);
8047     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
8048             x, y, 1.0f, size, touch, touch, tool, tool, 0, 0));
8049     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[1],
8050             x2, y2, 1.0f, size, touch, touch, tool, tool, 0, 0));
8051 }
8052 
TEST_F(MultiTouchInputMapperTest,Process_TouchAndToolAxes_AreaCalibration)8053 TEST_F(MultiTouchInputMapperTest, Process_TouchAndToolAxes_AreaCalibration) {
8054     addConfigurationProperty("touch.deviceType", "touchScreen");
8055     prepareDisplay(DISPLAY_ORIENTATION_0);
8056     prepareAxes(POSITION | TOUCH | TOOL);
8057     addConfigurationProperty("touch.size.calibration", "area");
8058     addConfigurationProperty("touch.size.scale", "43");
8059     addConfigurationProperty("touch.size.bias", "3");
8060     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
8061 
8062     // These calculations are based on the input device calibration documentation.
8063     int32_t rawX = 100;
8064     int32_t rawY = 200;
8065     int32_t rawTouchMajor = 5;
8066     int32_t rawToolMajor = 8;
8067 
8068     float x = toDisplayX(rawX);
8069     float y = toDisplayY(rawY);
8070     float size = float(rawTouchMajor) / RAW_TOUCH_MAX;
8071     float touch = sqrtf(rawTouchMajor) * 43.0f + 3.0f;
8072     float tool = sqrtf(rawToolMajor) * 43.0f + 3.0f;
8073 
8074     processPosition(mapper, rawX, rawY);
8075     processTouchMajor(mapper, rawTouchMajor);
8076     processToolMajor(mapper, rawToolMajor);
8077     processMTSync(mapper);
8078     processSync(mapper);
8079 
8080     NotifyMotionArgs args;
8081     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
8082     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
8083             x, y, 1.0f, size, touch, touch, tool, tool, 0, 0));
8084 }
8085 
TEST_F(MultiTouchInputMapperTest,Process_PressureAxis_AmplitudeCalibration)8086 TEST_F(MultiTouchInputMapperTest, Process_PressureAxis_AmplitudeCalibration) {
8087     addConfigurationProperty("touch.deviceType", "touchScreen");
8088     prepareDisplay(DISPLAY_ORIENTATION_0);
8089     prepareAxes(POSITION | PRESSURE);
8090     addConfigurationProperty("touch.pressure.calibration", "amplitude");
8091     addConfigurationProperty("touch.pressure.scale", "0.01");
8092     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
8093 
8094     InputDeviceInfo info;
8095     mapper.populateDeviceInfo(&info);
8096     ASSERT_NO_FATAL_FAILURE(assertMotionRange(info,
8097             AINPUT_MOTION_RANGE_PRESSURE, AINPUT_SOURCE_TOUCHSCREEN,
8098             0.0f, RAW_PRESSURE_MAX * 0.01, 0.0f, 0.0f));
8099 
8100     // These calculations are based on the input device calibration documentation.
8101     int32_t rawX = 100;
8102     int32_t rawY = 200;
8103     int32_t rawPressure = 60;
8104 
8105     float x = toDisplayX(rawX);
8106     float y = toDisplayY(rawY);
8107     float pressure = float(rawPressure) * 0.01f;
8108 
8109     processPosition(mapper, rawX, rawY);
8110     processPressure(mapper, rawPressure);
8111     processMTSync(mapper);
8112     processSync(mapper);
8113 
8114     NotifyMotionArgs args;
8115     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
8116     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
8117             x, y, pressure, 0, 0, 0, 0, 0, 0, 0));
8118 }
8119 
TEST_F(MultiTouchInputMapperTest,Process_ShouldHandleAllButtons)8120 TEST_F(MultiTouchInputMapperTest, Process_ShouldHandleAllButtons) {
8121     addConfigurationProperty("touch.deviceType", "touchScreen");
8122     prepareDisplay(DISPLAY_ORIENTATION_0);
8123     prepareAxes(POSITION | ID | SLOT);
8124     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
8125 
8126     NotifyMotionArgs motionArgs;
8127     NotifyKeyArgs keyArgs;
8128 
8129     processId(mapper, 1);
8130     processPosition(mapper, 100, 200);
8131     processSync(mapper);
8132     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8133     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
8134     ASSERT_EQ(0, motionArgs.buttonState);
8135 
8136     // press BTN_LEFT, release BTN_LEFT
8137     processKey(mapper, BTN_LEFT, 1);
8138     processSync(mapper);
8139     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8140     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8141     ASSERT_EQ(AMOTION_EVENT_BUTTON_PRIMARY, motionArgs.buttonState);
8142 
8143     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8144     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, motionArgs.action);
8145     ASSERT_EQ(AMOTION_EVENT_BUTTON_PRIMARY, motionArgs.buttonState);
8146 
8147     processKey(mapper, BTN_LEFT, 0);
8148     processSync(mapper);
8149     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8150     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, motionArgs.action);
8151     ASSERT_EQ(0, motionArgs.buttonState);
8152 
8153     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8154     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8155     ASSERT_EQ(0, motionArgs.buttonState);
8156 
8157     // press BTN_RIGHT + BTN_MIDDLE, release BTN_RIGHT, release BTN_MIDDLE
8158     processKey(mapper, BTN_RIGHT, 1);
8159     processKey(mapper, BTN_MIDDLE, 1);
8160     processSync(mapper);
8161     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8162     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8163     ASSERT_EQ(AMOTION_EVENT_BUTTON_SECONDARY | AMOTION_EVENT_BUTTON_TERTIARY,
8164             motionArgs.buttonState);
8165 
8166     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8167     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, motionArgs.action);
8168     ASSERT_EQ(AMOTION_EVENT_BUTTON_TERTIARY, motionArgs.buttonState);
8169 
8170     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8171     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, motionArgs.action);
8172     ASSERT_EQ(AMOTION_EVENT_BUTTON_SECONDARY | AMOTION_EVENT_BUTTON_TERTIARY,
8173             motionArgs.buttonState);
8174 
8175     processKey(mapper, BTN_RIGHT, 0);
8176     processSync(mapper);
8177     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8178     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, motionArgs.action);
8179     ASSERT_EQ(AMOTION_EVENT_BUTTON_TERTIARY, motionArgs.buttonState);
8180 
8181     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8182     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8183     ASSERT_EQ(AMOTION_EVENT_BUTTON_TERTIARY, motionArgs.buttonState);
8184 
8185     processKey(mapper, BTN_MIDDLE, 0);
8186     processSync(mapper);
8187     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8188     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, motionArgs.action);
8189     ASSERT_EQ(0, motionArgs.buttonState);
8190 
8191     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8192     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8193     ASSERT_EQ(0, motionArgs.buttonState);
8194 
8195     // press BTN_BACK, release BTN_BACK
8196     processKey(mapper, BTN_BACK, 1);
8197     processSync(mapper);
8198     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs));
8199     ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action);
8200     ASSERT_EQ(AKEYCODE_BACK, keyArgs.keyCode);
8201 
8202     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8203     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8204     ASSERT_EQ(AMOTION_EVENT_BUTTON_BACK, motionArgs.buttonState);
8205 
8206     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8207     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, motionArgs.action);
8208     ASSERT_EQ(AMOTION_EVENT_BUTTON_BACK, motionArgs.buttonState);
8209 
8210     processKey(mapper, BTN_BACK, 0);
8211     processSync(mapper);
8212     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8213     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, motionArgs.action);
8214     ASSERT_EQ(0, motionArgs.buttonState);
8215 
8216     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8217     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8218     ASSERT_EQ(0, motionArgs.buttonState);
8219 
8220     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs));
8221     ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action);
8222     ASSERT_EQ(AKEYCODE_BACK, keyArgs.keyCode);
8223 
8224     // press BTN_SIDE, release BTN_SIDE
8225     processKey(mapper, BTN_SIDE, 1);
8226     processSync(mapper);
8227     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs));
8228     ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action);
8229     ASSERT_EQ(AKEYCODE_BACK, keyArgs.keyCode);
8230 
8231     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8232     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8233     ASSERT_EQ(AMOTION_EVENT_BUTTON_BACK, motionArgs.buttonState);
8234 
8235     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8236     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, motionArgs.action);
8237     ASSERT_EQ(AMOTION_EVENT_BUTTON_BACK, motionArgs.buttonState);
8238 
8239     processKey(mapper, BTN_SIDE, 0);
8240     processSync(mapper);
8241     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8242     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, motionArgs.action);
8243     ASSERT_EQ(0, motionArgs.buttonState);
8244 
8245     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8246     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8247     ASSERT_EQ(0, motionArgs.buttonState);
8248 
8249     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs));
8250     ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action);
8251     ASSERT_EQ(AKEYCODE_BACK, keyArgs.keyCode);
8252 
8253     // press BTN_FORWARD, release BTN_FORWARD
8254     processKey(mapper, BTN_FORWARD, 1);
8255     processSync(mapper);
8256     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs));
8257     ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action);
8258     ASSERT_EQ(AKEYCODE_FORWARD, keyArgs.keyCode);
8259 
8260     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8261     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8262     ASSERT_EQ(AMOTION_EVENT_BUTTON_FORWARD, motionArgs.buttonState);
8263 
8264     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8265     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, motionArgs.action);
8266     ASSERT_EQ(AMOTION_EVENT_BUTTON_FORWARD, motionArgs.buttonState);
8267 
8268     processKey(mapper, BTN_FORWARD, 0);
8269     processSync(mapper);
8270     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8271     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, motionArgs.action);
8272     ASSERT_EQ(0, motionArgs.buttonState);
8273 
8274     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8275     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8276     ASSERT_EQ(0, motionArgs.buttonState);
8277 
8278     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs));
8279     ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action);
8280     ASSERT_EQ(AKEYCODE_FORWARD, keyArgs.keyCode);
8281 
8282     // press BTN_EXTRA, release BTN_EXTRA
8283     processKey(mapper, BTN_EXTRA, 1);
8284     processSync(mapper);
8285     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs));
8286     ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action);
8287     ASSERT_EQ(AKEYCODE_FORWARD, keyArgs.keyCode);
8288 
8289     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8290     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8291     ASSERT_EQ(AMOTION_EVENT_BUTTON_FORWARD, motionArgs.buttonState);
8292 
8293     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8294     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, motionArgs.action);
8295     ASSERT_EQ(AMOTION_EVENT_BUTTON_FORWARD, motionArgs.buttonState);
8296 
8297     processKey(mapper, BTN_EXTRA, 0);
8298     processSync(mapper);
8299     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8300     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, motionArgs.action);
8301     ASSERT_EQ(0, motionArgs.buttonState);
8302 
8303     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8304     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8305     ASSERT_EQ(0, motionArgs.buttonState);
8306 
8307     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasCalled(&keyArgs));
8308     ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action);
8309     ASSERT_EQ(AKEYCODE_FORWARD, keyArgs.keyCode);
8310 
8311     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyKeyWasNotCalled());
8312 
8313     // press BTN_STYLUS, release BTN_STYLUS
8314     processKey(mapper, BTN_STYLUS, 1);
8315     processSync(mapper);
8316     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8317     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8318     ASSERT_EQ(AMOTION_EVENT_BUTTON_STYLUS_PRIMARY, motionArgs.buttonState);
8319 
8320     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8321     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, motionArgs.action);
8322     ASSERT_EQ(AMOTION_EVENT_BUTTON_STYLUS_PRIMARY, motionArgs.buttonState);
8323 
8324     processKey(mapper, BTN_STYLUS, 0);
8325     processSync(mapper);
8326     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8327     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, motionArgs.action);
8328     ASSERT_EQ(0, motionArgs.buttonState);
8329 
8330     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8331     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8332     ASSERT_EQ(0, motionArgs.buttonState);
8333 
8334     // press BTN_STYLUS2, release BTN_STYLUS2
8335     processKey(mapper, BTN_STYLUS2, 1);
8336     processSync(mapper);
8337     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8338     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8339     ASSERT_EQ(AMOTION_EVENT_BUTTON_STYLUS_SECONDARY, motionArgs.buttonState);
8340 
8341     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8342     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, motionArgs.action);
8343     ASSERT_EQ(AMOTION_EVENT_BUTTON_STYLUS_SECONDARY, motionArgs.buttonState);
8344 
8345     processKey(mapper, BTN_STYLUS2, 0);
8346     processSync(mapper);
8347     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8348     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, motionArgs.action);
8349     ASSERT_EQ(0, motionArgs.buttonState);
8350 
8351     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8352     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8353     ASSERT_EQ(0, motionArgs.buttonState);
8354 
8355     // release touch
8356     processId(mapper, -1);
8357     processSync(mapper);
8358     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8359     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
8360     ASSERT_EQ(0, motionArgs.buttonState);
8361 }
8362 
TEST_F(MultiTouchInputMapperTest,Process_ShouldHandleAllToolTypes)8363 TEST_F(MultiTouchInputMapperTest, Process_ShouldHandleAllToolTypes) {
8364     addConfigurationProperty("touch.deviceType", "touchScreen");
8365     prepareDisplay(DISPLAY_ORIENTATION_0);
8366     prepareAxes(POSITION | ID | SLOT | TOOL_TYPE);
8367     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
8368 
8369     NotifyMotionArgs motionArgs;
8370 
8371     // default tool type is finger
8372     processId(mapper, 1);
8373     processPosition(mapper, 100, 200);
8374     processSync(mapper);
8375     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8376     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
8377     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
8378 
8379     // eraser
8380     processKey(mapper, BTN_TOOL_RUBBER, 1);
8381     processSync(mapper);
8382     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8383     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8384     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_ERASER, motionArgs.pointerProperties[0].toolType);
8385 
8386     // stylus
8387     processKey(mapper, BTN_TOOL_RUBBER, 0);
8388     processKey(mapper, BTN_TOOL_PEN, 1);
8389     processSync(mapper);
8390     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8391     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8392     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_STYLUS, motionArgs.pointerProperties[0].toolType);
8393 
8394     // brush
8395     processKey(mapper, BTN_TOOL_PEN, 0);
8396     processKey(mapper, BTN_TOOL_BRUSH, 1);
8397     processSync(mapper);
8398     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8399     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8400     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_STYLUS, motionArgs.pointerProperties[0].toolType);
8401 
8402     // pencil
8403     processKey(mapper, BTN_TOOL_BRUSH, 0);
8404     processKey(mapper, BTN_TOOL_PENCIL, 1);
8405     processSync(mapper);
8406     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8407     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8408     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_STYLUS, motionArgs.pointerProperties[0].toolType);
8409 
8410     // air-brush
8411     processKey(mapper, BTN_TOOL_PENCIL, 0);
8412     processKey(mapper, BTN_TOOL_AIRBRUSH, 1);
8413     processSync(mapper);
8414     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8415     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8416     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_STYLUS, motionArgs.pointerProperties[0].toolType);
8417 
8418     // mouse
8419     processKey(mapper, BTN_TOOL_AIRBRUSH, 0);
8420     processKey(mapper, BTN_TOOL_MOUSE, 1);
8421     processSync(mapper);
8422     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8423     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8424     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_MOUSE, motionArgs.pointerProperties[0].toolType);
8425 
8426     // lens
8427     processKey(mapper, BTN_TOOL_MOUSE, 0);
8428     processKey(mapper, BTN_TOOL_LENS, 1);
8429     processSync(mapper);
8430     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8431     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8432     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_MOUSE, motionArgs.pointerProperties[0].toolType);
8433 
8434     // double-tap
8435     processKey(mapper, BTN_TOOL_LENS, 0);
8436     processKey(mapper, BTN_TOOL_DOUBLETAP, 1);
8437     processSync(mapper);
8438     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8439     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8440     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
8441 
8442     // triple-tap
8443     processKey(mapper, BTN_TOOL_DOUBLETAP, 0);
8444     processKey(mapper, BTN_TOOL_TRIPLETAP, 1);
8445     processSync(mapper);
8446     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8447     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8448     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
8449 
8450     // quad-tap
8451     processKey(mapper, BTN_TOOL_TRIPLETAP, 0);
8452     processKey(mapper, BTN_TOOL_QUADTAP, 1);
8453     processSync(mapper);
8454     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8455     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8456     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
8457 
8458     // finger
8459     processKey(mapper, BTN_TOOL_QUADTAP, 0);
8460     processKey(mapper, BTN_TOOL_FINGER, 1);
8461     processSync(mapper);
8462     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8463     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8464     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
8465 
8466     // stylus trumps finger
8467     processKey(mapper, BTN_TOOL_PEN, 1);
8468     processSync(mapper);
8469     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8470     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8471     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_STYLUS, motionArgs.pointerProperties[0].toolType);
8472 
8473     // eraser trumps stylus
8474     processKey(mapper, BTN_TOOL_RUBBER, 1);
8475     processSync(mapper);
8476     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8477     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8478     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_ERASER, motionArgs.pointerProperties[0].toolType);
8479 
8480     // mouse trumps eraser
8481     processKey(mapper, BTN_TOOL_MOUSE, 1);
8482     processSync(mapper);
8483     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8484     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8485     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_MOUSE, motionArgs.pointerProperties[0].toolType);
8486 
8487     // MT tool type trumps BTN tool types: MT_TOOL_FINGER
8488     processToolType(mapper, MT_TOOL_FINGER); // this is the first time we send MT_TOOL_TYPE
8489     processSync(mapper);
8490     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8491     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8492     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
8493 
8494     // MT tool type trumps BTN tool types: MT_TOOL_PEN
8495     processToolType(mapper, MT_TOOL_PEN);
8496     processSync(mapper);
8497     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8498     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8499     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_STYLUS, motionArgs.pointerProperties[0].toolType);
8500 
8501     // back to default tool type
8502     processToolType(mapper, -1); // use a deliberately undefined tool type, for testing
8503     processKey(mapper, BTN_TOOL_MOUSE, 0);
8504     processKey(mapper, BTN_TOOL_RUBBER, 0);
8505     processKey(mapper, BTN_TOOL_PEN, 0);
8506     processKey(mapper, BTN_TOOL_FINGER, 0);
8507     processSync(mapper);
8508     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8509     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
8510     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
8511 }
8512 
TEST_F(MultiTouchInputMapperTest,Process_WhenBtnTouchPresent_HoversIfItsValueIsZero)8513 TEST_F(MultiTouchInputMapperTest, Process_WhenBtnTouchPresent_HoversIfItsValueIsZero) {
8514     addConfigurationProperty("touch.deviceType", "touchScreen");
8515     prepareDisplay(DISPLAY_ORIENTATION_0);
8516     prepareAxes(POSITION | ID | SLOT);
8517     mFakeEventHub->addKey(EVENTHUB_ID, BTN_TOUCH, 0, AKEYCODE_UNKNOWN, 0);
8518     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
8519 
8520     NotifyMotionArgs motionArgs;
8521 
8522     // initially hovering because BTN_TOUCH not sent yet, pressure defaults to 0
8523     processId(mapper, 1);
8524     processPosition(mapper, 100, 200);
8525     processSync(mapper);
8526     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8527     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_ENTER, motionArgs.action);
8528     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
8529             toDisplayX(100), toDisplayY(200), 0, 0, 0, 0, 0, 0, 0, 0));
8530 
8531     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8532     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action);
8533     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
8534             toDisplayX(100), toDisplayY(200), 0, 0, 0, 0, 0, 0, 0, 0));
8535 
8536     // move a little
8537     processPosition(mapper, 150, 250);
8538     processSync(mapper);
8539     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8540     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action);
8541     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
8542             toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0));
8543 
8544     // down when BTN_TOUCH is pressed, pressure defaults to 1
8545     processKey(mapper, BTN_TOUCH, 1);
8546     processSync(mapper);
8547     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8548     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_EXIT, motionArgs.action);
8549     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
8550             toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0));
8551 
8552     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8553     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
8554     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
8555             toDisplayX(150), toDisplayY(250), 1, 0, 0, 0, 0, 0, 0, 0));
8556 
8557     // up when BTN_TOUCH is released, hover restored
8558     processKey(mapper, BTN_TOUCH, 0);
8559     processSync(mapper);
8560     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8561     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
8562     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
8563             toDisplayX(150), toDisplayY(250), 1, 0, 0, 0, 0, 0, 0, 0));
8564 
8565     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8566     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_ENTER, motionArgs.action);
8567     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
8568             toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0));
8569 
8570     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8571     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action);
8572     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
8573             toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0));
8574 
8575     // exit hover when pointer goes away
8576     processId(mapper, -1);
8577     processSync(mapper);
8578     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8579     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_EXIT, motionArgs.action);
8580     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
8581             toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0));
8582 }
8583 
TEST_F(MultiTouchInputMapperTest,Process_WhenAbsMTPressureIsPresent_HoversIfItsValueIsZero)8584 TEST_F(MultiTouchInputMapperTest, Process_WhenAbsMTPressureIsPresent_HoversIfItsValueIsZero) {
8585     addConfigurationProperty("touch.deviceType", "touchScreen");
8586     prepareDisplay(DISPLAY_ORIENTATION_0);
8587     prepareAxes(POSITION | ID | SLOT | PRESSURE);
8588     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
8589 
8590     NotifyMotionArgs motionArgs;
8591 
8592     // initially hovering because pressure is 0
8593     processId(mapper, 1);
8594     processPosition(mapper, 100, 200);
8595     processPressure(mapper, 0);
8596     processSync(mapper);
8597     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8598     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_ENTER, motionArgs.action);
8599     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
8600             toDisplayX(100), toDisplayY(200), 0, 0, 0, 0, 0, 0, 0, 0));
8601 
8602     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8603     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action);
8604     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
8605             toDisplayX(100), toDisplayY(200), 0, 0, 0, 0, 0, 0, 0, 0));
8606 
8607     // move a little
8608     processPosition(mapper, 150, 250);
8609     processSync(mapper);
8610     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8611     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action);
8612     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
8613             toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0));
8614 
8615     // down when pressure becomes non-zero
8616     processPressure(mapper, RAW_PRESSURE_MAX);
8617     processSync(mapper);
8618     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8619     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_EXIT, motionArgs.action);
8620     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
8621             toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0));
8622 
8623     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8624     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
8625     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
8626             toDisplayX(150), toDisplayY(250), 1, 0, 0, 0, 0, 0, 0, 0));
8627 
8628     // up when pressure becomes 0, hover restored
8629     processPressure(mapper, 0);
8630     processSync(mapper);
8631     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8632     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
8633     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
8634             toDisplayX(150), toDisplayY(250), 1, 0, 0, 0, 0, 0, 0, 0));
8635 
8636     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8637     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_ENTER, motionArgs.action);
8638     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
8639             toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0));
8640 
8641     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8642     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action);
8643     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
8644             toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0));
8645 
8646     // exit hover when pointer goes away
8647     processId(mapper, -1);
8648     processSync(mapper);
8649     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8650     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_EXIT, motionArgs.action);
8651     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
8652             toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0));
8653 }
8654 
8655 /**
8656  * Set the input device port <--> display port associations, and check that the
8657  * events are routed to the display that matches the display port.
8658  * This can be checked by looking at the displayId of the resulting NotifyMotionArgs.
8659  */
TEST_F(MultiTouchInputMapperTest,Configure_AssignsDisplayPort)8660 TEST_F(MultiTouchInputMapperTest, Configure_AssignsDisplayPort) {
8661     const std::string usb2 = "USB2";
8662     const uint8_t hdmi1 = 0;
8663     const uint8_t hdmi2 = 1;
8664     const std::string secondaryUniqueId = "uniqueId2";
8665     constexpr ViewportType type = ViewportType::EXTERNAL;
8666 
8667     addConfigurationProperty("touch.deviceType", "touchScreen");
8668     prepareAxes(POSITION);
8669     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
8670 
8671     mFakePolicy->addInputPortAssociation(DEVICE_LOCATION, hdmi1);
8672     mFakePolicy->addInputPortAssociation(usb2, hdmi2);
8673 
8674     // We are intentionally not adding the viewport for display 1 yet. Since the port association
8675     // for this input device is specified, and the matching viewport is not present,
8676     // the input device should be disabled (at the mapper level).
8677 
8678     // Add viewport for display 2 on hdmi2
8679     prepareSecondaryDisplay(type, hdmi2);
8680     // Send a touch event
8681     processPosition(mapper, 100, 100);
8682     processSync(mapper);
8683     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());
8684 
8685     // Add viewport for display 1 on hdmi1
8686     prepareDisplay(DISPLAY_ORIENTATION_0, hdmi1);
8687     // Send a touch event again
8688     processPosition(mapper, 100, 100);
8689     processSync(mapper);
8690 
8691     NotifyMotionArgs args;
8692     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
8693     ASSERT_EQ(DISPLAY_ID, args.displayId);
8694 }
8695 
TEST_F(MultiTouchInputMapperTest,Configure_AssignsDisplayUniqueId)8696 TEST_F(MultiTouchInputMapperTest, Configure_AssignsDisplayUniqueId) {
8697     addConfigurationProperty("touch.deviceType", "touchScreen");
8698     prepareAxes(POSITION);
8699     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
8700 
8701     mFakePolicy->addInputUniqueIdAssociation(DEVICE_LOCATION, VIRTUAL_DISPLAY_UNIQUE_ID);
8702 
8703     prepareDisplay(DISPLAY_ORIENTATION_0);
8704     prepareVirtualDisplay(DISPLAY_ORIENTATION_0);
8705 
8706     // Send a touch event
8707     processPosition(mapper, 100, 100);
8708     processSync(mapper);
8709 
8710     NotifyMotionArgs args;
8711     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
8712     ASSERT_EQ(VIRTUAL_DISPLAY_ID, args.displayId);
8713 }
8714 
TEST_F(MultiTouchInputMapperTest,Process_Pointer_ShouldHandleDisplayId)8715 TEST_F(MultiTouchInputMapperTest, Process_Pointer_ShouldHandleDisplayId) {
8716     // Setup for second display.
8717     std::shared_ptr<FakePointerController> fakePointerController =
8718             std::make_shared<FakePointerController>();
8719     fakePointerController->setBounds(0, 0, DISPLAY_WIDTH - 1, DISPLAY_HEIGHT - 1);
8720     fakePointerController->setPosition(100, 200);
8721     fakePointerController->setButtonState(0);
8722     mFakePolicy->setPointerController(fakePointerController);
8723 
8724     mFakePolicy->setDefaultPointerDisplayId(SECONDARY_DISPLAY_ID);
8725     prepareSecondaryDisplay(ViewportType::EXTERNAL);
8726 
8727     prepareDisplay(DISPLAY_ORIENTATION_0);
8728     prepareAxes(POSITION);
8729     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
8730 
8731     // Check source is mouse that would obtain the PointerController.
8732     ASSERT_EQ(AINPUT_SOURCE_MOUSE, mapper.getSources());
8733 
8734     NotifyMotionArgs motionArgs;
8735     processPosition(mapper, 100, 100);
8736     processSync(mapper);
8737 
8738     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8739     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, motionArgs.action);
8740     ASSERT_EQ(SECONDARY_DISPLAY_ID, motionArgs.displayId);
8741 }
8742 
8743 /**
8744  * Ensure that the readTime is set to the SYN_REPORT value when processing touch events.
8745  */
TEST_F(MultiTouchInputMapperTest,Process_SendsReadTime)8746 TEST_F(MultiTouchInputMapperTest, Process_SendsReadTime) {
8747     addConfigurationProperty("touch.deviceType", "touchScreen");
8748     prepareAxes(POSITION);
8749     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
8750 
8751     prepareDisplay(DISPLAY_ORIENTATION_0);
8752     process(mapper, 10, 11 /*readTime*/, EV_ABS, ABS_MT_TRACKING_ID, 1);
8753     process(mapper, 15, 16 /*readTime*/, EV_ABS, ABS_MT_POSITION_X, 100);
8754     process(mapper, 20, 21 /*readTime*/, EV_ABS, ABS_MT_POSITION_Y, 100);
8755     process(mapper, 25, 26 /*readTime*/, EV_SYN, SYN_REPORT, 0);
8756 
8757     NotifyMotionArgs args;
8758     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
8759     ASSERT_EQ(26, args.readTime);
8760 
8761     process(mapper, 30, 31 /*readTime*/, EV_ABS, ABS_MT_POSITION_X, 110);
8762     process(mapper, 30, 32 /*readTime*/, EV_ABS, ABS_MT_POSITION_Y, 220);
8763     process(mapper, 30, 33 /*readTime*/, EV_SYN, SYN_REPORT, 0);
8764 
8765     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
8766     ASSERT_EQ(33, args.readTime);
8767 }
8768 
8769 /**
8770  * When the viewport is not active (isActive=false), the touch mapper should be disabled and the
8771  * events should not be delivered to the listener.
8772  */
TEST_F(MultiTouchInputMapperTest,WhenViewportIsNotActive_TouchesAreDropped)8773 TEST_F(MultiTouchInputMapperTest, WhenViewportIsNotActive_TouchesAreDropped) {
8774     addConfigurationProperty("touch.deviceType", "touchScreen");
8775     mFakePolicy->addDisplayViewport(DISPLAY_ID, DISPLAY_WIDTH, DISPLAY_HEIGHT,
8776                                     DISPLAY_ORIENTATION_0, false /*isActive*/, UNIQUE_ID, NO_PORT,
8777                                     ViewportType::INTERNAL);
8778     configureDevice(InputReaderConfiguration::CHANGE_DISPLAY_INFO);
8779     prepareAxes(POSITION);
8780     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
8781 
8782     NotifyMotionArgs motionArgs;
8783     processPosition(mapper, 100, 100);
8784     processSync(mapper);
8785 
8786     mFakeListener->assertNotifyMotionWasNotCalled();
8787 }
8788 
TEST_F(MultiTouchInputMapperTest,Process_DeactivateViewport_AbortTouches)8789 TEST_F(MultiTouchInputMapperTest, Process_DeactivateViewport_AbortTouches) {
8790     addConfigurationProperty("touch.deviceType", "touchScreen");
8791     mFakePolicy->addDisplayViewport(DISPLAY_ID, DISPLAY_WIDTH, DISPLAY_HEIGHT,
8792                                     DISPLAY_ORIENTATION_0, true /*isActive*/, UNIQUE_ID, NO_PORT,
8793                                     ViewportType::INTERNAL);
8794     std::optional<DisplayViewport> optionalDisplayViewport =
8795             mFakePolicy->getDisplayViewportByUniqueId(UNIQUE_ID);
8796     ASSERT_TRUE(optionalDisplayViewport.has_value());
8797     DisplayViewport displayViewport = *optionalDisplayViewport;
8798 
8799     configureDevice(InputReaderConfiguration::CHANGE_DISPLAY_INFO);
8800     prepareAxes(POSITION);
8801     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
8802 
8803     // Finger down
8804     int32_t x = 100, y = 100;
8805     processPosition(mapper, x, y);
8806     processSync(mapper);
8807 
8808     NotifyMotionArgs motionArgs;
8809     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8810     EXPECT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
8811 
8812     // Deactivate display viewport
8813     displayViewport.isActive = false;
8814     ASSERT_TRUE(mFakePolicy->updateViewport(displayViewport));
8815     configureDevice(InputReaderConfiguration::CHANGE_DISPLAY_INFO);
8816 
8817     // The ongoing touch should be canceled immediately
8818     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8819     EXPECT_EQ(AMOTION_EVENT_ACTION_CANCEL, motionArgs.action);
8820 
8821     // Finger move is ignored
8822     x += 10, y += 10;
8823     processPosition(mapper, x, y);
8824     processSync(mapper);
8825     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());
8826 
8827     // Reactivate display viewport
8828     displayViewport.isActive = true;
8829     ASSERT_TRUE(mFakePolicy->updateViewport(displayViewport));
8830     configureDevice(InputReaderConfiguration::CHANGE_DISPLAY_INFO);
8831 
8832     // Finger move again starts new gesture
8833     x += 10, y += 10;
8834     processPosition(mapper, x, y);
8835     processSync(mapper);
8836     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8837     EXPECT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
8838 }
8839 
TEST_F(MultiTouchInputMapperTest,Process_Pointer_ShowTouches)8840 TEST_F(MultiTouchInputMapperTest, Process_Pointer_ShowTouches) {
8841     // Setup the first touch screen device.
8842     prepareAxes(POSITION | ID | SLOT);
8843     addConfigurationProperty("touch.deviceType", "touchScreen");
8844     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
8845 
8846     // Create the second touch screen device, and enable multi fingers.
8847     const std::string USB2 = "USB2";
8848     const std::string DEVICE_NAME2 = "TOUCHSCREEN2";
8849     constexpr int32_t SECOND_DEVICE_ID = DEVICE_ID + 1;
8850     constexpr int32_t SECOND_EVENTHUB_ID = EVENTHUB_ID + 1;
8851     std::shared_ptr<InputDevice> device2 =
8852             newDevice(SECOND_DEVICE_ID, DEVICE_NAME2, USB2, SECOND_EVENTHUB_ID,
8853                       ftl::Flags<InputDeviceClass>(0));
8854 
8855     mFakeEventHub->addAbsoluteAxis(SECOND_EVENTHUB_ID, ABS_MT_POSITION_X, RAW_X_MIN, RAW_X_MAX,
8856                                    0 /*flat*/, 0 /*fuzz*/);
8857     mFakeEventHub->addAbsoluteAxis(SECOND_EVENTHUB_ID, ABS_MT_POSITION_Y, RAW_Y_MIN, RAW_Y_MAX,
8858                                    0 /*flat*/, 0 /*fuzz*/);
8859     mFakeEventHub->addAbsoluteAxis(SECOND_EVENTHUB_ID, ABS_MT_TRACKING_ID, RAW_ID_MIN, RAW_ID_MAX,
8860                                    0 /*flat*/, 0 /*fuzz*/);
8861     mFakeEventHub->addAbsoluteAxis(SECOND_EVENTHUB_ID, ABS_MT_SLOT, RAW_SLOT_MIN, RAW_SLOT_MAX,
8862                                    0 /*flat*/, 0 /*fuzz*/);
8863     mFakeEventHub->setAbsoluteAxisValue(SECOND_EVENTHUB_ID, ABS_MT_SLOT, 0 /*value*/);
8864     mFakeEventHub->addConfigurationProperty(SECOND_EVENTHUB_ID, String8("touch.deviceType"),
8865                                             String8("touchScreen"));
8866 
8867     // Setup the second touch screen device.
8868     MultiTouchInputMapper& mapper2 = device2->addMapper<MultiTouchInputMapper>(SECOND_EVENTHUB_ID);
8869     device2->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), 0 /*changes*/);
8870     device2->reset(ARBITRARY_TIME);
8871 
8872     // Setup PointerController.
8873     std::shared_ptr<FakePointerController> fakePointerController =
8874             std::make_shared<FakePointerController>();
8875     mFakePolicy->setPointerController(fakePointerController);
8876 
8877     // Setup policy for associated displays and show touches.
8878     const uint8_t hdmi1 = 0;
8879     const uint8_t hdmi2 = 1;
8880     mFakePolicy->addInputPortAssociation(DEVICE_LOCATION, hdmi1);
8881     mFakePolicy->addInputPortAssociation(USB2, hdmi2);
8882     mFakePolicy->setShowTouches(true);
8883 
8884     // Create displays.
8885     prepareDisplay(DISPLAY_ORIENTATION_0, hdmi1);
8886     prepareSecondaryDisplay(ViewportType::EXTERNAL, hdmi2);
8887 
8888     // Default device will reconfigure above, need additional reconfiguration for another device.
8889     device2->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(),
8890                        InputReaderConfiguration::CHANGE_DISPLAY_INFO);
8891 
8892     // Two fingers down at default display.
8893     int32_t x1 = 100, y1 = 125, x2 = 300, y2 = 500;
8894     processPosition(mapper, x1, y1);
8895     processId(mapper, 1);
8896     processSlot(mapper, 1);
8897     processPosition(mapper, x2, y2);
8898     processId(mapper, 2);
8899     processSync(mapper);
8900 
8901     std::map<int32_t, std::vector<int32_t>>::const_iterator iter =
8902             fakePointerController->getSpots().find(DISPLAY_ID);
8903     ASSERT_TRUE(iter != fakePointerController->getSpots().end());
8904     ASSERT_EQ(size_t(2), iter->second.size());
8905 
8906     // Two fingers down at second display.
8907     processPosition(mapper2, x1, y1);
8908     processId(mapper2, 1);
8909     processSlot(mapper2, 1);
8910     processPosition(mapper2, x2, y2);
8911     processId(mapper2, 2);
8912     processSync(mapper2);
8913 
8914     iter = fakePointerController->getSpots().find(SECONDARY_DISPLAY_ID);
8915     ASSERT_TRUE(iter != fakePointerController->getSpots().end());
8916     ASSERT_EQ(size_t(2), iter->second.size());
8917 }
8918 
TEST_F(MultiTouchInputMapperTest,VideoFrames_ReceivedByListener)8919 TEST_F(MultiTouchInputMapperTest, VideoFrames_ReceivedByListener) {
8920     prepareAxes(POSITION);
8921     addConfigurationProperty("touch.deviceType", "touchScreen");
8922     prepareDisplay(DISPLAY_ORIENTATION_0);
8923     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
8924 
8925     NotifyMotionArgs motionArgs;
8926     // Unrotated video frame
8927     TouchVideoFrame frame(3, 2, {1, 2, 3, 4, 5, 6}, {1, 2});
8928     std::vector<TouchVideoFrame> frames{frame};
8929     mFakeEventHub->setVideoFrames({{EVENTHUB_ID, frames}});
8930     processPosition(mapper, 100, 200);
8931     processSync(mapper);
8932     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8933     ASSERT_EQ(frames, motionArgs.videoFrames);
8934 
8935     // Subsequent touch events should not have any videoframes
8936     // This is implemented separately in FakeEventHub,
8937     // but that should match the behaviour of TouchVideoDevice.
8938     processPosition(mapper, 200, 200);
8939     processSync(mapper);
8940     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8941     ASSERT_EQ(std::vector<TouchVideoFrame>(), motionArgs.videoFrames);
8942 }
8943 
TEST_F(MultiTouchInputMapperTest,VideoFrames_AreNotRotated)8944 TEST_F(MultiTouchInputMapperTest, VideoFrames_AreNotRotated) {
8945     prepareAxes(POSITION);
8946     addConfigurationProperty("touch.deviceType", "touchScreen");
8947     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
8948     // Unrotated video frame
8949     TouchVideoFrame frame(3, 2, {1, 2, 3, 4, 5, 6}, {1, 2});
8950     NotifyMotionArgs motionArgs;
8951 
8952     // Test all 4 orientations
8953     for (int32_t orientation : {DISPLAY_ORIENTATION_0, DISPLAY_ORIENTATION_90,
8954                                 DISPLAY_ORIENTATION_180, DISPLAY_ORIENTATION_270}) {
8955         SCOPED_TRACE("Orientation " + StringPrintf("%i", orientation));
8956         clearViewports();
8957         prepareDisplay(orientation);
8958         std::vector<TouchVideoFrame> frames{frame};
8959         mFakeEventHub->setVideoFrames({{EVENTHUB_ID, frames}});
8960         processPosition(mapper, 100, 200);
8961         processSync(mapper);
8962         ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8963         ASSERT_EQ(frames, motionArgs.videoFrames);
8964     }
8965 }
8966 
TEST_F(MultiTouchInputMapperTest,VideoFrames_WhenNotOrientationAware_AreRotated)8967 TEST_F(MultiTouchInputMapperTest, VideoFrames_WhenNotOrientationAware_AreRotated) {
8968     prepareAxes(POSITION);
8969     addConfigurationProperty("touch.deviceType", "touchScreen");
8970     // Since InputReader works in the un-rotated coordinate space, only devices that are not
8971     // orientation-aware are affected by display rotation.
8972     addConfigurationProperty("touch.orientationAware", "0");
8973     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
8974     // Unrotated video frame
8975     TouchVideoFrame frame(3, 2, {1, 2, 3, 4, 5, 6}, {1, 2});
8976     NotifyMotionArgs motionArgs;
8977 
8978     // Test all 4 orientations
8979     for (int32_t orientation : {DISPLAY_ORIENTATION_0, DISPLAY_ORIENTATION_90,
8980              DISPLAY_ORIENTATION_180, DISPLAY_ORIENTATION_270}) {
8981         SCOPED_TRACE("Orientation " + StringPrintf("%i", orientation));
8982         clearViewports();
8983         prepareDisplay(orientation);
8984         std::vector<TouchVideoFrame> frames{frame};
8985         mFakeEventHub->setVideoFrames({{EVENTHUB_ID, frames}});
8986         processPosition(mapper, 100, 200);
8987         processSync(mapper);
8988         ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8989         // We expect the raw coordinates of the MotionEvent to be rotated in the inverse direction
8990         // compared to the display. This is so that when the window transform (which contains the
8991         // display rotation) is applied later by InputDispatcher, the coordinates end up in the
8992         // window's coordinate space.
8993         frames[0].rotate(getInverseRotation(orientation));
8994         ASSERT_EQ(frames, motionArgs.videoFrames);
8995 
8996         // Release finger.
8997         processSync(mapper);
8998         ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
8999     }
9000 }
9001 
TEST_F(MultiTouchInputMapperTest,VideoFrames_MultipleFramesAreNotRotated)9002 TEST_F(MultiTouchInputMapperTest, VideoFrames_MultipleFramesAreNotRotated) {
9003     prepareAxes(POSITION);
9004     addConfigurationProperty("touch.deviceType", "touchScreen");
9005     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
9006     // Unrotated video frames. There's no rule that they must all have the same dimensions,
9007     // so mix these.
9008     TouchVideoFrame frame1(3, 2, {1, 2, 3, 4, 5, 6}, {1, 2});
9009     TouchVideoFrame frame2(3, 3, {0, 1, 2, 3, 4, 5, 6, 7, 8}, {1, 3});
9010     TouchVideoFrame frame3(2, 2, {10, 20, 10, 0}, {1, 4});
9011     std::vector<TouchVideoFrame> frames{frame1, frame2, frame3};
9012     NotifyMotionArgs motionArgs;
9013 
9014     prepareDisplay(DISPLAY_ORIENTATION_90);
9015     mFakeEventHub->setVideoFrames({{EVENTHUB_ID, frames}});
9016     processPosition(mapper, 100, 200);
9017     processSync(mapper);
9018     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9019     ASSERT_EQ(frames, motionArgs.videoFrames);
9020 }
9021 
TEST_F(MultiTouchInputMapperTest,VideoFrames_WhenNotOrientationAware_MultipleFramesAreRotated)9022 TEST_F(MultiTouchInputMapperTest, VideoFrames_WhenNotOrientationAware_MultipleFramesAreRotated) {
9023     prepareAxes(POSITION);
9024     addConfigurationProperty("touch.deviceType", "touchScreen");
9025     // Since InputReader works in the un-rotated coordinate space, only devices that are not
9026     // orientation-aware are affected by display rotation.
9027     addConfigurationProperty("touch.orientationAware", "0");
9028     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
9029     // Unrotated video frames. There's no rule that they must all have the same dimensions,
9030     // so mix these.
9031     TouchVideoFrame frame1(3, 2, {1, 2, 3, 4, 5, 6}, {1, 2});
9032     TouchVideoFrame frame2(3, 3, {0, 1, 2, 3, 4, 5, 6, 7, 8}, {1, 3});
9033     TouchVideoFrame frame3(2, 2, {10, 20, 10, 0}, {1, 4});
9034     std::vector<TouchVideoFrame> frames{frame1, frame2, frame3};
9035     NotifyMotionArgs motionArgs;
9036 
9037     prepareDisplay(DISPLAY_ORIENTATION_90);
9038     mFakeEventHub->setVideoFrames({{EVENTHUB_ID, frames}});
9039     processPosition(mapper, 100, 200);
9040     processSync(mapper);
9041     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9042     std::for_each(frames.begin(), frames.end(), [](TouchVideoFrame& frame) {
9043         // We expect the raw coordinates of the MotionEvent to be rotated in the inverse direction
9044         // compared to the display. This is so that when the window transform (which contains the
9045         // display rotation) is applied later by InputDispatcher, the coordinates end up in the
9046         // window's coordinate space.
9047         frame.rotate(getInverseRotation(DISPLAY_ORIENTATION_90));
9048     });
9049     ASSERT_EQ(frames, motionArgs.videoFrames);
9050 }
9051 
9052 /**
9053  * If we had defined port associations, but the viewport is not ready, the touch device would be
9054  * expected to be disabled, and it should be enabled after the viewport has found.
9055  */
TEST_F(MultiTouchInputMapperTest,Configure_EnabledForAssociatedDisplay)9056 TEST_F(MultiTouchInputMapperTest, Configure_EnabledForAssociatedDisplay) {
9057     constexpr uint8_t hdmi2 = 1;
9058     const std::string secondaryUniqueId = "uniqueId2";
9059     constexpr ViewportType type = ViewportType::EXTERNAL;
9060 
9061     mFakePolicy->addInputPortAssociation(DEVICE_LOCATION, hdmi2);
9062 
9063     addConfigurationProperty("touch.deviceType", "touchScreen");
9064     prepareAxes(POSITION);
9065     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
9066 
9067     ASSERT_EQ(mDevice->isEnabled(), false);
9068 
9069     // Add display on hdmi2, the device should be enabled and can receive touch event.
9070     prepareSecondaryDisplay(type, hdmi2);
9071     ASSERT_EQ(mDevice->isEnabled(), true);
9072 
9073     // Send a touch event.
9074     processPosition(mapper, 100, 100);
9075     processSync(mapper);
9076 
9077     NotifyMotionArgs args;
9078     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
9079     ASSERT_EQ(SECONDARY_DISPLAY_ID, args.displayId);
9080 }
9081 
TEST_F(MultiTouchInputMapperTest,Process_ShouldHandleSingleTouch)9082 TEST_F(MultiTouchInputMapperTest, Process_ShouldHandleSingleTouch) {
9083     addConfigurationProperty("touch.deviceType", "touchScreen");
9084     prepareDisplay(DISPLAY_ORIENTATION_0);
9085     prepareAxes(POSITION | ID | SLOT | TOOL_TYPE);
9086     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
9087 
9088     NotifyMotionArgs motionArgs;
9089 
9090     constexpr int32_t x1 = 100, y1 = 200, x2 = 120, y2 = 220, x3 = 140, y3 = 240;
9091     // finger down
9092     processId(mapper, 1);
9093     processPosition(mapper, x1, y1);
9094     processSync(mapper);
9095     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9096     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
9097     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
9098 
9099     // finger move
9100     processId(mapper, 1);
9101     processPosition(mapper, x2, y2);
9102     processSync(mapper);
9103     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9104     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
9105     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
9106 
9107     // finger up.
9108     processId(mapper, -1);
9109     processSync(mapper);
9110     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9111     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
9112     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
9113 
9114     // new finger down
9115     processId(mapper, 1);
9116     processPosition(mapper, x3, y3);
9117     processSync(mapper);
9118     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9119     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
9120     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
9121 }
9122 
9123 /**
9124  * Test single touch should be canceled when received the MT_TOOL_PALM event, and the following
9125  * MOVE and UP events should be ignored.
9126  */
TEST_F(MultiTouchInputMapperTest,Process_ShouldHandlePalmToolType_SinglePointer)9127 TEST_F(MultiTouchInputMapperTest, Process_ShouldHandlePalmToolType_SinglePointer) {
9128     addConfigurationProperty("touch.deviceType", "touchScreen");
9129     prepareDisplay(DISPLAY_ORIENTATION_0);
9130     prepareAxes(POSITION | ID | SLOT | TOOL_TYPE);
9131     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
9132 
9133     NotifyMotionArgs motionArgs;
9134 
9135     // default tool type is finger
9136     constexpr int32_t x1 = 100, y1 = 200, x2 = 120, y2 = 220, x3 = 140, y3 = 240;
9137     processId(mapper, FIRST_TRACKING_ID);
9138     processPosition(mapper, x1, y1);
9139     processSync(mapper);
9140     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9141     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
9142     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
9143 
9144     // Tool changed to MT_TOOL_PALM expect sending the cancel event.
9145     processToolType(mapper, MT_TOOL_PALM);
9146     processSync(mapper);
9147     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9148     ASSERT_EQ(AMOTION_EVENT_ACTION_CANCEL, motionArgs.action);
9149 
9150     // Ignore the following MOVE and UP events if had detect a palm event.
9151     processId(mapper, FIRST_TRACKING_ID);
9152     processPosition(mapper, x2, y2);
9153     processSync(mapper);
9154     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());
9155 
9156     // finger up.
9157     processId(mapper, INVALID_TRACKING_ID);
9158     processSync(mapper);
9159     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());
9160 
9161     // new finger down
9162     processId(mapper, FIRST_TRACKING_ID);
9163     processToolType(mapper, MT_TOOL_FINGER);
9164     processPosition(mapper, x3, y3);
9165     processSync(mapper);
9166     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9167     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
9168     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
9169 }
9170 
9171 /**
9172  * Test multi-touch should sent POINTER_UP when received the MT_TOOL_PALM event from some finger,
9173  * and the rest active fingers could still be allowed to receive the events
9174  */
TEST_F(MultiTouchInputMapperTest,Process_ShouldHandlePalmToolType_TwoPointers)9175 TEST_F(MultiTouchInputMapperTest, Process_ShouldHandlePalmToolType_TwoPointers) {
9176     addConfigurationProperty("touch.deviceType", "touchScreen");
9177     prepareDisplay(DISPLAY_ORIENTATION_0);
9178     prepareAxes(POSITION | ID | SLOT | TOOL_TYPE);
9179     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
9180 
9181     NotifyMotionArgs motionArgs;
9182 
9183     // default tool type is finger
9184     constexpr int32_t x1 = 100, y1 = 200, x2 = 120, y2 = 220;
9185     processId(mapper, FIRST_TRACKING_ID);
9186     processPosition(mapper, x1, y1);
9187     processSync(mapper);
9188     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9189     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
9190     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
9191 
9192     // Second finger down.
9193     processSlot(mapper, SECOND_SLOT);
9194     processId(mapper, SECOND_TRACKING_ID);
9195     processPosition(mapper, x2, y2);
9196     processSync(mapper);
9197     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9198     ASSERT_EQ(ACTION_POINTER_1_DOWN, motionArgs.action);
9199     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType);
9200 
9201     // If the tool type of the first finger changes to MT_TOOL_PALM,
9202     // we expect to receive ACTION_POINTER_UP with cancel flag.
9203     processSlot(mapper, FIRST_SLOT);
9204     processId(mapper, FIRST_TRACKING_ID);
9205     processToolType(mapper, MT_TOOL_PALM);
9206     processSync(mapper);
9207     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9208     ASSERT_EQ(ACTION_POINTER_0_UP, motionArgs.action);
9209     ASSERT_EQ(AMOTION_EVENT_FLAG_CANCELED, motionArgs.flags);
9210 
9211     // The following MOVE events of second finger should be processed.
9212     processSlot(mapper, SECOND_SLOT);
9213     processId(mapper, SECOND_TRACKING_ID);
9214     processPosition(mapper, x2 + 1, y2 + 1);
9215     processSync(mapper);
9216     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9217     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
9218     ASSERT_EQ(uint32_t(1), motionArgs.pointerCount);
9219 
9220     // First finger up. It used to be in palm mode, and we already generated ACTION_POINTER_UP for
9221     // it. Second finger receive move.
9222     processSlot(mapper, FIRST_SLOT);
9223     processId(mapper, INVALID_TRACKING_ID);
9224     processSync(mapper);
9225     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9226     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
9227     ASSERT_EQ(uint32_t(1), motionArgs.pointerCount);
9228 
9229     // Second finger keeps moving.
9230     processSlot(mapper, SECOND_SLOT);
9231     processId(mapper, SECOND_TRACKING_ID);
9232     processPosition(mapper, x2 + 2, y2 + 2);
9233     processSync(mapper);
9234     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9235     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
9236     ASSERT_EQ(uint32_t(1), motionArgs.pointerCount);
9237 
9238     // Second finger up.
9239     processId(mapper, INVALID_TRACKING_ID);
9240     processSync(mapper);
9241     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9242     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
9243     ASSERT_NE(AMOTION_EVENT_FLAG_CANCELED, motionArgs.flags);
9244 }
9245 
9246 /**
9247  * Test multi-touch should sent POINTER_UP when received the MT_TOOL_PALM event, if only 1 finger
9248  * is active, it should send CANCEL after receiving the MT_TOOL_PALM event.
9249  */
TEST_F(MultiTouchInputMapperTest,Process_ShouldHandlePalmToolType_ShouldCancelWhenAllTouchIsPalm)9250 TEST_F(MultiTouchInputMapperTest, Process_ShouldHandlePalmToolType_ShouldCancelWhenAllTouchIsPalm) {
9251     addConfigurationProperty("touch.deviceType", "touchScreen");
9252     prepareDisplay(DISPLAY_ORIENTATION_0);
9253     prepareAxes(POSITION | ID | SLOT | TOOL_TYPE);
9254     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
9255 
9256     NotifyMotionArgs motionArgs;
9257 
9258     constexpr int32_t x1 = 100, y1 = 200, x2 = 120, y2 = 220, x3 = 140, y3 = 240;
9259     // First finger down.
9260     processId(mapper, FIRST_TRACKING_ID);
9261     processPosition(mapper, x1, y1);
9262     processSync(mapper);
9263     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9264     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
9265     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
9266 
9267     // Second finger down.
9268     processSlot(mapper, SECOND_SLOT);
9269     processId(mapper, SECOND_TRACKING_ID);
9270     processPosition(mapper, x2, y2);
9271     processSync(mapper);
9272     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9273     ASSERT_EQ(ACTION_POINTER_1_DOWN, motionArgs.action);
9274     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
9275 
9276     // If the tool type of the first finger changes to MT_TOOL_PALM,
9277     // we expect to receive ACTION_POINTER_UP with cancel flag.
9278     processSlot(mapper, FIRST_SLOT);
9279     processId(mapper, FIRST_TRACKING_ID);
9280     processToolType(mapper, MT_TOOL_PALM);
9281     processSync(mapper);
9282     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9283     ASSERT_EQ(ACTION_POINTER_0_UP, motionArgs.action);
9284     ASSERT_EQ(AMOTION_EVENT_FLAG_CANCELED, motionArgs.flags);
9285 
9286     // Second finger keeps moving.
9287     processSlot(mapper, SECOND_SLOT);
9288     processId(mapper, SECOND_TRACKING_ID);
9289     processPosition(mapper, x2 + 1, y2 + 1);
9290     processSync(mapper);
9291     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9292     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
9293 
9294     // second finger becomes palm, receive cancel due to only 1 finger is active.
9295     processId(mapper, SECOND_TRACKING_ID);
9296     processToolType(mapper, MT_TOOL_PALM);
9297     processSync(mapper);
9298     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9299     ASSERT_EQ(AMOTION_EVENT_ACTION_CANCEL, motionArgs.action);
9300 
9301     // third finger down.
9302     processSlot(mapper, THIRD_SLOT);
9303     processId(mapper, THIRD_TRACKING_ID);
9304     processToolType(mapper, MT_TOOL_FINGER);
9305     processPosition(mapper, x3, y3);
9306     processSync(mapper);
9307     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9308     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
9309     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
9310     ASSERT_EQ(uint32_t(1), motionArgs.pointerCount);
9311 
9312     // third finger move
9313     processId(mapper, THIRD_TRACKING_ID);
9314     processPosition(mapper, x3 + 1, y3 + 1);
9315     processSync(mapper);
9316     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9317     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
9318 
9319     // first finger up, third finger receive move.
9320     processSlot(mapper, FIRST_SLOT);
9321     processId(mapper, INVALID_TRACKING_ID);
9322     processSync(mapper);
9323     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9324     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
9325     ASSERT_EQ(uint32_t(1), motionArgs.pointerCount);
9326 
9327     // second finger up, third finger receive move.
9328     processSlot(mapper, SECOND_SLOT);
9329     processId(mapper, INVALID_TRACKING_ID);
9330     processSync(mapper);
9331     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9332     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
9333     ASSERT_EQ(uint32_t(1), motionArgs.pointerCount);
9334 
9335     // third finger up.
9336     processSlot(mapper, THIRD_SLOT);
9337     processId(mapper, INVALID_TRACKING_ID);
9338     processSync(mapper);
9339     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9340     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
9341     ASSERT_NE(AMOTION_EVENT_FLAG_CANCELED, motionArgs.flags);
9342 }
9343 
9344 /**
9345  * Test multi-touch should sent POINTER_UP when received the MT_TOOL_PALM event from some finger,
9346  * and the active finger could still be allowed to receive the events
9347  */
TEST_F(MultiTouchInputMapperTest,Process_ShouldHandlePalmToolType_KeepFirstPointer)9348 TEST_F(MultiTouchInputMapperTest, Process_ShouldHandlePalmToolType_KeepFirstPointer) {
9349     addConfigurationProperty("touch.deviceType", "touchScreen");
9350     prepareDisplay(DISPLAY_ORIENTATION_0);
9351     prepareAxes(POSITION | ID | SLOT | TOOL_TYPE);
9352     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
9353 
9354     NotifyMotionArgs motionArgs;
9355 
9356     // default tool type is finger
9357     constexpr int32_t x1 = 100, y1 = 200, x2 = 120, y2 = 220;
9358     processId(mapper, FIRST_TRACKING_ID);
9359     processPosition(mapper, x1, y1);
9360     processSync(mapper);
9361     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9362     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
9363     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
9364 
9365     // Second finger down.
9366     processSlot(mapper, SECOND_SLOT);
9367     processId(mapper, SECOND_TRACKING_ID);
9368     processPosition(mapper, x2, y2);
9369     processSync(mapper);
9370     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9371     ASSERT_EQ(ACTION_POINTER_1_DOWN, motionArgs.action);
9372     ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
9373 
9374     // If the tool type of the second finger changes to MT_TOOL_PALM,
9375     // we expect to receive ACTION_POINTER_UP with cancel flag.
9376     processId(mapper, SECOND_TRACKING_ID);
9377     processToolType(mapper, MT_TOOL_PALM);
9378     processSync(mapper);
9379     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9380     ASSERT_EQ(ACTION_POINTER_1_UP, motionArgs.action);
9381     ASSERT_EQ(AMOTION_EVENT_FLAG_CANCELED, motionArgs.flags);
9382 
9383     // The following MOVE event should be processed.
9384     processSlot(mapper, FIRST_SLOT);
9385     processId(mapper, FIRST_TRACKING_ID);
9386     processPosition(mapper, x1 + 1, y1 + 1);
9387     processSync(mapper);
9388     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9389     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
9390     ASSERT_EQ(uint32_t(1), motionArgs.pointerCount);
9391 
9392     // second finger up.
9393     processSlot(mapper, SECOND_SLOT);
9394     processId(mapper, INVALID_TRACKING_ID);
9395     processSync(mapper);
9396     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9397     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
9398 
9399     // first finger keep moving
9400     processSlot(mapper, FIRST_SLOT);
9401     processId(mapper, FIRST_TRACKING_ID);
9402     processPosition(mapper, x1 + 2, y1 + 2);
9403     processSync(mapper);
9404     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9405     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
9406 
9407     // first finger up.
9408     processId(mapper, INVALID_TRACKING_ID);
9409     processSync(mapper);
9410     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9411     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
9412     ASSERT_NE(AMOTION_EVENT_FLAG_CANCELED, motionArgs.flags);
9413 }
9414 
9415 /**
9416  * Test multi-touch should sent ACTION_POINTER_UP/ACTION_UP when received the INVALID_TRACKING_ID,
9417  * to prevent the driver side may send unexpected data after set tracking id as INVALID_TRACKING_ID
9418  * cause slot be valid again.
9419  */
TEST_F(MultiTouchInputMapperTest,Process_MultiTouch_WithInvalidTrackingId)9420 TEST_F(MultiTouchInputMapperTest, Process_MultiTouch_WithInvalidTrackingId) {
9421     addConfigurationProperty("touch.deviceType", "touchScreen");
9422     prepareDisplay(DISPLAY_ORIENTATION_0);
9423     prepareAxes(POSITION | ID | SLOT | PRESSURE);
9424     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
9425 
9426     NotifyMotionArgs motionArgs;
9427 
9428     constexpr int32_t x1 = 100, y1 = 200, x2 = 0, y2 = 0;
9429     // First finger down.
9430     processId(mapper, FIRST_TRACKING_ID);
9431     processPosition(mapper, x1, y1);
9432     processPressure(mapper, RAW_PRESSURE_MAX);
9433     processSync(mapper);
9434     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9435     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
9436     ASSERT_EQ(uint32_t(1), motionArgs.pointerCount);
9437 
9438     // First finger move.
9439     processId(mapper, FIRST_TRACKING_ID);
9440     processPosition(mapper, x1 + 1, y1 + 1);
9441     processPressure(mapper, RAW_PRESSURE_MAX);
9442     processSync(mapper);
9443     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9444     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
9445     ASSERT_EQ(uint32_t(1), motionArgs.pointerCount);
9446 
9447     // Second finger down.
9448     processSlot(mapper, SECOND_SLOT);
9449     processId(mapper, SECOND_TRACKING_ID);
9450     processPosition(mapper, x2, y2);
9451     processPressure(mapper, RAW_PRESSURE_MAX);
9452     processSync(mapper);
9453     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9454     ASSERT_EQ(ACTION_POINTER_1_DOWN, motionArgs.action);
9455     ASSERT_EQ(uint32_t(2), motionArgs.pointerCount);
9456 
9457     // second finger up with some unexpected data.
9458     processSlot(mapper, SECOND_SLOT);
9459     processId(mapper, INVALID_TRACKING_ID);
9460     processPosition(mapper, x2, y2);
9461     processSync(mapper);
9462     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9463     ASSERT_EQ(ACTION_POINTER_1_UP, motionArgs.action);
9464     ASSERT_EQ(uint32_t(2), motionArgs.pointerCount);
9465 
9466     // first finger up with some unexpected data.
9467     processSlot(mapper, FIRST_SLOT);
9468     processId(mapper, INVALID_TRACKING_ID);
9469     processPosition(mapper, x2, y2);
9470     processPressure(mapper, RAW_PRESSURE_MAX);
9471     processSync(mapper);
9472     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9473     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
9474     ASSERT_EQ(uint32_t(1), motionArgs.pointerCount);
9475 }
9476 
TEST_F(MultiTouchInputMapperTest,Reset_PreservesLastTouchState)9477 TEST_F(MultiTouchInputMapperTest, Reset_PreservesLastTouchState) {
9478     addConfigurationProperty("touch.deviceType", "touchScreen");
9479     prepareDisplay(DISPLAY_ORIENTATION_0);
9480     prepareAxes(POSITION | ID | SLOT | PRESSURE);
9481     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
9482 
9483     NotifyMotionArgs motionArgs;
9484 
9485     // First finger down.
9486     processId(mapper, FIRST_TRACKING_ID);
9487     processPosition(mapper, 100, 200);
9488     processPressure(mapper, RAW_PRESSURE_MAX);
9489     processSync(mapper);
9490     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9491     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
9492 
9493     // Second finger down.
9494     processSlot(mapper, SECOND_SLOT);
9495     processId(mapper, SECOND_TRACKING_ID);
9496     processPosition(mapper, 300, 400);
9497     processPressure(mapper, RAW_PRESSURE_MAX);
9498     processSync(mapper);
9499     ASSERT_NO_FATAL_FAILURE(
9500             mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9501     ASSERT_EQ(ACTION_POINTER_1_DOWN, motionArgs.action);
9502 
9503     // Reset the mapper. When the mapper is reset, we expect the current multi-touch state to be
9504     // preserved. Resetting should not generate any events.
9505     mapper.reset(ARBITRARY_TIME);
9506     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());
9507 
9508     // Send a sync to simulate an empty touch frame where nothing changes. The mapper should use
9509     // the existing touch state to generate a down event.
9510     processPosition(mapper, 301, 302);
9511     processSync(mapper);
9512     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9513     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
9514     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9515     ASSERT_EQ(ACTION_POINTER_1_DOWN, motionArgs.action);
9516 
9517     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());
9518 }
9519 
TEST_F(MultiTouchInputMapperTest,Reset_PreservesLastTouchState_NoPointersDown)9520 TEST_F(MultiTouchInputMapperTest, Reset_PreservesLastTouchState_NoPointersDown) {
9521     addConfigurationProperty("touch.deviceType", "touchScreen");
9522     prepareDisplay(DISPLAY_ORIENTATION_0);
9523     prepareAxes(POSITION | ID | SLOT | PRESSURE);
9524     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
9525 
9526     NotifyMotionArgs motionArgs;
9527 
9528     // First finger touches down and releases.
9529     processId(mapper, FIRST_TRACKING_ID);
9530     processPosition(mapper, 100, 200);
9531     processPressure(mapper, RAW_PRESSURE_MAX);
9532     processSync(mapper);
9533     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9534     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
9535     processId(mapper, INVALID_TRACKING_ID);
9536     processSync(mapper);
9537     ASSERT_NO_FATAL_FAILURE(
9538             mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9539     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
9540 
9541     // Reset the mapper. When the mapper is reset, we expect it to restore the latest
9542     // raw state where no pointers are down.
9543     mapper.reset(ARBITRARY_TIME);
9544     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());
9545 
9546     // Send an empty sync frame. Since there are no pointers, no events are generated.
9547     processSync(mapper);
9548     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());
9549 }
9550 
9551 // --- MultiTouchInputMapperTest_ExternalDevice ---
9552 
9553 class MultiTouchInputMapperTest_ExternalDevice : public MultiTouchInputMapperTest {
9554 protected:
SetUp()9555     void SetUp() override { InputMapperTest::SetUp(DEVICE_CLASSES | InputDeviceClass::EXTERNAL); }
9556 };
9557 
9558 /**
9559  * Expect fallback to internal viewport if device is external and external viewport is not present.
9560  */
TEST_F(MultiTouchInputMapperTest_ExternalDevice,Viewports_Fallback)9561 TEST_F(MultiTouchInputMapperTest_ExternalDevice, Viewports_Fallback) {
9562     prepareAxes(POSITION);
9563     addConfigurationProperty("touch.deviceType", "touchScreen");
9564     prepareDisplay(DISPLAY_ORIENTATION_0);
9565     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
9566 
9567     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, mapper.getSources());
9568 
9569     NotifyMotionArgs motionArgs;
9570 
9571     // Expect the event to be sent to the internal viewport,
9572     // because an external viewport is not present.
9573     processPosition(mapper, 100, 100);
9574     processSync(mapper);
9575     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9576     ASSERT_EQ(ADISPLAY_ID_DEFAULT, motionArgs.displayId);
9577 
9578     // Expect the event to be sent to the external viewport if it is present.
9579     prepareSecondaryDisplay(ViewportType::EXTERNAL);
9580     processPosition(mapper, 100, 100);
9581     processSync(mapper);
9582     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));
9583     ASSERT_EQ(SECONDARY_DISPLAY_ID, motionArgs.displayId);
9584 }
9585 
TEST_F(MultiTouchInputMapperTest,Process_TouchpadCapture)9586 TEST_F(MultiTouchInputMapperTest, Process_TouchpadCapture) {
9587     // we need a pointer controller for mouse mode of touchpad (start pointer at 0,0)
9588     std::shared_ptr<FakePointerController> fakePointerController =
9589             std::make_shared<FakePointerController>();
9590     fakePointerController->setBounds(0, 0, DISPLAY_WIDTH - 1, DISPLAY_HEIGHT - 1);
9591     fakePointerController->setPosition(0, 0);
9592     fakePointerController->setButtonState(0);
9593 
9594     // prepare device and capture
9595     prepareDisplay(DISPLAY_ORIENTATION_0);
9596     prepareAxes(POSITION | ID | SLOT);
9597     mFakeEventHub->addKey(EVENTHUB_ID, BTN_LEFT, 0, AKEYCODE_UNKNOWN, 0);
9598     mFakeEventHub->addKey(EVENTHUB_ID, BTN_TOUCH, 0, AKEYCODE_UNKNOWN, 0);
9599     mFakePolicy->setPointerCapture(true);
9600     mFakePolicy->setPointerController(fakePointerController);
9601     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
9602 
9603     // captured touchpad should be a touchpad source
9604     NotifyDeviceResetArgs resetArgs;
9605     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled(&resetArgs));
9606     ASSERT_EQ(AINPUT_SOURCE_TOUCHPAD, mapper.getSources());
9607 
9608     InputDeviceInfo deviceInfo = mDevice->getDeviceInfo();
9609 
9610     const InputDeviceInfo::MotionRange* relRangeX =
9611             deviceInfo.getMotionRange(AMOTION_EVENT_AXIS_RELATIVE_X, AINPUT_SOURCE_TOUCHPAD);
9612     ASSERT_NE(relRangeX, nullptr);
9613     ASSERT_EQ(relRangeX->min, -(RAW_X_MAX - RAW_X_MIN));
9614     ASSERT_EQ(relRangeX->max, RAW_X_MAX - RAW_X_MIN);
9615     const InputDeviceInfo::MotionRange* relRangeY =
9616             deviceInfo.getMotionRange(AMOTION_EVENT_AXIS_RELATIVE_Y, AINPUT_SOURCE_TOUCHPAD);
9617     ASSERT_NE(relRangeY, nullptr);
9618     ASSERT_EQ(relRangeY->min, -(RAW_Y_MAX - RAW_Y_MIN));
9619     ASSERT_EQ(relRangeY->max, RAW_Y_MAX - RAW_Y_MIN);
9620 
9621     // run captured pointer tests - note that this is unscaled, so input listener events should be
9622     //                              identical to what the hardware sends (accounting for any
9623     //                              calibration).
9624     // FINGER 0 DOWN
9625     processSlot(mapper, 0);
9626     processId(mapper, 1);
9627     processPosition(mapper, 100 + RAW_X_MIN, 100 + RAW_Y_MIN);
9628     processKey(mapper, BTN_TOUCH, 1);
9629     processSync(mapper);
9630 
9631     // expect coord[0] to contain initial location of touch 0
9632     NotifyMotionArgs args;
9633     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
9634     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action);
9635     ASSERT_EQ(1U, args.pointerCount);
9636     ASSERT_EQ(0, args.pointerProperties[0].id);
9637     ASSERT_EQ(AINPUT_SOURCE_TOUCHPAD, args.source);
9638     ASSERT_NO_FATAL_FAILURE(
9639             assertPointerCoords(args.pointerCoords[0], 100, 100, 1, 0, 0, 0, 0, 0, 0, 0));
9640 
9641     // FINGER 1 DOWN
9642     processSlot(mapper, 1);
9643     processId(mapper, 2);
9644     processPosition(mapper, 560 + RAW_X_MIN, 154 + RAW_Y_MIN);
9645     processSync(mapper);
9646 
9647     // expect coord[0] to contain previous location, coord[1] to contain new touch 1 location
9648     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
9649     ASSERT_EQ(ACTION_POINTER_1_DOWN, args.action);
9650     ASSERT_EQ(2U, args.pointerCount);
9651     ASSERT_EQ(0, args.pointerProperties[0].id);
9652     ASSERT_EQ(1, args.pointerProperties[1].id);
9653     ASSERT_NO_FATAL_FAILURE(
9654             assertPointerCoords(args.pointerCoords[0], 100, 100, 1, 0, 0, 0, 0, 0, 0, 0));
9655     ASSERT_NO_FATAL_FAILURE(
9656             assertPointerCoords(args.pointerCoords[1], 560, 154, 1, 0, 0, 0, 0, 0, 0, 0));
9657 
9658     // FINGER 1 MOVE
9659     processPosition(mapper, 540 + RAW_X_MIN, 690 + RAW_Y_MIN);
9660     processSync(mapper);
9661 
9662     // expect coord[0] to contain previous location, coord[1] to contain new touch 1 location
9663     // from move
9664     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
9665     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
9666     ASSERT_NO_FATAL_FAILURE(
9667             assertPointerCoords(args.pointerCoords[0], 100, 100, 1, 0, 0, 0, 0, 0, 0, 0));
9668     ASSERT_NO_FATAL_FAILURE(
9669             assertPointerCoords(args.pointerCoords[1], 540, 690, 1, 0, 0, 0, 0, 0, 0, 0));
9670 
9671     // FINGER 0 MOVE
9672     processSlot(mapper, 0);
9673     processPosition(mapper, 50 + RAW_X_MIN, 800 + RAW_Y_MIN);
9674     processSync(mapper);
9675 
9676     // expect coord[0] to contain new touch 0 location, coord[1] to contain previous location
9677     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
9678     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
9679     ASSERT_NO_FATAL_FAILURE(
9680             assertPointerCoords(args.pointerCoords[0], 50, 800, 1, 0, 0, 0, 0, 0, 0, 0));
9681     ASSERT_NO_FATAL_FAILURE(
9682             assertPointerCoords(args.pointerCoords[1], 540, 690, 1, 0, 0, 0, 0, 0, 0, 0));
9683 
9684     // BUTTON DOWN
9685     processKey(mapper, BTN_LEFT, 1);
9686     processSync(mapper);
9687 
9688     // touchinputmapper design sends a move before button press
9689     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
9690     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
9691     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
9692     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, args.action);
9693 
9694     // BUTTON UP
9695     processKey(mapper, BTN_LEFT, 0);
9696     processSync(mapper);
9697 
9698     // touchinputmapper design sends a move after button release
9699     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
9700     ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, args.action);
9701     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
9702     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
9703 
9704     // FINGER 0 UP
9705     processId(mapper, -1);
9706     processSync(mapper);
9707     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
9708     ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_UP | 0x0000, args.action);
9709 
9710     // FINGER 1 MOVE
9711     processSlot(mapper, 1);
9712     processPosition(mapper, 320 + RAW_X_MIN, 900 + RAW_Y_MIN);
9713     processSync(mapper);
9714 
9715     // expect coord[0] to contain new location of touch 1, and properties[0].id to contain 1
9716     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
9717     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
9718     ASSERT_EQ(1U, args.pointerCount);
9719     ASSERT_EQ(1, args.pointerProperties[0].id);
9720     ASSERT_NO_FATAL_FAILURE(
9721             assertPointerCoords(args.pointerCoords[0], 320, 900, 1, 0, 0, 0, 0, 0, 0, 0));
9722 
9723     // FINGER 1 UP
9724     processId(mapper, -1);
9725     processKey(mapper, BTN_TOUCH, 0);
9726     processSync(mapper);
9727     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
9728     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, args.action);
9729 
9730     // non captured touchpad should be a mouse source
9731     mFakePolicy->setPointerCapture(false);
9732     configureDevice(InputReaderConfiguration::CHANGE_POINTER_CAPTURE);
9733     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled(&resetArgs));
9734     ASSERT_EQ(AINPUT_SOURCE_MOUSE, mapper.getSources());
9735 }
9736 
TEST_F(MultiTouchInputMapperTest,Process_UnCapturedTouchpadPointer)9737 TEST_F(MultiTouchInputMapperTest, Process_UnCapturedTouchpadPointer) {
9738     std::shared_ptr<FakePointerController> fakePointerController =
9739             std::make_shared<FakePointerController>();
9740     fakePointerController->setBounds(0, 0, DISPLAY_WIDTH - 1, DISPLAY_HEIGHT - 1);
9741     fakePointerController->setPosition(0, 0);
9742     fakePointerController->setButtonState(0);
9743 
9744     // prepare device and capture
9745     prepareDisplay(DISPLAY_ORIENTATION_0);
9746     prepareAxes(POSITION | ID | SLOT);
9747     mFakeEventHub->addKey(EVENTHUB_ID, BTN_LEFT, 0, AKEYCODE_UNKNOWN, 0);
9748     mFakeEventHub->addKey(EVENTHUB_ID, BTN_TOUCH, 0, AKEYCODE_UNKNOWN, 0);
9749     mFakePolicy->setPointerController(fakePointerController);
9750     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
9751     // run uncaptured pointer tests - pushes out generic events
9752     // FINGER 0 DOWN
9753     processId(mapper, 3);
9754     processPosition(mapper, 100, 100);
9755     processKey(mapper, BTN_TOUCH, 1);
9756     processSync(mapper);
9757 
9758     // start at (100,100), cursor should be at (0,0) * scale
9759     NotifyMotionArgs args;
9760     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
9761     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, args.action);
9762     ASSERT_NO_FATAL_FAILURE(
9763             assertPointerCoords(args.pointerCoords[0], 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
9764 
9765     // FINGER 0 MOVE
9766     processPosition(mapper, 200, 200);
9767     processSync(mapper);
9768 
9769     // compute scaling to help with touch position checking
9770     float rawDiagonal = hypotf(RAW_X_MAX - RAW_X_MIN, RAW_Y_MAX - RAW_Y_MIN);
9771     float displayDiagonal = hypotf(DISPLAY_WIDTH, DISPLAY_HEIGHT);
9772     float scale =
9773             mFakePolicy->getPointerGestureMovementSpeedRatio() * displayDiagonal / rawDiagonal;
9774 
9775     // translate from (100,100) -> (200,200), cursor should have changed to (100,100) * scale)
9776     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
9777     ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, args.action);
9778     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], 100 * scale, 100 * scale, 0,
9779                                                 0, 0, 0, 0, 0, 0, 0));
9780 }
9781 
TEST_F(MultiTouchInputMapperTest,WhenCapturedAndNotCaptured_GetSources)9782 TEST_F(MultiTouchInputMapperTest, WhenCapturedAndNotCaptured_GetSources) {
9783     std::shared_ptr<FakePointerController> fakePointerController =
9784             std::make_shared<FakePointerController>();
9785 
9786     prepareDisplay(DISPLAY_ORIENTATION_0);
9787     prepareAxes(POSITION | ID | SLOT);
9788     mFakeEventHub->addKey(EVENTHUB_ID, BTN_LEFT, 0, AKEYCODE_UNKNOWN, 0);
9789     mFakePolicy->setPointerController(fakePointerController);
9790     mFakePolicy->setPointerCapture(false);
9791     MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();
9792 
9793     // uncaptured touchpad should be a pointer device
9794     ASSERT_EQ(AINPUT_SOURCE_MOUSE, mapper.getSources());
9795 
9796     // captured touchpad should be a touchpad device
9797     mFakePolicy->setPointerCapture(true);
9798     configureDevice(InputReaderConfiguration::CHANGE_POINTER_CAPTURE);
9799     ASSERT_EQ(AINPUT_SOURCE_TOUCHPAD, mapper.getSources());
9800 }
9801 
9802 // --- JoystickInputMapperTest ---
9803 
9804 class JoystickInputMapperTest : public InputMapperTest {
9805 protected:
9806     static const int32_t RAW_X_MIN;
9807     static const int32_t RAW_X_MAX;
9808     static const int32_t RAW_Y_MIN;
9809     static const int32_t RAW_Y_MAX;
9810 
SetUp()9811     void SetUp() override {
9812         InputMapperTest::SetUp(InputDeviceClass::JOYSTICK | InputDeviceClass::EXTERNAL);
9813     }
prepareAxes()9814     void prepareAxes() {
9815         mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_X, RAW_X_MIN, RAW_X_MAX, 0, 0);
9816         mFakeEventHub->addAbsoluteAxis(EVENTHUB_ID, ABS_Y, RAW_Y_MIN, RAW_Y_MAX, 0, 0);
9817     }
9818 
processAxis(JoystickInputMapper & mapper,int32_t axis,int32_t value)9819     void processAxis(JoystickInputMapper& mapper, int32_t axis, int32_t value) {
9820         process(mapper, ARBITRARY_TIME, READ_TIME, EV_ABS, axis, value);
9821     }
9822 
processSync(JoystickInputMapper & mapper)9823     void processSync(JoystickInputMapper& mapper) {
9824         process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0);
9825     }
9826 
prepareVirtualDisplay(int32_t orientation)9827     void prepareVirtualDisplay(int32_t orientation) {
9828         setDisplayInfoAndReconfigure(VIRTUAL_DISPLAY_ID, VIRTUAL_DISPLAY_WIDTH,
9829                                      VIRTUAL_DISPLAY_HEIGHT, orientation, VIRTUAL_DISPLAY_UNIQUE_ID,
9830                                      NO_PORT, ViewportType::VIRTUAL);
9831     }
9832 };
9833 
9834 const int32_t JoystickInputMapperTest::RAW_X_MIN = -32767;
9835 const int32_t JoystickInputMapperTest::RAW_X_MAX = 32767;
9836 const int32_t JoystickInputMapperTest::RAW_Y_MIN = -32767;
9837 const int32_t JoystickInputMapperTest::RAW_Y_MAX = 32767;
9838 
TEST_F(JoystickInputMapperTest,Configure_AssignsDisplayUniqueId)9839 TEST_F(JoystickInputMapperTest, Configure_AssignsDisplayUniqueId) {
9840     prepareAxes();
9841     JoystickInputMapper& mapper = addMapperAndConfigure<JoystickInputMapper>();
9842 
9843     mFakePolicy->addInputUniqueIdAssociation(DEVICE_LOCATION, VIRTUAL_DISPLAY_UNIQUE_ID);
9844 
9845     prepareVirtualDisplay(DISPLAY_ORIENTATION_0);
9846 
9847     // Send an axis event
9848     processAxis(mapper, ABS_X, 100);
9849     processSync(mapper);
9850 
9851     NotifyMotionArgs args;
9852     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
9853     ASSERT_EQ(VIRTUAL_DISPLAY_ID, args.displayId);
9854 
9855     // Send another axis event
9856     processAxis(mapper, ABS_Y, 100);
9857     processSync(mapper);
9858 
9859     ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
9860     ASSERT_EQ(VIRTUAL_DISPLAY_ID, args.displayId);
9861 }
9862 
9863 // --- PeripheralControllerTest ---
9864 
9865 class PeripheralControllerTest : public testing::Test {
9866 protected:
9867     static const char* DEVICE_NAME;
9868     static const char* DEVICE_LOCATION;
9869     static const int32_t DEVICE_ID;
9870     static const int32_t DEVICE_GENERATION;
9871     static const int32_t DEVICE_CONTROLLER_NUMBER;
9872     static const ftl::Flags<InputDeviceClass> DEVICE_CLASSES;
9873     static const int32_t EVENTHUB_ID;
9874 
9875     std::shared_ptr<FakeEventHub> mFakeEventHub;
9876     sp<FakeInputReaderPolicy> mFakePolicy;
9877     std::unique_ptr<TestInputListener> mFakeListener;
9878     std::unique_ptr<InstrumentedInputReader> mReader;
9879     std::shared_ptr<InputDevice> mDevice;
9880 
SetUp(ftl::Flags<InputDeviceClass> classes)9881     virtual void SetUp(ftl::Flags<InputDeviceClass> classes) {
9882         mFakeEventHub = std::make_unique<FakeEventHub>();
9883         mFakePolicy = new FakeInputReaderPolicy();
9884         mFakeListener = std::make_unique<TestInputListener>();
9885         mReader = std::make_unique<InstrumentedInputReader>(mFakeEventHub, mFakePolicy,
9886                                                             *mFakeListener);
9887         mDevice = newDevice(DEVICE_ID, DEVICE_NAME, DEVICE_LOCATION, EVENTHUB_ID, classes);
9888     }
9889 
SetUp()9890     void SetUp() override { SetUp(DEVICE_CLASSES); }
9891 
TearDown()9892     void TearDown() override {
9893         mFakeListener.reset();
9894         mFakePolicy.clear();
9895     }
9896 
configureDevice(uint32_t changes)9897     void configureDevice(uint32_t changes) {
9898         if (!changes || (changes & InputReaderConfiguration::CHANGE_DISPLAY_INFO)) {
9899             mReader->requestRefreshConfiguration(changes);
9900             mReader->loopOnce();
9901         }
9902         mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), changes);
9903     }
9904 
newDevice(int32_t deviceId,const std::string & name,const std::string & location,int32_t eventHubId,ftl::Flags<InputDeviceClass> classes)9905     std::shared_ptr<InputDevice> newDevice(int32_t deviceId, const std::string& name,
9906                                            const std::string& location, int32_t eventHubId,
9907                                            ftl::Flags<InputDeviceClass> classes) {
9908         InputDeviceIdentifier identifier;
9909         identifier.name = name;
9910         identifier.location = location;
9911         std::shared_ptr<InputDevice> device =
9912                 std::make_shared<InputDevice>(mReader->getContext(), deviceId, DEVICE_GENERATION,
9913                                               identifier);
9914         mReader->pushNextDevice(device);
9915         mFakeEventHub->addDevice(eventHubId, name, classes);
9916         mReader->loopOnce();
9917         return device;
9918     }
9919 
9920     template <class T, typename... Args>
addControllerAndConfigure(Args...args)9921     T& addControllerAndConfigure(Args... args) {
9922         T& controller = mDevice->addController<T>(EVENTHUB_ID, args...);
9923 
9924         return controller;
9925     }
9926 };
9927 
9928 const char* PeripheralControllerTest::DEVICE_NAME = "device";
9929 const char* PeripheralControllerTest::DEVICE_LOCATION = "BLUETOOTH";
9930 const int32_t PeripheralControllerTest::DEVICE_ID = END_RESERVED_ID + 1000;
9931 const int32_t PeripheralControllerTest::DEVICE_GENERATION = 2;
9932 const int32_t PeripheralControllerTest::DEVICE_CONTROLLER_NUMBER = 0;
9933 const ftl::Flags<InputDeviceClass> PeripheralControllerTest::DEVICE_CLASSES =
9934         ftl::Flags<InputDeviceClass>(0); // not needed for current tests
9935 const int32_t PeripheralControllerTest::EVENTHUB_ID = 1;
9936 
9937 // --- BatteryControllerTest ---
9938 class BatteryControllerTest : public PeripheralControllerTest {
9939 protected:
SetUp()9940     void SetUp() override {
9941         PeripheralControllerTest::SetUp(DEVICE_CLASSES | InputDeviceClass::BATTERY);
9942     }
9943 };
9944 
TEST_F(BatteryControllerTest,GetBatteryCapacity)9945 TEST_F(BatteryControllerTest, GetBatteryCapacity) {
9946     PeripheralController& controller = addControllerAndConfigure<PeripheralController>();
9947 
9948     ASSERT_TRUE(controller.getBatteryCapacity(DEFAULT_BATTERY));
9949     ASSERT_EQ(controller.getBatteryCapacity(DEFAULT_BATTERY).value_or(-1), BATTERY_CAPACITY);
9950 }
9951 
TEST_F(BatteryControllerTest,GetBatteryStatus)9952 TEST_F(BatteryControllerTest, GetBatteryStatus) {
9953     PeripheralController& controller = addControllerAndConfigure<PeripheralController>();
9954 
9955     ASSERT_TRUE(controller.getBatteryStatus(DEFAULT_BATTERY));
9956     ASSERT_EQ(controller.getBatteryStatus(DEFAULT_BATTERY).value_or(-1), BATTERY_STATUS);
9957 }
9958 
9959 // --- LightControllerTest ---
9960 class LightControllerTest : public PeripheralControllerTest {
9961 protected:
SetUp()9962     void SetUp() override {
9963         PeripheralControllerTest::SetUp(DEVICE_CLASSES | InputDeviceClass::LIGHT);
9964     }
9965 };
9966 
TEST_F(LightControllerTest,MonoLight)9967 TEST_F(LightControllerTest, MonoLight) {
9968     RawLightInfo infoMono = {.id = 1,
9969                              .name = "Mono",
9970                              .maxBrightness = 255,
9971                              .flags = InputLightClass::BRIGHTNESS,
9972                              .path = ""};
9973     mFakeEventHub->addRawLightInfo(infoMono.id, std::move(infoMono));
9974 
9975     PeripheralController& controller = addControllerAndConfigure<PeripheralController>();
9976     InputDeviceInfo info;
9977     controller.populateDeviceInfo(&info);
9978     std::vector<InputDeviceLightInfo> lights = info.getLights();
9979     ASSERT_EQ(1U, lights.size());
9980     ASSERT_EQ(InputDeviceLightType::MONO, lights[0].type);
9981 
9982     ASSERT_TRUE(controller.setLightColor(lights[0].id, LIGHT_BRIGHTNESS));
9983     ASSERT_EQ(controller.getLightColor(lights[0].id).value_or(-1), LIGHT_BRIGHTNESS);
9984 }
9985 
TEST_F(LightControllerTest,RGBLight)9986 TEST_F(LightControllerTest, RGBLight) {
9987     RawLightInfo infoRed = {.id = 1,
9988                             .name = "red",
9989                             .maxBrightness = 255,
9990                             .flags = InputLightClass::BRIGHTNESS | InputLightClass::RED,
9991                             .path = ""};
9992     RawLightInfo infoGreen = {.id = 2,
9993                               .name = "green",
9994                               .maxBrightness = 255,
9995                               .flags = InputLightClass::BRIGHTNESS | InputLightClass::GREEN,
9996                               .path = ""};
9997     RawLightInfo infoBlue = {.id = 3,
9998                              .name = "blue",
9999                              .maxBrightness = 255,
10000                              .flags = InputLightClass::BRIGHTNESS | InputLightClass::BLUE,
10001                              .path = ""};
10002     mFakeEventHub->addRawLightInfo(infoRed.id, std::move(infoRed));
10003     mFakeEventHub->addRawLightInfo(infoGreen.id, std::move(infoGreen));
10004     mFakeEventHub->addRawLightInfo(infoBlue.id, std::move(infoBlue));
10005 
10006     PeripheralController& controller = addControllerAndConfigure<PeripheralController>();
10007     InputDeviceInfo info;
10008     controller.populateDeviceInfo(&info);
10009     std::vector<InputDeviceLightInfo> lights = info.getLights();
10010     ASSERT_EQ(1U, lights.size());
10011     ASSERT_EQ(InputDeviceLightType::RGB, lights[0].type);
10012 
10013     ASSERT_TRUE(controller.setLightColor(lights[0].id, LIGHT_COLOR));
10014     ASSERT_EQ(controller.getLightColor(lights[0].id).value_or(-1), LIGHT_COLOR);
10015 }
10016 
TEST_F(LightControllerTest,MultiColorRGBLight)10017 TEST_F(LightControllerTest, MultiColorRGBLight) {
10018     RawLightInfo infoColor = {.id = 1,
10019                               .name = "red",
10020                               .maxBrightness = 255,
10021                               .flags = InputLightClass::BRIGHTNESS |
10022                                       InputLightClass::MULTI_INTENSITY |
10023                                       InputLightClass::MULTI_INDEX,
10024                               .path = ""};
10025 
10026     mFakeEventHub->addRawLightInfo(infoColor.id, std::move(infoColor));
10027 
10028     PeripheralController& controller = addControllerAndConfigure<PeripheralController>();
10029     InputDeviceInfo info;
10030     controller.populateDeviceInfo(&info);
10031     std::vector<InputDeviceLightInfo> lights = info.getLights();
10032     ASSERT_EQ(1U, lights.size());
10033     ASSERT_EQ(InputDeviceLightType::MULTI_COLOR, lights[0].type);
10034 
10035     ASSERT_TRUE(controller.setLightColor(lights[0].id, LIGHT_COLOR));
10036     ASSERT_EQ(controller.getLightColor(lights[0].id).value_or(-1), LIGHT_COLOR);
10037 }
10038 
TEST_F(LightControllerTest,PlayerIdLight)10039 TEST_F(LightControllerTest, PlayerIdLight) {
10040     RawLightInfo info1 = {.id = 1,
10041                           .name = "player1",
10042                           .maxBrightness = 255,
10043                           .flags = InputLightClass::BRIGHTNESS,
10044                           .path = ""};
10045     RawLightInfo info2 = {.id = 2,
10046                           .name = "player2",
10047                           .maxBrightness = 255,
10048                           .flags = InputLightClass::BRIGHTNESS,
10049                           .path = ""};
10050     RawLightInfo info3 = {.id = 3,
10051                           .name = "player3",
10052                           .maxBrightness = 255,
10053                           .flags = InputLightClass::BRIGHTNESS,
10054                           .path = ""};
10055     RawLightInfo info4 = {.id = 4,
10056                           .name = "player4",
10057                           .maxBrightness = 255,
10058                           .flags = InputLightClass::BRIGHTNESS,
10059                           .path = ""};
10060     mFakeEventHub->addRawLightInfo(info1.id, std::move(info1));
10061     mFakeEventHub->addRawLightInfo(info2.id, std::move(info2));
10062     mFakeEventHub->addRawLightInfo(info3.id, std::move(info3));
10063     mFakeEventHub->addRawLightInfo(info4.id, std::move(info4));
10064 
10065     PeripheralController& controller = addControllerAndConfigure<PeripheralController>();
10066     InputDeviceInfo info;
10067     controller.populateDeviceInfo(&info);
10068     std::vector<InputDeviceLightInfo> lights = info.getLights();
10069     ASSERT_EQ(1U, lights.size());
10070     ASSERT_EQ(InputDeviceLightType::PLAYER_ID, lights[0].type);
10071 
10072     ASSERT_FALSE(controller.setLightColor(lights[0].id, LIGHT_COLOR));
10073     ASSERT_TRUE(controller.setLightPlayerId(lights[0].id, LIGHT_PLAYER_ID));
10074     ASSERT_EQ(controller.getLightPlayerId(lights[0].id).value_or(-1), LIGHT_PLAYER_ID);
10075 }
10076 
10077 } // namespace android
10078