blob: de4b05ae3d3df648a5c714fef1cc0ffb89df8d14 [file] [log] [blame]
Jeff Brown3c3cc622010-10-20 15:33:38 -07001//
2// Copyright 2010 The Android Open Source Project
3//
4
5#include <ui/InputReader.h>
6#include <utils/List.h>
7#include <gtest/gtest.h>
8#include <math.h>
9
10namespace android {
11
12// An arbitrary time value.
13static const nsecs_t ARBITRARY_TIME = 1234;
14
15// Arbitrary display properties.
16static const int32_t DISPLAY_ID = 0;
17static const int32_t DISPLAY_WIDTH = 480;
18static const int32_t DISPLAY_HEIGHT = 800;
19
20// Error tolerance for floating point assertions.
21static const float EPSILON = 0.001f;
22
23template<typename T>
24static inline T min(T a, T b) {
25 return a < b ? a : b;
26}
27
28static inline float avg(float x, float y) {
29 return (x + y) / 2;
30}
31
32
33// --- FakeInputReaderPolicy ---
34
35class FakeInputReaderPolicy : public InputReaderPolicyInterface {
36 struct DisplayInfo {
37 int32_t width;
38 int32_t height;
39 int32_t orientation;
40 };
41
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;
48
49protected:
50 virtual ~FakeInputReaderPolicy() { }
51
52public:
53 FakeInputReaderPolicy() :
54 mFilterTouchEvents(false), mFilterJumpyTouchEvents(false) {
55 }
56
57 void removeDisplayInfo(int32_t displayId) {
58 mDisplayInfos.removeItem(displayId);
59 }
60
61 void setDisplayInfo(int32_t displayId, int32_t width, int32_t height, int32_t orientation) {
62 removeDisplayInfo(displayId);
63
64 DisplayInfo info;
65 info.width = width;
66 info.height = height;
67 info.orientation = orientation;
68 mDisplayInfos.add(displayId, info);
69 }
70
71 void setFilterTouchEvents(bool enabled) {
72 mFilterTouchEvents = enabled;
73 }
74
75 void setFilterJumpyTouchEvents(bool enabled) {
76 mFilterJumpyTouchEvents = enabled;
77 }
78
79 void addInputDeviceCalibration(const String8& deviceName,
80 const InputDeviceCalibration& calibration) {
81 mInputDeviceCalibrations.add(deviceName, calibration);
82 }
83
84 void addInputDeviceCalibrationProperty(const String8& deviceName,
85 const String8& key, const String8& value) {
86 ssize_t index = mInputDeviceCalibrations.indexOfKey(deviceName);
87 if (index < 0) {
88 index = mInputDeviceCalibrations.add(deviceName, InputDeviceCalibration());
89 }
90 mInputDeviceCalibrations.editValueAt(index).addProperty(key, value);
91 }
92
93 void addVirtualKeyDefinition(const String8& deviceName,
94 const VirtualKeyDefinition& definition) {
95 if (mVirtualKeyDefinitions.indexOfKey(deviceName) < 0) {
96 mVirtualKeyDefinitions.add(deviceName, Vector<VirtualKeyDefinition>());
97 }
98
99 mVirtualKeyDefinitions.editValueFor(deviceName).push(definition);
100 }
101
102 void addExcludedDeviceName(const String8& deviceName) {
103 mExcludedDeviceNames.push(deviceName);
104 }
105
106private:
107 virtual bool getDisplayInfo(int32_t displayId,
108 int32_t* width, int32_t* height, int32_t* orientation) {
109 ssize_t index = mDisplayInfos.indexOfKey(displayId);
110 if (index >= 0) {
111 const DisplayInfo& info = mDisplayInfos.valueAt(index);
112 if (width) {
113 *width = info.width;
114 }
115 if (height) {
116 *height = info.height;
117 }
118 if (orientation) {
119 *orientation = info.orientation;
120 }
121 return true;
122 }
123 return false;
124 }
125
126 virtual bool filterTouchEvents() {
127 return mFilterTouchEvents;
128 }
129
130 virtual bool filterJumpyTouchEvents() {
131 return mFilterJumpyTouchEvents;
132 }
133
134 virtual void getVirtualKeyDefinitions(const String8& deviceName,
135 Vector<VirtualKeyDefinition>& outVirtualKeyDefinitions) {
136 ssize_t index = mVirtualKeyDefinitions.indexOfKey(deviceName);
137 if (index >= 0) {
138 outVirtualKeyDefinitions.appendVector(mVirtualKeyDefinitions.valueAt(index));
139 }
140 }
141
142 virtual void getInputDeviceCalibration(const String8& deviceName,
143 InputDeviceCalibration& outCalibration) {
144 ssize_t index = mInputDeviceCalibrations.indexOfKey(deviceName);
145 if (index >= 0) {
146 outCalibration = mInputDeviceCalibrations.valueAt(index);
147 }
148 }
149
150 virtual void getExcludedDeviceNames(Vector<String8>& outExcludedDeviceNames) {
151 outExcludedDeviceNames.appendVector(mExcludedDeviceNames);
152 }
153};
154
155
156// --- FakeInputDispatcher ---
157
158class FakeInputDispatcher : public InputDispatcherInterface {
159public:
160 struct NotifyConfigurationChangedArgs {
161 nsecs_t eventTime;
162 };
163
164 struct NotifyKeyArgs {
165 nsecs_t eventTime;
166 int32_t deviceId;
167 int32_t source;
168 uint32_t policyFlags;
169 int32_t action;
170 int32_t flags;
171 int32_t keyCode;
172 int32_t scanCode;
173 int32_t metaState;
174 nsecs_t downTime;
175 };
176
177 struct NotifyMotionArgs {
178 nsecs_t eventTime;
179 int32_t deviceId;
180 int32_t source;
181 uint32_t policyFlags;
182 int32_t action;
183 int32_t flags;
184 int32_t metaState;
185 int32_t edgeFlags;
186 uint32_t pointerCount;
187 Vector<int32_t> pointerIds;
188 Vector<PointerCoords> pointerCoords;
189 float xPrecision;
190 float yPrecision;
191 nsecs_t downTime;
192 };
193
194 struct NotifySwitchArgs {
195 nsecs_t when;
196 int32_t switchCode;
197 int32_t switchValue;
198 uint32_t policyFlags;
199 };
200
201private:
202 List<NotifyConfigurationChangedArgs> mNotifyConfigurationChangedArgs;
203 List<NotifyKeyArgs> mNotifyKeyArgs;
204 List<NotifyMotionArgs> mNotifyMotionArgs;
205 List<NotifySwitchArgs> mNotifySwitchArgs;
206
207protected:
208 virtual ~FakeInputDispatcher() { }
209
210public:
211 FakeInputDispatcher() {
212 }
213
214 void assertNotifyConfigurationChangedWasCalled(NotifyConfigurationChangedArgs* outArgs = NULL) {
215 ASSERT_FALSE(mNotifyConfigurationChangedArgs.empty())
216 << "Expected notifyConfigurationChanged() to have been called.";
217 if (outArgs) {
218 *outArgs = *mNotifyConfigurationChangedArgs.begin();
219 }
220 mNotifyConfigurationChangedArgs.erase(mNotifyConfigurationChangedArgs.begin());
221 }
222
223 void assertNotifyKeyWasCalled(NotifyKeyArgs* outArgs = NULL) {
224 ASSERT_FALSE(mNotifyKeyArgs.empty())
225 << "Expected notifyKey() to have been called.";
226 if (outArgs) {
227 *outArgs = *mNotifyKeyArgs.begin();
228 }
229 mNotifyKeyArgs.erase(mNotifyKeyArgs.begin());
230 }
231
232 void assertNotifyKeyWasNotCalled() {
233 ASSERT_TRUE(mNotifyKeyArgs.empty())
234 << "Expected notifyKey() to not have been called.";
235 }
236
237 void assertNotifyMotionWasCalled(NotifyMotionArgs* outArgs = NULL) {
238 ASSERT_FALSE(mNotifyMotionArgs.empty())
239 << "Expected notifyMotion() to have been called.";
240 if (outArgs) {
241 *outArgs = *mNotifyMotionArgs.begin();
242 }
243 mNotifyMotionArgs.erase(mNotifyMotionArgs.begin());
244 }
245
246 void assertNotifyMotionWasNotCalled() {
247 ASSERT_TRUE(mNotifyMotionArgs.empty())
248 << "Expected notifyMotion() to not have been called.";
249 }
250
251 void assertNotifySwitchWasCalled(NotifySwitchArgs* outArgs = NULL) {
252 ASSERT_FALSE(mNotifySwitchArgs.empty())
253 << "Expected notifySwitch() to have been called.";
254 if (outArgs) {
255 *outArgs = *mNotifySwitchArgs.begin();
256 }
257 mNotifySwitchArgs.erase(mNotifySwitchArgs.begin());
258 }
259
260private:
261 virtual void notifyConfigurationChanged(nsecs_t eventTime) {
262 NotifyConfigurationChangedArgs args;
263 args.eventTime = eventTime;
264 mNotifyConfigurationChangedArgs.push_back(args);
265 }
266
267 virtual void notifyKey(nsecs_t eventTime, int32_t deviceId, int32_t source,
268 uint32_t policyFlags, int32_t action, int32_t flags, int32_t keyCode,
269 int32_t scanCode, int32_t metaState, nsecs_t downTime) {
270 NotifyKeyArgs args;
271 args.eventTime = eventTime;
272 args.deviceId = deviceId;
273 args.source = source;
274 args.policyFlags = policyFlags;
275 args.action = action;
276 args.flags = flags;
277 args.keyCode = keyCode;
278 args.scanCode = scanCode;
279 args.metaState = metaState;
280 args.downTime = downTime;
281 mNotifyKeyArgs.push_back(args);
282 }
283
284 virtual void notifyMotion(nsecs_t eventTime, int32_t deviceId, int32_t source,
285 uint32_t policyFlags, int32_t action, int32_t flags,
286 int32_t metaState, int32_t edgeFlags,
287 uint32_t pointerCount, const int32_t* pointerIds, const PointerCoords* pointerCoords,
288 float xPrecision, float yPrecision, nsecs_t downTime) {
289 NotifyMotionArgs args;
290 args.eventTime = eventTime;
291 args.deviceId = deviceId;
292 args.source = source;
293 args.policyFlags = policyFlags;
294 args.action = action;
295 args.flags = flags;
296 args.metaState = metaState;
297 args.edgeFlags = edgeFlags;
298 args.pointerCount = pointerCount;
299 args.pointerIds.clear();
300 args.pointerIds.appendArray(pointerIds, pointerCount);
301 args.pointerCoords.clear();
302 args.pointerCoords.appendArray(pointerCoords, pointerCount);
303 args.xPrecision = xPrecision;
304 args.yPrecision = yPrecision;
305 args.downTime = downTime;
306 mNotifyMotionArgs.push_back(args);
307 }
308
309 virtual void notifySwitch(nsecs_t when,
310 int32_t switchCode, int32_t switchValue, uint32_t policyFlags) {
311 NotifySwitchArgs args;
312 args.when = when;
313 args.switchCode = switchCode;
314 args.switchValue = switchValue;
315 args.policyFlags = policyFlags;
316 mNotifySwitchArgs.push_back(args);
317 }
318
319 virtual void dump(String8& dump) {
320 ADD_FAILURE() << "Should never be called by input reader.";
321 }
322
323 virtual void dispatchOnce() {
324 ADD_FAILURE() << "Should never be called by input reader.";
325 }
326
327 virtual int32_t injectInputEvent(const InputEvent* event,
328 int32_t injectorPid, int32_t injectorUid, int32_t syncMode, int32_t timeoutMillis) {
329 ADD_FAILURE() << "Should never be called by input reader.";
330 return INPUT_EVENT_INJECTION_FAILED;
331 }
332
333 virtual void setInputWindows(const Vector<InputWindow>& inputWindows) {
334 ADD_FAILURE() << "Should never be called by input reader.";
335 }
336
337 virtual void setFocusedApplication(const InputApplication* inputApplication) {
338 ADD_FAILURE() << "Should never be called by input reader.";
339 }
340
341 virtual void setInputDispatchMode(bool enabled, bool frozen) {
342 ADD_FAILURE() << "Should never be called by input reader.";
343 }
344
345 virtual status_t registerInputChannel(const sp<InputChannel>& inputChannel, bool monitor) {
346 ADD_FAILURE() << "Should never be called by input reader.";
347 return 0;
348 }
349
350 virtual status_t unregisterInputChannel(const sp<InputChannel>& inputChannel) {
351 ADD_FAILURE() << "Should never be called by input reader.";
352 return 0;
353 }
354};
355
356
357// --- FakeEventHub ---
358
359class FakeEventHub : public EventHubInterface {
360 struct KeyInfo {
361 int32_t keyCode;
362 uint32_t flags;
363 };
364
365 struct Device {
366 String8 name;
367 uint32_t classes;
368 KeyedVector<int, RawAbsoluteAxisInfo> axes;
369 KeyedVector<int32_t, int32_t> keyCodeStates;
370 KeyedVector<int32_t, int32_t> scanCodeStates;
371 KeyedVector<int32_t, int32_t> switchStates;
372 KeyedVector<int32_t, KeyInfo> keys;
373
374 Device(const String8& name, uint32_t classes) :
375 name(name), classes(classes) {
376 }
377 };
378
379 KeyedVector<int32_t, Device*> mDevices;
380 Vector<String8> mExcludedDevices;
381 List<RawEvent> mEvents;
382
383protected:
384 virtual ~FakeEventHub() {
385 for (size_t i = 0; i < mDevices.size(); i++) {
386 delete mDevices.valueAt(i);
387 }
388 }
389
390public:
391 FakeEventHub() { }
392
393 void addDevice(int32_t deviceId, const String8& name, uint32_t classes) {
394 Device* device = new Device(name, classes);
395 mDevices.add(deviceId, device);
396
397 enqueueEvent(ARBITRARY_TIME, deviceId, EventHubInterface::DEVICE_ADDED, 0, 0, 0, 0);
398 }
399
400 void removeDevice(int32_t deviceId) {
401 delete mDevices.valueFor(deviceId);
402 mDevices.removeItem(deviceId);
403
404 enqueueEvent(ARBITRARY_TIME, deviceId, EventHubInterface::DEVICE_REMOVED, 0, 0, 0, 0);
405 }
406
407 void finishDeviceScan() {
408 enqueueEvent(ARBITRARY_TIME, 0, EventHubInterface::FINISHED_DEVICE_SCAN, 0, 0, 0, 0);
409 }
410
411 void addAxis(int32_t deviceId, int axis,
412 int32_t minValue, int32_t maxValue, int flat, int fuzz) {
413 Device* device = getDevice(deviceId);
414
415 RawAbsoluteAxisInfo info;
416 info.valid = true;
417 info.minValue = minValue;
418 info.maxValue = maxValue;
419 info.flat = flat;
420 info.fuzz = fuzz;
421 device->axes.add(axis, info);
422 }
423
424 void setKeyCodeState(int32_t deviceId, int32_t keyCode, int32_t state) {
425 Device* device = getDevice(deviceId);
426 device->keyCodeStates.replaceValueFor(keyCode, state);
427 }
428
429 void setScanCodeState(int32_t deviceId, int32_t scanCode, int32_t state) {
430 Device* device = getDevice(deviceId);
431 device->scanCodeStates.replaceValueFor(scanCode, state);
432 }
433
434 void setSwitchState(int32_t deviceId, int32_t switchCode, int32_t state) {
435 Device* device = getDevice(deviceId);
436 device->switchStates.replaceValueFor(switchCode, state);
437 }
438
439 void addKey(int32_t deviceId, int32_t scanCode, int32_t keyCode, uint32_t flags) {
440 Device* device = getDevice(deviceId);
441 KeyInfo info;
442 info.keyCode = keyCode;
443 info.flags = flags;
444 device->keys.add(scanCode, info);
445 }
446
447 Vector<String8>& getExcludedDevices() {
448 return mExcludedDevices;
449 }
450
451 void enqueueEvent(nsecs_t when, int32_t deviceId, int32_t type,
452 int32_t scanCode, int32_t keyCode, int32_t value, uint32_t flags) {
453 RawEvent event;
454 event.when = when;
455 event.deviceId = deviceId;
456 event.type = type;
457 event.scanCode = scanCode;
458 event.keyCode = keyCode;
459 event.value = value;
460 event.flags = flags;
461 mEvents.push_back(event);
462 }
463
464 void assertQueueIsEmpty() {
465 ASSERT_EQ(size_t(0), mEvents.size())
466 << "Expected the event queue to be empty (fully consumed).";
467 }
468
469private:
470 Device* getDevice(int32_t deviceId) const {
471 ssize_t index = mDevices.indexOfKey(deviceId);
472 return index >= 0 ? mDevices.valueAt(index) : NULL;
473 }
474
475 virtual uint32_t getDeviceClasses(int32_t deviceId) const {
476 Device* device = getDevice(deviceId);
477 return device ? device->classes : 0;
478 }
479
480 virtual String8 getDeviceName(int32_t deviceId) const {
481 Device* device = getDevice(deviceId);
482 return device ? device->name : String8("unknown");
483 }
484
485 virtual status_t getAbsoluteAxisInfo(int32_t deviceId, int axis,
486 RawAbsoluteAxisInfo* outAxisInfo) const {
487 Device* device = getDevice(deviceId);
488 if (device) {
489 ssize_t index = device->axes.indexOfKey(axis);
490 if (index >= 0) {
491 *outAxisInfo = device->axes.valueAt(index);
492 return OK;
493 }
494 }
495 return -1;
496 }
497
498 virtual status_t scancodeToKeycode(int32_t deviceId, int scancode,
499 int32_t* outKeycode, uint32_t* outFlags) const {
500 Device* device = getDevice(deviceId);
501 if (device) {
502 ssize_t index = device->keys.indexOfKey(scancode);
503 if (index >= 0) {
504 if (outKeycode) {
505 *outKeycode = device->keys.valueAt(index).keyCode;
506 }
507 if (outFlags) {
508 *outFlags = device->keys.valueAt(index).flags;
509 }
510 return OK;
511 }
512 }
513 return NAME_NOT_FOUND;
514 }
515
516 virtual void addExcludedDevice(const char* deviceName) {
517 mExcludedDevices.add(String8(deviceName));
518 }
519
520 virtual bool getEvent(RawEvent* outEvent) {
521 if (mEvents.empty()) {
522 return false;
523 }
524
525 *outEvent = *mEvents.begin();
526 mEvents.erase(mEvents.begin());
527 return true;
528 }
529
530 virtual int32_t getScanCodeState(int32_t deviceId, int32_t scanCode) const {
531 Device* device = getDevice(deviceId);
532 if (device) {
533 ssize_t index = device->scanCodeStates.indexOfKey(scanCode);
534 if (index >= 0) {
535 return device->scanCodeStates.valueAt(index);
536 }
537 }
538 return AKEY_STATE_UNKNOWN;
539 }
540
541 virtual int32_t getKeyCodeState(int32_t deviceId, int32_t keyCode) const {
542 Device* device = getDevice(deviceId);
543 if (device) {
544 ssize_t index = device->keyCodeStates.indexOfKey(keyCode);
545 if (index >= 0) {
546 return device->keyCodeStates.valueAt(index);
547 }
548 }
549 return AKEY_STATE_UNKNOWN;
550 }
551
552 virtual int32_t getSwitchState(int32_t deviceId, int32_t sw) const {
553 Device* device = getDevice(deviceId);
554 if (device) {
555 ssize_t index = device->switchStates.indexOfKey(sw);
556 if (index >= 0) {
557 return device->switchStates.valueAt(index);
558 }
559 }
560 return AKEY_STATE_UNKNOWN;
561 }
562
563 virtual bool markSupportedKeyCodes(int32_t deviceId, size_t numCodes, const int32_t* keyCodes,
564 uint8_t* outFlags) const {
565 bool result = false;
566 Device* device = getDevice(deviceId);
567 if (device) {
568 for (size_t i = 0; i < numCodes; i++) {
569 for (size_t j = 0; j < device->keys.size(); j++) {
570 if (keyCodes[i] == device->keys.valueAt(j).keyCode) {
571 outFlags[i] = 1;
572 result = true;
573 }
574 }
575 }
576 }
577 return result;
578 }
579
580 virtual void dump(String8& dump) {
581 }
582};
583
584
585// --- FakeInputReaderContext ---
586
587class FakeInputReaderContext : public InputReaderContext {
588 sp<EventHubInterface> mEventHub;
589 sp<InputReaderPolicyInterface> mPolicy;
590 sp<InputDispatcherInterface> mDispatcher;
591 int32_t mGlobalMetaState;
592 bool mUpdateGlobalMetaStateWasCalled;
593
594public:
595 FakeInputReaderContext(const sp<EventHubInterface>& eventHub,
596 const sp<InputReaderPolicyInterface>& policy,
597 const sp<InputDispatcherInterface>& dispatcher) :
598 mEventHub(eventHub), mPolicy(policy), mDispatcher(dispatcher),
599 mGlobalMetaState(0) {
600 }
601
602 virtual ~FakeInputReaderContext() { }
603
604 void assertUpdateGlobalMetaStateWasCalled() {
605 ASSERT_TRUE(mUpdateGlobalMetaStateWasCalled)
606 << "Expected updateGlobalMetaState() to have been called.";
607 mUpdateGlobalMetaStateWasCalled = false;
608 }
609
610 void setGlobalMetaState(int32_t state) {
611 mGlobalMetaState = state;
612 }
613
614private:
615 virtual void updateGlobalMetaState() {
616 mUpdateGlobalMetaStateWasCalled = true;
617 }
618
619 virtual int32_t getGlobalMetaState() {
620 return mGlobalMetaState;
621 }
622
623 virtual EventHubInterface* getEventHub() {
624 return mEventHub.get();
625 }
626
627 virtual InputReaderPolicyInterface* getPolicy() {
628 return mPolicy.get();
629 }
630
631 virtual InputDispatcherInterface* getDispatcher() {
632 return mDispatcher.get();
633 }
634};
635
636
637// --- FakeInputMapper ---
638
639class FakeInputMapper : public InputMapper {
640 uint32_t mSources;
641 int32_t mKeyboardType;
642 int32_t mMetaState;
643 KeyedVector<int32_t, int32_t> mKeyCodeStates;
644 KeyedVector<int32_t, int32_t> mScanCodeStates;
645 KeyedVector<int32_t, int32_t> mSwitchStates;
646 Vector<int32_t> mSupportedKeyCodes;
647 RawEvent mLastEvent;
648
649 bool mConfigureWasCalled;
650 bool mResetWasCalled;
651 bool mProcessWasCalled;
652
653public:
654 FakeInputMapper(InputDevice* device, uint32_t sources) :
655 InputMapper(device),
656 mSources(sources), mKeyboardType(AINPUT_KEYBOARD_TYPE_NONE),
657 mMetaState(0),
658 mConfigureWasCalled(false), mResetWasCalled(false), mProcessWasCalled(false) {
659 }
660
661 virtual ~FakeInputMapper() { }
662
663 void setKeyboardType(int32_t keyboardType) {
664 mKeyboardType = keyboardType;
665 }
666
667 void setMetaState(int32_t metaState) {
668 mMetaState = metaState;
669 }
670
671 void assertConfigureWasCalled() {
672 ASSERT_TRUE(mConfigureWasCalled)
673 << "Expected configure() to have been called.";
674 mConfigureWasCalled = false;
675 }
676
677 void assertResetWasCalled() {
678 ASSERT_TRUE(mResetWasCalled)
679 << "Expected reset() to have been called.";
680 mResetWasCalled = false;
681 }
682
683 void assertProcessWasCalled(RawEvent* outLastEvent = NULL) {
684 ASSERT_TRUE(mProcessWasCalled)
685 << "Expected process() to have been called.";
686 if (outLastEvent) {
687 *outLastEvent = mLastEvent;
688 }
689 mProcessWasCalled = false;
690 }
691
692 void setKeyCodeState(int32_t keyCode, int32_t state) {
693 mKeyCodeStates.replaceValueFor(keyCode, state);
694 }
695
696 void setScanCodeState(int32_t scanCode, int32_t state) {
697 mScanCodeStates.replaceValueFor(scanCode, state);
698 }
699
700 void setSwitchState(int32_t switchCode, int32_t state) {
701 mSwitchStates.replaceValueFor(switchCode, state);
702 }
703
704 void addSupportedKeyCode(int32_t keyCode) {
705 mSupportedKeyCodes.add(keyCode);
706 }
707
708private:
709 virtual uint32_t getSources() {
710 return mSources;
711 }
712
713 virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo) {
714 InputMapper::populateDeviceInfo(deviceInfo);
715
716 if (mKeyboardType != AINPUT_KEYBOARD_TYPE_NONE) {
717 deviceInfo->setKeyboardType(mKeyboardType);
718 }
719 }
720
721 virtual void configure() {
722 mConfigureWasCalled = true;
723 }
724
725 virtual void reset() {
726 mResetWasCalled = true;
727 }
728
729 virtual void process(const RawEvent* rawEvent) {
730 mLastEvent = *rawEvent;
731 mProcessWasCalled = true;
732 }
733
734 virtual int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode) {
735 ssize_t index = mKeyCodeStates.indexOfKey(keyCode);
736 return index >= 0 ? mKeyCodeStates.valueAt(index) : AKEY_STATE_UNKNOWN;
737 }
738
739 virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode) {
740 ssize_t index = mScanCodeStates.indexOfKey(scanCode);
741 return index >= 0 ? mScanCodeStates.valueAt(index) : AKEY_STATE_UNKNOWN;
742 }
743
744 virtual int32_t getSwitchState(uint32_t sourceMask, int32_t switchCode) {
745 ssize_t index = mSwitchStates.indexOfKey(switchCode);
746 return index >= 0 ? mSwitchStates.valueAt(index) : AKEY_STATE_UNKNOWN;
747 }
748
749 virtual bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes,
750 const int32_t* keyCodes, uint8_t* outFlags) {
751 bool result = false;
752 for (size_t i = 0; i < numCodes; i++) {
753 for (size_t j = 0; j < mSupportedKeyCodes.size(); j++) {
754 if (keyCodes[i] == mSupportedKeyCodes[j]) {
755 outFlags[i] = 1;
756 result = true;
757 }
758 }
759 }
760 return result;
761 }
762
763 virtual int32_t getMetaState() {
764 return mMetaState;
765 }
766};
767
768
769// --- InstrumentedInputReader ---
770
771class InstrumentedInputReader : public InputReader {
772 InputDevice* mNextDevice;
773
774public:
775 InstrumentedInputReader(const sp<EventHubInterface>& eventHub,
776 const sp<InputReaderPolicyInterface>& policy,
777 const sp<InputDispatcherInterface>& dispatcher) :
778 InputReader(eventHub, policy, dispatcher) {
779 }
780
781 virtual ~InstrumentedInputReader() {
782 if (mNextDevice) {
783 delete mNextDevice;
784 }
785 }
786
787 void setNextDevice(InputDevice* device) {
788 mNextDevice = device;
789 }
790
791protected:
792 virtual InputDevice* createDevice(int32_t deviceId, const String8& name, uint32_t classes) {
793 if (mNextDevice) {
794 InputDevice* device = mNextDevice;
795 mNextDevice = NULL;
796 return device;
797 }
798 return InputReader::createDevice(deviceId, name, classes);
799 }
800
801 friend class InputReaderTest;
802};
803
804
805// --- InputReaderTest ---
806
807class InputReaderTest : public testing::Test {
808protected:
809 sp<FakeInputDispatcher> mFakeDispatcher;
810 sp<FakeInputReaderPolicy> mFakePolicy;
811 sp<FakeEventHub> mFakeEventHub;
812 sp<InstrumentedInputReader> mReader;
813
814 virtual void SetUp() {
815 mFakeEventHub = new FakeEventHub();
816 mFakePolicy = new FakeInputReaderPolicy();
817 mFakeDispatcher = new FakeInputDispatcher();
818
819 mReader = new InstrumentedInputReader(mFakeEventHub, mFakePolicy, mFakeDispatcher);
820 }
821
822 virtual void TearDown() {
823 mReader.clear();
824
825 mFakeDispatcher.clear();
826 mFakePolicy.clear();
827 mFakeEventHub.clear();
828 }
829
830 void addDevice(int32_t deviceId, const String8& name, uint32_t classes) {
831 mFakeEventHub->addDevice(deviceId, name, classes);
832 mFakeEventHub->finishDeviceScan();
833 mReader->loopOnce();
834 mReader->loopOnce();
835 mFakeEventHub->assertQueueIsEmpty();
836 }
837
838 FakeInputMapper* addDeviceWithFakeInputMapper(int32_t deviceId,
839 const String8& name, uint32_t classes, uint32_t sources) {
840 InputDevice* device = new InputDevice(mReader.get(), deviceId, name);
841 FakeInputMapper* mapper = new FakeInputMapper(device, sources);
842 device->addMapper(mapper);
843 mReader->setNextDevice(device);
844 addDevice(deviceId, name, classes);
845 return mapper;
846 }
847};
848
849TEST_F(InputReaderTest, GetInputConfiguration_WhenNoDevices_ReturnsDefaults) {
850 InputConfiguration config;
851 mReader->getInputConfiguration(&config);
852
853 ASSERT_EQ(InputConfiguration::KEYBOARD_NOKEYS, config.keyboard);
854 ASSERT_EQ(InputConfiguration::NAVIGATION_NONAV, config.navigation);
855 ASSERT_EQ(InputConfiguration::TOUCHSCREEN_NOTOUCH, config.touchScreen);
856}
857
858TEST_F(InputReaderTest, GetInputConfiguration_WhenAlphabeticKeyboardPresent_ReturnsQwertyKeyboard) {
859 ASSERT_NO_FATAL_FAILURE(addDevice(0, String8("keyboard"),
860 INPUT_DEVICE_CLASS_KEYBOARD | INPUT_DEVICE_CLASS_ALPHAKEY));
861
862 InputConfiguration config;
863 mReader->getInputConfiguration(&config);
864
865 ASSERT_EQ(InputConfiguration::KEYBOARD_QWERTY, config.keyboard);
866 ASSERT_EQ(InputConfiguration::NAVIGATION_NONAV, config.navigation);
867 ASSERT_EQ(InputConfiguration::TOUCHSCREEN_NOTOUCH, config.touchScreen);
868}
869
870TEST_F(InputReaderTest, GetInputConfiguration_WhenTouchScreenPresent_ReturnsFingerTouchScreen) {
871 ASSERT_NO_FATAL_FAILURE(addDevice(0, String8("touchscreen"),
872 INPUT_DEVICE_CLASS_TOUCHSCREEN));
873
874 InputConfiguration config;
875 mReader->getInputConfiguration(&config);
876
877 ASSERT_EQ(InputConfiguration::KEYBOARD_NOKEYS, config.keyboard);
878 ASSERT_EQ(InputConfiguration::NAVIGATION_NONAV, config.navigation);
879 ASSERT_EQ(InputConfiguration::TOUCHSCREEN_FINGER, config.touchScreen);
880}
881
882TEST_F(InputReaderTest, GetInputConfiguration_WhenTrackballPresent_ReturnsTrackballNavigation) {
883 ASSERT_NO_FATAL_FAILURE(addDevice(0, String8("trackball"),
884 INPUT_DEVICE_CLASS_TRACKBALL));
885
886 InputConfiguration config;
887 mReader->getInputConfiguration(&config);
888
889 ASSERT_EQ(InputConfiguration::KEYBOARD_NOKEYS, config.keyboard);
890 ASSERT_EQ(InputConfiguration::NAVIGATION_TRACKBALL, config.navigation);
891 ASSERT_EQ(InputConfiguration::TOUCHSCREEN_NOTOUCH, config.touchScreen);
892}
893
894TEST_F(InputReaderTest, GetInputConfiguration_WhenDPadPresent_ReturnsDPadNavigation) {
895 ASSERT_NO_FATAL_FAILURE(addDevice(0, String8("dpad"),
896 INPUT_DEVICE_CLASS_DPAD));
897
898 InputConfiguration config;
899 mReader->getInputConfiguration(&config);
900
901 ASSERT_EQ(InputConfiguration::KEYBOARD_NOKEYS, config.keyboard);
902 ASSERT_EQ(InputConfiguration::NAVIGATION_DPAD, config.navigation);
903 ASSERT_EQ(InputConfiguration::TOUCHSCREEN_NOTOUCH, config.touchScreen);
904}
905
906TEST_F(InputReaderTest, GetInputDeviceInfo_WhenDeviceIdIsValid) {
907 ASSERT_NO_FATAL_FAILURE(addDevice(1, String8("keyboard"),
908 INPUT_DEVICE_CLASS_KEYBOARD));
909
910 InputDeviceInfo info;
911 status_t result = mReader->getInputDeviceInfo(1, &info);
912
913 ASSERT_EQ(OK, result);
914 ASSERT_EQ(1, info.getId());
915 ASSERT_STREQ("keyboard", info.getName().string());
916 ASSERT_EQ(AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC, info.getKeyboardType());
917 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, info.getSources());
918 ASSERT_EQ(size_t(0), info.getMotionRanges().size());
919}
920
921TEST_F(InputReaderTest, GetInputDeviceInfo_WhenDeviceIdIsInvalid) {
922 InputDeviceInfo info;
923 status_t result = mReader->getInputDeviceInfo(-1, &info);
924
925 ASSERT_EQ(NAME_NOT_FOUND, result);
926}
927
928TEST_F(InputReaderTest, GetInputDeviceInfo_WhenDeviceIdIsIgnored) {
929 addDevice(1, String8("ignored"), 0); // no classes so device will be ignored
930
931 InputDeviceInfo info;
932 status_t result = mReader->getInputDeviceInfo(1, &info);
933
934 ASSERT_EQ(NAME_NOT_FOUND, result);
935}
936
937TEST_F(InputReaderTest, GetInputDeviceIds) {
938 ASSERT_NO_FATAL_FAILURE(addDevice(1, String8("keyboard"),
939 INPUT_DEVICE_CLASS_KEYBOARD | INPUT_DEVICE_CLASS_ALPHAKEY));
940 ASSERT_NO_FATAL_FAILURE(addDevice(2, String8("trackball"),
941 INPUT_DEVICE_CLASS_TRACKBALL));
942
943 Vector<int32_t> ids;
944 mReader->getInputDeviceIds(ids);
945
946 ASSERT_EQ(size_t(2), ids.size());
947 ASSERT_EQ(1, ids[0]);
948 ASSERT_EQ(2, ids[1]);
949}
950
951TEST_F(InputReaderTest, GetKeyCodeState_ForwardsRequestsToMappers) {
952 FakeInputMapper* mapper = NULL;
953 ASSERT_NO_FATAL_FAILURE(mapper = addDeviceWithFakeInputMapper(1, String8("fake"),
954 INPUT_DEVICE_CLASS_KEYBOARD, AINPUT_SOURCE_KEYBOARD));
955 mapper->setKeyCodeState(AKEYCODE_A, AKEY_STATE_DOWN);
956
957 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getKeyCodeState(0,
958 AINPUT_SOURCE_ANY, AKEYCODE_A))
959 << "Should return unknown when the device id is >= 0 but unknown.";
960
961 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getKeyCodeState(1,
962 AINPUT_SOURCE_TRACKBALL, AKEYCODE_A))
963 << "Should return unknown when the device id is valid but the sources are not supported by the device.";
964
965 ASSERT_EQ(AKEY_STATE_DOWN, mReader->getKeyCodeState(1,
966 AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, AKEYCODE_A))
967 << "Should return value provided by mapper when device id is valid and the device supports some of the sources.";
968
969 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getKeyCodeState(-1,
970 AINPUT_SOURCE_TRACKBALL, AKEYCODE_A))
971 << "Should return unknown when the device id is < 0 but the sources are not supported by any device.";
972
973 ASSERT_EQ(AKEY_STATE_DOWN, mReader->getKeyCodeState(-1,
974 AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, AKEYCODE_A))
975 << "Should return value provided by mapper when device id is < 0 and one of the devices supports some of the sources.";
976}
977
978TEST_F(InputReaderTest, GetScanCodeState_ForwardsRequestsToMappers) {
979 FakeInputMapper* mapper = NULL;
980 ASSERT_NO_FATAL_FAILURE(mapper = addDeviceWithFakeInputMapper(1, String8("fake"),
981 INPUT_DEVICE_CLASS_KEYBOARD, AINPUT_SOURCE_KEYBOARD));
982 mapper->setScanCodeState(KEY_A, AKEY_STATE_DOWN);
983
984 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getScanCodeState(0,
985 AINPUT_SOURCE_ANY, KEY_A))
986 << "Should return unknown when the device id is >= 0 but unknown.";
987
988 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getScanCodeState(1,
989 AINPUT_SOURCE_TRACKBALL, KEY_A))
990 << "Should return unknown when the device id is valid but the sources are not supported by the device.";
991
992 ASSERT_EQ(AKEY_STATE_DOWN, mReader->getScanCodeState(1,
993 AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, KEY_A))
994 << "Should return value provided by mapper when device id is valid and the device supports some of the sources.";
995
996 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getScanCodeState(-1,
997 AINPUT_SOURCE_TRACKBALL, KEY_A))
998 << "Should return unknown when the device id is < 0 but the sources are not supported by any device.";
999
1000 ASSERT_EQ(AKEY_STATE_DOWN, mReader->getScanCodeState(-1,
1001 AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, KEY_A))
1002 << "Should return value provided by mapper when device id is < 0 and one of the devices supports some of the sources.";
1003}
1004
1005TEST_F(InputReaderTest, GetSwitchState_ForwardsRequestsToMappers) {
1006 FakeInputMapper* mapper = NULL;
1007 ASSERT_NO_FATAL_FAILURE(mapper = addDeviceWithFakeInputMapper(1, String8("fake"),
1008 INPUT_DEVICE_CLASS_KEYBOARD, AINPUT_SOURCE_KEYBOARD));
1009 mapper->setSwitchState(SW_LID, AKEY_STATE_DOWN);
1010
1011 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getSwitchState(0,
1012 AINPUT_SOURCE_ANY, SW_LID))
1013 << "Should return unknown when the device id is >= 0 but unknown.";
1014
1015 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getSwitchState(1,
1016 AINPUT_SOURCE_TRACKBALL, SW_LID))
1017 << "Should return unknown when the device id is valid but the sources are not supported by the device.";
1018
1019 ASSERT_EQ(AKEY_STATE_DOWN, mReader->getSwitchState(1,
1020 AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, SW_LID))
1021 << "Should return value provided by mapper when device id is valid and the device supports some of the sources.";
1022
1023 ASSERT_EQ(AKEY_STATE_UNKNOWN, mReader->getSwitchState(-1,
1024 AINPUT_SOURCE_TRACKBALL, SW_LID))
1025 << "Should return unknown when the device id is < 0 but the sources are not supported by any device.";
1026
1027 ASSERT_EQ(AKEY_STATE_DOWN, mReader->getSwitchState(-1,
1028 AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, SW_LID))
1029 << "Should return value provided by mapper when device id is < 0 and one of the devices supports some of the sources.";
1030}
1031
1032TEST_F(InputReaderTest, MarkSupportedKeyCodes_ForwardsRequestsToMappers) {
1033 FakeInputMapper* mapper = NULL;
1034 ASSERT_NO_FATAL_FAILURE(mapper = addDeviceWithFakeInputMapper(1, String8("fake"),
1035 INPUT_DEVICE_CLASS_KEYBOARD, AINPUT_SOURCE_KEYBOARD));
1036 mapper->addSupportedKeyCode(AKEYCODE_A);
1037 mapper->addSupportedKeyCode(AKEYCODE_B);
1038
1039 const int32_t keyCodes[4] = { AKEYCODE_A, AKEYCODE_B, AKEYCODE_1, AKEYCODE_2 };
1040 uint8_t flags[4] = { 0, 0, 0, 1 };
1041
1042 ASSERT_FALSE(mReader->hasKeys(0, AINPUT_SOURCE_ANY, 4, keyCodes, flags))
1043 << "Should return false when device id is >= 0 but unknown.";
1044 ASSERT_TRUE(!flags[0] && !flags[1] && !flags[2] && !flags[3]);
1045
1046 flags[3] = 1;
1047 ASSERT_FALSE(mReader->hasKeys(1, AINPUT_SOURCE_TRACKBALL, 4, keyCodes, flags))
1048 << "Should return false when device id is valid but the sources are not supported by the device.";
1049 ASSERT_TRUE(!flags[0] && !flags[1] && !flags[2] && !flags[3]);
1050
1051 flags[3] = 1;
1052 ASSERT_TRUE(mReader->hasKeys(1, AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, 4, keyCodes, flags))
1053 << "Should return value provided by mapper when device id is valid and the device supports some of the sources.";
1054 ASSERT_TRUE(flags[0] && flags[1] && !flags[2] && !flags[3]);
1055
1056 flags[3] = 1;
1057 ASSERT_FALSE(mReader->hasKeys(-1, AINPUT_SOURCE_TRACKBALL, 4, keyCodes, flags))
1058 << "Should return false when the device id is < 0 but the sources are not supported by any device.";
1059 ASSERT_TRUE(!flags[0] && !flags[1] && !flags[2] && !flags[3]);
1060
1061 flags[3] = 1;
1062 ASSERT_TRUE(mReader->hasKeys(-1, AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TRACKBALL, 4, keyCodes, flags))
1063 << "Should return value provided by mapper when device id is < 0 and one of the devices supports some of the sources.";
1064 ASSERT_TRUE(flags[0] && flags[1] && !flags[2] && !flags[3]);
1065}
1066
1067TEST_F(InputReaderTest, LoopOnce_WhenDeviceScanFinished_SendsConfigurationChanged) {
1068 addDevice(1, String8("ignored"), INPUT_DEVICE_CLASS_KEYBOARD);
1069
1070 FakeInputDispatcher::NotifyConfigurationChangedArgs args;
1071 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyConfigurationChangedWasCalled(&args));
1072 ASSERT_EQ(ARBITRARY_TIME, args.eventTime);
1073}
1074
1075TEST_F(InputReaderTest, LoopOnce_ForwardsRawEventsToMappers) {
1076 FakeInputMapper* mapper = NULL;
1077 ASSERT_NO_FATAL_FAILURE(mapper = addDeviceWithFakeInputMapper(1, String8("fake"),
1078 INPUT_DEVICE_CLASS_KEYBOARD, AINPUT_SOURCE_KEYBOARD));
1079
1080 mFakeEventHub->enqueueEvent(0, 1, EV_KEY, KEY_A, AKEYCODE_A, 1, POLICY_FLAG_WAKE);
1081 mReader->loopOnce();
1082 ASSERT_NO_FATAL_FAILURE(mFakeEventHub->assertQueueIsEmpty());
1083
1084 RawEvent event;
1085 ASSERT_NO_FATAL_FAILURE(mapper->assertProcessWasCalled(&event));
1086 ASSERT_EQ(0, event.when);
1087 ASSERT_EQ(1, event.deviceId);
1088 ASSERT_EQ(EV_KEY, event.type);
1089 ASSERT_EQ(KEY_A, event.scanCode);
1090 ASSERT_EQ(AKEYCODE_A, event.keyCode);
1091 ASSERT_EQ(1, event.value);
1092 ASSERT_EQ(POLICY_FLAG_WAKE, event.flags);
1093}
1094
1095
1096// --- InputDeviceTest ---
1097
1098class InputDeviceTest : public testing::Test {
1099protected:
1100 static const char* DEVICE_NAME;
1101 static const int32_t DEVICE_ID;
1102
1103 sp<FakeEventHub> mFakeEventHub;
1104 sp<FakeInputReaderPolicy> mFakePolicy;
1105 sp<FakeInputDispatcher> mFakeDispatcher;
1106 FakeInputReaderContext* mFakeContext;
1107
1108 InputDevice* mDevice;
1109
1110 virtual void SetUp() {
1111 mFakeEventHub = new FakeEventHub();
1112 mFakePolicy = new FakeInputReaderPolicy();
1113 mFakeDispatcher = new FakeInputDispatcher();
1114 mFakeContext = new FakeInputReaderContext(mFakeEventHub, mFakePolicy, mFakeDispatcher);
1115
1116 mDevice = new InputDevice(mFakeContext, DEVICE_ID, String8(DEVICE_NAME));
1117 }
1118
1119 virtual void TearDown() {
1120 delete mDevice;
1121
1122 delete mFakeContext;
1123 mFakeDispatcher.clear();
1124 mFakePolicy.clear();
1125 mFakeEventHub.clear();
1126 }
1127};
1128
1129const char* InputDeviceTest::DEVICE_NAME = "device";
1130const int32_t InputDeviceTest::DEVICE_ID = 1;
1131
1132TEST_F(InputDeviceTest, ImmutableProperties) {
1133 ASSERT_EQ(DEVICE_ID, mDevice->getId());
1134 ASSERT_STREQ(DEVICE_NAME, mDevice->getName());
1135}
1136
1137TEST_F(InputDeviceTest, WhenNoMappersAreRegistered_DeviceIsIgnored) {
1138 // Configuration.
1139 mDevice->configure();
1140
1141 // Metadata.
1142 ASSERT_TRUE(mDevice->isIgnored());
1143 ASSERT_EQ(AINPUT_SOURCE_UNKNOWN, mDevice->getSources());
1144
1145 InputDeviceInfo info;
1146 mDevice->getDeviceInfo(&info);
1147 ASSERT_EQ(DEVICE_ID, info.getId());
1148 ASSERT_STREQ(DEVICE_NAME, info.getName().string());
1149 ASSERT_EQ(AINPUT_KEYBOARD_TYPE_NONE, info.getKeyboardType());
1150 ASSERT_EQ(AINPUT_SOURCE_UNKNOWN, info.getSources());
1151
1152 // State queries.
1153 ASSERT_EQ(0, mDevice->getMetaState());
1154
1155 ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getKeyCodeState(AINPUT_SOURCE_KEYBOARD, 0))
1156 << "Ignored device should return unknown key code state.";
1157 ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getScanCodeState(AINPUT_SOURCE_KEYBOARD, 0))
1158 << "Ignored device should return unknown scan code state.";
1159 ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getSwitchState(AINPUT_SOURCE_KEYBOARD, 0))
1160 << "Ignored device should return unknown switch state.";
1161
1162 const int32_t keyCodes[2] = { AKEYCODE_A, AKEYCODE_B };
1163 uint8_t flags[2] = { 0, 1 };
1164 ASSERT_FALSE(mDevice->markSupportedKeyCodes(AINPUT_SOURCE_KEYBOARD, 2, keyCodes, flags))
1165 << "Ignored device should never mark any key codes.";
1166 ASSERT_EQ(0, flags[0]) << "Flag for unsupported key should be unchanged.";
1167 ASSERT_EQ(1, flags[1]) << "Flag for unsupported key should be unchanged.";
1168
1169 // Reset.
1170 mDevice->reset();
1171}
1172
1173TEST_F(InputDeviceTest, WhenMappersAreRegistered_DeviceIsNotIgnoredAndForwardsRequestsToMappers) {
1174 // Configuration.
1175 InputDeviceCalibration calibration;
1176 calibration.addProperty(String8("key"), String8("value"));
1177 mFakePolicy->addInputDeviceCalibration(String8(DEVICE_NAME), calibration);
1178
1179 FakeInputMapper* mapper1 = new FakeInputMapper(mDevice, AINPUT_SOURCE_KEYBOARD);
1180 mapper1->setKeyboardType(AINPUT_KEYBOARD_TYPE_ALPHABETIC);
1181 mapper1->setMetaState(AMETA_ALT_ON);
1182 mapper1->addSupportedKeyCode(AKEYCODE_A);
1183 mapper1->addSupportedKeyCode(AKEYCODE_B);
1184 mapper1->setKeyCodeState(AKEYCODE_A, AKEY_STATE_DOWN);
1185 mapper1->setKeyCodeState(AKEYCODE_B, AKEY_STATE_UP);
1186 mapper1->setScanCodeState(2, AKEY_STATE_DOWN);
1187 mapper1->setScanCodeState(3, AKEY_STATE_UP);
1188 mapper1->setSwitchState(4, AKEY_STATE_DOWN);
1189 mDevice->addMapper(mapper1);
1190
1191 FakeInputMapper* mapper2 = new FakeInputMapper(mDevice, AINPUT_SOURCE_TOUCHSCREEN);
1192 mapper2->setMetaState(AMETA_SHIFT_ON);
1193 mDevice->addMapper(mapper2);
1194
1195 mDevice->configure();
1196
1197 String8 propertyValue;
1198 ASSERT_TRUE(mDevice->getCalibration().tryGetProperty(String8("key"), propertyValue))
1199 << "Device should have read calibration during configuration phase.";
1200 ASSERT_STREQ("value", propertyValue.string());
1201
1202 ASSERT_NO_FATAL_FAILURE(mapper1->assertConfigureWasCalled());
1203 ASSERT_NO_FATAL_FAILURE(mapper2->assertConfigureWasCalled());
1204
1205 // Metadata.
1206 ASSERT_FALSE(mDevice->isIgnored());
1207 ASSERT_EQ(uint32_t(AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TOUCHSCREEN), mDevice->getSources());
1208
1209 InputDeviceInfo info;
1210 mDevice->getDeviceInfo(&info);
1211 ASSERT_EQ(DEVICE_ID, info.getId());
1212 ASSERT_STREQ(DEVICE_NAME, info.getName().string());
1213 ASSERT_EQ(AINPUT_KEYBOARD_TYPE_ALPHABETIC, info.getKeyboardType());
1214 ASSERT_EQ(uint32_t(AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_TOUCHSCREEN), info.getSources());
1215
1216 // State queries.
1217 ASSERT_EQ(AMETA_ALT_ON | AMETA_SHIFT_ON, mDevice->getMetaState())
1218 << "Should query mappers and combine meta states.";
1219
1220 ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getKeyCodeState(AINPUT_SOURCE_TRACKBALL, AKEYCODE_A))
1221 << "Should return unknown key code state when source not supported.";
1222 ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getScanCodeState(AINPUT_SOURCE_TRACKBALL, AKEYCODE_A))
1223 << "Should return unknown scan code state when source not supported.";
1224 ASSERT_EQ(AKEY_STATE_UNKNOWN, mDevice->getSwitchState(AINPUT_SOURCE_TRACKBALL, AKEYCODE_A))
1225 << "Should return unknown switch state when source not supported.";
1226
1227 ASSERT_EQ(AKEY_STATE_DOWN, mDevice->getKeyCodeState(AINPUT_SOURCE_KEYBOARD, AKEYCODE_A))
1228 << "Should query mapper when source is supported.";
1229 ASSERT_EQ(AKEY_STATE_UP, mDevice->getScanCodeState(AINPUT_SOURCE_KEYBOARD, 3))
1230 << "Should query mapper when source is supported.";
1231 ASSERT_EQ(AKEY_STATE_DOWN, mDevice->getSwitchState(AINPUT_SOURCE_KEYBOARD, 4))
1232 << "Should query mapper when source is supported.";
1233
1234 const int32_t keyCodes[4] = { AKEYCODE_A, AKEYCODE_B, AKEYCODE_1, AKEYCODE_2 };
1235 uint8_t flags[4] = { 0, 0, 0, 1 };
1236 ASSERT_FALSE(mDevice->markSupportedKeyCodes(AINPUT_SOURCE_TRACKBALL, 4, keyCodes, flags))
1237 << "Should do nothing when source is unsupported.";
1238 ASSERT_EQ(0, flags[0]) << "Flag should be unchanged when source is unsupported.";
1239 ASSERT_EQ(0, flags[1]) << "Flag should be unchanged when source is unsupported.";
1240 ASSERT_EQ(0, flags[2]) << "Flag should be unchanged when source is unsupported.";
1241 ASSERT_EQ(1, flags[3]) << "Flag should be unchanged when source is unsupported.";
1242
1243 ASSERT_TRUE(mDevice->markSupportedKeyCodes(AINPUT_SOURCE_KEYBOARD, 4, keyCodes, flags))
1244 << "Should query mapper when source is supported.";
1245 ASSERT_EQ(1, flags[0]) << "Flag for supported key should be set.";
1246 ASSERT_EQ(1, flags[1]) << "Flag for supported key should be set.";
1247 ASSERT_EQ(0, flags[2]) << "Flag for unsupported key should be unchanged.";
1248 ASSERT_EQ(1, flags[3]) << "Flag for unsupported key should be unchanged.";
1249
1250 // Event handling.
1251 RawEvent event;
1252 mDevice->process(&event);
1253
1254 ASSERT_NO_FATAL_FAILURE(mapper1->assertProcessWasCalled());
1255 ASSERT_NO_FATAL_FAILURE(mapper2->assertProcessWasCalled());
1256
1257 // Reset.
1258 mDevice->reset();
1259
1260 ASSERT_NO_FATAL_FAILURE(mapper1->assertResetWasCalled());
1261 ASSERT_NO_FATAL_FAILURE(mapper2->assertResetWasCalled());
1262}
1263
1264
1265// --- InputMapperTest ---
1266
1267class InputMapperTest : public testing::Test {
1268protected:
1269 static const char* DEVICE_NAME;
1270 static const int32_t DEVICE_ID;
1271
1272 sp<FakeEventHub> mFakeEventHub;
1273 sp<FakeInputReaderPolicy> mFakePolicy;
1274 sp<FakeInputDispatcher> mFakeDispatcher;
1275 FakeInputReaderContext* mFakeContext;
1276 InputDevice* mDevice;
1277
1278 virtual void SetUp() {
1279 mFakeEventHub = new FakeEventHub();
1280 mFakePolicy = new FakeInputReaderPolicy();
1281 mFakeDispatcher = new FakeInputDispatcher();
1282 mFakeContext = new FakeInputReaderContext(mFakeEventHub, mFakePolicy, mFakeDispatcher);
1283 mDevice = new InputDevice(mFakeContext, DEVICE_ID, String8(DEVICE_NAME));
1284
1285 mFakeEventHub->addDevice(DEVICE_ID, String8(DEVICE_NAME), 0);
1286 }
1287
1288 virtual void TearDown() {
1289 delete mDevice;
1290 delete mFakeContext;
1291 mFakeDispatcher.clear();
1292 mFakePolicy.clear();
1293 mFakeEventHub.clear();
1294 }
1295
1296 void prepareCalibration(const char* key, const char* value) {
1297 mFakePolicy->addInputDeviceCalibrationProperty(String8(DEVICE_NAME),
1298 String8(key), String8(value));
1299 }
1300
1301 void addMapperAndConfigure(InputMapper* mapper) {
1302 mDevice->addMapper(mapper);
1303 mDevice->configure();
1304 }
1305
1306 static void process(InputMapper* mapper, nsecs_t when, int32_t deviceId, int32_t type,
1307 int32_t scanCode, int32_t keyCode, int32_t value, uint32_t flags) {
1308 RawEvent event;
1309 event.when = when;
1310 event.deviceId = deviceId;
1311 event.type = type;
1312 event.scanCode = scanCode;
1313 event.keyCode = keyCode;
1314 event.value = value;
1315 event.flags = flags;
1316 mapper->process(&event);
1317 }
1318
1319 static void assertMotionRange(const InputDeviceInfo& info,
1320 int32_t rangeType, float min, float max, float flat, float fuzz) {
1321 const InputDeviceInfo::MotionRange* range = info.getMotionRange(rangeType);
1322 ASSERT_TRUE(range != NULL) << "Range: " << rangeType;
1323 ASSERT_NEAR(min, range->min, EPSILON) << "Range: " << rangeType;
1324 ASSERT_NEAR(max, range->max, EPSILON) << "Range: " << rangeType;
1325 ASSERT_NEAR(flat, range->flat, EPSILON) << "Range: " << rangeType;
1326 ASSERT_NEAR(fuzz, range->fuzz, EPSILON) << "Range: " << rangeType;
1327 }
1328
1329 static void assertPointerCoords(const PointerCoords& coords,
1330 float x, float y, float pressure, float size,
1331 float touchMajor, float touchMinor, float toolMajor, float toolMinor,
1332 float orientation) {
1333 ASSERT_NEAR(x, coords.x, 1);
1334 ASSERT_NEAR(y, coords.y, 1);
1335 ASSERT_NEAR(pressure, coords.pressure, EPSILON);
1336 ASSERT_NEAR(size, coords.size, EPSILON);
1337 ASSERT_NEAR(touchMajor, coords.touchMajor, 1);
1338 ASSERT_NEAR(touchMinor, coords.touchMinor, 1);
1339 ASSERT_NEAR(toolMajor, coords.toolMajor, 1);
1340 ASSERT_NEAR(toolMinor, coords.toolMinor, 1);
1341 ASSERT_NEAR(orientation, coords.orientation, EPSILON);
1342 }
1343};
1344
1345const char* InputMapperTest::DEVICE_NAME = "device";
1346const int32_t InputMapperTest::DEVICE_ID = 1;
1347
1348
1349// --- SwitchInputMapperTest ---
1350
1351class SwitchInputMapperTest : public InputMapperTest {
1352protected:
1353};
1354
1355TEST_F(SwitchInputMapperTest, GetSources) {
1356 SwitchInputMapper* mapper = new SwitchInputMapper(mDevice);
1357 addMapperAndConfigure(mapper);
1358
1359 ASSERT_EQ(uint32_t(0), mapper->getSources());
1360}
1361
1362TEST_F(SwitchInputMapperTest, GetSwitchState) {
1363 SwitchInputMapper* mapper = new SwitchInputMapper(mDevice);
1364 addMapperAndConfigure(mapper);
1365
1366 mFakeEventHub->setSwitchState(DEVICE_ID, SW_LID, 1);
1367 ASSERT_EQ(1, mapper->getSwitchState(AINPUT_SOURCE_ANY, SW_LID));
1368
1369 mFakeEventHub->setSwitchState(DEVICE_ID, SW_LID, 0);
1370 ASSERT_EQ(0, mapper->getSwitchState(AINPUT_SOURCE_ANY, SW_LID));
1371}
1372
1373TEST_F(SwitchInputMapperTest, Process) {
1374 SwitchInputMapper* mapper = new SwitchInputMapper(mDevice);
1375 addMapperAndConfigure(mapper);
1376
1377 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SW, SW_LID, 0, 1, 0);
1378
1379 FakeInputDispatcher::NotifySwitchArgs args;
1380 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifySwitchWasCalled(&args));
1381 ASSERT_EQ(ARBITRARY_TIME, args.when);
1382 ASSERT_EQ(SW_LID, args.switchCode);
1383 ASSERT_EQ(1, args.switchValue);
1384 ASSERT_EQ(uint32_t(0), args.policyFlags);
1385}
1386
1387
1388// --- KeyboardInputMapperTest ---
1389
1390class KeyboardInputMapperTest : public InputMapperTest {
1391protected:
1392 void testDPadKeyRotation(KeyboardInputMapper* mapper,
1393 int32_t originalScanCode, int32_t originalKeyCode, int32_t rotatedKeyCode);
1394};
1395
1396void KeyboardInputMapperTest::testDPadKeyRotation(KeyboardInputMapper* mapper,
1397 int32_t originalScanCode, int32_t originalKeyCode, int32_t rotatedKeyCode) {
1398 FakeInputDispatcher::NotifyKeyArgs args;
1399
1400 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, originalScanCode, originalKeyCode, 1, 0);
1401 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
1402 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, args.action);
1403 ASSERT_EQ(originalScanCode, args.scanCode);
1404 ASSERT_EQ(rotatedKeyCode, args.keyCode);
1405
1406 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, originalScanCode, originalKeyCode, 0, 0);
1407 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
1408 ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action);
1409 ASSERT_EQ(originalScanCode, args.scanCode);
1410 ASSERT_EQ(rotatedKeyCode, args.keyCode);
1411}
1412
1413
1414TEST_F(KeyboardInputMapperTest, GetSources) {
1415 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, -1,
1416 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
1417 addMapperAndConfigure(mapper);
1418
1419 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, mapper->getSources());
1420}
1421
1422TEST_F(KeyboardInputMapperTest, Process_SimpleKeyPress) {
1423 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, -1,
1424 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
1425 addMapperAndConfigure(mapper);
1426
1427 // Key down.
1428 process(mapper, ARBITRARY_TIME, DEVICE_ID,
1429 EV_KEY, KEY_HOME, AKEYCODE_HOME, 1, POLICY_FLAG_WAKE);
1430 FakeInputDispatcher::NotifyKeyArgs args;
1431 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
1432 ASSERT_EQ(DEVICE_ID, args.deviceId);
1433 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source);
1434 ASSERT_EQ(ARBITRARY_TIME, args.eventTime);
1435 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, args.action);
1436 ASSERT_EQ(AKEYCODE_HOME, args.keyCode);
1437 ASSERT_EQ(KEY_HOME, args.scanCode);
1438 ASSERT_EQ(AMETA_NONE, args.metaState);
1439 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, args.flags);
1440 ASSERT_EQ(POLICY_FLAG_WAKE, args.policyFlags);
1441 ASSERT_EQ(ARBITRARY_TIME, args.downTime);
1442
1443 // Key up.
1444 process(mapper, ARBITRARY_TIME + 1, DEVICE_ID,
1445 EV_KEY, KEY_HOME, AKEYCODE_HOME, 0, POLICY_FLAG_WAKE);
1446 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
1447 ASSERT_EQ(DEVICE_ID, args.deviceId);
1448 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source);
1449 ASSERT_EQ(ARBITRARY_TIME + 1, args.eventTime);
1450 ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action);
1451 ASSERT_EQ(AKEYCODE_HOME, args.keyCode);
1452 ASSERT_EQ(KEY_HOME, args.scanCode);
1453 ASSERT_EQ(AMETA_NONE, args.metaState);
1454 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, args.flags);
1455 ASSERT_EQ(POLICY_FLAG_WAKE, args.policyFlags);
1456 ASSERT_EQ(ARBITRARY_TIME, args.downTime);
1457}
1458
1459TEST_F(KeyboardInputMapperTest, Reset_WhenKeysAreNotDown_DoesNotSynthesizeKeyUp) {
1460 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, -1,
1461 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
1462 addMapperAndConfigure(mapper);
1463
1464 // Key down.
1465 process(mapper, ARBITRARY_TIME, DEVICE_ID,
1466 EV_KEY, KEY_HOME, AKEYCODE_HOME, 1, POLICY_FLAG_WAKE);
1467 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
1468
1469 // Key up.
1470 process(mapper, ARBITRARY_TIME, DEVICE_ID,
1471 EV_KEY, KEY_HOME, AKEYCODE_HOME, 0, POLICY_FLAG_WAKE);
1472 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
1473
1474 // Reset. Since no keys still down, should not synthesize any key ups.
1475 mapper->reset();
1476 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled());
1477}
1478
1479TEST_F(KeyboardInputMapperTest, Reset_WhenKeysAreDown_SynthesizesKeyUps) {
1480 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, -1,
1481 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
1482 addMapperAndConfigure(mapper);
1483
1484 // Metakey down.
1485 process(mapper, ARBITRARY_TIME, DEVICE_ID,
1486 EV_KEY, KEY_LEFTSHIFT, AKEYCODE_SHIFT_LEFT, 1, 0);
1487 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
1488
1489 // Key down.
1490 process(mapper, ARBITRARY_TIME + 1, DEVICE_ID,
1491 EV_KEY, KEY_A, AKEYCODE_A, 1, 0);
1492 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
1493
1494 // Reset. Since two keys are still down, should synthesize two key ups in reverse order.
1495 mapper->reset();
1496
1497 FakeInputDispatcher::NotifyKeyArgs args;
1498 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
1499 ASSERT_EQ(DEVICE_ID, args.deviceId);
1500 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source);
1501 ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action);
1502 ASSERT_EQ(AKEYCODE_A, args.keyCode);
1503 ASSERT_EQ(KEY_A, args.scanCode);
1504 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
1505 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, args.flags);
1506 ASSERT_EQ(uint32_t(0), args.policyFlags);
1507 ASSERT_EQ(ARBITRARY_TIME + 1, args.downTime);
1508
1509 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
1510 ASSERT_EQ(DEVICE_ID, args.deviceId);
1511 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source);
1512 ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action);
1513 ASSERT_EQ(AKEYCODE_SHIFT_LEFT, args.keyCode);
1514 ASSERT_EQ(KEY_LEFTSHIFT, args.scanCode);
1515 ASSERT_EQ(AMETA_NONE, args.metaState);
1516 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, args.flags);
1517 ASSERT_EQ(uint32_t(0), args.policyFlags);
1518 ASSERT_EQ(ARBITRARY_TIME + 1, args.downTime);
1519
1520 // And that's it.
1521 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled());
1522}
1523
1524TEST_F(KeyboardInputMapperTest, Process_ShouldUpdateMetaState) {
1525 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, -1,
1526 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
1527 addMapperAndConfigure(mapper);
1528
1529 // Initial metastate.
1530 ASSERT_EQ(AMETA_NONE, mapper->getMetaState());
1531
1532 // Metakey down.
1533 process(mapper, ARBITRARY_TIME, DEVICE_ID,
1534 EV_KEY, KEY_LEFTSHIFT, AKEYCODE_SHIFT_LEFT, 1, 0);
1535 FakeInputDispatcher::NotifyKeyArgs args;
1536 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
1537 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
1538 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, mapper->getMetaState());
1539 ASSERT_NO_FATAL_FAILURE(mFakeContext->assertUpdateGlobalMetaStateWasCalled());
1540
1541 // Key down.
1542 process(mapper, ARBITRARY_TIME + 1, DEVICE_ID,
1543 EV_KEY, KEY_A, AKEYCODE_A, 1, 0);
1544 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
1545 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
1546 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, mapper->getMetaState());
1547
1548 // Key up.
1549 process(mapper, ARBITRARY_TIME + 2, DEVICE_ID,
1550 EV_KEY, KEY_A, AKEYCODE_A, 0, 0);
1551 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
1552 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
1553 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, mapper->getMetaState());
1554
1555 // Metakey up.
1556 process(mapper, ARBITRARY_TIME + 3, DEVICE_ID,
1557 EV_KEY, KEY_LEFTSHIFT, AKEYCODE_SHIFT_LEFT, 0, 0);
1558 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
1559 ASSERT_EQ(AMETA_NONE, args.metaState);
1560 ASSERT_EQ(AMETA_NONE, mapper->getMetaState());
1561 ASSERT_NO_FATAL_FAILURE(mFakeContext->assertUpdateGlobalMetaStateWasCalled());
1562}
1563
1564TEST_F(KeyboardInputMapperTest, Process_WhenNotAttachedToDisplay_ShouldNotRotateDPad) {
1565 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, -1,
1566 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
1567 addMapperAndConfigure(mapper);
1568
1569 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1570 KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_UP));
1571 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1572 KEY_RIGHT, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_RIGHT));
1573 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1574 KEY_DOWN, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_DOWN));
1575 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1576 KEY_LEFT, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_LEFT));
1577}
1578
1579TEST_F(KeyboardInputMapperTest, Process_WhenAttachedToDisplay_ShouldRotateDPad) {
1580 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, DISPLAY_ID,
1581 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
1582 addMapperAndConfigure(mapper);
1583
1584 mFakePolicy->setDisplayInfo(DISPLAY_ID,
1585 DISPLAY_WIDTH, DISPLAY_HEIGHT,
1586 InputReaderPolicyInterface::ROTATION_0);
1587 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1588 KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_UP));
1589 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1590 KEY_RIGHT, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_RIGHT));
1591 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1592 KEY_DOWN, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_DOWN));
1593 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1594 KEY_LEFT, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_LEFT));
1595
1596 mFakePolicy->setDisplayInfo(DISPLAY_ID,
1597 DISPLAY_WIDTH, DISPLAY_HEIGHT,
1598 InputReaderPolicyInterface::ROTATION_90);
1599 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1600 KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_LEFT));
1601 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1602 KEY_RIGHT, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_UP));
1603 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1604 KEY_DOWN, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_RIGHT));
1605 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1606 KEY_LEFT, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_DOWN));
1607
1608 mFakePolicy->setDisplayInfo(DISPLAY_ID,
1609 DISPLAY_WIDTH, DISPLAY_HEIGHT,
1610 InputReaderPolicyInterface::ROTATION_180);
1611 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1612 KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_DOWN));
1613 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1614 KEY_RIGHT, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_LEFT));
1615 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1616 KEY_DOWN, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_UP));
1617 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1618 KEY_LEFT, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_RIGHT));
1619
1620 mFakePolicy->setDisplayInfo(DISPLAY_ID,
1621 DISPLAY_WIDTH, DISPLAY_HEIGHT,
1622 InputReaderPolicyInterface::ROTATION_270);
1623 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1624 KEY_UP, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_RIGHT));
1625 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1626 KEY_RIGHT, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_DOWN));
1627 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1628 KEY_DOWN, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_LEFT));
1629 ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper,
1630 KEY_LEFT, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_UP));
1631
1632 // Special case: if orientation changes while key is down, we still emit the same keycode
1633 // in the key up as we did in the key down.
1634 FakeInputDispatcher::NotifyKeyArgs args;
1635
1636 mFakePolicy->setDisplayInfo(DISPLAY_ID,
1637 DISPLAY_WIDTH, DISPLAY_HEIGHT,
1638 InputReaderPolicyInterface::ROTATION_270);
1639 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, KEY_UP, AKEYCODE_DPAD_UP, 1, 0);
1640 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
1641 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, args.action);
1642 ASSERT_EQ(KEY_UP, args.scanCode);
1643 ASSERT_EQ(AKEYCODE_DPAD_RIGHT, args.keyCode);
1644
1645 mFakePolicy->setDisplayInfo(DISPLAY_ID,
1646 DISPLAY_WIDTH, DISPLAY_HEIGHT,
1647 InputReaderPolicyInterface::ROTATION_180);
1648 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, KEY_UP, AKEYCODE_DPAD_UP, 0, 0);
1649 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
1650 ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action);
1651 ASSERT_EQ(KEY_UP, args.scanCode);
1652 ASSERT_EQ(AKEYCODE_DPAD_RIGHT, args.keyCode);
1653}
1654
1655TEST_F(KeyboardInputMapperTest, GetKeyCodeState) {
1656 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, -1,
1657 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
1658 addMapperAndConfigure(mapper);
1659
1660 mFakeEventHub->setKeyCodeState(DEVICE_ID, AKEYCODE_A, 1);
1661 ASSERT_EQ(1, mapper->getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_A));
1662
1663 mFakeEventHub->setKeyCodeState(DEVICE_ID, AKEYCODE_A, 0);
1664 ASSERT_EQ(0, mapper->getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_A));
1665}
1666
1667TEST_F(KeyboardInputMapperTest, GetScanCodeState) {
1668 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, -1,
1669 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
1670 addMapperAndConfigure(mapper);
1671
1672 mFakeEventHub->setScanCodeState(DEVICE_ID, KEY_A, 1);
1673 ASSERT_EQ(1, mapper->getScanCodeState(AINPUT_SOURCE_ANY, KEY_A));
1674
1675 mFakeEventHub->setScanCodeState(DEVICE_ID, KEY_A, 0);
1676 ASSERT_EQ(0, mapper->getScanCodeState(AINPUT_SOURCE_ANY, KEY_A));
1677}
1678
1679TEST_F(KeyboardInputMapperTest, MarkSupportedKeyCodes) {
1680 KeyboardInputMapper* mapper = new KeyboardInputMapper(mDevice, -1,
1681 AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC);
1682 addMapperAndConfigure(mapper);
1683
1684 mFakeEventHub->addKey(DEVICE_ID, KEY_A, AKEYCODE_A, 0);
1685
1686 const int32_t keyCodes[2] = { AKEYCODE_A, AKEYCODE_B };
1687 uint8_t flags[2] = { 0, 0 };
1688 ASSERT_TRUE(mapper->markSupportedKeyCodes(AINPUT_SOURCE_ANY, 1, keyCodes, flags));
1689 ASSERT_TRUE(flags[0]);
1690 ASSERT_FALSE(flags[1]);
1691}
1692
1693
1694// --- TrackballInputMapperTest ---
1695
1696class TrackballInputMapperTest : public InputMapperTest {
1697protected:
1698 static const int32_t TRACKBALL_MOVEMENT_THRESHOLD;
1699
1700 void testMotionRotation(TrackballInputMapper* mapper,
1701 int32_t originalX, int32_t originalY, int32_t rotatedX, int32_t rotatedY);
1702};
1703
1704const int32_t TrackballInputMapperTest::TRACKBALL_MOVEMENT_THRESHOLD = 6;
1705
1706void TrackballInputMapperTest::testMotionRotation(TrackballInputMapper* mapper,
1707 int32_t originalX, int32_t originalY, int32_t rotatedX, int32_t rotatedY) {
1708 FakeInputDispatcher::NotifyMotionArgs args;
1709
1710 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_X, 0, originalX, 0);
1711 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_Y, 0, originalY, 0);
1712 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0, 0, 0);
1713 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
1714 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
1715 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
1716 float(rotatedX) / TRACKBALL_MOVEMENT_THRESHOLD,
1717 float(rotatedY) / TRACKBALL_MOVEMENT_THRESHOLD,
1718 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
1719}
1720
1721TEST_F(TrackballInputMapperTest, GetSources) {
1722 TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, -1);
1723 addMapperAndConfigure(mapper);
1724
1725 ASSERT_EQ(AINPUT_SOURCE_TRACKBALL, mapper->getSources());
1726}
1727
1728TEST_F(TrackballInputMapperTest, PopulateDeviceInfo) {
1729 TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, -1);
1730 addMapperAndConfigure(mapper);
1731
1732 InputDeviceInfo info;
1733 mapper->populateDeviceInfo(&info);
1734
1735 ASSERT_NO_FATAL_FAILURE(assertMotionRange(info, AINPUT_MOTION_RANGE_X,
1736 -1.0f, 1.0f, 0.0f, 1.0f / TRACKBALL_MOVEMENT_THRESHOLD));
1737 ASSERT_NO_FATAL_FAILURE(assertMotionRange(info, AINPUT_MOTION_RANGE_Y,
1738 -1.0f, 1.0f, 0.0f, 1.0f / TRACKBALL_MOVEMENT_THRESHOLD));
1739}
1740
1741TEST_F(TrackballInputMapperTest, Process_ShouldSetAllFieldsAndIncludeGlobalMetaState) {
1742 TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, -1);
1743 addMapperAndConfigure(mapper);
1744
1745 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
1746
1747 FakeInputDispatcher::NotifyMotionArgs args;
1748
1749 // Button press.
1750 // Mostly testing non x/y behavior here so we don't need to check again elsewhere.
1751 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 1, 0);
1752 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
1753 ASSERT_EQ(ARBITRARY_TIME, args.eventTime);
1754 ASSERT_EQ(DEVICE_ID, args.deviceId);
1755 ASSERT_EQ(AINPUT_SOURCE_TRACKBALL, args.source);
1756 ASSERT_EQ(uint32_t(0), args.policyFlags);
1757 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action);
1758 ASSERT_EQ(0, args.flags);
1759 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
1760 ASSERT_EQ(0, args.edgeFlags);
1761 ASSERT_EQ(uint32_t(1), args.pointerCount);
1762 ASSERT_EQ(0, args.pointerIds[0]);
1763 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
1764 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
1765 ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.xPrecision);
1766 ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.yPrecision);
1767 ASSERT_EQ(ARBITRARY_TIME, args.downTime);
1768
1769 // Button release. Should have same down time.
1770 process(mapper, ARBITRARY_TIME + 1, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 0, 0);
1771 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
1772 ASSERT_EQ(ARBITRARY_TIME + 1, args.eventTime);
1773 ASSERT_EQ(DEVICE_ID, args.deviceId);
1774 ASSERT_EQ(AINPUT_SOURCE_TRACKBALL, args.source);
1775 ASSERT_EQ(uint32_t(0), args.policyFlags);
1776 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, args.action);
1777 ASSERT_EQ(0, args.flags);
1778 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
1779 ASSERT_EQ(0, args.edgeFlags);
1780 ASSERT_EQ(uint32_t(1), args.pointerCount);
1781 ASSERT_EQ(0, args.pointerIds[0]);
1782 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
1783 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
1784 ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.xPrecision);
1785 ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.yPrecision);
1786 ASSERT_EQ(ARBITRARY_TIME, args.downTime);
1787}
1788
1789TEST_F(TrackballInputMapperTest, Process_ShouldHandleIndependentXYUpdates) {
1790 TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, -1);
1791 addMapperAndConfigure(mapper);
1792
1793 FakeInputDispatcher::NotifyMotionArgs args;
1794
1795 // Motion in X but not Y.
1796 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_X, 0, 1, 0);
1797 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0, 0, 0);
1798 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
1799 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
1800 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
1801 1.0f / TRACKBALL_MOVEMENT_THRESHOLD, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
1802
1803 // Motion in Y but not X.
1804 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_Y, 0, -2, 0);
1805 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0, 0, 0);
1806 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
1807 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
1808 ASSERT_NEAR(0.0f, args.pointerCoords[0].x, EPSILON);
1809 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
1810 0.0f, -2.0f / TRACKBALL_MOVEMENT_THRESHOLD, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
1811}
1812
1813TEST_F(TrackballInputMapperTest, Process_ShouldHandleIndependentButtonUpdates) {
1814 TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, -1);
1815 addMapperAndConfigure(mapper);
1816
1817 FakeInputDispatcher::NotifyMotionArgs args;
1818
1819 // Button press without following sync.
1820 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 1, 0);
1821 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
1822 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action);
1823 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
1824 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
1825
1826 // Button release without following sync.
1827 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 0, 0);
1828 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
1829 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, args.action);
1830 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
1831 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
1832}
1833
1834TEST_F(TrackballInputMapperTest, Process_ShouldHandleCombinedXYAndButtonUpdates) {
1835 TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, -1);
1836 addMapperAndConfigure(mapper);
1837
1838 FakeInputDispatcher::NotifyMotionArgs args;
1839
1840 // Combined X, Y and Button.
1841 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_X, 0, 1, 0);
1842 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_Y, 0, -2, 0);
1843 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 1, 0);
1844 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0, 0, 0);
1845 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
1846 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action);
1847 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
1848 1.0f / TRACKBALL_MOVEMENT_THRESHOLD, -2.0f / TRACKBALL_MOVEMENT_THRESHOLD,
1849 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
1850
1851 // Move X, Y a bit while pressed.
1852 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_X, 0, 2, 0);
1853 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_Y, 0, 1, 0);
1854 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0, 0, 0);
1855 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
1856 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
1857 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
1858 2.0f / TRACKBALL_MOVEMENT_THRESHOLD, 1.0f / TRACKBALL_MOVEMENT_THRESHOLD,
1859 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
1860
1861 // Release Button.
1862 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 0, 0);
1863 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
1864 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, args.action);
1865 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
1866 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
1867}
1868
1869TEST_F(TrackballInputMapperTest, Reset_WhenButtonIsNotDown_ShouldNotSynthesizeButtonUp) {
1870 TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, -1);
1871 addMapperAndConfigure(mapper);
1872
1873 FakeInputDispatcher::NotifyMotionArgs args;
1874
1875 // Button press.
1876 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 1, 0);
1877 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
1878
1879 // Button release.
1880 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 0, 0);
1881 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
1882
1883 // Reset. Should not synthesize button up since button is not pressed.
1884 mapper->reset();
1885
1886 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled());
1887}
1888
1889TEST_F(TrackballInputMapperTest, Reset_WhenButtonIsDown_ShouldSynthesizeButtonUp) {
1890 TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, -1);
1891 addMapperAndConfigure(mapper);
1892
1893 FakeInputDispatcher::NotifyMotionArgs args;
1894
1895 // Button press.
1896 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 0, 1, 0);
1897 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
1898
1899 // Reset. Should synthesize button up.
1900 mapper->reset();
1901
1902 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
1903 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, args.action);
1904 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
1905 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
1906}
1907
1908TEST_F(TrackballInputMapperTest, Process_WhenNotAttachedToDisplay_ShouldNotRotateMotions) {
1909 TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, -1);
1910 addMapperAndConfigure(mapper);
1911
1912 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, 1, 0, 1));
1913 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 1, 1, 1));
1914 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 0, 1, 0));
1915 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, -1, 1, -1));
1916 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, -1, 0, -1));
1917 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1, -1, -1));
1918 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 0, -1, 0));
1919 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 1, -1, 1));
1920}
1921
1922TEST_F(TrackballInputMapperTest, Process_WhenAttachedToDisplay_ShouldRotateMotions) {
1923 TrackballInputMapper* mapper = new TrackballInputMapper(mDevice, DISPLAY_ID);
1924 addMapperAndConfigure(mapper);
1925
1926 mFakePolicy->setDisplayInfo(DISPLAY_ID,
1927 DISPLAY_WIDTH, DISPLAY_HEIGHT,
1928 InputReaderPolicyInterface::ROTATION_0);
1929 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, 1, 0, 1));
1930 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 1, 1, 1));
1931 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 0, 1, 0));
1932 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, -1, 1, -1));
1933 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, -1, 0, -1));
1934 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1, -1, -1));
1935 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 0, -1, 0));
1936 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 1, -1, 1));
1937
1938 mFakePolicy->setDisplayInfo(DISPLAY_ID,
1939 DISPLAY_WIDTH, DISPLAY_HEIGHT,
1940 InputReaderPolicyInterface::ROTATION_90);
1941 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, 1, 1, 0));
1942 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 1, 1, -1));
1943 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 0, 0, -1));
1944 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, -1, -1, -1));
1945 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, -1, -1, 0));
1946 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1, -1, 1));
1947 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 0, 0, 1));
1948 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 1, 1, 1));
1949
1950 mFakePolicy->setDisplayInfo(DISPLAY_ID,
1951 DISPLAY_WIDTH, DISPLAY_HEIGHT,
1952 InputReaderPolicyInterface::ROTATION_180);
1953 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, 1, 0, -1));
1954 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 1, -1, -1));
1955 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 0, -1, 0));
1956 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, -1, -1, 1));
1957 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, -1, 0, 1));
1958 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1, 1, 1));
1959 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 0, 1, 0));
1960 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 1, 1, -1));
1961
1962 mFakePolicy->setDisplayInfo(DISPLAY_ID,
1963 DISPLAY_WIDTH, DISPLAY_HEIGHT,
1964 InputReaderPolicyInterface::ROTATION_270);
1965 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, 1, -1, 0));
1966 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 1, -1, 1));
1967 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, 0, 0, 1));
1968 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 1, -1, 1, 1));
1969 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, 0, -1, 1, 0));
1970 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, -1, 1, -1));
1971 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 0, 0, -1));
1972 ASSERT_NO_FATAL_FAILURE(testMotionRotation(mapper, -1, 1, -1, -1));
1973}
1974
1975
1976// --- TouchInputMapperTest ---
1977
1978class TouchInputMapperTest : public InputMapperTest {
1979protected:
1980 static const int32_t RAW_X_MIN;
1981 static const int32_t RAW_X_MAX;
1982 static const int32_t RAW_Y_MIN;
1983 static const int32_t RAW_Y_MAX;
1984 static const int32_t RAW_TOUCH_MIN;
1985 static const int32_t RAW_TOUCH_MAX;
1986 static const int32_t RAW_TOOL_MIN;
1987 static const int32_t RAW_TOOL_MAX;
1988 static const int32_t RAW_PRESSURE_MIN;
1989 static const int32_t RAW_PRESSURE_MAX;
1990 static const int32_t RAW_ORIENTATION_MIN;
1991 static const int32_t RAW_ORIENTATION_MAX;
1992 static const int32_t RAW_ID_MIN;
1993 static const int32_t RAW_ID_MAX;
1994 static const float X_PRECISION;
1995 static const float Y_PRECISION;
1996
1997 static const VirtualKeyDefinition VIRTUAL_KEYS[2];
1998
1999 enum Axes {
2000 POSITION = 1 << 0,
2001 TOUCH = 1 << 1,
2002 TOOL = 1 << 2,
2003 PRESSURE = 1 << 3,
2004 ORIENTATION = 1 << 4,
2005 MINOR = 1 << 5,
2006 ID = 1 << 6,
2007 };
2008
2009 void prepareDisplay(int32_t orientation);
2010 void prepareVirtualKeys();
2011 int32_t toRawX(float displayX);
2012 int32_t toRawY(float displayY);
2013 float toDisplayX(int32_t rawX);
2014 float toDisplayY(int32_t rawY);
2015};
2016
2017const int32_t TouchInputMapperTest::RAW_X_MIN = 25;
2018const int32_t TouchInputMapperTest::RAW_X_MAX = 1020;
2019const int32_t TouchInputMapperTest::RAW_Y_MIN = 30;
2020const int32_t TouchInputMapperTest::RAW_Y_MAX = 1010;
2021const int32_t TouchInputMapperTest::RAW_TOUCH_MIN = 0;
2022const int32_t TouchInputMapperTest::RAW_TOUCH_MAX = 31;
2023const int32_t TouchInputMapperTest::RAW_TOOL_MIN = 0;
2024const int32_t TouchInputMapperTest::RAW_TOOL_MAX = 15;
2025const int32_t TouchInputMapperTest::RAW_PRESSURE_MIN = RAW_TOUCH_MIN;
2026const int32_t TouchInputMapperTest::RAW_PRESSURE_MAX = RAW_TOUCH_MAX;
2027const int32_t TouchInputMapperTest::RAW_ORIENTATION_MIN = -7;
2028const int32_t TouchInputMapperTest::RAW_ORIENTATION_MAX = 7;
2029const int32_t TouchInputMapperTest::RAW_ID_MIN = 0;
2030const int32_t TouchInputMapperTest::RAW_ID_MAX = 9;
2031const float TouchInputMapperTest::X_PRECISION = float(RAW_X_MAX - RAW_X_MIN) / DISPLAY_WIDTH;
2032const float TouchInputMapperTest::Y_PRECISION = float(RAW_Y_MAX - RAW_Y_MIN) / DISPLAY_HEIGHT;
2033
2034const VirtualKeyDefinition TouchInputMapperTest::VIRTUAL_KEYS[2] = {
2035 { KEY_HOME, 60, DISPLAY_HEIGHT + 15, 20, 20 },
2036 { KEY_MENU, DISPLAY_HEIGHT - 60, DISPLAY_WIDTH + 15, 20, 20 },
2037};
2038
2039void TouchInputMapperTest::prepareDisplay(int32_t orientation) {
2040 mFakePolicy->setDisplayInfo(DISPLAY_ID, DISPLAY_WIDTH, DISPLAY_HEIGHT, orientation);
2041}
2042
2043void TouchInputMapperTest::prepareVirtualKeys() {
2044 mFakePolicy->addVirtualKeyDefinition(String8(DEVICE_NAME), VIRTUAL_KEYS[0]);
2045 mFakePolicy->addVirtualKeyDefinition(String8(DEVICE_NAME), VIRTUAL_KEYS[1]);
2046 mFakeEventHub->addKey(DEVICE_ID, KEY_HOME, AKEYCODE_HOME, POLICY_FLAG_WAKE);
2047 mFakeEventHub->addKey(DEVICE_ID, KEY_MENU, AKEYCODE_MENU, POLICY_FLAG_WAKE);
2048}
2049
2050int32_t TouchInputMapperTest::toRawX(float displayX) {
2051 return int32_t(displayX * (RAW_X_MAX - RAW_X_MIN) / DISPLAY_WIDTH + RAW_X_MIN);
2052}
2053
2054int32_t TouchInputMapperTest::toRawY(float displayY) {
2055 return int32_t(displayY * (RAW_Y_MAX - RAW_Y_MIN) / DISPLAY_HEIGHT + RAW_Y_MIN);
2056}
2057
2058float TouchInputMapperTest::toDisplayX(int32_t rawX) {
2059 return float(rawX - RAW_X_MIN) * DISPLAY_WIDTH / (RAW_X_MAX - RAW_X_MIN);
2060}
2061
2062float TouchInputMapperTest::toDisplayY(int32_t rawY) {
2063 return float(rawY - RAW_Y_MIN) * DISPLAY_HEIGHT / (RAW_Y_MAX - RAW_Y_MIN);
2064}
2065
2066
2067// --- SingleTouchInputMapperTest ---
2068
2069class SingleTouchInputMapperTest : public TouchInputMapperTest {
2070protected:
2071 void prepareAxes(int axes);
2072
2073 void processDown(SingleTouchInputMapper* mapper, int32_t x, int32_t y);
2074 void processMove(SingleTouchInputMapper* mapper, int32_t x, int32_t y);
2075 void processUp(SingleTouchInputMapper* mappery);
2076 void processPressure(SingleTouchInputMapper* mapper, int32_t pressure);
2077 void processToolMajor(SingleTouchInputMapper* mapper, int32_t toolMajor);
2078 void processSync(SingleTouchInputMapper* mapper);
2079};
2080
2081void SingleTouchInputMapperTest::prepareAxes(int axes) {
2082 if (axes & POSITION) {
2083 mFakeEventHub->addAxis(DEVICE_ID, ABS_X, RAW_X_MIN, RAW_X_MAX, 0, 0);
2084 mFakeEventHub->addAxis(DEVICE_ID, ABS_Y, RAW_Y_MIN, RAW_Y_MAX, 0, 0);
2085 }
2086 if (axes & PRESSURE) {
2087 mFakeEventHub->addAxis(DEVICE_ID, ABS_PRESSURE, RAW_PRESSURE_MIN, RAW_PRESSURE_MAX, 0, 0);
2088 }
2089 if (axes & TOOL) {
2090 mFakeEventHub->addAxis(DEVICE_ID, ABS_TOOL_WIDTH, RAW_TOOL_MIN, RAW_TOOL_MAX, 0, 0);
2091 }
2092}
2093
2094void SingleTouchInputMapperTest::processDown(SingleTouchInputMapper* mapper, int32_t x, int32_t y) {
2095 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_TOUCH, 0, 1, 0);
2096 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_X, 0, x, 0);
2097 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_Y, 0, y, 0);
2098}
2099
2100void SingleTouchInputMapperTest::processMove(SingleTouchInputMapper* mapper, int32_t x, int32_t y) {
2101 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_X, 0, x, 0);
2102 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_Y, 0, y, 0);
2103}
2104
2105void SingleTouchInputMapperTest::processUp(SingleTouchInputMapper* mapper) {
2106 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_TOUCH, 0, 0, 0);
2107}
2108
2109void SingleTouchInputMapperTest::processPressure(
2110 SingleTouchInputMapper* mapper, int32_t pressure) {
2111 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_PRESSURE, 0, pressure, 0);
2112}
2113
2114void SingleTouchInputMapperTest::processToolMajor(
2115 SingleTouchInputMapper* mapper, int32_t toolMajor) {
2116 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_TOOL_WIDTH, 0, toolMajor, 0);
2117}
2118
2119void SingleTouchInputMapperTest::processSync(SingleTouchInputMapper* mapper) {
2120 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0, 0, 0);
2121}
2122
2123
2124TEST_F(SingleTouchInputMapperTest, GetSources_WhenNotAttachedToADisplay_ReturnsTouchPad) {
2125 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, -1);
2126 prepareAxes(POSITION);
2127 addMapperAndConfigure(mapper);
2128
2129 ASSERT_EQ(AINPUT_SOURCE_TOUCHPAD, mapper->getSources());
2130}
2131
2132TEST_F(SingleTouchInputMapperTest, GetSources_WhenAttachedToADisplay_ReturnsTouchScreen) {
2133 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
2134 prepareAxes(POSITION);
2135 addMapperAndConfigure(mapper);
2136
2137 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, mapper->getSources());
2138}
2139
2140TEST_F(SingleTouchInputMapperTest, GetKeyCodeState) {
2141 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
2142 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
2143 prepareAxes(POSITION);
2144 prepareVirtualKeys();
2145 addMapperAndConfigure(mapper);
2146
2147 // Unknown key.
2148 ASSERT_EQ(AKEY_STATE_UNKNOWN, mapper->getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_A));
2149
2150 // Virtual key is down.
2151 int32_t x = toRawX(VIRTUAL_KEYS[0].centerX);
2152 int32_t y = toRawY(VIRTUAL_KEYS[0].centerY);
2153 processDown(mapper, x, y);
2154 processSync(mapper);
2155 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
2156
2157 ASSERT_EQ(AKEY_STATE_VIRTUAL, mapper->getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_HOME));
2158
2159 // Virtual key is up.
2160 processUp(mapper);
2161 processSync(mapper);
2162 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
2163
2164 ASSERT_EQ(AKEY_STATE_UP, mapper->getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_HOME));
2165}
2166
2167TEST_F(SingleTouchInputMapperTest, GetScanCodeState) {
2168 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
2169 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
2170 prepareAxes(POSITION);
2171 prepareVirtualKeys();
2172 addMapperAndConfigure(mapper);
2173
2174 // Unknown key.
2175 ASSERT_EQ(AKEY_STATE_UNKNOWN, mapper->getScanCodeState(AINPUT_SOURCE_ANY, KEY_A));
2176
2177 // Virtual key is down.
2178 int32_t x = toRawX(VIRTUAL_KEYS[0].centerX);
2179 int32_t y = toRawY(VIRTUAL_KEYS[0].centerY);
2180 processDown(mapper, x, y);
2181 processSync(mapper);
2182 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
2183
2184 ASSERT_EQ(AKEY_STATE_VIRTUAL, mapper->getScanCodeState(AINPUT_SOURCE_ANY, KEY_HOME));
2185
2186 // Virtual key is up.
2187 processUp(mapper);
2188 processSync(mapper);
2189 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
2190
2191 ASSERT_EQ(AKEY_STATE_UP, mapper->getScanCodeState(AINPUT_SOURCE_ANY, KEY_HOME));
2192}
2193
2194TEST_F(SingleTouchInputMapperTest, MarkSupportedKeyCodes) {
2195 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
2196 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
2197 prepareAxes(POSITION);
2198 prepareVirtualKeys();
2199 addMapperAndConfigure(mapper);
2200
2201 const int32_t keys[2] = { AKEYCODE_HOME, AKEYCODE_A };
2202 uint8_t flags[2] = { 0, 0 };
2203 ASSERT_TRUE(mapper->markSupportedKeyCodes(AINPUT_SOURCE_ANY, 2, keys, flags));
2204 ASSERT_TRUE(flags[0]);
2205 ASSERT_FALSE(flags[1]);
2206}
2207
2208TEST_F(SingleTouchInputMapperTest, Reset_WhenVirtualKeysAreDown_SendsUp) {
2209 // Note: Ideally we should send cancels but the implementation is more straightforward
2210 // with up and this will only happen if a device is forcibly removed.
2211 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
2212 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
2213 prepareAxes(POSITION);
2214 prepareVirtualKeys();
2215 addMapperAndConfigure(mapper);
2216
2217 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
2218
2219 // Press virtual key.
2220 int32_t x = toRawX(VIRTUAL_KEYS[0].centerX);
2221 int32_t y = toRawY(VIRTUAL_KEYS[0].centerY);
2222 processDown(mapper, x, y);
2223 processSync(mapper);
2224 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
2225
2226 // Reset. Since key is down, synthesize key up.
2227 mapper->reset();
2228
2229 FakeInputDispatcher::NotifyKeyArgs args;
2230 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
2231 //ASSERT_EQ(ARBITRARY_TIME, args.eventTime);
2232 ASSERT_EQ(DEVICE_ID, args.deviceId);
2233 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source);
2234 ASSERT_EQ(POLICY_FLAG_VIRTUAL, args.policyFlags);
2235 ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action);
2236 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY, args.flags);
2237 ASSERT_EQ(AKEYCODE_HOME, args.keyCode);
2238 ASSERT_EQ(KEY_HOME, args.scanCode);
2239 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
2240 ASSERT_EQ(ARBITRARY_TIME, args.downTime);
2241}
2242
2243TEST_F(SingleTouchInputMapperTest, Reset_WhenNothingIsPressed_NothingMuchHappens) {
2244 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
2245 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
2246 prepareAxes(POSITION);
2247 prepareVirtualKeys();
2248 addMapperAndConfigure(mapper);
2249
2250 // Press virtual key.
2251 int32_t x = toRawX(VIRTUAL_KEYS[0].centerX);
2252 int32_t y = toRawY(VIRTUAL_KEYS[0].centerY);
2253 processDown(mapper, x, y);
2254 processSync(mapper);
2255 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
2256
2257 // Release virtual key.
2258 processUp(mapper);
2259 processSync(mapper);
2260 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled());
2261
2262 // Reset. Since no key is down, nothing happens.
2263 mapper->reset();
2264
2265 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled());
2266 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled());
2267}
2268
2269TEST_F(SingleTouchInputMapperTest, Process_WhenVirtualKeyIsPressedAndReleasedNormally_SendsKeyDownAndKeyUp) {
2270 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
2271 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
2272 prepareAxes(POSITION);
2273 prepareVirtualKeys();
2274 addMapperAndConfigure(mapper);
2275
2276 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
2277
2278 FakeInputDispatcher::NotifyKeyArgs args;
2279
2280 // Press virtual key.
2281 int32_t x = toRawX(VIRTUAL_KEYS[0].centerX);
2282 int32_t y = toRawY(VIRTUAL_KEYS[0].centerY);
2283 processDown(mapper, x, y);
2284 processSync(mapper);
2285
2286 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
2287 ASSERT_EQ(ARBITRARY_TIME, args.eventTime);
2288 ASSERT_EQ(DEVICE_ID, args.deviceId);
2289 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source);
2290 ASSERT_EQ(POLICY_FLAG_VIRTUAL, args.policyFlags);
2291 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, args.action);
2292 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY, args.flags);
2293 ASSERT_EQ(AKEYCODE_HOME, args.keyCode);
2294 ASSERT_EQ(KEY_HOME, args.scanCode);
2295 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
2296 ASSERT_EQ(ARBITRARY_TIME, args.downTime);
2297
2298 // Release virtual key.
2299 processUp(mapper);
2300 processSync(mapper);
2301
2302 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&args));
2303 ASSERT_EQ(ARBITRARY_TIME, args.eventTime);
2304 ASSERT_EQ(DEVICE_ID, args.deviceId);
2305 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, args.source);
2306 ASSERT_EQ(POLICY_FLAG_VIRTUAL, args.policyFlags);
2307 ASSERT_EQ(AKEY_EVENT_ACTION_UP, args.action);
2308 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY, args.flags);
2309 ASSERT_EQ(AKEYCODE_HOME, args.keyCode);
2310 ASSERT_EQ(KEY_HOME, args.scanCode);
2311 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
2312 ASSERT_EQ(ARBITRARY_TIME, args.downTime);
2313
2314 // Should not have sent any motions.
2315 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled());
2316}
2317
2318TEST_F(SingleTouchInputMapperTest, Process_WhenVirtualKeyIsPressedAndMovedOutOfBounds_SendsKeyDownAndKeyCancel) {
2319 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
2320 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
2321 prepareAxes(POSITION);
2322 prepareVirtualKeys();
2323 addMapperAndConfigure(mapper);
2324
2325 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
2326
2327 FakeInputDispatcher::NotifyKeyArgs keyArgs;
2328
2329 // Press virtual key.
2330 int32_t x = toRawX(VIRTUAL_KEYS[0].centerX);
2331 int32_t y = toRawY(VIRTUAL_KEYS[0].centerY);
2332 processDown(mapper, x, y);
2333 processSync(mapper);
2334
2335 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&keyArgs));
2336 ASSERT_EQ(ARBITRARY_TIME, keyArgs.eventTime);
2337 ASSERT_EQ(DEVICE_ID, keyArgs.deviceId);
2338 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, keyArgs.source);
2339 ASSERT_EQ(POLICY_FLAG_VIRTUAL, keyArgs.policyFlags);
2340 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, keyArgs.action);
2341 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY, keyArgs.flags);
2342 ASSERT_EQ(AKEYCODE_HOME, keyArgs.keyCode);
2343 ASSERT_EQ(KEY_HOME, keyArgs.scanCode);
2344 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, keyArgs.metaState);
2345 ASSERT_EQ(ARBITRARY_TIME, keyArgs.downTime);
2346
2347 // Move out of bounds. This should generate a cancel and a pointer down since we moved
2348 // into the display area.
2349 y -= 100;
2350 processMove(mapper, x, y);
2351 processSync(mapper);
2352
2353 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasCalled(&keyArgs));
2354 ASSERT_EQ(ARBITRARY_TIME, keyArgs.eventTime);
2355 ASSERT_EQ(DEVICE_ID, keyArgs.deviceId);
2356 ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, keyArgs.source);
2357 ASSERT_EQ(POLICY_FLAG_VIRTUAL, keyArgs.policyFlags);
2358 ASSERT_EQ(AKEY_EVENT_ACTION_UP, keyArgs.action);
2359 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY
2360 | AKEY_EVENT_FLAG_CANCELED, keyArgs.flags);
2361 ASSERT_EQ(AKEYCODE_HOME, keyArgs.keyCode);
2362 ASSERT_EQ(KEY_HOME, keyArgs.scanCode);
2363 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, keyArgs.metaState);
2364 ASSERT_EQ(ARBITRARY_TIME, keyArgs.downTime);
2365
2366 FakeInputDispatcher::NotifyMotionArgs motionArgs;
2367 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2368 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2369 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2370 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2371 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2372 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
2373 ASSERT_EQ(0, motionArgs.flags);
2374 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2375 ASSERT_EQ(0, motionArgs.edgeFlags);
2376 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
2377 ASSERT_EQ(0, motionArgs.pointerIds[0]);
2378 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2379 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
2380 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2381 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2382 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2383
2384 // Keep moving out of bounds. Should generate a pointer move.
2385 y -= 50;
2386 processMove(mapper, x, y);
2387 processSync(mapper);
2388
2389 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2390 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2391 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2392 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2393 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2394 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
2395 ASSERT_EQ(0, motionArgs.flags);
2396 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2397 ASSERT_EQ(0, motionArgs.edgeFlags);
2398 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
2399 ASSERT_EQ(0, motionArgs.pointerIds[0]);
2400 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2401 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
2402 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2403 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2404 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2405
2406 // Release out of bounds. Should generate a pointer up.
2407 processUp(mapper);
2408 processSync(mapper);
2409
2410 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2411 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2412 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2413 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2414 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2415 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
2416 ASSERT_EQ(0, motionArgs.flags);
2417 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2418 ASSERT_EQ(0, motionArgs.edgeFlags);
2419 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
2420 ASSERT_EQ(0, motionArgs.pointerIds[0]);
2421 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2422 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
2423 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2424 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2425 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2426
2427 // Should not have sent any more keys or motions.
2428 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled());
2429 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled());
2430}
2431
2432TEST_F(SingleTouchInputMapperTest, Process_WhenTouchStartsOutsideDisplayAndMovesIn_SendsDownAsTouchEntersDisplay) {
2433 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
2434 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
2435 prepareAxes(POSITION);
2436 prepareVirtualKeys();
2437 addMapperAndConfigure(mapper);
2438
2439 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
2440
2441 FakeInputDispatcher::NotifyMotionArgs motionArgs;
2442
2443 // Initially go down out of bounds.
2444 int32_t x = -10;
2445 int32_t y = -10;
2446 processDown(mapper, x, y);
2447 processSync(mapper);
2448
2449 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled());
2450
2451 // Move into the display area. Should generate a pointer down.
2452 x = 50;
2453 y = 75;
2454 processMove(mapper, x, y);
2455 processSync(mapper);
2456
2457 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2458 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2459 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2460 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2461 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2462 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
2463 ASSERT_EQ(0, motionArgs.flags);
2464 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2465 ASSERT_EQ(0, motionArgs.edgeFlags);
2466 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
2467 ASSERT_EQ(0, motionArgs.pointerIds[0]);
2468 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2469 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
2470 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2471 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2472 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2473
2474 // Release. Should generate a pointer up.
2475 processUp(mapper);
2476 processSync(mapper);
2477
2478 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2479 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2480 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2481 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2482 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2483 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
2484 ASSERT_EQ(0, motionArgs.flags);
2485 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2486 ASSERT_EQ(0, motionArgs.edgeFlags);
2487 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
2488 ASSERT_EQ(0, motionArgs.pointerIds[0]);
2489 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2490 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
2491 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2492 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2493 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2494
2495 // Should not have sent any more keys or motions.
2496 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled());
2497 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled());
2498}
2499
2500TEST_F(SingleTouchInputMapperTest, Process_NormalSingleTouchGesture) {
2501 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
2502 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
2503 prepareAxes(POSITION);
2504 prepareVirtualKeys();
2505 addMapperAndConfigure(mapper);
2506
2507 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
2508
2509 FakeInputDispatcher::NotifyMotionArgs motionArgs;
2510
2511 // Down.
2512 int32_t x = 100;
2513 int32_t y = 125;
2514 processDown(mapper, x, y);
2515 processSync(mapper);
2516
2517 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2518 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2519 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2520 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2521 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2522 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
2523 ASSERT_EQ(0, motionArgs.flags);
2524 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2525 ASSERT_EQ(0, motionArgs.edgeFlags);
2526 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
2527 ASSERT_EQ(0, motionArgs.pointerIds[0]);
2528 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2529 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
2530 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2531 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2532 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2533
2534 // Move.
2535 x += 50;
2536 y += 75;
2537 processMove(mapper, x, y);
2538 processSync(mapper);
2539
2540 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2541 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2542 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2543 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2544 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2545 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
2546 ASSERT_EQ(0, motionArgs.flags);
2547 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2548 ASSERT_EQ(0, motionArgs.edgeFlags);
2549 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
2550 ASSERT_EQ(0, motionArgs.pointerIds[0]);
2551 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2552 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
2553 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2554 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2555 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2556
2557 // Up.
2558 processUp(mapper);
2559 processSync(mapper);
2560
2561 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2562 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2563 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2564 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2565 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2566 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
2567 ASSERT_EQ(0, motionArgs.flags);
2568 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2569 ASSERT_EQ(0, motionArgs.edgeFlags);
2570 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
2571 ASSERT_EQ(0, motionArgs.pointerIds[0]);
2572 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2573 toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
2574 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2575 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2576 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2577
2578 // Should not have sent any more keys or motions.
2579 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled());
2580 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled());
2581}
2582
2583TEST_F(SingleTouchInputMapperTest, Process_Rotation) {
2584 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
2585 prepareAxes(POSITION);
2586 addMapperAndConfigure(mapper);
2587
2588 FakeInputDispatcher::NotifyMotionArgs args;
2589
2590 // Rotation 0.
2591 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
2592 processDown(mapper, toRawX(50), toRawY(75));
2593 processSync(mapper);
2594
2595 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
2596 ASSERT_NEAR(50, args.pointerCoords[0].x, 1);
2597 ASSERT_NEAR(75, args.pointerCoords[0].y, 1);
2598
2599 processUp(mapper);
2600 processSync(mapper);
2601 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled());
2602
2603 // Rotation 90.
2604 prepareDisplay(InputReaderPolicyInterface::ROTATION_90);
2605 processDown(mapper, toRawX(50), toRawY(75));
2606 processSync(mapper);
2607
2608 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
2609 ASSERT_NEAR(75, args.pointerCoords[0].x, 1);
2610 ASSERT_NEAR(DISPLAY_WIDTH - 50, args.pointerCoords[0].y, 1);
2611
2612 processUp(mapper);
2613 processSync(mapper);
2614 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled());
2615
2616 // Rotation 180.
2617 prepareDisplay(InputReaderPolicyInterface::ROTATION_180);
2618 processDown(mapper, toRawX(50), toRawY(75));
2619 processSync(mapper);
2620
2621 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
2622 ASSERT_NEAR(DISPLAY_WIDTH - 50, args.pointerCoords[0].x, 1);
2623 ASSERT_NEAR(DISPLAY_HEIGHT - 75, args.pointerCoords[0].y, 1);
2624
2625 processUp(mapper);
2626 processSync(mapper);
2627 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled());
2628
2629 // Rotation 270.
2630 prepareDisplay(InputReaderPolicyInterface::ROTATION_270);
2631 processDown(mapper, toRawX(50), toRawY(75));
2632 processSync(mapper);
2633
2634 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
2635 ASSERT_NEAR(DISPLAY_HEIGHT - 75, args.pointerCoords[0].x, 1);
2636 ASSERT_NEAR(50, args.pointerCoords[0].y, 1);
2637
2638 processUp(mapper);
2639 processSync(mapper);
2640 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled());
2641}
2642
2643TEST_F(SingleTouchInputMapperTest, Process_AllAxes_DefaultCalibration) {
2644 SingleTouchInputMapper* mapper = new SingleTouchInputMapper(mDevice, DISPLAY_ID);
2645 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
2646 prepareAxes(POSITION | PRESSURE | TOOL);
2647 addMapperAndConfigure(mapper);
2648
2649 // These calculations are based on the input device calibration documentation.
2650 int32_t rawX = 100;
2651 int32_t rawY = 200;
2652 int32_t rawPressure = 10;
2653 int32_t rawToolMajor = 12;
2654
2655 float x = toDisplayX(rawX);
2656 float y = toDisplayY(rawY);
2657 float pressure = float(rawPressure) / RAW_PRESSURE_MAX;
2658 float size = float(rawToolMajor) / RAW_TOOL_MAX;
2659 float tool = min(DISPLAY_WIDTH, DISPLAY_HEIGHT) * size;
2660 float touch = min(tool * pressure, tool);
2661
2662 processDown(mapper, rawX, rawY);
2663 processPressure(mapper, rawPressure);
2664 processToolMajor(mapper, rawToolMajor);
2665 processSync(mapper);
2666
2667 FakeInputDispatcher::NotifyMotionArgs args;
2668 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
2669 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
2670 x, y, pressure, size, touch, touch, tool, tool, 0));
2671}
2672
2673
2674// --- MultiTouchInputMapperTest ---
2675
2676class MultiTouchInputMapperTest : public TouchInputMapperTest {
2677protected:
2678 void prepareAxes(int axes);
2679
2680 void processPosition(MultiTouchInputMapper* mapper, int32_t x, int32_t y);
2681 void processTouchMajor(MultiTouchInputMapper* mapper, int32_t touchMajor);
2682 void processTouchMinor(MultiTouchInputMapper* mapper, int32_t touchMinor);
2683 void processToolMajor(MultiTouchInputMapper* mapper, int32_t toolMajor);
2684 void processToolMinor(MultiTouchInputMapper* mapper, int32_t toolMinor);
2685 void processOrientation(MultiTouchInputMapper* mapper, int32_t orientation);
2686 void processPressure(MultiTouchInputMapper* mapper, int32_t pressure);
2687 void processId(MultiTouchInputMapper* mapper, int32_t id);
2688 void processMTSync(MultiTouchInputMapper* mapper);
2689 void processSync(MultiTouchInputMapper* mapper);
2690};
2691
2692void MultiTouchInputMapperTest::prepareAxes(int axes) {
2693 if (axes & POSITION) {
2694 mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_POSITION_X, RAW_X_MIN, RAW_X_MAX, 0, 0);
2695 mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_POSITION_Y, RAW_Y_MIN, RAW_Y_MAX, 0, 0);
2696 }
2697 if (axes & TOUCH) {
2698 mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_TOUCH_MAJOR, RAW_TOUCH_MIN, RAW_TOUCH_MAX, 0, 0);
2699 if (axes & MINOR) {
2700 mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_TOUCH_MINOR,
2701 RAW_TOUCH_MIN, RAW_TOUCH_MAX, 0, 0);
2702 }
2703 }
2704 if (axes & TOOL) {
2705 mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_WIDTH_MAJOR, RAW_TOOL_MIN, RAW_TOOL_MAX, 0, 0);
2706 if (axes & MINOR) {
2707 mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_WIDTH_MINOR,
2708 RAW_TOOL_MAX, RAW_TOOL_MAX, 0, 0);
2709 }
2710 }
2711 if (axes & ORIENTATION) {
2712 mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_ORIENTATION,
2713 RAW_ORIENTATION_MIN, RAW_ORIENTATION_MAX, 0, 0);
2714 }
2715 if (axes & PRESSURE) {
2716 mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_PRESSURE,
2717 RAW_PRESSURE_MIN, RAW_PRESSURE_MAX, 0, 0);
2718 }
2719 if (axes & ID) {
2720 mFakeEventHub->addAxis(DEVICE_ID, ABS_MT_TRACKING_ID,
2721 RAW_ID_MIN, RAW_ID_MAX, 0, 0);
2722 }
2723}
2724
2725void MultiTouchInputMapperTest::processPosition(
2726 MultiTouchInputMapper* mapper, int32_t x, int32_t y) {
2727 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_POSITION_X, 0, x, 0);
2728 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_POSITION_Y, 0, y, 0);
2729}
2730
2731void MultiTouchInputMapperTest::processTouchMajor(
2732 MultiTouchInputMapper* mapper, int32_t touchMajor) {
2733 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_TOUCH_MAJOR, 0, touchMajor, 0);
2734}
2735
2736void MultiTouchInputMapperTest::processTouchMinor(
2737 MultiTouchInputMapper* mapper, int32_t touchMinor) {
2738 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_TOUCH_MINOR, 0, touchMinor, 0);
2739}
2740
2741void MultiTouchInputMapperTest::processToolMajor(
2742 MultiTouchInputMapper* mapper, int32_t toolMajor) {
2743 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_WIDTH_MAJOR, 0, toolMajor, 0);
2744}
2745
2746void MultiTouchInputMapperTest::processToolMinor(
2747 MultiTouchInputMapper* mapper, int32_t toolMinor) {
2748 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_WIDTH_MINOR, 0, toolMinor, 0);
2749}
2750
2751void MultiTouchInputMapperTest::processOrientation(
2752 MultiTouchInputMapper* mapper, int32_t orientation) {
2753 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_ORIENTATION, 0, orientation, 0);
2754}
2755
2756void MultiTouchInputMapperTest::processPressure(
2757 MultiTouchInputMapper* mapper, int32_t pressure) {
2758 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_PRESSURE, 0, pressure, 0);
2759}
2760
2761void MultiTouchInputMapperTest::processId(
2762 MultiTouchInputMapper* mapper, int32_t id) {
2763 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_ABS, ABS_MT_TRACKING_ID, 0, id, 0);
2764}
2765
2766void MultiTouchInputMapperTest::processMTSync(MultiTouchInputMapper* mapper) {
2767 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_MT_REPORT, 0, 0, 0);
2768}
2769
2770void MultiTouchInputMapperTest::processSync(MultiTouchInputMapper* mapper) {
2771 process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0, 0, 0);
2772}
2773
2774
2775TEST_F(MultiTouchInputMapperTest, Process_NormalMultiTouchGesture_WithoutTrackingIds) {
2776 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice, DISPLAY_ID);
2777 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
2778 prepareAxes(POSITION);
2779 prepareVirtualKeys();
2780 addMapperAndConfigure(mapper);
2781
2782 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
2783
2784 FakeInputDispatcher::NotifyMotionArgs motionArgs;
2785
2786 // Two fingers down at once.
2787 int32_t x1 = 100, y1 = 125, x2 = 300, y2 = 500;
2788 processPosition(mapper, x1, y1);
2789 processMTSync(mapper);
2790 processPosition(mapper, x2, y2);
2791 processMTSync(mapper);
2792 processSync(mapper);
2793
2794 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2795 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2796 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2797 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2798 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2799 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
2800 ASSERT_EQ(0, motionArgs.flags);
2801 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2802 ASSERT_EQ(0, motionArgs.edgeFlags);
2803 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
2804 ASSERT_EQ(0, motionArgs.pointerIds[0]);
2805 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2806 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
2807 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2808 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2809 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2810
2811 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2812 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2813 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2814 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2815 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2816 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_DOWN | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
2817 motionArgs.action);
2818 ASSERT_EQ(0, motionArgs.flags);
2819 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2820 ASSERT_EQ(0, motionArgs.edgeFlags);
2821 ASSERT_EQ(size_t(2), motionArgs.pointerCount);
2822 ASSERT_EQ(0, motionArgs.pointerIds[0]);
2823 ASSERT_EQ(1, motionArgs.pointerIds[1]);
2824 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2825 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
2826 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
2827 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
2828 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2829 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2830 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2831
2832 // Move.
2833 x1 += 10; y1 += 15; x2 += 5; y2 -= 10;
2834 processPosition(mapper, x1, y1);
2835 processMTSync(mapper);
2836 processPosition(mapper, x2, y2);
2837 processMTSync(mapper);
2838 processSync(mapper);
2839
2840 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2841 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2842 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2843 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2844 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2845 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
2846 ASSERT_EQ(0, motionArgs.flags);
2847 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2848 ASSERT_EQ(0, motionArgs.edgeFlags);
2849 ASSERT_EQ(size_t(2), motionArgs.pointerCount);
2850 ASSERT_EQ(0, motionArgs.pointerIds[0]);
2851 ASSERT_EQ(1, motionArgs.pointerIds[1]);
2852 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2853 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
2854 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
2855 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
2856 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2857 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2858 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2859
2860 // First finger up.
2861 x2 += 15; y2 -= 20;
2862 processPosition(mapper, x2, y2);
2863 processMTSync(mapper);
2864 processSync(mapper);
2865
2866 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2867 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2868 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2869 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2870 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2871 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_UP | (0 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
2872 motionArgs.action);
2873 ASSERT_EQ(0, motionArgs.flags);
2874 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2875 ASSERT_EQ(0, motionArgs.edgeFlags);
2876 ASSERT_EQ(size_t(2), motionArgs.pointerCount);
2877 ASSERT_EQ(0, motionArgs.pointerIds[0]);
2878 ASSERT_EQ(1, motionArgs.pointerIds[1]);
2879 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2880 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
2881 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
2882 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
2883 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2884 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2885 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2886
2887 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2888 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2889 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2890 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2891 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2892 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
2893 ASSERT_EQ(0, motionArgs.flags);
2894 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2895 ASSERT_EQ(0, motionArgs.edgeFlags);
2896 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
2897 ASSERT_EQ(1, motionArgs.pointerIds[0]);
2898 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2899 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
2900 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2901 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2902 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2903
2904 // Move.
2905 x2 += 20; y2 -= 25;
2906 processPosition(mapper, x2, y2);
2907 processMTSync(mapper);
2908 processSync(mapper);
2909
2910 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2911 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2912 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2913 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2914 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2915 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
2916 ASSERT_EQ(0, motionArgs.flags);
2917 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2918 ASSERT_EQ(0, motionArgs.edgeFlags);
2919 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
2920 ASSERT_EQ(1, motionArgs.pointerIds[0]);
2921 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2922 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
2923 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2924 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2925 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2926
2927 // New finger down.
2928 int32_t x3 = 700, y3 = 300;
2929 processPosition(mapper, x2, y2);
2930 processMTSync(mapper);
2931 processPosition(mapper, x3, y3);
2932 processMTSync(mapper);
2933 processSync(mapper);
2934
2935 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2936 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2937 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2938 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2939 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2940 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_DOWN | (0 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
2941 motionArgs.action);
2942 ASSERT_EQ(0, motionArgs.flags);
2943 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2944 ASSERT_EQ(0, motionArgs.edgeFlags);
2945 ASSERT_EQ(size_t(2), motionArgs.pointerCount);
2946 ASSERT_EQ(0, motionArgs.pointerIds[0]);
2947 ASSERT_EQ(1, motionArgs.pointerIds[1]);
2948 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2949 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
2950 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
2951 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
2952 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2953 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2954 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2955
2956 // Second finger up.
2957 x3 += 30; y3 -= 20;
2958 processPosition(mapper, x3, y3);
2959 processMTSync(mapper);
2960 processSync(mapper);
2961
2962 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2963 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2964 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2965 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2966 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2967 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_UP | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
2968 motionArgs.action);
2969 ASSERT_EQ(0, motionArgs.flags);
2970 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2971 ASSERT_EQ(0, motionArgs.edgeFlags);
2972 ASSERT_EQ(size_t(2), motionArgs.pointerCount);
2973 ASSERT_EQ(0, motionArgs.pointerIds[0]);
2974 ASSERT_EQ(1, motionArgs.pointerIds[1]);
2975 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2976 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
2977 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
2978 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
2979 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2980 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2981 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2982
2983 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
2984 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
2985 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
2986 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
2987 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
2988 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
2989 ASSERT_EQ(0, motionArgs.flags);
2990 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
2991 ASSERT_EQ(0, motionArgs.edgeFlags);
2992 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
2993 ASSERT_EQ(0, motionArgs.pointerIds[0]);
2994 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
2995 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
2996 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
2997 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
2998 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
2999
3000 // Last finger up.
3001 processMTSync(mapper);
3002 processSync(mapper);
3003
3004 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
3005 ASSERT_EQ(ARBITRARY_TIME, motionArgs.eventTime);
3006 ASSERT_EQ(DEVICE_ID, motionArgs.deviceId);
3007 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, motionArgs.source);
3008 ASSERT_EQ(uint32_t(0), motionArgs.policyFlags);
3009 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
3010 ASSERT_EQ(0, motionArgs.flags);
3011 ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
3012 ASSERT_EQ(0, motionArgs.edgeFlags);
3013 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
3014 ASSERT_EQ(0, motionArgs.pointerIds[0]);
3015 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
3016 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
3017 ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
3018 ASSERT_NEAR(Y_PRECISION, motionArgs.yPrecision, EPSILON);
3019 ASSERT_EQ(ARBITRARY_TIME, motionArgs.downTime);
3020
3021 // Should not have sent any more keys or motions.
3022 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled());
3023 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled());
3024}
3025
3026TEST_F(MultiTouchInputMapperTest, Process_NormalMultiTouchGesture_WithTrackingIds) {
3027 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice, DISPLAY_ID);
3028 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
3029 prepareAxes(POSITION | ID);
3030 prepareVirtualKeys();
3031 addMapperAndConfigure(mapper);
3032
3033 mFakeContext->setGlobalMetaState(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON);
3034
3035 FakeInputDispatcher::NotifyMotionArgs motionArgs;
3036
3037 // Two fingers down at once.
3038 int32_t x1 = 100, y1 = 125, x2 = 300, y2 = 500;
3039 processPosition(mapper, x1, y1);
3040 processId(mapper, 1);
3041 processMTSync(mapper);
3042 processPosition(mapper, x2, y2);
3043 processId(mapper, 2);
3044 processMTSync(mapper);
3045 processSync(mapper);
3046
3047 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
3048 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
3049 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
3050 ASSERT_EQ(1, motionArgs.pointerIds[0]);
3051 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
3052 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
3053
3054 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
3055 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_DOWN | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
3056 motionArgs.action);
3057 ASSERT_EQ(size_t(2), motionArgs.pointerCount);
3058 ASSERT_EQ(1, motionArgs.pointerIds[0]);
3059 ASSERT_EQ(2, motionArgs.pointerIds[1]);
3060 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
3061 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
3062 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
3063 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
3064
3065 // Move.
3066 x1 += 10; y1 += 15; x2 += 5; y2 -= 10;
3067 processPosition(mapper, x1, y1);
3068 processId(mapper, 1);
3069 processMTSync(mapper);
3070 processPosition(mapper, x2, y2);
3071 processId(mapper, 2);
3072 processMTSync(mapper);
3073 processSync(mapper);
3074
3075 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
3076 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
3077 ASSERT_EQ(size_t(2), motionArgs.pointerCount);
3078 ASSERT_EQ(1, motionArgs.pointerIds[0]);
3079 ASSERT_EQ(2, motionArgs.pointerIds[1]);
3080 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
3081 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
3082 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
3083 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
3084
3085 // First finger up.
3086 x2 += 15; y2 -= 20;
3087 processPosition(mapper, x2, y2);
3088 processId(mapper, 2);
3089 processMTSync(mapper);
3090 processSync(mapper);
3091
3092 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
3093 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_UP | (0 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
3094 motionArgs.action);
3095 ASSERT_EQ(size_t(2), motionArgs.pointerCount);
3096 ASSERT_EQ(1, motionArgs.pointerIds[0]);
3097 ASSERT_EQ(2, motionArgs.pointerIds[1]);
3098 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
3099 toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
3100 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
3101 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
3102
3103 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
3104 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
3105 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
3106 ASSERT_EQ(2, motionArgs.pointerIds[0]);
3107 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
3108 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
3109
3110 // Move.
3111 x2 += 20; y2 -= 25;
3112 processPosition(mapper, x2, y2);
3113 processId(mapper, 2);
3114 processMTSync(mapper);
3115 processSync(mapper);
3116
3117 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
3118 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
3119 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
3120 ASSERT_EQ(2, motionArgs.pointerIds[0]);
3121 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
3122 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
3123
3124 // New finger down.
3125 int32_t x3 = 700, y3 = 300;
3126 processPosition(mapper, x2, y2);
3127 processId(mapper, 2);
3128 processMTSync(mapper);
3129 processPosition(mapper, x3, y3);
3130 processId(mapper, 3);
3131 processMTSync(mapper);
3132 processSync(mapper);
3133
3134 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
3135 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_DOWN | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
3136 motionArgs.action);
3137 ASSERT_EQ(size_t(2), motionArgs.pointerCount);
3138 ASSERT_EQ(2, motionArgs.pointerIds[0]);
3139 ASSERT_EQ(3, motionArgs.pointerIds[1]);
3140 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
3141 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
3142 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
3143 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
3144
3145 // Second finger up.
3146 x3 += 30; y3 -= 20;
3147 processPosition(mapper, x3, y3);
3148 processId(mapper, 3);
3149 processMTSync(mapper);
3150 processSync(mapper);
3151
3152 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
3153 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_UP | (0 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
3154 motionArgs.action);
3155 ASSERT_EQ(size_t(2), motionArgs.pointerCount);
3156 ASSERT_EQ(2, motionArgs.pointerIds[0]);
3157 ASSERT_EQ(3, motionArgs.pointerIds[1]);
3158 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
3159 toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
3160 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
3161 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
3162
3163 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
3164 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
3165 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
3166 ASSERT_EQ(3, motionArgs.pointerIds[0]);
3167 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
3168 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
3169
3170 // Last finger up.
3171 processMTSync(mapper);
3172 processSync(mapper);
3173
3174 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
3175 ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
3176 ASSERT_EQ(size_t(1), motionArgs.pointerCount);
3177 ASSERT_EQ(3, motionArgs.pointerIds[0]);
3178 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
3179 toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
3180
3181 // Should not have sent any more keys or motions.
3182 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyKeyWasNotCalled());
3183 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasNotCalled());
3184}
3185
3186TEST_F(MultiTouchInputMapperTest, Process_AllAxes_WithDefaultCalibration) {
3187 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice, DISPLAY_ID);
3188 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
3189 prepareAxes(POSITION | TOUCH | TOOL | PRESSURE | ORIENTATION | ID | MINOR);
3190 addMapperAndConfigure(mapper);
3191
3192 // These calculations are based on the input device calibration documentation.
3193 int32_t rawX = 100;
3194 int32_t rawY = 200;
3195 int32_t rawTouchMajor = 7;
3196 int32_t rawTouchMinor = 6;
3197 int32_t rawToolMajor = 9;
3198 int32_t rawToolMinor = 8;
3199 int32_t rawPressure = 11;
3200 int32_t rawOrientation = 3;
3201 int32_t id = 5;
3202
3203 float x = toDisplayX(rawX);
3204 float y = toDisplayY(rawY);
3205 float pressure = float(rawPressure) / RAW_PRESSURE_MAX;
3206 float size = avg(rawToolMajor, rawToolMinor) / RAW_TOOL_MAX;
3207 float toolMajor = float(min(DISPLAY_WIDTH, DISPLAY_HEIGHT)) * rawToolMajor / RAW_TOOL_MAX;
3208 float toolMinor = float(min(DISPLAY_WIDTH, DISPLAY_HEIGHT)) * rawToolMinor / RAW_TOOL_MAX;
3209 float touchMajor = min(toolMajor * pressure, toolMajor);
3210 float touchMinor = min(toolMinor * pressure, toolMinor);
3211 float orientation = float(rawOrientation) / RAW_ORIENTATION_MAX * M_PI_2;
3212
3213 processPosition(mapper, rawX, rawY);
3214 processTouchMajor(mapper, rawTouchMajor);
3215 processTouchMinor(mapper, rawTouchMinor);
3216 processToolMajor(mapper, rawToolMajor);
3217 processToolMinor(mapper, rawToolMinor);
3218 processPressure(mapper, rawPressure);
3219 processOrientation(mapper, rawOrientation);
3220 processId(mapper, id);
3221 processMTSync(mapper);
3222 processSync(mapper);
3223
3224 FakeInputDispatcher::NotifyMotionArgs args;
3225 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
3226 ASSERT_EQ(id, args.pointerIds[0]);
3227 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
3228 x, y, pressure, size, touchMajor, touchMinor, toolMajor, toolMinor, orientation));
3229}
3230
3231TEST_F(MultiTouchInputMapperTest, Process_TouchAndToolAxes_GeometricCalibration) {
3232 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice, DISPLAY_ID);
3233 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
3234 prepareAxes(POSITION | TOUCH | TOOL | MINOR);
3235 prepareCalibration("touch.touchSize.calibration", "geometric");
3236 prepareCalibration("touch.toolSize.calibration", "geometric");
3237 addMapperAndConfigure(mapper);
3238
3239 // These calculations are based on the input device calibration documentation.
3240 int32_t rawX = 100;
3241 int32_t rawY = 200;
3242 int32_t rawTouchMajor = 140;
3243 int32_t rawTouchMinor = 120;
3244 int32_t rawToolMajor = 180;
3245 int32_t rawToolMinor = 160;
3246
3247 float x = toDisplayX(rawX);
3248 float y = toDisplayY(rawY);
3249 float pressure = float(rawTouchMajor) / RAW_TOUCH_MAX;
3250 float size = avg(rawToolMajor, rawToolMinor) / RAW_TOOL_MAX;
3251 float scale = avg(float(DISPLAY_WIDTH) / (RAW_X_MAX - RAW_X_MIN),
3252 float(DISPLAY_HEIGHT) / (RAW_Y_MAX - RAW_Y_MIN));
3253 float toolMajor = float(rawToolMajor) * scale;
3254 float toolMinor = float(rawToolMinor) * scale;
3255 float touchMajor = min(float(rawTouchMajor) * scale, toolMajor);
3256 float touchMinor = min(float(rawTouchMinor) * scale, toolMinor);
3257
3258 processPosition(mapper, rawX, rawY);
3259 processTouchMajor(mapper, rawTouchMajor);
3260 processTouchMinor(mapper, rawTouchMinor);
3261 processToolMajor(mapper, rawToolMajor);
3262 processToolMinor(mapper, rawToolMinor);
3263 processMTSync(mapper);
3264 processSync(mapper);
3265
3266 FakeInputDispatcher::NotifyMotionArgs args;
3267 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
3268 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
3269 x, y, pressure, size, touchMajor, touchMinor, toolMajor, toolMinor, 0));
3270}
3271
3272TEST_F(MultiTouchInputMapperTest, Process_TouchToolPressureSizeAxes_SummedLinearCalibration) {
3273 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice, DISPLAY_ID);
3274 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
3275 prepareAxes(POSITION | TOUCH | TOOL);
3276 prepareCalibration("touch.touchSize.calibration", "pressure");
3277 prepareCalibration("touch.toolSize.calibration", "linear");
3278 prepareCalibration("touch.toolSize.linearScale", "10");
3279 prepareCalibration("touch.toolSize.linearBias", "160");
3280 prepareCalibration("touch.toolSize.isSummed", "1");
3281 prepareCalibration("touch.pressure.calibration", "amplitude");
3282 prepareCalibration("touch.pressure.source", "touch");
3283 prepareCalibration("touch.pressure.scale", "0.01");
3284 addMapperAndConfigure(mapper);
3285
3286 // These calculations are based on the input device calibration documentation.
3287 // Note: We only provide a single common touch/tool value because the device is assumed
3288 // not to emit separate values for each pointer (isSummed = 1).
3289 int32_t rawX = 100;
3290 int32_t rawY = 200;
3291 int32_t rawX2 = 150;
3292 int32_t rawY2 = 250;
3293 int32_t rawTouchMajor = 60;
3294 int32_t rawToolMajor = 5;
3295
3296 float x = toDisplayX(rawX);
3297 float y = toDisplayY(rawY);
3298 float x2 = toDisplayX(rawX2);
3299 float y2 = toDisplayY(rawY2);
3300 float pressure = float(rawTouchMajor) * 0.01f;
3301 float size = float(rawToolMajor) / RAW_TOOL_MAX;
3302 float tool = (float(rawToolMajor) * 10.0f + 160.0f) / 2;
3303 float touch = min(tool * pressure, tool);
3304
3305 processPosition(mapper, rawX, rawY);
3306 processTouchMajor(mapper, rawTouchMajor);
3307 processToolMajor(mapper, rawToolMajor);
3308 processMTSync(mapper);
3309 processPosition(mapper, rawX2, rawY2);
3310 processTouchMajor(mapper, rawTouchMajor);
3311 processToolMajor(mapper, rawToolMajor);
3312 processMTSync(mapper);
3313 processSync(mapper);
3314
3315 FakeInputDispatcher::NotifyMotionArgs args;
3316 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
3317 ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action);
3318 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
3319 ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_DOWN | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
3320 args.action);
3321 ASSERT_EQ(size_t(2), args.pointerCount);
3322 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
3323 x, y, pressure, size, touch, touch, tool, tool, 0));
3324 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[1],
3325 x2, y2, pressure, size, touch, touch, tool, tool, 0));
3326}
3327
3328TEST_F(MultiTouchInputMapperTest, Process_TouchToolPressureSizeAxes_AreaCalibration) {
3329 MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice, DISPLAY_ID);
3330 prepareDisplay(InputReaderPolicyInterface::ROTATION_0);
3331 prepareAxes(POSITION | TOUCH | TOOL);
3332 prepareCalibration("touch.touchSize.calibration", "pressure");
3333 prepareCalibration("touch.toolSize.calibration", "area");
3334 prepareCalibration("touch.toolSize.areaScale", "22");
3335 prepareCalibration("touch.toolSize.areaBias", "1");
3336 prepareCalibration("touch.toolSize.linearScale", "9.2");
3337 prepareCalibration("touch.toolSize.linearBias", "3");
3338 prepareCalibration("touch.pressure.calibration", "amplitude");
3339 prepareCalibration("touch.pressure.source", "touch");
3340 prepareCalibration("touch.pressure.scale", "0.01");
3341 addMapperAndConfigure(mapper);
3342
3343 // These calculations are based on the input device calibration documentation.
3344 int32_t rawX = 100;
3345 int32_t rawY = 200;
3346 int32_t rawTouchMajor = 60;
3347 int32_t rawToolMajor = 5;
3348
3349 float x = toDisplayX(rawX);
3350 float y = toDisplayY(rawY);
3351 float pressure = float(rawTouchMajor) * 0.01f;
3352 float size = float(rawToolMajor) / RAW_TOOL_MAX;
3353 float tool = sqrtf(float(rawToolMajor) * 22.0f + 1.0f) * 9.2f + 3.0f;
3354 float touch = min(tool * pressure, tool);
3355
3356 processPosition(mapper, rawX, rawY);
3357 processTouchMajor(mapper, rawTouchMajor);
3358 processToolMajor(mapper, rawToolMajor);
3359 processMTSync(mapper);
3360 processSync(mapper);
3361
3362 FakeInputDispatcher::NotifyMotionArgs args;
3363 ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
3364 ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
3365 x, y, pressure, size, touch, touch, tool, tool, 0));
3366}
3367
3368} // namespace android