2 // Copyright 2010 The Android Open Source Project
5 #include <ui/InputReader.h>
6 #include <utils/List.h>
7 #include <gtest/gtest.h>
12 // An arbitrary time value.
13 static const nsecs_t ARBITRARY_TIME = 1234;
15 // Arbitrary display properties.
16 static const int32_t DISPLAY_ID = 0;
17 static const int32_t DISPLAY_WIDTH = 480;
18 static const int32_t DISPLAY_HEIGHT = 800;
20 // Error tolerance for floating point assertions.
21 static const float EPSILON = 0.001f;
24 static inline T min(T a, T b) {
28 static inline float avg(float x, float y) {
33 // --- FakeInputReaderPolicy ---
35 class FakeInputReaderPolicy : public InputReaderPolicyInterface {
42 KeyedVector<int32_t, DisplayInfo> mDisplayInfos;
43 bool mFilterTouchEvents;
44 bool mFilterJumpyTouchEvents;
45 KeyedVector<String8, Vector<VirtualKeyDefinition> > mVirtualKeyDefinitions;
46 KeyedVector<String8, InputDeviceCalibration> mInputDeviceCalibrations;
47 Vector<String8> mExcludedDeviceNames;
50 virtual ~FakeInputReaderPolicy() { }
53 FakeInputReaderPolicy() :
54 mFilterTouchEvents(false), mFilterJumpyTouchEvents(false) {
57 void removeDisplayInfo(int32_t displayId) {
58 mDisplayInfos.removeItem(displayId);
61 void setDisplayInfo(int32_t displayId, int32_t width, int32_t height, int32_t orientation) {
62 removeDisplayInfo(displayId);
67 info.orientation = orientation;
68 mDisplayInfos.add(displayId, info);
71 void setFilterTouchEvents(bool enabled) {
72 mFilterTouchEvents = enabled;
75 void setFilterJumpyTouchEvents(bool enabled) {
76 mFilterJumpyTouchEvents = enabled;
79 void addInputDeviceCalibration(const String8& deviceName,
80 const InputDeviceCalibration& calibration) {
81 mInputDeviceCalibrations.add(deviceName, calibration);
84 void addInputDeviceCalibrationProperty(const String8& deviceName,
85 const String8& key, const String8& value) {
86 ssize_t index = mInputDeviceCalibrations.indexOfKey(deviceName);
88 index = mInputDeviceCalibrations.add(deviceName, InputDeviceCalibration());
90 mInputDeviceCalibrations.editValueAt(index).addProperty(key, value);
93 void addVirtualKeyDefinition(const String8& deviceName,
94 const VirtualKeyDefinition& definition) {
95 if (mVirtualKeyDefinitions.indexOfKey(deviceName) < 0) {
96 mVirtualKeyDefinitions.add(deviceName, Vector<VirtualKeyDefinition>());
99 mVirtualKeyDefinitions.editValueFor(deviceName).push(definition);
102 void addExcludedDeviceName(const String8& deviceName) {
103 mExcludedDeviceNames.push(deviceName);
107 virtual bool getDisplayInfo(int32_t displayId,
108 int32_t* width, int32_t* height, int32_t* orientation) {
109 ssize_t index = mDisplayInfos.indexOfKey(displayId);
111 const DisplayInfo& info = mDisplayInfos.valueAt(index);
116 *height = info.height;
119 *orientation = info.orientation;
126 virtual bool filterTouchEvents() {
127 return mFilterTouchEvents;
130 virtual bool filterJumpyTouchEvents() {
131 return mFilterJumpyTouchEvents;
134 virtual nsecs_t getVirtualKeyQuietTime() {
138 virtual void getVirtualKeyDefinitions(const String8& deviceName,
139 Vector<VirtualKeyDefinition>& outVirtualKeyDefinitions) {
140 ssize_t index = mVirtualKeyDefinitions.indexOfKey(deviceName);
142 outVirtualKeyDefinitions.appendVector(mVirtualKeyDefinitions.valueAt(index));
146 virtual void getInputDeviceCalibration(const String8& deviceName,
147 InputDeviceCalibration& outCalibration) {
148 ssize_t index = mInputDeviceCalibrations.indexOfKey(deviceName);
150 outCalibration = mInputDeviceCalibrations.valueAt(index);
154 virtual void getExcludedDeviceNames(Vector<String8>& outExcludedDeviceNames) {
155 outExcludedDeviceNames.appendVector(mExcludedDeviceNames);
160 // --- FakeInputDispatcher ---
162 class FakeInputDispatcher : public InputDispatcherInterface {
164 struct NotifyConfigurationChangedArgs {
168 struct NotifyKeyArgs {
172 uint32_t policyFlags;
181 struct NotifyMotionArgs {
185 uint32_t policyFlags;
190 uint32_t pointerCount;
191 Vector<int32_t> pointerIds;
192 Vector<PointerCoords> pointerCoords;
198 struct NotifySwitchArgs {
202 uint32_t policyFlags;
206 List<NotifyConfigurationChangedArgs> mNotifyConfigurationChangedArgs;
207 List<NotifyKeyArgs> mNotifyKeyArgs;
208 List<NotifyMotionArgs> mNotifyMotionArgs;
209 List<NotifySwitchArgs> mNotifySwitchArgs;
212 virtual ~FakeInputDispatcher() { }
215 FakeInputDispatcher() {
218 void assertNotifyConfigurationChangedWasCalled(NotifyConfigurationChangedArgs* outArgs = NULL) {
219 ASSERT_FALSE(mNotifyConfigurationChangedArgs.empty())
220 << "Expected notifyConfigurationChanged() to have been called.";
222 *outArgs = *mNotifyConfigurationChangedArgs.begin();
224 mNotifyConfigurationChangedArgs.erase(mNotifyConfigurationChangedArgs.begin());
227 void assertNotifyKeyWasCalled(NotifyKeyArgs* outArgs = NULL) {
228 ASSERT_FALSE(mNotifyKeyArgs.empty())
229 << "Expected notifyKey() to have been called.";
231 *outArgs = *mNotifyKeyArgs.begin();
233 mNotifyKeyArgs.erase(mNotifyKeyArgs.begin());
236 void assertNotifyKeyWasNotCalled() {
237 ASSERT_TRUE(mNotifyKeyArgs.empty())
238 << "Expected notifyKey() to not have been called.";
241 void assertNotifyMotionWasCalled(NotifyMotionArgs* outArgs = NULL) {
242 ASSERT_FALSE(mNotifyMotionArgs.empty())
243 << "Expected notifyMotion() to have been called.";
245 *outArgs = *mNotifyMotionArgs.begin();
247 mNotifyMotionArgs.erase(mNotifyMotionArgs.begin());
250 void assertNotifyMotionWasNotCalled() {
251 ASSERT_TRUE(mNotifyMotionArgs.empty())
252 << "Expected notifyMotion() to not have been called.";
255 void assertNotifySwitchWasCalled(NotifySwitchArgs* outArgs = NULL) {
256 ASSERT_FALSE(mNotifySwitchArgs.empty())
257 << "Expected notifySwitch() to have been called.";
259 *outArgs = *mNotifySwitchArgs.begin();
261 mNotifySwitchArgs.erase(mNotifySwitchArgs.begin());
265 virtual void notifyConfigurationChanged(nsecs_t eventTime) {
266 NotifyConfigurationChangedArgs args;
267 args.eventTime = eventTime;
268 mNotifyConfigurationChangedArgs.push_back(args);
271 virtual void notifyKey(nsecs_t eventTime, int32_t deviceId, int32_t source,
272 uint32_t policyFlags, int32_t action, int32_t flags, int32_t keyCode,
273 int32_t scanCode, int32_t metaState, nsecs_t downTime) {
275 args.eventTime = eventTime;
276 args.deviceId = deviceId;
277 args.source = source;
278 args.policyFlags = policyFlags;
279 args.action = action;
281 args.keyCode = keyCode;
282 args.scanCode = scanCode;
283 args.metaState = metaState;
284 args.downTime = downTime;
285 mNotifyKeyArgs.push_back(args);
288 virtual void notifyMotion(nsecs_t eventTime, int32_t deviceId, int32_t source,
289 uint32_t policyFlags, int32_t action, int32_t flags,
290 int32_t metaState, int32_t edgeFlags,
291 uint32_t pointerCount, const int32_t* pointerIds, const PointerCoords* pointerCoords,
292 float xPrecision, float yPrecision, nsecs_t downTime) {
293 NotifyMotionArgs args;
294 args.eventTime = eventTime;
295 args.deviceId = deviceId;
296 args.source = source;
297 args.policyFlags = policyFlags;
298 args.action = action;
300 args.metaState = metaState;
301 args.edgeFlags = edgeFlags;
302 args.pointerCount = pointerCount;
303 args.pointerIds.clear();
304 args.pointerIds.appendArray(pointerIds, pointerCount);
305 args.pointerCoords.clear();
306 args.pointerCoords.appendArray(pointerCoords, pointerCount);
307 args.xPrecision = xPrecision;
308 args.yPrecision = yPrecision;
309 args.downTime = downTime;
310 mNotifyMotionArgs.push_back(args);
313 virtual void notifySwitch(nsecs_t when,
314 int32_t switchCode, int32_t switchValue, uint32_t policyFlags) {
315 NotifySwitchArgs args;
317 args.switchCode = switchCode;
318 args.switchValue = switchValue;
319 args.policyFlags = policyFlags;
320 mNotifySwitchArgs.push_back(args);
323 virtual void dump(String8& dump) {
324 ADD_FAILURE() << "Should never be called by input reader.";
327 virtual void dispatchOnce() {
328 ADD_FAILURE() << "Should never be called by input reader.";
331 virtual int32_t injectInputEvent(const InputEvent* event,
332 int32_t injectorPid, int32_t injectorUid, int32_t syncMode, int32_t timeoutMillis) {
333 ADD_FAILURE() << "Should never be called by input reader.";
334 return INPUT_EVENT_INJECTION_FAILED;
337 virtual void setInputWindows(const Vector<InputWindow>& inputWindows) {
338 ADD_FAILURE() << "Should never be called by input reader.";
341 virtual void setFocusedApplication(const InputApplication* inputApplication) {
342 ADD_FAILURE() << "Should never be called by input reader.";
345 virtual void setInputDispatchMode(bool enabled, bool frozen) {
346 ADD_FAILURE() << "Should never be called by input reader.";
349 virtual status_t registerInputChannel(const sp<InputChannel>& inputChannel, bool monitor) {
350 ADD_FAILURE() << "Should never be called by input reader.";
354 virtual status_t unregisterInputChannel(const sp<InputChannel>& inputChannel) {
355 ADD_FAILURE() << "Should never be called by input reader.";
361 // --- FakeEventHub ---
363 class FakeEventHub : public EventHubInterface {
372 KeyedVector<int, RawAbsoluteAxisInfo> axes;
373 KeyedVector<int32_t, int32_t> keyCodeStates;
374 KeyedVector<int32_t, int32_t> scanCodeStates;
375 KeyedVector<int32_t, int32_t> switchStates;
376 KeyedVector<int32_t, KeyInfo> keys;
378 Device(const String8& name, uint32_t classes) :
379 name(name), classes(classes) {
383 KeyedVector<int32_t, Device*> mDevices;
384 Vector<String8> mExcludedDevices;
385 List<RawEvent> mEvents;
388 virtual ~FakeEventHub() {
389 for (size_t i = 0; i < mDevices.size(); i++) {
390 delete mDevices.valueAt(i);
397 void addDevice(int32_t deviceId, const String8& name, uint32_t classes) {
398 Device* device = new Device(name, classes);
399 mDevices.add(deviceId, device);
401 enqueueEvent(ARBITRARY_TIME, deviceId, EventHubInterface::DEVICE_ADDED, 0, 0, 0, 0);
404 void removeDevice(int32_t deviceId) {
405 delete mDevices.valueFor(deviceId);
406 mDevices.removeItem(deviceId);
408 enqueueEvent(ARBITRARY_TIME, deviceId, EventHubInterface::DEVICE_REMOVED, 0, 0, 0, 0);
411 void finishDeviceScan() {
412 enqueueEvent(ARBITRARY_TIME, 0, EventHubInterface::FINISHED_DEVICE_SCAN, 0, 0, 0, 0);
415 void addAxis(int32_t deviceId, int axis,
416 int32_t minValue, int32_t maxValue, int flat, int fuzz) {
417 Device* device = getDevice(deviceId);
419 RawAbsoluteAxisInfo info;
421 info.minValue = minValue;
422 info.maxValue = maxValue;
425 device->axes.add(axis, info);
428 void setKeyCodeState(int32_t deviceId, int32_t keyCode, int32_t state) {
429 Device* device = getDevice(deviceId);
430 device->keyCodeStates.replaceValueFor(keyCode, state);
433 void setScanCodeState(int32_t deviceId, int32_t scanCode, int32_t state) {
434 Device* device = getDevice(deviceId);
435 device->scanCodeStates.replaceValueFor(scanCode, state);
438 void setSwitchState(int32_t deviceId, int32_t switchCode, int32_t state) {
439 Device* device = getDevice(deviceId);
440 device->switchStates.replaceValueFor(switchCode, state);
443 void addKey(int32_t deviceId, int32_t scanCode, int32_t keyCode, uint32_t flags) {
444 Device* device = getDevice(deviceId);
446 info.keyCode = keyCode;
448 device->keys.add(scanCode, info);
451 Vector<String8>& getExcludedDevices() {
452 return mExcludedDevices;
455 void enqueueEvent(nsecs_t when, int32_t deviceId, int32_t type,
456 int32_t scanCode, int32_t keyCode, int32_t value, uint32_t flags) {
459 event.deviceId = deviceId;
461 event.scanCode = scanCode;
462 event.keyCode = keyCode;
465 mEvents.push_back(event);
468 void assertQueueIsEmpty() {
469 ASSERT_EQ(size_t(0), mEvents.size())
470 << "Expected the event queue to be empty (fully consumed).";
474 Device* getDevice(int32_t deviceId) const {
475 ssize_t index = mDevices.indexOfKey(deviceId);
476 return index >= 0 ? mDevices.valueAt(index) : NULL;
479 virtual uint32_t getDeviceClasses(int32_t deviceId) const {
480 Device* device = getDevice(deviceId);
481 return device ? device->classes : 0;
484 virtual String8 getDeviceName(int32_t deviceId) const {
485 Device* device = getDevice(deviceId);
486 return device ? device->name : String8("unknown");
489 virtual status_t getAbsoluteAxisInfo(int32_t deviceId, int axis,
490 RawAbsoluteAxisInfo* outAxisInfo) const {
491 Device* device = getDevice(deviceId);
493 ssize_t index = device->axes.indexOfKey(axis);
495 *outAxisInfo = device->axes.valueAt(index);
502 virtual status_t scancodeToKeycode(int32_t deviceId, int scancode,
503 int32_t* outKeycode, uint32_t* outFlags) const {
504 Device* device = getDevice(deviceId);
506 ssize_t index = device->keys.indexOfKey(scancode);
509 *outKeycode = device->keys.valueAt(index).keyCode;
512 *outFlags = device->keys.valueAt(index).flags;
517 return NAME_NOT_FOUND;
520 virtual void addExcludedDevice(const char* deviceName) {
521 mExcludedDevices.add(String8(deviceName));
524 virtual bool getEvent(RawEvent* outEvent) {
525 if (mEvents.empty()) {
529 *outEvent = *mEvents.begin();
530 mEvents.erase(mEvents.begin());
534 virtual int32_t getScanCodeState(int32_t deviceId, int32_t scanCode) const {
535 Device* device = getDevice(deviceId);
537 ssize_t index = device->scanCodeStates.indexOfKey(scanCode);
539 return device->scanCodeStates.valueAt(index);
542 return AKEY_STATE_UNKNOWN;
545 virtual int32_t getKeyCodeState(int32_t deviceId, int32_t keyCode) const {
546 Device* device = getDevice(deviceId);
548 ssize_t index = device->keyCodeStates.indexOfKey(keyCode);
550 return device->keyCodeStates.valueAt(index);
553 return AKEY_STATE_UNKNOWN;
556 virtual int32_t getSwitchState(int32_t deviceId, int32_t sw) const {
557 Device* device = getDevice(deviceId);
559 ssize_t index = device->switchStates.indexOfKey(sw);
561 return device->switchStates.valueAt(index);
564 return AKEY_STATE_UNKNOWN;
567 virtual bool markSupportedKeyCodes(int32_t deviceId, size_t numCodes, const int32_t* keyCodes,
568 uint8_t* outFlags) const {
570 Device* device = getDevice(deviceId);
572 for (size_t i = 0; i < numCodes; i++) {
573 for (size_t j = 0; j < device->keys.size(); j++) {
574 if (keyCodes[i] == device->keys.valueAt(j).keyCode) {
584 virtual void dump(String8& dump) {
589 // --- FakeInputReaderContext ---
591 class FakeInputReaderContext : public InputReaderContext {
592 sp<EventHubInterface> mEventHub;
593 sp<InputReaderPolicyInterface> mPolicy;
594 sp<InputDispatcherInterface> mDispatcher;
595 int32_t mGlobalMetaState;
596 bool mUpdateGlobalMetaStateWasCalled;
599 FakeInputReaderContext(const sp<EventHubInterface>& eventHub,
600 const sp<InputReaderPolicyInterface>& policy,
601 const sp<InputDispatcherInterface>& dispatcher) :
602 mEventHub(eventHub), mPolicy(policy), mDispatcher(dispatcher),
603 mGlobalMetaState(0) {
606 virtual ~FakeInputReaderContext() { }
608 void assertUpdateGlobalMetaStateWasCalled() {
609 ASSERT_TRUE(mUpdateGlobalMetaStateWasCalled)
610 << "Expected updateGlobalMetaState() to have been called.";
611 mUpdateGlobalMetaStateWasCalled = false;
614 void setGlobalMetaState(int32_t state) {
615 mGlobalMetaState = state;
619 virtual void updateGlobalMetaState() {
620 mUpdateGlobalMetaStateWasCalled = true;
623 virtual int32_t getGlobalMetaState() {
624 return mGlobalMetaState;
627 virtual EventHubInterface* getEventHub() {
628 return mEventHub.get();
631 virtual InputReaderPolicyInterface* getPolicy() {
632 return mPolicy.get();
635 virtual InputDispatcherInterface* getDispatcher() {
636 return mDispatcher.get();
639 virtual void disableVirtualKeysUntil(nsecs_t time) {
642 virtual bool shouldDropVirtualKey(nsecs_t now,
643 InputDevice* device, int32_t keyCode, int32_t scanCode) {
649 // --- FakeInputMapper ---
651 class FakeInputMapper : public InputMapper {
653 int32_t mKeyboardType;
655 KeyedVector<int32_t, int32_t> mKeyCodeStates;
656 KeyedVector<int32_t, int32_t> mScanCodeStates;
657 KeyedVector<int32_t, int32_t> mSwitchStates;
658 Vector<int32_t> mSupportedKeyCodes;
661 bool mConfigureWasCalled;
662 bool mResetWasCalled;
663 bool mProcessWasCalled;
666 FakeInputMapper(InputDevice* device, uint32_t sources) :
668 mSources(sources), mKeyboardType(AINPUT_KEYBOARD_TYPE_NONE),
670 mConfigureWasCalled(false), mResetWasCalled(false), mProcessWasCalled(false) {
673 virtual ~FakeInputMapper() { }
675 void setKeyboardType(int32_t keyboardType) {
676 mKeyboardType = keyboardType;
679 void setMetaState(int32_t metaState) {
680 mMetaState = metaState;
683 void assertConfigureWasCalled() {
684 ASSERT_TRUE(mConfigureWasCalled)
685 << "Expected configure() to have been called.";
686 mConfigureWasCalled = false;
689 void assertResetWasCalled() {
690 ASSERT_TRUE(mResetWasCalled)
691 << "Expected reset() to have been called.";
692 mResetWasCalled = false;
695 void assertProcessWasCalled(RawEvent* outLastEvent = NULL) {
696 ASSERT_TRUE(mProcessWasCalled)
697 << "Expected process() to have been called.";
699 *outLastEvent = mLastEvent;
701 mProcessWasCalled = false;
704 void setKeyCodeState(int32_t keyCode, int32_t state) {
705 mKeyCodeStates.replaceValueFor(keyCode, state);
708 void setScanCodeState(int32_t scanCode, int32_t state) {
709 mScanCodeStates.replaceValueFor(scanCode, state);
712 void setSwitchState(int32_t switchCode, int32_t state) {
713 mSwitchStates.replaceValueFor(switchCode, state);
716 void addSupportedKeyCode(int32_t keyCode) {
717 mSupportedKeyCodes.add(keyCode);
721 virtual uint32_t getSources() {
725 virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo) {
726 InputMapper::populateDeviceInfo(deviceInfo);
728 if (mKeyboardType != AINPUT_KEYBOARD_TYPE_NONE) {
729 deviceInfo->setKeyboardType(mKeyboardType);
733 virtual void configure() {
734 mConfigureWasCalled = true;
737 virtual void reset() {
738 mResetWasCalled = true;
741 virtual void process(const RawEvent* rawEvent) {
742 mLastEvent = *rawEvent;
743 mProcessWasCalled = true;
746 virtual int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode) {
747 ssize_t index = mKeyCodeStates.indexOfKey(keyCode);
748 return index >= 0 ? mKeyCodeStates.valueAt(index) : AKEY_STATE_UNKNOWN;
751 virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode) {
752 ssize_t index = mScanCodeStates.indexOfKey(scanCode);
753 return index >= 0 ? mScanCodeStates.valueAt(index) : AKEY_STATE_UNKNOWN;
756 virtual int32_t getSwitchState(uint32_t sourceMask, int32_t switchCode) {
757 ssize_t index = mSwitchStates.indexOfKey(switchCode);
758 return index >= 0 ? mSwitchStates.valueAt(index) : AKEY_STATE_UNKNOWN;
761 virtual bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes,
762 const int32_t* keyCodes, uint8_t* outFlags) {
764 for (size_t i = 0; i < numCodes; i++) {
765 for (size_t j = 0; j < mSupportedKeyCodes.size(); j++) {
766 if (keyCodes[i] == mSupportedKeyCodes[j]) {
775 virtual int32_t getMetaState() {
781 // --- InstrumentedInputReader ---
783 class InstrumentedInputReader : public InputReader {
784 InputDevice* mNextDevice;
787 InstrumentedInputReader(const sp<EventHubInterface>& eventHub,
788 const sp<InputReaderPolicyInterface>& policy,
789 const sp<InputDispatcherInterface>& dispatcher) :
790 InputReader(eventHub, policy, dispatcher) {
793 virtual ~InstrumentedInputReader() {
799 void setNextDevice(InputDevice* device) {
800 mNextDevice = device;
804 virtual InputDevice* createDevice(int32_t deviceId, const String8& name, uint32_t classes) {
806 InputDevice* device = mNextDevice;
810 return InputReader::createDevice(deviceId, name, classes);
813 friend class InputReaderTest;
817 // --- InputReaderTest ---
819 class InputReaderTest : public testing::Test {
821 sp<FakeInputDispatcher> mFakeDispatcher;
822 sp<FakeInputReaderPolicy> mFakePolicy;
823 sp<FakeEventHub> mFakeEventHub;
824 sp<InstrumentedInputReader> mReader;
826 virtual void SetUp() {
827 mFakeEventHub = new FakeEventHub();
828 mFakePolicy = new FakeInputReaderPolicy();
829 mFakeDispatcher = new FakeInputDispatcher();
831 mReader = new InstrumentedInputReader(mFakeEventHub, mFakePolicy, mFakeDispatcher);
834 virtual void TearDown() {
837 mFakeDispatcher.clear();
839 mFakeEventHub.clear();
842 void addDevice(int32_t deviceId, const String8& name, uint32_t classes) {
843 mFakeEventHub->addDevice(deviceId, name, classes);
844 mFakeEventHub->finishDeviceScan();
847 mFakeEventHub->assertQueueIsEmpty();
850 FakeInputMapper* addDeviceWithFakeInputMapper(int32_t deviceId,
851 const String8& name, uint32_t classes, uint32_t sources) {
852 InputDevice* device = new InputDevice(mReader.get(), deviceId, name);
853 FakeInputMapper* mapper = new FakeInputMapper(device, sources);
854 device->addMapper(mapper);
855 mReader->setNextDevice(device);
856 addDevice(deviceId, name, classes);
861 TEST_F(InputReaderTest, GetInputConfiguration_WhenNoDevices_ReturnsDefaults) {
862 InputConfiguration config;
863 mReader->getInputConfiguration(&config);
865 ASSERT_EQ(InputConfiguration::KEYBOARD_NOKEYS, config.keyboard);
866 ASSERT_EQ(InputConfiguration::NAVIGATION_NONAV, config.navigation);
867 ASSERT_EQ(InputConfiguration::TOUCHSCREEN_NOTOUCH, config.touchScreen);
870 TEST_F(InputReaderTest, GetInputConfiguration_WhenAlphabeticKeyboardPresent_ReturnsQwertyKeyboard) {
871 ASSERT_NO_FATAL_FAILURE(addDevice(0, String8("keyboard"),
872 INPUT_DEVICE_CLASS_KEYBOARD | INPUT_DEVICE_CLASS_ALPHAKEY));
874 InputConfiguration config;
875 mReader->getInputConfiguration(&config);
877 ASSERT_EQ(InputConfiguration::KEYBOARD_QWERTY, config.keyboard);
878 ASSERT_EQ(InputConfiguration::NAVIGATION_NONAV, config.navigation);
879 ASSERT_EQ(InputConfiguration::TOUCHSCREEN_NOTOUCH, config.touchScreen);
882 TEST_F(InputReaderTest, GetInputConfiguration_WhenTouchScreenPresent_ReturnsFingerTouchScreen) {
883 ASSERT_NO_FATAL_FAILURE(addDevice(0, String8("touchscreen"),
884 INPUT_DEVICE_CLASS_TOUCHSCREEN));
886 InputConfiguration config;
887 mReader->getInputConfiguration(&config);
889 ASSERT_EQ(InputConfiguration::KEYBOARD_NOKEYS, config.keyboard);
890 ASSERT_EQ(InputConfiguration::NAVIGATION_NONAV, config.navigation);
891 ASSERT_EQ(InputConfiguration::TOUCHSCREEN_FINGER, config.touchScreen);
894 TEST_F(InputReaderTest, GetInputConfiguration_WhenTrackballPresent_ReturnsTrackballNavigation) {
895 ASSERT_NO_FATAL_FAILURE(addDevice(0, String8("trackball"),
896 INPUT_DEVICE_CLASS_TRACKBALL));
898 InputConfiguration config;
899 mReader->getInputConfiguration(&config);
901 ASSERT_EQ(InputConfiguration::KEYBOARD_NOKEYS, config.keyboard);
902 ASSERT_EQ(InputConfiguration::NAVIGATION_TRACKBALL, config.navigation);
903 ASSERT_EQ(InputConfiguration::TOUCHSCREEN_NOTOUCH, config.touchScreen);
906 TEST_F(InputReaderTest, GetInputConfiguration_WhenDPadPresent_ReturnsDPadNavigation) {
907 ASSERT_NO_FATAL_FAILURE(addDevice(0, String8("dpad"),
908 INPUT_DEVICE_CLASS_DPAD));
910 InputConfiguration config;
911 mReader->getInputConfiguration(&config);
913 ASSERT_EQ(InputConfiguration::KEYBOARD_NOKEYS, config.keyboard);
914 ASSERT_EQ(InputConfiguration::NAVIGATION_DPAD, config.navigation);
915 ASSERT_EQ(InputConfiguration::TOUCHSCREEN_NOTOUCH, config.touchScreen);
918 TEST_F(InputReaderTest, GetInputDeviceInfo_WhenDeviceIdIsValid) {
919 ASSERT_NO_FATAL_FAILURE(addDevice(1, String8("keyboard"),
920 INPUT_DEVICE_CLASS_KEYBOARD));
922 InputDeviceInfo info;
923 status_t result = mReader->getInputDeviceInfo(1, &info);
925 ASSERT_EQ(OK, result);
926 ASSERT_EQ(1, info.getId());
927 ASSERT_STREQ("keyboard", info.getName().string());
928 ASSERT_EQ(AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC, info.getKeyboardType());
929 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, info.getSources());
930 ASSERT_EQ(size_t(0), info.getMotionRanges().size());
933 TEST_F(InputReaderTest, GetInputDeviceInfo_WhenDeviceIdIsInvalid) {
934 InputDeviceInfo info;
935 status_t result = mReader->getInputDeviceInfo(-1, &info);
937 ASSERT_EQ(NAME_NOT_FOUND, result);
940 TEST_F(InputReaderTest, GetInputDeviceInfo_WhenDeviceIdIsIgnored) {
941 addDevice(1, String8("ignored"), 0); // no classes so device will be ignored
943 InputDeviceInfo info;
944 status_t result = mReader->getInputDeviceInfo(1, &info);
946 ASSERT_EQ(NAME_NOT_FOUND, result);
949 TEST_F(InputReaderTest, GetInputDeviceIds) {
950 ASSERT_NO_FATAL_FAILURE(addDevice(1, String8("keyboard"),
951 INPUT_DEVICE_CLASS_KEYBOARD | INPUT_DEVICE_CLASS_ALPHAKEY));
952 ASSERT_NO_FATAL_FAILURE(addDevice(2, String8("trackball"),
953 INPUT_DEVICE_CLASS_TRACKBALL));
956 mReader->getInputDeviceIds(ids);
958 ASSERT_EQ(size_t(2), ids.size());
959 ASSERT_EQ(1, ids[0]);
960 ASSERT_EQ(2, ids[1]);
963 TEST_F(InputReaderTest, GetKeyCodeState_ForwardsRequestsToMappers) {
964 FakeInputMapper* mapper = NULL;
965 ASSERT_NO_FATAL_FAILURE(mapper = addDeviceWithFakeInputMapper(1, String8("fake"),
966 INPUT_DEVICE_CLASS_KEYBOARD, AINPUT_SOURCE_KEYBOARD));
967 mapper->setKeyCodeState(AKEYCODE_A, AKEY_STATE_DOWN);
969 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getKeyCodeState(0,
970 AINPUT_SOURCE_ANY, AKEYCODE_A))
971 << "Should return unknown when the device id is >= 0 but unknown.";
973 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getKeyCodeState(1,
974 AINPUT_SOURCE_TRACKBALL, AKEYCODE_A))
975 << "Should return unknown when the device id is valid but the sources are not supported by the device.";
977 ASSERT_EQ(AKEY_STATE_DOWN, mReader->getKeyCodeState(1,
978 AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, AKEYCODE_A))
979 << "Should return value provided by mapper when device id is valid and the device supports some of the sources.";
981 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getKeyCodeState(-1,
982 AINPUT_SOURCE_TRACKBALL, AKEYCODE_A))
983 << "Should return unknown when the device id is < 0 but the sources are not supported by any device.";
985 ASSERT_EQ(AKEY_STATE_DOWN, mReader->getKeyCodeState(-1,
986 AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, AKEYCODE_A))
987 << "Should return value provided by mapper when device id is < 0 and one of the devices supports some of the sources.";
990 TEST_F(InputReaderTest, GetScanCodeState_ForwardsRequestsToMappers) {
991 FakeInputMapper* mapper = NULL;
992 ASSERT_NO_FATAL_FAILURE(mapper = addDeviceWithFakeInputMapper(1, String8("fake"),
993 INPUT_DEVICE_CLASS_KEYBOARD, AINPUT_SOURCE_KEYBOARD));
994 mapper->setScanCodeState(KEY_A, AKEY_STATE_DOWN);
996 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getScanCodeState(0,
997 AINPUT_SOURCE_ANY, KEY_A))
998 << "Should return unknown when the device id is >= 0 but unknown.";
1000 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getScanCodeState(1,
1001 AINPUT_SOURCE_TRACKBALL, KEY_A))
1002 << "Should return unknown when the device id is valid but the sources are not supported by the device.";
1004 ASSERT_EQ(AKEY_STATE_DOWN, mReader->getScanCodeState(1,
1005 AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, KEY_A))
1006 << "Should return value provided by mapper when device id is valid and the device supports some of the sources.";
1008 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getScanCodeState(-1,
1009 AINPUT_SOURCE_TRACKBALL, KEY_A))
1010 << "Should return unknown when the device id is < 0 but the sources are not supported by any device.";
1012 ASSERT_EQ(AKEY_STATE_DOWN, mReader->getScanCodeState(-1,
1013 AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, KEY_A))
1014 << "Should return value provided by mapper when device id is < 0 and one of the devices supports some of the sources.";
1017 TEST_F(InputReaderTest, GetSwitchState_ForwardsRequestsToMappers) {
1018 FakeInputMapper* mapper = NULL;
1019 ASSERT_NO_FATAL_FAILURE(mapper = addDeviceWithFakeInputMapper(1, String8("fake"),
1020 INPUT_DEVICE_CLASS_KEYBOARD, AINPUT_SOURCE_KEYBOARD));
1021 mapper->setSwitchState(SW_LID, AKEY_STATE_DOWN);
1023 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getSwitchState(0,
1024 AINPUT_SOURCE_ANY, SW_LID))
1025 << "Should return unknown when the device id is >= 0 but unknown.";
1027 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getSwitchState(1,
1028 AINPUT_SOURCE_TRACKBALL, SW_LID))
1029 << "Should return unknown when the device id is valid but the sources are not supported by the device.";
1031 ASSERT_EQ(AKEY_STATE_DOWN, mReader->getSwitchState(1,
1032 AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, SW_LID))
1033 << "Should return value provided by mapper when device id is valid and the device supports some of the sources.";
1035 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getSwitchState(-1,
1036 AINPUT_SOURCE_TRACKBALL, SW_LID))
1037 << "Should return unknown when the device id is < 0 but the sources are not supported by any device.";
1039 ASSERT_EQ(AKEY_STATE_DOWN, mReader->getSwitchState(-1,
1040 AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, SW_LID))
1041 << "Should return value provided by mapper when device id is < 0 and one of the devices supports some of the sources.";
1044 TEST_F(InputReaderTest, MarkSupportedKeyCodes_ForwardsRequestsToMappers) {
1045 FakeInputMapper* mapper = NULL;
1046 ASSERT_NO_FATAL_FAILURE(mapper = addDeviceWithFakeInputMapper(1, String8("fake"),
1047 INPUT_DEVICE_CLASS_KEYBOARD, AINPUT_SOURCE_KEYBOARD));
1048 mapper->addSupportedKeyCode(AKEYCODE_A);
1049 mapper->addSupportedKeyCode(AKEYCODE_B);
1051 const int32_t keyCodes[4] = { AKEYCODE_A, AKEYCODE_B, AKEYCODE_1, AKEYCODE_2 };
1052 uint8_t flags[4] = { 0, 0, 0, 1 };
1054 ASSERT_FALSE(mReader->hasKeys(0, AINPUT_SOURCE_ANY, 4, keyCodes, flags))
1055 << "Should return false when device id is >= 0 but unknown.";
1056 ASSERT_TRUE(!flags[0] && !flags[1] && !flags[2] && !flags[3]);
1059 ASSERT_FALSE(mReader->hasKeys(1, AINPUT_SOURCE_TRACKBALL, 4, keyCodes, flags))
1060 << "Should return false when device id is valid but the sources are not supported by the device.";
1061 ASSERT_TRUE(!flags[0] && !flags[1] && !flags[2] && !flags[3]);
1064 ASSERT_TRUE(mReader->hasKeys(1, AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, 4, keyCodes, flags))
1065 << "Should return value provided by mapper when device id is valid and the device supports some of the sources.";
1066 ASSERT_TRUE(flags[0] && flags[1] && !flags[2] && !flags[3]);
1069 ASSERT_FALSE(mReader->hasKeys(-1, AINPUT_SOURCE_TRACKBALL, 4, keyCodes, flags))
1070 << "Should return false when the device id is < 0 but the sources are not supported by any device.";
1071 ASSERT_TRUE(!flags[0] && !flags[1] && !flags[2] && !flags[3]);
1074 ASSERT_TRUE(mReader->hasKeys(-1, AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, 4, keyCodes, flags))
1075 << "Should return value provided by mapper when device id is < 0 and one of the devices supports some of the sources.";
1076 ASSERT_TRUE(flags[0] && flags[1] && !flags[2] && !flags[3]);
1079 TEST_F(InputReaderTest, LoopOnce_WhenDeviceScanFinished_SendsConfigurationChanged) {
1080 addDevice(1, String8("ignored"), INPUT_DEVICE_CLASS_KEYBOARD);
1082 FakeInputDispatcher::NotifyConfigurationChangedArgs args;
1083 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyConfigurationChangedWasCalled(&args));
1084 ASSERT_EQ(ARBITRARY_TIME, args.eventTime);
1087 TEST_F(InputReaderTest, LoopOnce_ForwardsRawEventsToMappers) {
1088 FakeInputMapper* mapper = NULL;
1089 ASSERT_NO_FATAL_FAILURE(mapper = addDeviceWithFakeInputMapper(1, String8("fake"),
1090 INPUT_DEVICE_CLASS_KEYBOARD, AINPUT_SOURCE_KEYBOARD));
1092 mFakeEventHub->enqueueEvent(0, 1, EV_KEY, KEY_A, AKEYCODE_A, 1, POLICY_FLAG_WAKE);
1093 mReader->loopOnce();
1094 ASSERT_NO_FATAL_FAILURE(mFakeEventHub->assertQueueIsEmpty());
1097 ASSERT_NO_FATAL_FAILURE(mapper->assertProcessWasCalled(&event));
1098 ASSERT_EQ(0, event.when);
1099 ASSERT_EQ(1, event.deviceId);
1100 ASSERT_EQ(EV_KEY, event.type);
1101 ASSERT_EQ(KEY_A, event.scanCode);
1102 ASSERT_EQ(AKEYCODE_A, event.keyCode);
1103 ASSERT_EQ(1, event.value);
1104 ASSERT_EQ(POLICY_FLAG_WAKE, event.flags);
1108 // --- InputDeviceTest ---
1110 class InputDeviceTest : public testing::Test {
1112 static const char* DEVICE_NAME;
1113 static const int32_t DEVICE_ID;
1115 sp<FakeEventHub> mFakeEventHub;
1116 sp<FakeInputReaderPolicy> mFakePolicy;
1117 sp<FakeInputDispatcher> mFakeDispatcher;
1118 FakeInputReaderContext* mFakeContext;
1120 InputDevice* mDevice;
1122 virtual void SetUp() {
1123 mFakeEventHub = new FakeEventHub();
1124 mFakePolicy = new FakeInputReaderPolicy();
1125 mFakeDispatcher = new FakeInputDispatcher();
1126 mFakeContext = new FakeInputReaderContext(mFakeEventHub, mFakePolicy, mFakeDispatcher);
1128 mDevice = new InputDevice(mFakeContext, DEVICE_ID, String8(DEVICE_NAME));
1131 virtual void TearDown() {
1134 delete mFakeContext;
1135 mFakeDispatcher.clear();
1136 mFakePolicy.clear();
1137 mFakeEventHub.clear();
1141 const char* InputDeviceTest::DEVICE_NAME = "device";
1142 const int32_t InputDeviceTest::DEVICE_ID = 1;
1144 TEST_F(InputDeviceTest, ImmutableProperties) {
1145 ASSERT_EQ(DEVICE_ID, mDevice->getId());
1146 ASSERT_STREQ(DEVICE_NAME, mDevice->getName());
1149 TEST_F(InputDeviceTest, WhenNoMappersAreRegistered_DeviceIsIgnored) {
1151 mDevice->configure();
1154 ASSERT_TRUE(mDevice->isIgnored());
1155 ASSERT_EQ(AINPUT_SOURCE_UNKNOWN, mDevice->getSources());
1157 InputDeviceInfo info;
1158 mDevice->getDeviceInfo(&info);
1159 ASSERT_EQ(DEVICE_ID, info.getId());
1160 ASSERT_STREQ(DEVICE_NAME, info.getName().string());
1161 ASSERT_EQ(AINPUT_KEYBOARD_TYPE_NONE, info.getKeyboardType());
1162 ASSERT_EQ(AINPUT_SOURCE_UNKNOWN, info.getSources());
1165 ASSERT_EQ(0, mDevice->getMetaState());
1167 ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getKeyCodeState(AINPUT_SOURCE_KEYBOARD, 0))
1168 << "Ignored device should return unknown key code state.";
1169 ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getScanCodeState(AINPUT_SOURCE_KEYBOARD, 0))
1170 << "Ignored device should return unknown scan code state.";
1171 ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getSwitchState(AINPUT_SOURCE_KEYBOARD, 0))
1172 << "Ignored device should return unknown switch state.";
1174 const int32_t keyCodes[2] = { AKEYCODE_A, AKEYCODE_B };
1175 uint8_t flags[2] = { 0, 1 };
1176 ASSERT_FALSE(mDevice->markSupportedKeyCodes(AINPUT_SOURCE_KEYBOARD, 2, keyCodes, flags))
1177 << "Ignored device should never mark any key codes.";
1178 ASSERT_EQ(0, flags[0]) << "Flag for unsupported key should be unchanged.";
1179 ASSERT_EQ(1, flags[1]) << "Flag for unsupported key should be unchanged.";
1185 TEST_F(InputDeviceTest, WhenMappersAreRegistered_DeviceIsNotIgnoredAndForwardsRequestsToMappers) {
1187 InputDeviceCalibration calibration;
1188 calibration.addProperty(String8("key"), String8("value"));
1189 mFakePolicy->addInputDeviceCalibration(String8(DEVICE_NAME), calibration);
1191 FakeInputMapper* mapper1 = new FakeInputMapper(mDevice, AINPUT_SOURCE_KEYBOARD);
1192 mapper1->setKeyboardType(AINPUT_KEYBOARD_TYPE_ALPHABETIC);
1193 mapper1->setMetaState(AMETA_ALT_ON);
1194 mapper1->addSupportedKeyCode(AKEYCODE_A);
1195 mapper1->addSupportedKeyCode(AKEYCODE_B);
1196 mapper1->setKeyCodeState(AKEYCODE_A, AKEY_STATE_DOWN);
1197 mapper1->setKeyCodeState(AKEYCODE_B, AKEY_STATE_UP);
1198 mapper1->setScanCodeState(2, AKEY_STATE_DOWN);
1199 mapper1->setScanCodeState(3, AKEY_STATE_UP);
1200 mapper1->setSwitchState(4, AKEY_STATE_DOWN);
1201 mDevice->addMapper(mapper1);
1203 FakeInputMapper* mapper2 = new FakeInputMapper(mDevice, AINPUT_SOURCE_TOUCHSCREEN);
1204 mapper2->setMetaState(AMETA_SHIFT_ON);
1205 mDevice->addMapper(mapper2);
1207 mDevice->configure();
1209 String8 propertyValue;
1210 ASSERT_TRUE(mDevice->getCalibration().tryGetProperty(String8("key"), propertyValue))
1211 << "Device should have read calibration during configuration phase.";
1212 ASSERT_STREQ("value", propertyValue.string());
1214 ASSERT_NO_FATAL_FAILURE(mapper1->assertConfigureWasCalled());
1215 ASSERT_NO_FATAL_FAILURE(mapper2->assertConfigureWasCalled());
1218 ASSERT_FALSE(mDevice->isIgnored());
1219 ASSERT_EQ(uint32_t(AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TOUCHSCREEN), mDevice->getSources());
1221 InputDeviceInfo info;
1222 mDevice->getDeviceInfo(&info);
1223 ASSERT_EQ(DEVICE_ID, info.getId());
1224 ASSERT_STREQ(DEVICE_NAME, info.getName().string());
1225 ASSERT_EQ(AINPUT_KEYBOARD_TYPE_ALPHABETIC, info.getKeyboardType());
1226 ASSERT_EQ(uint32_t(AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TOUCHSCREEN), info.getSources());
1229 ASSERT_EQ(AMETA_ALT_ON | AMETA_SHIFT_ON, mDevice->getMetaState())
1230 << "Should query mappers and combine meta states.";
1232 ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getKeyCodeState(AINPUT_SOURCE_TRACKBALL, AKEYCODE_A))
1233 << "Should return unknown key code state when source not supported.";
1234 ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getScanCodeState(AINPUT_SOURCE_TRACKBALL, AKEYCODE_A))
1235 << "Should return unknown scan code state when source not supported.";
1236 ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getSwitchState(AINPUT_SOURCE_TRACKBALL, AKEYCODE_A))
1237 << "Should return unknown switch state when source not supported.";
1239 ASSERT_EQ(AKEY_STATE_DOWN, mDevice->getKeyCodeState(AINPUT_SOURCE_KEYBOARD, AKEYCODE_A))
1240 << "Should query mapper when source is supported.";
1241 ASSERT_EQ(AKEY_STATE_UP, mDevice->getScanCodeState(AINPUT_SOURCE_KEYBOARD, 3))
1242 << "Should query mapper when source is supported.";
1243 ASSERT_EQ(AKEY_STATE_DOWN, mDevice->getSwitchState(AINPUT_SOURCE_KEYBOARD, 4))
1244 << "Should query mapper when source is supported.";
1246 const int32_t keyCodes[4] = { AKEYCODE_A, AKEYCODE_B, AKEYCODE_1, AKEYCODE_2 };
1247 uint8_t flags[4] = { 0, 0, 0, 1 };
1248 ASSERT_FALSE(mDevice->markSupportedKeyCodes(AINPUT_SOURCE_TRACKBALL, 4, keyCodes, flags))
1249 << "Should do nothing when source is unsupported.";
1250 ASSERT_EQ(0, flags[0]) << "Flag should be unchanged when source is unsupported.";
1251 ASSERT_EQ(0, flags[1]) << "Flag should be unchanged when source is unsupported.";
1252 ASSERT_EQ(0, flags[2]) << "Flag should be unchanged when source is unsupported.";
1253 ASSERT_EQ(1, flags[3]) << "Flag should be unchanged when source is unsupported.";
1255 ASSERT_TRUE(mDevice->markSupportedKeyCodes(AINPUT_SOURCE_KEYBOARD, 4, keyCodes, flags))
1256 << "Should query mapper when source is supported.";
1257 ASSERT_EQ(1, flags[0]) << "Flag for supported key should be set.";
1258 ASSERT_EQ(1, flags[1]) << "Flag for supported key should be set.";
1259 ASSERT_EQ(0, flags[2]) << "Flag for unsupported key should be unchanged.";
1260 ASSERT_EQ(1, flags[3]) << "Flag for unsupported key should be unchanged.";
1264 mDevice->process(&event);
1266 ASSERT_NO_FATAL_FAILURE(mapper1->assertProcessWasCalled());
1267 ASSERT_NO_FATAL_FAILURE(mapper2->assertProcessWasCalled());
1272 ASSERT_NO_FATAL_FAILURE(mapper1->assertResetWasCalled());
1273 ASSERT_NO_FATAL_FAILURE(mapper2->assertResetWasCalled());
1277 // --- InputMapperTest ---
1279 class InputMapperTest : public testing::Test {
1281 static const char* DEVICE_NAME;
1282 static const int32_t DEVICE_ID;
1284 sp<FakeEventHub> mFakeEventHub;
1285 sp<FakeInputReaderPolicy> mFakePolicy;
1286 sp<FakeInputDispatcher> mFakeDispatcher;
1287 FakeInputReaderContext* mFakeContext;
1288 InputDevice* mDevice;
1290 virtual void SetUp() {
1291 mFakeEventHub = new FakeEventHub();
1292 mFakePolicy = new FakeInputReaderPolicy();
1293 mFakeDispatcher = new FakeInputDispatcher();
1294 mFakeContext = new FakeInputReaderContext(mFakeEventHub, mFakePolicy, mFakeDispatcher);
1295 mDevice = new InputDevice(mFakeContext, DEVICE_ID, String8(DEVICE_NAME));
1297 mFakeEventHub->addDevice(DEVICE_ID, String8(DEVICE_NAME), 0);
1300 virtual void TearDown() {
1302 delete mFakeContext;
1303 mFakeDispatcher.clear();
1304 mFakePolicy.clear();
1305 mFakeEventHub.clear();
1308 void prepareCalibration(const char* key, const char* value) {
1309 mFakePolicy->addInputDeviceCalibrationProperty(String8(DEVICE_NAME),
1310 String8(key), String8(value));
1313 void addMapperAndConfigure(InputMapper* mapper) {
1314 mDevice->addMapper(mapper);
1315 mDevice->configure();
1318 static void process(InputMapper* mapper, nsecs_t when, int32_t deviceId, int32_t type,
1319 int32_t scanCode, int32_t keyCode, int32_t value, uint32_t flags) {
1322 event.deviceId = deviceId;
1324 event.scanCode = scanCode;
1325 event.keyCode = keyCode;
1326 event.value = value;
1327 event.flags = flags;
1328 mapper->process(&event);
1331 static void assertMotionRange(const InputDeviceInfo& info,
1332 int32_t rangeType, float min, float max, float flat, float fuzz) {
1333 const InputDeviceInfo::MotionRange* range = info.getMotionRange(rangeType);
1334 ASSERT_TRUE(range != NULL) << "Range: " << rangeType;
1335 ASSERT_NEAR(min, range->min, EPSILON) << "Range: " << rangeType;
1336 ASSERT_NEAR(max, range->max, EPSILON) << "Range: " << rangeType;
1337 ASSERT_NEAR(flat, range->flat, EPSILON) << "Range: " << rangeType;
1338 ASSERT_NEAR(fuzz, range->fuzz, EPSILON) << "Range: " << rangeType;
1341 static void assertPointerCoords(const PointerCoords& coords,
1342 float x, float y, float pressure, float size,
1343 float touchMajor, float touchMinor, float toolMajor, float toolMinor,
1344 float orientation) {
1345 ASSERT_NEAR(x, coords.x, 1);
1346 ASSERT_NEAR(y, coords.y, 1);
1347 ASSERT_NEAR(pressure, coords.pressure, EPSILON);
1348 ASSERT_NEAR(size, coords.size, EPSILON);
1349 ASSERT_NEAR(touchMajor, coords.touchMajor, 1);
1350 ASSERT_NEAR(touchMinor, coords.touchMinor, 1);
1351 ASSERT_NEAR(toolMajor, coords.toolMajor, 1);
1352 ASSERT_NEAR(toolMinor, coords.toolMinor, 1);
1353 ASSERT_NEAR(orientation, coords.orientation, EPSILON);
1357 const char* InputMapperTest::DEVICE_NAME = "device";
1358 const int32_t InputMapperTest::DEVICE_ID = 1;
1361 // --- SwitchInputMapperTest ---
1363 class SwitchInputMapperTest : public InputMapperTest {
1367 TEST_F(SwitchInputMapperTest, GetSources) {
1368 SwitchInputMapper* mapper = new SwitchInputMapper(mDevice);
1369 addMapperAndConfigure(mapper);
1371 ASSERT_EQ(uint32_t(0), mapper->getSources());
1374 TEST_F(SwitchInputMapperTest, GetSwitchState) {
1375 SwitchInputMapper* mapper = new SwitchInputMapper(mDevice);
1376 addMapperAndConfigure(mapper);
1378 mFakeEventHub->setSwitchState(DEVICE_ID, SW_LID, 1);
1379 ASSERT_EQ(1, mapper->getSwitchState(AINPUT_SOURCE_ANY, SW_LID));
1381 mFakeEventHub->setSwitchState(DEVICE_ID, SW_LID, 0);
1382 ASSERT_EQ(0, mapper->getSwitchState(AINPUT_SOURCE_ANY, SW_LID));
1385 TEST_F(SwitchInputMapperTest, Process) {
1386 SwitchInputMapper* mapper = new SwitchInputMapper(mDevice);
1387 addMapperAndConfigure(mapper);
1389 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SW, SW_LID, 0, 1, 0);
1391 FakeInputDispatcher::NotifySwitchArgs args;
1392 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifySwitchWasCalled(&args));
1393 ASSERT_EQ(ARBITRARY_TIME, args.when);
1394 ASSERT_EQ(SW_LID, args.switchCode);
1395 ASSERT_EQ(1, args.switchValue);
1396 ASSERT_EQ(uint32_t(0), args.policyFlags);
1400 // --- KeyboardInputMapperTest ---
1402 class KeyboardInputMapperTest : public InputMapperTest {
1404 void testDPadKeyRotation(KeyboardInputMapper* mapper,
1405 int32_t originalScanCode, int32_t originalKeyCode, int32_t rotatedKeyCode);
1408 void KeyboardInputMapperTest::testDPadKeyRotation(KeyboardInputMapper* mapper,
1409 int32_t originalScanCode, int32_t originalKeyCode, int32_t rotatedKeyCode) {
1410 FakeInputDispatcher::NotifyKeyArgs args;
1412 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, originalScanCode, originalKeyCode, 1, 0);
1413 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
1414 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, args.action);
1415 ASSERT_EQ(originalScanCode, args.scanCode);
1416 ASSERT_EQ(rotatedKeyCode, args.keyCode);
1418 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, originalScanCode, originalKeyCode, 0, 0);
1419 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
1420 ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action);
1421 ASSERT_EQ(originalScanCode, args.scanCode);
1422 ASSERT_EQ(rotatedKeyCode, args.keyCode);
1426 TEST_F(KeyboardInputMapperTest, GetSources) {
1427 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, -1,
1428 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
1429 addMapperAndConfigure(mapper);
1431 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, mapper->getSources());
1434 TEST_F(KeyboardInputMapperTest, Process_SimpleKeyPress) {
1435 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, -1,
1436 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
1437 addMapperAndConfigure(mapper);
1440 process(mapper, ARBITRARY_TIME, DEVICE_ID,
1441 EV_KEY, KEY_HOME, AKEYCODE_HOME, 1, POLICY_FLAG_WAKE);
1442 FakeInputDispatcher::NotifyKeyArgs args;
1443 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
1444 ASSERT_EQ(DEVICE_ID, args.deviceId);
1445 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source);
1446 ASSERT_EQ(ARBITRARY_TIME, args.eventTime);
1447 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, args.action);
1448 ASSERT_EQ(AKEYCODE_HOME, args.keyCode);
1449 ASSERT_EQ(KEY_HOME, args.scanCode);
1450 ASSERT_EQ(AMETA_NONE, args.metaState);
1451 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, args.flags);
1452 ASSERT_EQ(POLICY_FLAG_WAKE, args.policyFlags);
1453 ASSERT_EQ(ARBITRARY_TIME, args.downTime);
1456 process(mapper, ARBITRARY_TIME + 1, DEVICE_ID,
1457 EV_KEY, KEY_HOME, AKEYCODE_HOME, 0, POLICY_FLAG_WAKE);
1458 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
1459 ASSERT_EQ(DEVICE_ID, args.deviceId);
1460 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source);
1461 ASSERT_EQ(ARBITRARY_TIME + 1, args.eventTime);
1462 ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action);
1463 ASSERT_EQ(AKEYCODE_HOME, args.keyCode);
1464 ASSERT_EQ(KEY_HOME, args.scanCode);
1465 ASSERT_EQ(AMETA_NONE, args.metaState);
1466 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, args.flags);
1467 ASSERT_EQ(POLICY_FLAG_WAKE, args.policyFlags);
1468 ASSERT_EQ(ARBITRARY_TIME, args.downTime);
1471 TEST_F(KeyboardInputMapperTest, Reset_WhenKeysAreNotDown_DoesNotSynthesizeKeyUp) {
1472 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, -1,
1473 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
1474 addMapperAndConfigure(mapper);
1477 process(mapper, ARBITRARY_TIME, DEVICE_ID,
1478 EV_KEY, KEY_HOME, AKEYCODE_HOME, 1, POLICY_FLAG_WAKE);
1479 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
1482 process(mapper, ARBITRARY_TIME, DEVICE_ID,
1483 EV_KEY, KEY_HOME, AKEYCODE_HOME, 0, POLICY_FLAG_WAKE);
1484 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
1486 // Reset. Since no keys still down, should not synthesize any key ups.
1488 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled());
1491 TEST_F(KeyboardInputMapperTest, Reset_WhenKeysAreDown_SynthesizesKeyUps) {
1492 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, -1,
1493 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
1494 addMapperAndConfigure(mapper);
1497 process(mapper, ARBITRARY_TIME, DEVICE_ID,
1498 EV_KEY, KEY_LEFTSHIFT, AKEYCODE_SHIFT_LEFT, 1, 0);
1499 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
1502 process(mapper, ARBITRARY_TIME + 1, DEVICE_ID,
1503 EV_KEY, KEY_A, AKEYCODE_A, 1, 0);
1504 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
1506 // Reset. Since two keys are still down, should synthesize two key ups in reverse order.
1509 FakeInputDispatcher::NotifyKeyArgs args;
1510 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
1511 ASSERT_EQ(DEVICE_ID, args.deviceId);
1512 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source);
1513 ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action);
1514 ASSERT_EQ(AKEYCODE_A, args.keyCode);
1515 ASSERT_EQ(KEY_A, args.scanCode);
1516 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
1517 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, args.flags);
1518 ASSERT_EQ(uint32_t(0), args.policyFlags);
1519 ASSERT_EQ(ARBITRARY_TIME + 1, args.downTime);
1521 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
1522 ASSERT_EQ(DEVICE_ID, args.deviceId);
1523 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source);
1524 ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action);
1525 ASSERT_EQ(AKEYCODE_SHIFT_LEFT, args.keyCode);
1526 ASSERT_EQ(KEY_LEFTSHIFT, args.scanCode);
1527 ASSERT_EQ(AMETA_NONE, args.metaState);
1528 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, args.flags);
1529 ASSERT_EQ(uint32_t(0), args.policyFlags);
1530 ASSERT_EQ(ARBITRARY_TIME + 1, args.downTime);
1533 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled());
1536 TEST_F(KeyboardInputMapperTest, Process_ShouldUpdateMetaState) {
1537 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, -1,
1538 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
1539 addMapperAndConfigure(mapper);
1541 // Initial metastate.
1542 ASSERT_EQ(AMETA_NONE, mapper->getMetaState());
1545 process(mapper, ARBITRARY_TIME, DEVICE_ID,
1546 EV_KEY, KEY_LEFTSHIFT, AKEYCODE_SHIFT_LEFT, 1, 0);
1547 FakeInputDispatcher::NotifyKeyArgs args;
1548 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
1549 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
1550 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, mapper->getMetaState());
1551 ASSERT_NO_FATAL_FAILURE(mFakeContext->assertUpdateGlobalMetaStateWasCalled());
1554 process(mapper, ARBITRARY_TIME + 1, DEVICE_ID,
1555 EV_KEY, KEY_A, AKEYCODE_A, 1, 0);
1556 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
1557 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
1558 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, mapper->getMetaState());
1561 process(mapper, ARBITRARY_TIME + 2, DEVICE_ID,
1562 EV_KEY, KEY_A, AKEYCODE_A, 0, 0);
1563 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
1564 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
1565 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, mapper->getMetaState());
1568 process(mapper, ARBITRARY_TIME + 3, DEVICE_ID,
1569 EV_KEY, KEY_LEFTSHIFT, AKEYCODE_SHIFT_LEFT, 0, 0);
1570 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
1571 ASSERT_EQ(AMETA_NONE, args.metaState);
1572 ASSERT_EQ(AMETA_NONE, mapper->getMetaState());
1573 ASSERT_NO_FATAL_FAILURE(mFakeContext->assertUpdateGlobalMetaStateWasCalled());
1576 TEST_F(KeyboardInputMapperTest, Process_WhenNotAttachedToDisplay_ShouldNotRotateDPad) {
1577 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, -1,
1578 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
1579 addMapperAndConfigure(mapper);
1581 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1582 KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_UP));
1583 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1584 KEY_RIGHT, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_RIGHT));
1585 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1586 KEY_DOWN, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_DOWN));
1587 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1588 KEY_LEFT, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_LEFT));
1591 TEST_F(KeyboardInputMapperTest, Process_WhenAttachedToDisplay_ShouldRotateDPad) {
1592 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, DISPLAY_ID,
1593 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
1594 addMapperAndConfigure(mapper);
1596 mFakePolicy->setDisplayInfo(DISPLAY_ID,
1597 DISPLAY_WIDTH, DISPLAY_HEIGHT,
1598 InputReaderPolicyInterface::ROTATION_0);
1599 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1600 KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_UP));
1601 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1602 KEY_RIGHT, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_RIGHT));
1603 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1604 KEY_DOWN, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_DOWN));
1605 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1606 KEY_LEFT, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_LEFT));
1608 mFakePolicy->setDisplayInfo(DISPLAY_ID,
1609 DISPLAY_WIDTH, DISPLAY_HEIGHT,
1610 InputReaderPolicyInterface::ROTATION_90);
1611 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1612 KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_LEFT));
1613 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1614 KEY_RIGHT, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_UP));
1615 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1616 KEY_DOWN, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_RIGHT));
1617 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1618 KEY_LEFT, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_DOWN));
1620 mFakePolicy->setDisplayInfo(DISPLAY_ID,
1621 DISPLAY_WIDTH, DISPLAY_HEIGHT,
1622 InputReaderPolicyInterface::ROTATION_180);
1623 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1624 KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_DOWN));
1625 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1626 KEY_RIGHT, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_LEFT));
1627 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1628 KEY_DOWN, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_UP));
1629 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1630 KEY_LEFT, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_RIGHT));
1632 mFakePolicy->setDisplayInfo(DISPLAY_ID,
1633 DISPLAY_WIDTH, DISPLAY_HEIGHT,
1634 InputReaderPolicyInterface::ROTATION_270);
1635 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1636 KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_RIGHT));
1637 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1638 KEY_RIGHT, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_DOWN));
1639 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1640 KEY_DOWN, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_LEFT));
1641 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1642 KEY_LEFT, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_UP));
1644 // Special case: if orientation changes while key is down, we still emit the same keycode
1645 // in the key up as we did in the key down.
1646 FakeInputDispatcher::NotifyKeyArgs args;
1648 mFakePolicy->setDisplayInfo(DISPLAY_ID,
1649 DISPLAY_WIDTH, DISPLAY_HEIGHT,
1650 InputReaderPolicyInterface::ROTATION_270);
1651 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, KEY_UP, AKEYCODE_DPAD_UP, 1, 0);
1652 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
1653 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, args.action);
1654 ASSERT_EQ(KEY_UP, args.scanCode);
1655 ASSERT_EQ(AKEYCODE_DPAD_RIGHT, args.keyCode);
1657 mFakePolicy->setDisplayInfo(DISPLAY_ID,
1658 DISPLAY_WIDTH, DISPLAY_HEIGHT,
1659 InputReaderPolicyInterface::ROTATION_180);
1660 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, KEY_UP, AKEYCODE_DPAD_UP, 0, 0);
1661 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
1662 ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action);
1663 ASSERT_EQ(KEY_UP, args.scanCode);
1664 ASSERT_EQ(AKEYCODE_DPAD_RIGHT, args.keyCode);
1667 TEST_F(KeyboardInputMapperTest, GetKeyCodeState) {
1668 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, -1,
1669 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
1670 addMapperAndConfigure(mapper);
1672 mFakeEventHub->setKeyCodeState(DEVICE_ID, AKEYCODE_A, 1);
1673 ASSERT_EQ(1, mapper->getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_A));
1675 mFakeEventHub->setKeyCodeState(DEVICE_ID, AKEYCODE_A, 0);
1676 ASSERT_EQ(0, mapper->getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_A));
1679 TEST_F(KeyboardInputMapperTest, GetScanCodeState) {
1680 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, -1,
1681 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
1682 addMapperAndConfigure(mapper);
1684 mFakeEventHub->setScanCodeState(DEVICE_ID, KEY_A, 1);
1685 ASSERT_EQ(1, mapper->getScanCodeState(AINPUT_SOURCE_ANY, KEY_A));
1687 mFakeEventHub->setScanCodeState(DEVICE_ID, KEY_A, 0);
1688 ASSERT_EQ(0, mapper->getScanCodeState(AINPUT_SOURCE_ANY, KEY_A));
1691 TEST_F(KeyboardInputMapperTest, MarkSupportedKeyCodes) {
1692 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, -1,
1693 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
1694 addMapperAndConfigure(mapper);
1696 mFakeEventHub->addKey(DEVICE_ID, KEY_A, AKEYCODE_A, 0);
1698 const int32_t keyCodes[2] = { AKEYCODE_A, AKEYCODE_B };
1699 uint8_t flags[2] = { 0, 0 };
1700 ASSERT_TRUE(mapper->markSupportedKeyCodes(AINPUT_SOURCE_ANY, 1, keyCodes, flags));
1701 ASSERT_TRUE(flags[0]);
1702 ASSERT_FALSE(flags[1]);
1706 // --- TrackballInputMapperTest ---
1708 class TrackballInputMapperTest : public InputMapperTest {
1710 static const int32_t TRACKBALL_MOVEMENT_THRESHOLD;
1712 void testMotionRotation(TrackballInputMapper* mapper,
1713 int32_t originalX, int32_t originalY, int32_t rotatedX, int32_t rotatedY);
1716 const int32_t TrackballInputMapperTest::TRACKBALL_MOVEMENT_THRESHOLD = 6;
1718 void TrackballInputMapperTest::testMotionRotation(TrackballInputMapper* mapper,
1719 int32_t originalX, int32_t originalY, int32_t rotatedX, int32_t rotatedY) {
1720 FakeInputDispatcher::NotifyMotionArgs args;
1722 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_X, 0, originalX, 0);
1723 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_Y, 0, originalY, 0);
1724 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0, 0, 0);
1725 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
1726 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
1727 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
1728 float(rotatedX) / TRACKBALL_MOVEMENT_THRESHOLD,
1729 float(rotatedY) / TRACKBALL_MOVEMENT_THRESHOLD,
1730 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
1733 TEST_F(TrackballInputMapperTest, GetSources) {
1734 TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, -1);
1735 addMapperAndConfigure(mapper);
1737 ASSERT_EQ(AINPUT_SOURCE_TRACKBALL, mapper->getSources());
1740 TEST_F(TrackballInputMapperTest, PopulateDeviceInfo) {
1741 TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, -1);
1742 addMapperAndConfigure(mapper);
1744 InputDeviceInfo info;
1745 mapper->populateDeviceInfo(&info);
1747 ASSERT_NO_FATAL_FAILURE(assertMotionRange(info, AINPUT_MOTION_RANGE_X,
1748 -1.0f, 1.0f, 0.0f, 1.0f / TRACKBALL_MOVEMENT_THRESHOLD));
1749 ASSERT_NO_FATAL_FAILURE(assertMotionRange(info, AINPUT_MOTION_RANGE_Y,
1750 -1.0f, 1.0f, 0.0f, 1.0f / TRACKBALL_MOVEMENT_THRESHOLD));
1753 TEST_F(TrackballInputMapperTest, Process_ShouldSetAllFieldsAndIncludeGlobalMetaState) {
1754 TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, -1);
1755 addMapperAndConfigure(mapper);
1757 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
1759 FakeInputDispatcher::NotifyMotionArgs args;
1762 // Mostly testing non x/y behavior here so we don't need to check again elsewhere.
1763 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 1, 0);
1764 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
1765 ASSERT_EQ(ARBITRARY_TIME, args.eventTime);
1766 ASSERT_EQ(DEVICE_ID, args.deviceId);
1767 ASSERT_EQ(AINPUT_SOURCE_TRACKBALL, args.source);
1768 ASSERT_EQ(uint32_t(0), args.policyFlags);
1769 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action);
1770 ASSERT_EQ(0, args.flags);
1771 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
1772 ASSERT_EQ(0, args.edgeFlags);
1773 ASSERT_EQ(uint32_t(1), args.pointerCount);
1774 ASSERT_EQ(0, args.pointerIds[0]);
1775 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
1776 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
1777 ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.xPrecision);
1778 ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.yPrecision);
1779 ASSERT_EQ(ARBITRARY_TIME, args.downTime);
1781 // Button release. Should have same down time.
1782 process(mapper, ARBITRARY_TIME + 1, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 0, 0);
1783 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
1784 ASSERT_EQ(ARBITRARY_TIME + 1, args.eventTime);
1785 ASSERT_EQ(DEVICE_ID, args.deviceId);
1786 ASSERT_EQ(AINPUT_SOURCE_TRACKBALL, args.source);
1787 ASSERT_EQ(uint32_t(0), args.policyFlags);
1788 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, args.action);
1789 ASSERT_EQ(0, args.flags);
1790 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
1791 ASSERT_EQ(0, args.edgeFlags);
1792 ASSERT_EQ(uint32_t(1), args.pointerCount);
1793 ASSERT_EQ(0, args.pointerIds[0]);
1794 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
1795 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
1796 ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.xPrecision);
1797 ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.yPrecision);
1798 ASSERT_EQ(ARBITRARY_TIME, args.downTime);
1801 TEST_F(TrackballInputMapperTest, Process_ShouldHandleIndependentXYUpdates) {
1802 TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, -1);
1803 addMapperAndConfigure(mapper);
1805 FakeInputDispatcher::NotifyMotionArgs args;
1807 // Motion in X but not Y.
1808 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_X, 0, 1, 0);
1809 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0, 0, 0);
1810 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
1811 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
1812 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
1813 1.0f / TRACKBALL_MOVEMENT_THRESHOLD, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
1815 // Motion in Y but not X.
1816 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_Y, 0, -2, 0);
1817 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0, 0, 0);
1818 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
1819 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
1820 ASSERT_NEAR(0.0f, args.pointerCoords[0].x, EPSILON);
1821 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
1822 0.0f, -2.0f / TRACKBALL_MOVEMENT_THRESHOLD, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
1825 TEST_F(TrackballInputMapperTest, Process_ShouldHandleIndependentButtonUpdates) {
1826 TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, -1);
1827 addMapperAndConfigure(mapper);
1829 FakeInputDispatcher::NotifyMotionArgs args;
1831 // Button press without following sync.
1832 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 1, 0);
1833 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
1834 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action);
1835 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
1836 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
1838 // Button release without following sync.
1839 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 0, 0);
1840 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
1841 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, args.action);
1842 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
1843 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
1846 TEST_F(TrackballInputMapperTest, Process_ShouldHandleCombinedXYAndButtonUpdates) {
1847 TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, -1);
1848 addMapperAndConfigure(mapper);
1850 FakeInputDispatcher::NotifyMotionArgs args;
1852 // Combined X, Y and Button.
1853 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_X, 0, 1, 0);
1854 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_Y, 0, -2, 0);
1855 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 1, 0);
1856 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0, 0, 0);
1857 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
1858 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action);
1859 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
1860 1.0f / TRACKBALL_MOVEMENT_THRESHOLD, -2.0f / TRACKBALL_MOVEMENT_THRESHOLD,
1861 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
1863 // Move X, Y a bit while pressed.
1864 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_X, 0, 2, 0);
1865 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_Y, 0, 1, 0);
1866 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0, 0, 0);
1867 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
1868 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
1869 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
1870 2.0f / TRACKBALL_MOVEMENT_THRESHOLD, 1.0f / TRACKBALL_MOVEMENT_THRESHOLD,
1871 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
1874 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 0, 0);
1875 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
1876 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, args.action);
1877 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
1878 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
1881 TEST_F(TrackballInputMapperTest, Reset_WhenButtonIsNotDown_ShouldNotSynthesizeButtonUp) {
1882 TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, -1);
1883 addMapperAndConfigure(mapper);
1885 FakeInputDispatcher::NotifyMotionArgs args;
1888 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 1, 0);
1889 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
1892 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 0, 0);
1893 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
1895 // Reset. Should not synthesize button up since button is not pressed.
1898 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled());
1901 TEST_F(TrackballInputMapperTest, Reset_WhenButtonIsDown_ShouldSynthesizeButtonUp) {
1902 TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, -1);
1903 addMapperAndConfigure(mapper);
1905 FakeInputDispatcher::NotifyMotionArgs args;
1908 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 1, 0);
1909 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
1911 // Reset. Should synthesize button up.
1914 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
1915 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, args.action);
1916 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
1917 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
1920 TEST_F(TrackballInputMapperTest, Process_WhenNotAttachedToDisplay_ShouldNotRotateMotions) {
1921 TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, -1);
1922 addMapperAndConfigure(mapper);
1924 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, 1, 0, 1));
1925 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 1, 1, 1));
1926 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 0, 1, 0));
1927 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, -1, 1, -1));
1928 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, -1, 0, -1));
1929 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1, -1, -1));
1930 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 0, -1, 0));
1931 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 1, -1, 1));
1934 TEST_F(TrackballInputMapperTest, Process_WhenAttachedToDisplay_ShouldRotateMotions) {
1935 TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, DISPLAY_ID);
1936 addMapperAndConfigure(mapper);
1938 mFakePolicy->setDisplayInfo(DISPLAY_ID,
1939 DISPLAY_WIDTH, DISPLAY_HEIGHT,
1940 InputReaderPolicyInterface::ROTATION_0);
1941 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, 1, 0, 1));
1942 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 1, 1, 1));
1943 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 0, 1, 0));
1944 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, -1, 1, -1));
1945 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, -1, 0, -1));
1946 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1, -1, -1));
1947 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 0, -1, 0));
1948 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 1, -1, 1));
1950 mFakePolicy->setDisplayInfo(DISPLAY_ID,
1951 DISPLAY_WIDTH, DISPLAY_HEIGHT,
1952 InputReaderPolicyInterface::ROTATION_90);
1953 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, 1, 1, 0));
1954 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 1, 1, -1));
1955 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 0, 0, -1));
1956 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, -1, -1, -1));
1957 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, -1, -1, 0));
1958 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1, -1, 1));
1959 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 0, 0, 1));
1960 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 1, 1, 1));
1962 mFakePolicy->setDisplayInfo(DISPLAY_ID,
1963 DISPLAY_WIDTH, DISPLAY_HEIGHT,
1964 InputReaderPolicyInterface::ROTATION_180);
1965 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, 1, 0, -1));
1966 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 1, -1, -1));
1967 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 0, -1, 0));
1968 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, -1, -1, 1));
1969 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, -1, 0, 1));
1970 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1, 1, 1));
1971 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 0, 1, 0));
1972 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 1, 1, -1));
1974 mFakePolicy->setDisplayInfo(DISPLAY_ID,
1975 DISPLAY_WIDTH, DISPLAY_HEIGHT,
1976 InputReaderPolicyInterface::ROTATION_270);
1977 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, 1, -1, 0));
1978 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 1, -1, 1));
1979 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 0, 0, 1));
1980 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, -1, 1, 1));
1981 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, -1, 1, 0));
1982 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1, 1, -1));
1983 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 0, 0, -1));
1984 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 1, -1, -1));
1988 // --- TouchInputMapperTest ---
1990 class TouchInputMapperTest : public InputMapperTest {
1992 static const int32_t RAW_X_MIN;
1993 static const int32_t RAW_X_MAX;
1994 static const int32_t RAW_Y_MIN;
1995 static const int32_t RAW_Y_MAX;
1996 static const int32_t RAW_TOUCH_MIN;
1997 static const int32_t RAW_TOUCH_MAX;
1998 static const int32_t RAW_TOOL_MIN;
1999 static const int32_t RAW_TOOL_MAX;
2000 static const int32_t RAW_PRESSURE_MIN;
2001 static const int32_t RAW_PRESSURE_MAX;
2002 static const int32_t RAW_ORIENTATION_MIN;
2003 static const int32_t RAW_ORIENTATION_MAX;
2004 static const int32_t RAW_ID_MIN;
2005 static const int32_t RAW_ID_MAX;
2006 static const float X_PRECISION;
2007 static const float Y_PRECISION;
2009 static const VirtualKeyDefinition VIRTUAL_KEYS[2];
2016 ORIENTATION = 1 << 4,
2021 void prepareDisplay(int32_t orientation);
2022 void prepareVirtualKeys();
2023 int32_t toRawX(float displayX);
2024 int32_t toRawY(float displayY);
2025 float toDisplayX(int32_t rawX);
2026 float toDisplayY(int32_t rawY);
2029 const int32_t TouchInputMapperTest::RAW_X_MIN = 25;
2030 const int32_t TouchInputMapperTest::RAW_X_MAX = 1020;
2031 const int32_t TouchInputMapperTest::RAW_Y_MIN = 30;
2032 const int32_t TouchInputMapperTest::RAW_Y_MAX = 1010;
2033 const int32_t TouchInputMapperTest::RAW_TOUCH_MIN = 0;
2034 const int32_t TouchInputMapperTest::RAW_TOUCH_MAX = 31;
2035 const int32_t TouchInputMapperTest::RAW_TOOL_MIN = 0;
2036 const int32_t TouchInputMapperTest::RAW_TOOL_MAX = 15;
2037 const int32_t TouchInputMapperTest::RAW_PRESSURE_MIN = RAW_TOUCH_MIN;
2038 const int32_t TouchInputMapperTest::RAW_PRESSURE_MAX = RAW_TOUCH_MAX;
2039 const int32_t TouchInputMapperTest::RAW_ORIENTATION_MIN = -7;
2040 const int32_t TouchInputMapperTest::RAW_ORIENTATION_MAX = 7;
2041 const int32_t TouchInputMapperTest::RAW_ID_MIN = 0;
2042 const int32_t TouchInputMapperTest::RAW_ID_MAX = 9;
2043 const float TouchInputMapperTest::X_PRECISION = float(RAW_X_MAX - RAW_X_MIN) / DISPLAY_WIDTH;
2044 const float TouchInputMapperTest::Y_PRECISION = float(RAW_Y_MAX - RAW_Y_MIN) / DISPLAY_HEIGHT;
2046 const VirtualKeyDefinition TouchInputMapperTest::VIRTUAL_KEYS[2] = {
2047 { KEY_HOME, 60, DISPLAY_HEIGHT + 15, 20, 20 },
2048 { KEY_MENU, DISPLAY_HEIGHT - 60, DISPLAY_WIDTH + 15, 20, 20 },
2051 void TouchInputMapperTest::prepareDisplay(int32_t orientation) {
2052 mFakePolicy->setDisplayInfo(DISPLAY_ID, DISPLAY_WIDTH, DISPLAY_HEIGHT, orientation);
2055 void TouchInputMapperTest::prepareVirtualKeys() {
2056 mFakePolicy->addVirtualKeyDefinition(String8(DEVICE_NAME), VIRTUAL_KEYS[0]);
2057 mFakePolicy->addVirtualKeyDefinition(String8(DEVICE_NAME), VIRTUAL_KEYS[1]);
2058 mFakeEventHub->addKey(DEVICE_ID, KEY_HOME, AKEYCODE_HOME, POLICY_FLAG_WAKE);
2059 mFakeEventHub->addKey(DEVICE_ID, KEY_MENU, AKEYCODE_MENU, POLICY_FLAG_WAKE);
2062 int32_t TouchInputMapperTest::toRawX(float displayX) {
2063 return int32_t(displayX * (RAW_X_MAX - RAW_X_MIN) / DISPLAY_WIDTH + RAW_X_MIN);
2066 int32_t TouchInputMapperTest::toRawY(float displayY) {
2067 return int32_t(displayY * (RAW_Y_MAX - RAW_Y_MIN) / DISPLAY_HEIGHT + RAW_Y_MIN);
2070 float TouchInputMapperTest::toDisplayX(int32_t rawX) {
2071 return float(rawX - RAW_X_MIN) * DISPLAY_WIDTH / (RAW_X_MAX - RAW_X_MIN);
2074 float TouchInputMapperTest::toDisplayY(int32_t rawY) {
2075 return float(rawY - RAW_Y_MIN) * DISPLAY_HEIGHT / (RAW_Y_MAX - RAW_Y_MIN);
2079 // --- SingleTouchInputMapperTest ---
2081 class SingleTouchInputMapperTest : public TouchInputMapperTest {
2083 void prepareAxes(int axes);
2085 void processDown(SingleTouchInputMapper* mapper, int32_t x, int32_t y);
2086 void processMove(SingleTouchInputMapper* mapper, int32_t x, int32_t y);
2087 void processUp(SingleTouchInputMapper* mappery);
2088 void processPressure(SingleTouchInputMapper* mapper, int32_t pressure);
2089 void processToolMajor(SingleTouchInputMapper* mapper, int32_t toolMajor);
2090 void processSync(SingleTouchInputMapper* mapper);
2093 void SingleTouchInputMapperTest::prepareAxes(int axes) {
2094 if (axes & POSITION) {
2095 mFakeEventHub->addAxis(DEVICE_ID, ABS_X, RAW_X_MIN, RAW_X_MAX, 0, 0);
2096 mFakeEventHub->addAxis(DEVICE_ID, ABS_Y, RAW_Y_MIN, RAW_Y_MAX, 0, 0);
2098 if (axes & PRESSURE) {
2099 mFakeEventHub->addAxis(DEVICE_ID, ABS_PRESSURE, RAW_PRESSURE_MIN, RAW_PRESSURE_MAX, 0, 0);
2102 mFakeEventHub->addAxis(DEVICE_ID, ABS_TOOL_WIDTH, RAW_TOOL_MIN, RAW_TOOL_MAX, 0, 0);
2106 void SingleTouchInputMapperTest::processDown(SingleTouchInputMapper* mapper, int32_t x, int32_t y) {
2107 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_TOUCH, 0, 1, 0);
2108 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_X, 0, x, 0);
2109 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_Y, 0, y, 0);
2112 void SingleTouchInputMapperTest::processMove(SingleTouchInputMapper* mapper, int32_t x, int32_t y) {
2113 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_X, 0, x, 0);
2114 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_Y, 0, y, 0);
2117 void SingleTouchInputMapperTest::processUp(SingleTouchInputMapper* mapper) {
2118 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_TOUCH, 0, 0, 0);
2121 void SingleTouchInputMapperTest::processPressure(
2122 SingleTouchInputMapper* mapper, int32_t pressure) {
2123 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_PRESSURE, 0, pressure, 0);
2126 void SingleTouchInputMapperTest::processToolMajor(
2127 SingleTouchInputMapper* mapper, int32_t toolMajor) {
2128 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_TOOL_WIDTH, 0, toolMajor, 0);
2131 void SingleTouchInputMapperTest::processSync(SingleTouchInputMapper* mapper) {
2132 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0, 0, 0);
2136 TEST_F(SingleTouchInputMapperTest, GetSources_WhenNotAttachedToADisplay_ReturnsTouchPad) {
2137 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, -1);
2138 prepareAxes(POSITION);
2139 addMapperAndConfigure(mapper);
2141 ASSERT_EQ(AINPUT_SOURCE_TOUCHPAD, mapper->getSources());
2144 TEST_F(SingleTouchInputMapperTest, GetSources_WhenAttachedToADisplay_ReturnsTouchScreen) {
2145 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
2146 prepareAxes(POSITION);
2147 addMapperAndConfigure(mapper);
2149 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, mapper->getSources());
2152 TEST_F(SingleTouchInputMapperTest, GetKeyCodeState) {
2153 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
2154 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
2155 prepareAxes(POSITION);
2156 prepareVirtualKeys();
2157 addMapperAndConfigure(mapper);
2160 ASSERT_EQ(AKEY_STATE_UNKNOWN, mapper->getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_A));
2162 // Virtual key is down.
2163 int32_t x = toRawX(VIRTUAL_KEYS[0].centerX);
2164 int32_t y = toRawY(VIRTUAL_KEYS[0].centerY);
2165 processDown(mapper, x, y);
2166 processSync(mapper);
2167 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
2169 ASSERT_EQ(AKEY_STATE_VIRTUAL, mapper->getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_HOME));
2171 // Virtual key is up.
2173 processSync(mapper);
2174 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
2176 ASSERT_EQ(AKEY_STATE_UP, mapper->getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_HOME));
2179 TEST_F(SingleTouchInputMapperTest, GetScanCodeState) {
2180 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
2181 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
2182 prepareAxes(POSITION);
2183 prepareVirtualKeys();
2184 addMapperAndConfigure(mapper);
2187 ASSERT_EQ(AKEY_STATE_UNKNOWN, mapper->getScanCodeState(AINPUT_SOURCE_ANY, KEY_A));
2189 // Virtual key is down.
2190 int32_t x = toRawX(VIRTUAL_KEYS[0].centerX);
2191 int32_t y = toRawY(VIRTUAL_KEYS[0].centerY);
2192 processDown(mapper, x, y);
2193 processSync(mapper);
2194 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
2196 ASSERT_EQ(AKEY_STATE_VIRTUAL, mapper->getScanCodeState(AINPUT_SOURCE_ANY, KEY_HOME));
2198 // Virtual key is up.
2200 processSync(mapper);
2201 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
2203 ASSERT_EQ(AKEY_STATE_UP, mapper->getScanCodeState(AINPUT_SOURCE_ANY, KEY_HOME));
2206 TEST_F(SingleTouchInputMapperTest, MarkSupportedKeyCodes) {
2207 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
2208 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
2209 prepareAxes(POSITION);
2210 prepareVirtualKeys();
2211 addMapperAndConfigure(mapper);
2213 const int32_t keys[2] = { AKEYCODE_HOME, AKEYCODE_A };
2214 uint8_t flags[2] = { 0, 0 };
2215 ASSERT_TRUE(mapper->markSupportedKeyCodes(AINPUT_SOURCE_ANY, 2, keys, flags));
2216 ASSERT_TRUE(flags[0]);
2217 ASSERT_FALSE(flags[1]);
2220 TEST_F(SingleTouchInputMapperTest, Reset_WhenVirtualKeysAreDown_SendsUp) {
2221 // Note: Ideally we should send cancels but the implementation is more straightforward
2222 // with up and this will only happen if a device is forcibly removed.
2223 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
2224 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
2225 prepareAxes(POSITION);
2226 prepareVirtualKeys();
2227 addMapperAndConfigure(mapper);
2229 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
2231 // Press virtual key.
2232 int32_t x = toRawX(VIRTUAL_KEYS[0].centerX);
2233 int32_t y = toRawY(VIRTUAL_KEYS[0].centerY);
2234 processDown(mapper, x, y);
2235 processSync(mapper);
2236 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
2238 // Reset. Since key is down, synthesize key up.
2241 FakeInputDispatcher::NotifyKeyArgs args;
2242 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
2243 //ASSERT_EQ(ARBITRARY_TIME, args.eventTime);
2244 ASSERT_EQ(DEVICE_ID, args.deviceId);
2245 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source);
2246 ASSERT_EQ(POLICY_FLAG_VIRTUAL, args.policyFlags);
2247 ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action);
2248 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY, args.flags);
2249 ASSERT_EQ(AKEYCODE_HOME, args.keyCode);
2250 ASSERT_EQ(KEY_HOME, args.scanCode);
2251 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
2252 ASSERT_EQ(ARBITRARY_TIME, args.downTime);
2255 TEST_F(SingleTouchInputMapperTest, Reset_WhenNothingIsPressed_NothingMuchHappens) {
2256 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
2257 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
2258 prepareAxes(POSITION);
2259 prepareVirtualKeys();
2260 addMapperAndConfigure(mapper);
2262 // Press virtual key.
2263 int32_t x = toRawX(VIRTUAL_KEYS[0].centerX);
2264 int32_t y = toRawY(VIRTUAL_KEYS[0].centerY);
2265 processDown(mapper, x, y);
2266 processSync(mapper);
2267 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
2269 // Release virtual key.
2271 processSync(mapper);
2272 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
2274 // Reset. Since no key is down, nothing happens.
2277 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled());
2278 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled());
2281 TEST_F(SingleTouchInputMapperTest, Process_WhenVirtualKeyIsPressedAndReleasedNormally_SendsKeyDownAndKeyUp) {
2282 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
2283 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
2284 prepareAxes(POSITION);
2285 prepareVirtualKeys();
2286 addMapperAndConfigure(mapper);
2288 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
2290 FakeInputDispatcher::NotifyKeyArgs args;
2292 // Press virtual key.
2293 int32_t x = toRawX(VIRTUAL_KEYS[0].centerX);
2294 int32_t y = toRawY(VIRTUAL_KEYS[0].centerY);
2295 processDown(mapper, x, y);
2296 processSync(mapper);
2298 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
2299 ASSERT_EQ(ARBITRARY_TIME, args.eventTime);
2300 ASSERT_EQ(DEVICE_ID, args.deviceId);
2301 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source);
2302 ASSERT_EQ(POLICY_FLAG_VIRTUAL, args.policyFlags);
2303 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, args.action);
2304 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY, args.flags);
2305 ASSERT_EQ(AKEYCODE_HOME, args.keyCode);
2306 ASSERT_EQ(KEY_HOME, args.scanCode);
2307 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
2308 ASSERT_EQ(ARBITRARY_TIME, args.downTime);
2310 // Release virtual key.
2312 processSync(mapper);
2314 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
2315 ASSERT_EQ(ARBITRARY_TIME, args.eventTime);
2316 ASSERT_EQ(DEVICE_ID, args.deviceId);
2317 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source);
2318 ASSERT_EQ(POLICY_FLAG_VIRTUAL, args.policyFlags);
2319 ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action);
2320 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY, args.flags);
2321 ASSERT_EQ(AKEYCODE_HOME, args.keyCode);
2322 ASSERT_EQ(KEY_HOME, args.scanCode);
2323 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
2324 ASSERT_EQ(ARBITRARY_TIME, args.downTime);
2326 // Should not have sent any motions.
2327 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled());
2330 TEST_F(SingleTouchInputMapperTest, Process_WhenVirtualKeyIsPressedAndMovedOutOfBounds_SendsKeyDownAndKeyCancel) {
2331 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
2332 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
2333 prepareAxes(POSITION);
2334 prepareVirtualKeys();
2335 addMapperAndConfigure(mapper);
2337 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
2339 FakeInputDispatcher::NotifyKeyArgs keyArgs;
2341 // Press virtual key.
2342 int32_t x = toRawX(VIRTUAL_KEYS[0].centerX);
2343 int32_t y = toRawY(VIRTUAL_KEYS[0].centerY);
2344 processDown(mapper, x, y);
2345 processSync(mapper);
2347 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&keyArgs));
2348 ASSERT_EQ(ARBITRARY_TIME, keyArgs.eventTime);
2349 ASSERT_EQ(DEVICE_ID, keyArgs.deviceId);
2350 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, keyArgs.source);
2351 ASSERT_EQ(POLICY_FLAG_VIRTUAL, keyArgs.policyFlags);
2352 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action);
2353 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY, keyArgs.flags);
2354 ASSERT_EQ(AKEYCODE_HOME, keyArgs.keyCode);
2355 ASSERT_EQ(KEY_HOME, keyArgs.scanCode);
2356 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, keyArgs.metaState);
2357 ASSERT_EQ(ARBITRARY_TIME, keyArgs.downTime);
2359 // Move out of bounds. This should generate a cancel and a pointer down since we moved
2360 // into the display area.
2362 processMove(mapper, x, y);
2363 processSync(mapper);
2365 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&keyArgs));
2366 ASSERT_EQ(ARBITRARY_TIME, keyArgs.eventTime);
2367 ASSERT_EQ(DEVICE_ID, keyArgs.deviceId);
2368 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, keyArgs.source);
2369 ASSERT_EQ(POLICY_FLAG_VIRTUAL, keyArgs.policyFlags);
2370 ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action);
2371 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY
2372 | AKEY_EVENT_FLAG_CANCELED, keyArgs.flags);
2373 ASSERT_EQ(AKEYCODE_HOME, keyArgs.keyCode);
2374 ASSERT_EQ(KEY_HOME, keyArgs.scanCode);
2375 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, keyArgs.metaState);
2376 ASSERT_EQ(ARBITRARY_TIME, keyArgs.downTime);
2378 FakeInputDispatcher::NotifyMotionArgs motionArgs;
2379 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2380 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2381 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2382 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2383 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2384 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
2385 ASSERT_EQ(0, motionArgs.flags);
2386 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2387 ASSERT_EQ(0, motionArgs.edgeFlags);
2388 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
2389 ASSERT_EQ(0, motionArgs.pointerIds[0]);
2390 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2391 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
2392 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2393 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2394 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2396 // Keep moving out of bounds. Should generate a pointer move.
2398 processMove(mapper, x, y);
2399 processSync(mapper);
2401 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2402 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2403 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2404 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2405 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2406 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
2407 ASSERT_EQ(0, motionArgs.flags);
2408 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2409 ASSERT_EQ(0, motionArgs.edgeFlags);
2410 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
2411 ASSERT_EQ(0, motionArgs.pointerIds[0]);
2412 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2413 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
2414 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2415 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2416 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2418 // Release out of bounds. Should generate a pointer up.
2420 processSync(mapper);
2422 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2423 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2424 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2425 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2426 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2427 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
2428 ASSERT_EQ(0, motionArgs.flags);
2429 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2430 ASSERT_EQ(0, motionArgs.edgeFlags);
2431 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
2432 ASSERT_EQ(0, motionArgs.pointerIds[0]);
2433 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2434 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
2435 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2436 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2437 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2439 // Should not have sent any more keys or motions.
2440 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled());
2441 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled());
2444 TEST_F(SingleTouchInputMapperTest, Process_WhenTouchStartsOutsideDisplayAndMovesIn_SendsDownAsTouchEntersDisplay) {
2445 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
2446 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
2447 prepareAxes(POSITION);
2448 prepareVirtualKeys();
2449 addMapperAndConfigure(mapper);
2451 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
2453 FakeInputDispatcher::NotifyMotionArgs motionArgs;
2455 // Initially go down out of bounds.
2458 processDown(mapper, x, y);
2459 processSync(mapper);
2461 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled());
2463 // Move into the display area. Should generate a pointer down.
2466 processMove(mapper, x, y);
2467 processSync(mapper);
2469 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2470 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2471 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2472 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2473 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2474 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
2475 ASSERT_EQ(0, motionArgs.flags);
2476 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2477 ASSERT_EQ(0, motionArgs.edgeFlags);
2478 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
2479 ASSERT_EQ(0, motionArgs.pointerIds[0]);
2480 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2481 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
2482 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2483 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2484 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2486 // Release. Should generate a pointer up.
2488 processSync(mapper);
2490 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2491 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2492 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2493 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2494 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2495 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
2496 ASSERT_EQ(0, motionArgs.flags);
2497 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2498 ASSERT_EQ(0, motionArgs.edgeFlags);
2499 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
2500 ASSERT_EQ(0, motionArgs.pointerIds[0]);
2501 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2502 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
2503 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2504 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2505 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2507 // Should not have sent any more keys or motions.
2508 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled());
2509 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled());
2512 TEST_F(SingleTouchInputMapperTest, Process_NormalSingleTouchGesture) {
2513 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
2514 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
2515 prepareAxes(POSITION);
2516 prepareVirtualKeys();
2517 addMapperAndConfigure(mapper);
2519 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
2521 FakeInputDispatcher::NotifyMotionArgs motionArgs;
2526 processDown(mapper, x, y);
2527 processSync(mapper);
2529 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2530 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2531 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2532 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2533 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2534 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
2535 ASSERT_EQ(0, motionArgs.flags);
2536 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2537 ASSERT_EQ(0, motionArgs.edgeFlags);
2538 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
2539 ASSERT_EQ(0, motionArgs.pointerIds[0]);
2540 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2541 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
2542 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2543 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2544 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2549 processMove(mapper, x, y);
2550 processSync(mapper);
2552 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2553 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2554 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2555 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2556 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2557 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
2558 ASSERT_EQ(0, motionArgs.flags);
2559 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2560 ASSERT_EQ(0, motionArgs.edgeFlags);
2561 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
2562 ASSERT_EQ(0, motionArgs.pointerIds[0]);
2563 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2564 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
2565 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2566 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2567 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2571 processSync(mapper);
2573 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2574 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2575 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2576 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2577 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2578 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
2579 ASSERT_EQ(0, motionArgs.flags);
2580 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2581 ASSERT_EQ(0, motionArgs.edgeFlags);
2582 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
2583 ASSERT_EQ(0, motionArgs.pointerIds[0]);
2584 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2585 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
2586 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2587 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2588 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2590 // Should not have sent any more keys or motions.
2591 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled());
2592 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled());
2595 TEST_F(SingleTouchInputMapperTest, Process_Rotation) {
2596 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
2597 prepareAxes(POSITION);
2598 addMapperAndConfigure(mapper);
2600 FakeInputDispatcher::NotifyMotionArgs args;
2603 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
2604 processDown(mapper, toRawX(50), toRawY(75));
2605 processSync(mapper);
2607 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
2608 ASSERT_NEAR(50, args.pointerCoords[0].x, 1);
2609 ASSERT_NEAR(75, args.pointerCoords[0].y, 1);
2612 processSync(mapper);
2613 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled());
2616 prepareDisplay(InputReaderPolicyInterface::ROTATION_90);
2617 processDown(mapper, toRawX(50), toRawY(75));
2618 processSync(mapper);
2620 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
2621 ASSERT_NEAR(75, args.pointerCoords[0].x, 1);
2622 ASSERT_NEAR(DISPLAY_WIDTH - 50, args.pointerCoords[0].y, 1);
2625 processSync(mapper);
2626 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled());
2629 prepareDisplay(InputReaderPolicyInterface::ROTATION_180);
2630 processDown(mapper, toRawX(50), toRawY(75));
2631 processSync(mapper);
2633 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
2634 ASSERT_NEAR(DISPLAY_WIDTH - 50, args.pointerCoords[0].x, 1);
2635 ASSERT_NEAR(DISPLAY_HEIGHT - 75, args.pointerCoords[0].y, 1);
2638 processSync(mapper);
2639 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled());
2642 prepareDisplay(InputReaderPolicyInterface::ROTATION_270);
2643 processDown(mapper, toRawX(50), toRawY(75));
2644 processSync(mapper);
2646 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
2647 ASSERT_NEAR(DISPLAY_HEIGHT - 75, args.pointerCoords[0].x, 1);
2648 ASSERT_NEAR(50, args.pointerCoords[0].y, 1);
2651 processSync(mapper);
2652 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled());
2655 TEST_F(SingleTouchInputMapperTest, Process_AllAxes_DefaultCalibration) {
2656 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
2657 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
2658 prepareAxes(POSITION | PRESSURE | TOOL);
2659 addMapperAndConfigure(mapper);
2661 // These calculations are based on the input device calibration documentation.
2664 int32_t rawPressure = 10;
2665 int32_t rawToolMajor = 12;
2667 float x = toDisplayX(rawX);
2668 float y = toDisplayY(rawY);
2669 float pressure = float(rawPressure) / RAW_PRESSURE_MAX;
2670 float size = float(rawToolMajor) / RAW_TOOL_MAX;
2671 float tool = min(DISPLAY_WIDTH, DISPLAY_HEIGHT) * size;
2672 float touch = min(tool * pressure, tool);
2674 processDown(mapper, rawX, rawY);
2675 processPressure(mapper, rawPressure);
2676 processToolMajor(mapper, rawToolMajor);
2677 processSync(mapper);
2679 FakeInputDispatcher::NotifyMotionArgs args;
2680 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
2681 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
2682 x, y, pressure, size, touch, touch, tool, tool, 0));
2686 // --- MultiTouchInputMapperTest ---
2688 class MultiTouchInputMapperTest : public TouchInputMapperTest {
2690 void prepareAxes(int axes);
2692 void processPosition(MultiTouchInputMapper* mapper, int32_t x, int32_t y);
2693 void processTouchMajor(MultiTouchInputMapper* mapper, int32_t touchMajor);
2694 void processTouchMinor(MultiTouchInputMapper* mapper, int32_t touchMinor);
2695 void processToolMajor(MultiTouchInputMapper* mapper, int32_t toolMajor);
2696 void processToolMinor(MultiTouchInputMapper* mapper, int32_t toolMinor);
2697 void processOrientation(MultiTouchInputMapper* mapper, int32_t orientation);
2698 void processPressure(MultiTouchInputMapper* mapper, int32_t pressure);
2699 void processId(MultiTouchInputMapper* mapper, int32_t id);
2700 void processMTSync(MultiTouchInputMapper* mapper);
2701 void processSync(MultiTouchInputMapper* mapper);
2704 void MultiTouchInputMapperTest::prepareAxes(int axes) {
2705 if (axes & POSITION) {
2706 mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_POSITION_X, RAW_X_MIN, RAW_X_MAX, 0, 0);
2707 mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_POSITION_Y, RAW_Y_MIN, RAW_Y_MAX, 0, 0);
2710 mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_TOUCH_MAJOR, RAW_TOUCH_MIN, RAW_TOUCH_MAX, 0, 0);
2712 mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_TOUCH_MINOR,
2713 RAW_TOUCH_MIN, RAW_TOUCH_MAX, 0, 0);
2717 mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_WIDTH_MAJOR, RAW_TOOL_MIN, RAW_TOOL_MAX, 0, 0);
2719 mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_WIDTH_MINOR,
2720 RAW_TOOL_MAX, RAW_TOOL_MAX, 0, 0);
2723 if (axes & ORIENTATION) {
2724 mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_ORIENTATION,
2725 RAW_ORIENTATION_MIN, RAW_ORIENTATION_MAX, 0, 0);
2727 if (axes & PRESSURE) {
2728 mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_PRESSURE,
2729 RAW_PRESSURE_MIN, RAW_PRESSURE_MAX, 0, 0);
2732 mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_TRACKING_ID,
2733 RAW_ID_MIN, RAW_ID_MAX, 0, 0);
2737 void MultiTouchInputMapperTest::processPosition(
2738 MultiTouchInputMapper* mapper, int32_t x, int32_t y) {
2739 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_POSITION_X, 0, x, 0);
2740 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_POSITION_Y, 0, y, 0);
2743 void MultiTouchInputMapperTest::processTouchMajor(
2744 MultiTouchInputMapper* mapper, int32_t touchMajor) {
2745 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_TOUCH_MAJOR, 0, touchMajor, 0);
2748 void MultiTouchInputMapperTest::processTouchMinor(
2749 MultiTouchInputMapper* mapper, int32_t touchMinor) {
2750 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_TOUCH_MINOR, 0, touchMinor, 0);
2753 void MultiTouchInputMapperTest::processToolMajor(
2754 MultiTouchInputMapper* mapper, int32_t toolMajor) {
2755 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_WIDTH_MAJOR, 0, toolMajor, 0);
2758 void MultiTouchInputMapperTest::processToolMinor(
2759 MultiTouchInputMapper* mapper, int32_t toolMinor) {
2760 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_WIDTH_MINOR, 0, toolMinor, 0);
2763 void MultiTouchInputMapperTest::processOrientation(
2764 MultiTouchInputMapper* mapper, int32_t orientation) {
2765 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_ORIENTATION, 0, orientation, 0);
2768 void MultiTouchInputMapperTest::processPressure(
2769 MultiTouchInputMapper* mapper, int32_t pressure) {
2770 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_PRESSURE, 0, pressure, 0);
2773 void MultiTouchInputMapperTest::processId(
2774 MultiTouchInputMapper* mapper, int32_t id) {
2775 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_TRACKING_ID, 0, id, 0);
2778 void MultiTouchInputMapperTest::processMTSync(MultiTouchInputMapper* mapper) {
2779 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_MT_REPORT, 0, 0, 0);
2782 void MultiTouchInputMapperTest::processSync(MultiTouchInputMapper* mapper) {
2783 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0, 0, 0);
2787 TEST_F(MultiTouchInputMapperTest, Process_NormalMultiTouchGesture_WithoutTrackingIds) {
2788 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice, DISPLAY_ID);
2789 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
2790 prepareAxes(POSITION);
2791 prepareVirtualKeys();
2792 addMapperAndConfigure(mapper);
2794 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
2796 FakeInputDispatcher::NotifyMotionArgs motionArgs;
2798 // Two fingers down at once.
2799 int32_t x1 = 100, y1 = 125, x2 = 300, y2 = 500;
2800 processPosition(mapper, x1, y1);
2801 processMTSync(mapper);
2802 processPosition(mapper, x2, y2);
2803 processMTSync(mapper);
2804 processSync(mapper);
2806 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2807 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2808 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2809 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2810 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2811 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
2812 ASSERT_EQ(0, motionArgs.flags);
2813 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2814 ASSERT_EQ(0, motionArgs.edgeFlags);
2815 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
2816 ASSERT_EQ(0, motionArgs.pointerIds[0]);
2817 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2818 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
2819 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2820 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2821 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2823 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2824 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2825 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2826 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2827 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2828 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_DOWN | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
2830 ASSERT_EQ(0, motionArgs.flags);
2831 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2832 ASSERT_EQ(0, motionArgs.edgeFlags);
2833 ASSERT_EQ(size_t(2), motionArgs.pointerCount);
2834 ASSERT_EQ(0, motionArgs.pointerIds[0]);
2835 ASSERT_EQ(1, motionArgs.pointerIds[1]);
2836 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2837 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
2838 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
2839 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
2840 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2841 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2842 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2845 x1 += 10; y1 += 15; x2 += 5; y2 -= 10;
2846 processPosition(mapper, x1, y1);
2847 processMTSync(mapper);
2848 processPosition(mapper, x2, y2);
2849 processMTSync(mapper);
2850 processSync(mapper);
2852 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2853 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2854 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2855 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2856 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2857 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
2858 ASSERT_EQ(0, motionArgs.flags);
2859 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2860 ASSERT_EQ(0, motionArgs.edgeFlags);
2861 ASSERT_EQ(size_t(2), motionArgs.pointerCount);
2862 ASSERT_EQ(0, motionArgs.pointerIds[0]);
2863 ASSERT_EQ(1, motionArgs.pointerIds[1]);
2864 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2865 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
2866 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
2867 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
2868 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2869 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2870 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2874 processPosition(mapper, x2, y2);
2875 processMTSync(mapper);
2876 processSync(mapper);
2878 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2879 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2880 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2881 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2882 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2883 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_UP | (0 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
2885 ASSERT_EQ(0, motionArgs.flags);
2886 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2887 ASSERT_EQ(0, motionArgs.edgeFlags);
2888 ASSERT_EQ(size_t(2), motionArgs.pointerCount);
2889 ASSERT_EQ(0, motionArgs.pointerIds[0]);
2890 ASSERT_EQ(1, motionArgs.pointerIds[1]);
2891 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2892 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
2893 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
2894 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
2895 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2896 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2897 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2899 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2900 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2901 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2902 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2903 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2904 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
2905 ASSERT_EQ(0, motionArgs.flags);
2906 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2907 ASSERT_EQ(0, motionArgs.edgeFlags);
2908 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
2909 ASSERT_EQ(1, motionArgs.pointerIds[0]);
2910 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2911 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
2912 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2913 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2914 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2918 processPosition(mapper, x2, y2);
2919 processMTSync(mapper);
2920 processSync(mapper);
2922 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2923 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2924 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2925 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2926 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2927 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
2928 ASSERT_EQ(0, motionArgs.flags);
2929 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2930 ASSERT_EQ(0, motionArgs.edgeFlags);
2931 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
2932 ASSERT_EQ(1, motionArgs.pointerIds[0]);
2933 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2934 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
2935 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2936 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2937 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2940 int32_t x3 = 700, y3 = 300;
2941 processPosition(mapper, x2, y2);
2942 processMTSync(mapper);
2943 processPosition(mapper, x3, y3);
2944 processMTSync(mapper);
2945 processSync(mapper);
2947 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2948 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2949 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2950 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2951 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2952 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_DOWN | (0 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
2954 ASSERT_EQ(0, motionArgs.flags);
2955 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2956 ASSERT_EQ(0, motionArgs.edgeFlags);
2957 ASSERT_EQ(size_t(2), motionArgs.pointerCount);
2958 ASSERT_EQ(0, motionArgs.pointerIds[0]);
2959 ASSERT_EQ(1, motionArgs.pointerIds[1]);
2960 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2961 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
2962 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
2963 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
2964 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2965 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2966 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2968 // Second finger up.
2970 processPosition(mapper, x3, y3);
2971 processMTSync(mapper);
2972 processSync(mapper);
2974 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2975 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2976 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2977 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2978 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2979 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_UP | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
2981 ASSERT_EQ(0, motionArgs.flags);
2982 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2983 ASSERT_EQ(0, motionArgs.edgeFlags);
2984 ASSERT_EQ(size_t(2), motionArgs.pointerCount);
2985 ASSERT_EQ(0, motionArgs.pointerIds[0]);
2986 ASSERT_EQ(1, motionArgs.pointerIds[1]);
2987 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2988 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
2989 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
2990 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
2991 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2992 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2993 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2995 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2996 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2997 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2998 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2999 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
3000 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
3001 ASSERT_EQ(0, motionArgs.flags);
3002 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
3003 ASSERT_EQ(0, motionArgs.edgeFlags);
3004 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
3005 ASSERT_EQ(0, motionArgs.pointerIds[0]);
3006 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
3007 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
3008 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
3009 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
3010 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
3013 processMTSync(mapper);
3014 processSync(mapper);
3016 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
3017 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
3018 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
3019 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
3020 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
3021 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
3022 ASSERT_EQ(0, motionArgs.flags);
3023 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
3024 ASSERT_EQ(0, motionArgs.edgeFlags);
3025 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
3026 ASSERT_EQ(0, motionArgs.pointerIds[0]);
3027 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
3028 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
3029 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
3030 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
3031 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
3033 // Should not have sent any more keys or motions.
3034 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled());
3035 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled());
3038 TEST_F(MultiTouchInputMapperTest, Process_NormalMultiTouchGesture_WithTrackingIds) {
3039 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice, DISPLAY_ID);
3040 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
3041 prepareAxes(POSITION | ID);
3042 prepareVirtualKeys();
3043 addMapperAndConfigure(mapper);
3045 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
3047 FakeInputDispatcher::NotifyMotionArgs motionArgs;
3049 // Two fingers down at once.
3050 int32_t x1 = 100, y1 = 125, x2 = 300, y2 = 500;
3051 processPosition(mapper, x1, y1);
3052 processId(mapper, 1);
3053 processMTSync(mapper);
3054 processPosition(mapper, x2, y2);
3055 processId(mapper, 2);
3056 processMTSync(mapper);
3057 processSync(mapper);
3059 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
3060 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
3061 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
3062 ASSERT_EQ(1, motionArgs.pointerIds[0]);
3063 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
3064 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
3066 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
3067 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_DOWN | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
3069 ASSERT_EQ(size_t(2), motionArgs.pointerCount);
3070 ASSERT_EQ(1, motionArgs.pointerIds[0]);
3071 ASSERT_EQ(2, motionArgs.pointerIds[1]);
3072 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
3073 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
3074 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
3075 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
3078 x1 += 10; y1 += 15; x2 += 5; y2 -= 10;
3079 processPosition(mapper, x1, y1);
3080 processId(mapper, 1);
3081 processMTSync(mapper);
3082 processPosition(mapper, x2, y2);
3083 processId(mapper, 2);
3084 processMTSync(mapper);
3085 processSync(mapper);
3087 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
3088 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
3089 ASSERT_EQ(size_t(2), motionArgs.pointerCount);
3090 ASSERT_EQ(1, motionArgs.pointerIds[0]);
3091 ASSERT_EQ(2, motionArgs.pointerIds[1]);
3092 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
3093 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
3094 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
3095 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
3099 processPosition(mapper, x2, y2);
3100 processId(mapper, 2);
3101 processMTSync(mapper);
3102 processSync(mapper);
3104 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
3105 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_UP | (0 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
3107 ASSERT_EQ(size_t(2), motionArgs.pointerCount);
3108 ASSERT_EQ(1, motionArgs.pointerIds[0]);
3109 ASSERT_EQ(2, motionArgs.pointerIds[1]);
3110 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
3111 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
3112 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
3113 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
3115 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
3116 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
3117 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
3118 ASSERT_EQ(2, motionArgs.pointerIds[0]);
3119 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
3120 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
3124 processPosition(mapper, x2, y2);
3125 processId(mapper, 2);
3126 processMTSync(mapper);
3127 processSync(mapper);
3129 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
3130 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
3131 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
3132 ASSERT_EQ(2, motionArgs.pointerIds[0]);
3133 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
3134 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
3137 int32_t x3 = 700, y3 = 300;
3138 processPosition(mapper, x2, y2);
3139 processId(mapper, 2);
3140 processMTSync(mapper);
3141 processPosition(mapper, x3, y3);
3142 processId(mapper, 3);
3143 processMTSync(mapper);
3144 processSync(mapper);
3146 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
3147 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_DOWN | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
3149 ASSERT_EQ(size_t(2), motionArgs.pointerCount);
3150 ASSERT_EQ(2, motionArgs.pointerIds[0]);
3151 ASSERT_EQ(3, motionArgs.pointerIds[1]);
3152 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
3153 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
3154 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
3155 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
3157 // Second finger up.
3159 processPosition(mapper, x3, y3);
3160 processId(mapper, 3);
3161 processMTSync(mapper);
3162 processSync(mapper);
3164 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
3165 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_UP | (0 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
3167 ASSERT_EQ(size_t(2), motionArgs.pointerCount);
3168 ASSERT_EQ(2, motionArgs.pointerIds[0]);
3169 ASSERT_EQ(3, motionArgs.pointerIds[1]);
3170 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
3171 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
3172 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
3173 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
3175 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
3176 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
3177 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
3178 ASSERT_EQ(3, motionArgs.pointerIds[0]);
3179 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
3180 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
3183 processMTSync(mapper);
3184 processSync(mapper);
3186 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
3187 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
3188 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
3189 ASSERT_EQ(3, motionArgs.pointerIds[0]);
3190 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
3191 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
3193 // Should not have sent any more keys or motions.
3194 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled());
3195 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled());
3198 TEST_F(MultiTouchInputMapperTest, Process_AllAxes_WithDefaultCalibration) {
3199 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice, DISPLAY_ID);
3200 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
3201 prepareAxes(POSITION | TOUCH | TOOL | PRESSURE | ORIENTATION | ID | MINOR);
3202 addMapperAndConfigure(mapper);
3204 // These calculations are based on the input device calibration documentation.
3207 int32_t rawTouchMajor = 7;
3208 int32_t rawTouchMinor = 6;
3209 int32_t rawToolMajor = 9;
3210 int32_t rawToolMinor = 8;
3211 int32_t rawPressure = 11;
3212 int32_t rawOrientation = 3;
3215 float x = toDisplayX(rawX);
3216 float y = toDisplayY(rawY);
3217 float pressure = float(rawPressure) / RAW_PRESSURE_MAX;
3218 float size = avg(rawToolMajor, rawToolMinor) / RAW_TOOL_MAX;
3219 float toolMajor = float(min(DISPLAY_WIDTH, DISPLAY_HEIGHT)) * rawToolMajor / RAW_TOOL_MAX;
3220 float toolMinor = float(min(DISPLAY_WIDTH, DISPLAY_HEIGHT)) * rawToolMinor / RAW_TOOL_MAX;
3221 float touchMajor = min(toolMajor * pressure, toolMajor);
3222 float touchMinor = min(toolMinor * pressure, toolMinor);
3223 float orientation = float(rawOrientation) / RAW_ORIENTATION_MAX * M_PI_2;
3225 processPosition(mapper, rawX, rawY);
3226 processTouchMajor(mapper, rawTouchMajor);
3227 processTouchMinor(mapper, rawTouchMinor);
3228 processToolMajor(mapper, rawToolMajor);
3229 processToolMinor(mapper, rawToolMinor);
3230 processPressure(mapper, rawPressure);
3231 processOrientation(mapper, rawOrientation);
3232 processId(mapper, id);
3233 processMTSync(mapper);
3234 processSync(mapper);
3236 FakeInputDispatcher::NotifyMotionArgs args;
3237 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
3238 ASSERT_EQ(id, args.pointerIds[0]);
3239 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
3240 x, y, pressure, size, touchMajor, touchMinor, toolMajor, toolMinor, orientation));
3243 TEST_F(MultiTouchInputMapperTest, Process_TouchAndToolAxes_GeometricCalibration) {
3244 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice, DISPLAY_ID);
3245 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
3246 prepareAxes(POSITION | TOUCH | TOOL | MINOR);
3247 prepareCalibration("touch.touchSize.calibration", "geometric");
3248 prepareCalibration("touch.toolSize.calibration", "geometric");
3249 addMapperAndConfigure(mapper);
3251 // These calculations are based on the input device calibration documentation.
3254 int32_t rawTouchMajor = 140;
3255 int32_t rawTouchMinor = 120;
3256 int32_t rawToolMajor = 180;
3257 int32_t rawToolMinor = 160;
3259 float x = toDisplayX(rawX);
3260 float y = toDisplayY(rawY);
3261 float pressure = float(rawTouchMajor) / RAW_TOUCH_MAX;
3262 float size = avg(rawToolMajor, rawToolMinor) / RAW_TOOL_MAX;
3263 float scale = avg(float(DISPLAY_WIDTH) / (RAW_X_MAX - RAW_X_MIN),
3264 float(DISPLAY_HEIGHT) / (RAW_Y_MAX - RAW_Y_MIN));
3265 float toolMajor = float(rawToolMajor) * scale;
3266 float toolMinor = float(rawToolMinor) * scale;
3267 float touchMajor = min(float(rawTouchMajor) * scale, toolMajor);
3268 float touchMinor = min(float(rawTouchMinor) * scale, toolMinor);
3270 processPosition(mapper, rawX, rawY);
3271 processTouchMajor(mapper, rawTouchMajor);
3272 processTouchMinor(mapper, rawTouchMinor);
3273 processToolMajor(mapper, rawToolMajor);
3274 processToolMinor(mapper, rawToolMinor);
3275 processMTSync(mapper);
3276 processSync(mapper);
3278 FakeInputDispatcher::NotifyMotionArgs args;
3279 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
3280 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
3281 x, y, pressure, size, touchMajor, touchMinor, toolMajor, toolMinor, 0));
3284 TEST_F(MultiTouchInputMapperTest, Process_TouchToolPressureSizeAxes_SummedLinearCalibration) {
3285 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice, DISPLAY_ID);
3286 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
3287 prepareAxes(POSITION | TOUCH | TOOL);
3288 prepareCalibration("touch.touchSize.calibration", "pressure");
3289 prepareCalibration("touch.toolSize.calibration", "linear");
3290 prepareCalibration("touch.toolSize.linearScale", "10");
3291 prepareCalibration("touch.toolSize.linearBias", "160");
3292 prepareCalibration("touch.toolSize.isSummed", "1");
3293 prepareCalibration("touch.pressure.calibration", "amplitude");
3294 prepareCalibration("touch.pressure.source", "touch");
3295 prepareCalibration("touch.pressure.scale", "0.01");
3296 addMapperAndConfigure(mapper);
3298 // These calculations are based on the input device calibration documentation.
3299 // Note: We only provide a single common touch/tool value because the device is assumed
3300 // not to emit separate values for each pointer (isSummed = 1).
3303 int32_t rawX2 = 150;
3304 int32_t rawY2 = 250;
3305 int32_t rawTouchMajor = 60;
3306 int32_t rawToolMajor = 5;
3308 float x = toDisplayX(rawX);
3309 float y = toDisplayY(rawY);
3310 float x2 = toDisplayX(rawX2);
3311 float y2 = toDisplayY(rawY2);
3312 float pressure = float(rawTouchMajor) * 0.01f;
3313 float size = float(rawToolMajor) / RAW_TOOL_MAX;
3314 float tool = (float(rawToolMajor) * 10.0f + 160.0f) / 2;
3315 float touch = min(tool * pressure, tool);
3317 processPosition(mapper, rawX, rawY);
3318 processTouchMajor(mapper, rawTouchMajor);
3319 processToolMajor(mapper, rawToolMajor);
3320 processMTSync(mapper);
3321 processPosition(mapper, rawX2, rawY2);
3322 processTouchMajor(mapper, rawTouchMajor);
3323 processToolMajor(mapper, rawToolMajor);
3324 processMTSync(mapper);
3325 processSync(mapper);
3327 FakeInputDispatcher::NotifyMotionArgs args;
3328 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
3329 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action);
3330 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
3331 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_DOWN | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
3333 ASSERT_EQ(size_t(2), args.pointerCount);
3334 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
3335 x, y, pressure, size, touch, touch, tool, tool, 0));
3336 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[1],
3337 x2, y2, pressure, size, touch, touch, tool, tool, 0));
3340 TEST_F(MultiTouchInputMapperTest, Process_TouchToolPressureSizeAxes_AreaCalibration) {
3341 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice, DISPLAY_ID);
3342 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
3343 prepareAxes(POSITION | TOUCH | TOOL);
3344 prepareCalibration("touch.touchSize.calibration", "pressure");
3345 prepareCalibration("touch.toolSize.calibration", "area");
3346 prepareCalibration("touch.toolSize.areaScale", "22");
3347 prepareCalibration("touch.toolSize.areaBias", "1");
3348 prepareCalibration("touch.toolSize.linearScale", "9.2");
3349 prepareCalibration("touch.toolSize.linearBias", "3");
3350 prepareCalibration("touch.pressure.calibration", "amplitude");
3351 prepareCalibration("touch.pressure.source", "touch");
3352 prepareCalibration("touch.pressure.scale", "0.01");
3353 addMapperAndConfigure(mapper);
3355 // These calculations are based on the input device calibration documentation.
3358 int32_t rawTouchMajor = 60;
3359 int32_t rawToolMajor = 5;
3361 float x = toDisplayX(rawX);
3362 float y = toDisplayY(rawY);
3363 float pressure = float(rawTouchMajor) * 0.01f;
3364 float size = float(rawToolMajor) / RAW_TOOL_MAX;
3365 float tool = sqrtf(float(rawToolMajor) * 22.0f + 1.0f) * 9.2f + 3.0f;
3366 float touch = min(tool * pressure, tool);
3368 processPosition(mapper, rawX, rawY);
3369 processTouchMajor(mapper, rawTouchMajor);
3370 processToolMajor(mapper, rawToolMajor);
3371 processMTSync(mapper);
3372 processSync(mapper);
3374 FakeInputDispatcher::NotifyMotionArgs args;
3375 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
3376 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
3377 x, y, pressure, size, touch, touch, tool, tool, 0));
3380 } // namespace android