1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
|
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef _UI_INPUT_READER_H
#define _UI_INPUT_READER_H
#include "EventHub.h"
#include "InputDispatcher.h"
#include "PointerController.h"
#include <ui/Input.h>
#include <ui/DisplayInfo.h>
#include <utils/KeyedVector.h>
#include <utils/threads.h>
#include <utils/Timers.h>
#include <utils/RefBase.h>
#include <utils/String8.h>
#include <utils/BitSet.h>
#include <stddef.h>
#include <unistd.h>
namespace android {
class InputDevice;
class InputMapper;
/*
* Input reader policy interface.
*
* The input reader policy is used by the input reader to interact with the Window Manager
* and other system components.
*
* The actual implementation is partially supported by callbacks into the DVM
* via JNI. This interface is also mocked in the unit tests.
*/
class InputReaderPolicyInterface : public virtual RefBase {
protected:
InputReaderPolicyInterface() { }
virtual ~InputReaderPolicyInterface() { }
public:
/* Display orientations. */
enum {
ROTATION_0 = 0,
ROTATION_90 = 1,
ROTATION_180 = 2,
ROTATION_270 = 3
};
/* Gets information about the display with the specified id.
* Returns true if the display info is available, false otherwise.
*/
virtual bool getDisplayInfo(int32_t displayId,
int32_t* width, int32_t* height, int32_t* orientation) = 0;
/* Determines whether to turn on some hacks we have to improve the touch interaction with a
* certain device whose screen currently is not all that good.
*/
virtual bool filterTouchEvents() = 0;
/* Determines whether to turn on some hacks to improve touch interaction with another device
* where touch coordinate data can get corrupted.
*/
virtual bool filterJumpyTouchEvents() = 0;
/* Gets the amount of time to disable virtual keys after the screen is touched
* in order to filter out accidental virtual key presses due to swiping gestures
* or taps near the edge of the display. May be 0 to disable the feature.
*/
virtual nsecs_t getVirtualKeyQuietTime() = 0;
/* Gets the excluded device names for the platform. */
virtual void getExcludedDeviceNames(Vector<String8>& outExcludedDeviceNames) = 0;
/* Gets a pointer controller associated with the specified cursor device (ie. a mouse). */
virtual sp<PointerControllerInterface> obtainPointerController(int32_t deviceId) = 0;
};
/* Processes raw input events and sends cooked event data to an input dispatcher. */
class InputReaderInterface : public virtual RefBase {
protected:
InputReaderInterface() { }
virtual ~InputReaderInterface() { }
public:
/* Dumps the state of the input reader.
*
* This method may be called on any thread (usually by the input manager). */
virtual void dump(String8& dump) = 0;
/* Runs a single iteration of the processing loop.
* Nominally reads and processes one incoming message from the EventHub.
*
* This method should be called on the input reader thread.
*/
virtual void loopOnce() = 0;
/* Gets the current input device configuration.
*
* This method may be called on any thread (usually by the input manager).
*/
virtual void getInputConfiguration(InputConfiguration* outConfiguration) = 0;
/* Gets information about the specified input device.
* Returns OK if the device information was obtained or NAME_NOT_FOUND if there
* was no such device.
*
* This method may be called on any thread (usually by the input manager).
*/
virtual status_t getInputDeviceInfo(int32_t deviceId, InputDeviceInfo* outDeviceInfo) = 0;
/* Gets the list of all registered device ids. */
virtual void getInputDeviceIds(Vector<int32_t>& outDeviceIds) = 0;
/* Query current input state. */
virtual int32_t getScanCodeState(int32_t deviceId, uint32_t sourceMask,
int32_t scanCode) = 0;
virtual int32_t getKeyCodeState(int32_t deviceId, uint32_t sourceMask,
int32_t keyCode) = 0;
virtual int32_t getSwitchState(int32_t deviceId, uint32_t sourceMask,
int32_t sw) = 0;
/* Determine whether physical keys exist for the given framework-domain key codes. */
virtual bool hasKeys(int32_t deviceId, uint32_t sourceMask,
size_t numCodes, const int32_t* keyCodes, uint8_t* outFlags) = 0;
};
/* Internal interface used by individual input devices to access global input device state
* and parameters maintained by the input reader.
*/
class InputReaderContext {
public:
InputReaderContext() { }
virtual ~InputReaderContext() { }
virtual void updateGlobalMetaState() = 0;
virtual int32_t getGlobalMetaState() = 0;
virtual void disableVirtualKeysUntil(nsecs_t time) = 0;
virtual bool shouldDropVirtualKey(nsecs_t now,
InputDevice* device, int32_t keyCode, int32_t scanCode) = 0;
virtual void fadePointer() = 0;
virtual void requestTimeoutAtTime(nsecs_t when) = 0;
virtual InputReaderPolicyInterface* getPolicy() = 0;
virtual InputDispatcherInterface* getDispatcher() = 0;
virtual EventHubInterface* getEventHub() = 0;
};
/* The input reader reads raw event data from the event hub and processes it into input events
* that it sends to the input dispatcher. Some functions of the input reader, such as early
* event filtering in low power states, are controlled by a separate policy object.
*
* IMPORTANT INVARIANT:
* Because the policy and dispatcher can potentially block or cause re-entrance into
* the input reader, the input reader never calls into other components while holding
* an exclusive internal lock whenever re-entrance can happen.
*/
class InputReader : public InputReaderInterface, protected InputReaderContext {
public:
InputReader(const sp<EventHubInterface>& eventHub,
const sp<InputReaderPolicyInterface>& policy,
const sp<InputDispatcherInterface>& dispatcher);
virtual ~InputReader();
virtual void dump(String8& dump);
virtual void loopOnce();
virtual void getInputConfiguration(InputConfiguration* outConfiguration);
virtual status_t getInputDeviceInfo(int32_t deviceId, InputDeviceInfo* outDeviceInfo);
virtual void getInputDeviceIds(Vector<int32_t>& outDeviceIds);
virtual int32_t getScanCodeState(int32_t deviceId, uint32_t sourceMask,
int32_t scanCode);
virtual int32_t getKeyCodeState(int32_t deviceId, uint32_t sourceMask,
int32_t keyCode);
virtual int32_t getSwitchState(int32_t deviceId, uint32_t sourceMask,
int32_t sw);
virtual bool hasKeys(int32_t deviceId, uint32_t sourceMask,
size_t numCodes, const int32_t* keyCodes, uint8_t* outFlags);
protected:
// These methods are protected virtual so they can be overridden and instrumented
// by test cases.
virtual InputDevice* createDevice(int32_t deviceId, const String8& name, uint32_t classes);
private:
sp<EventHubInterface> mEventHub;
sp<InputReaderPolicyInterface> mPolicy;
sp<InputDispatcherInterface> mDispatcher;
virtual InputReaderPolicyInterface* getPolicy() { return mPolicy.get(); }
virtual InputDispatcherInterface* getDispatcher() { return mDispatcher.get(); }
virtual EventHubInterface* getEventHub() { return mEventHub.get(); }
// This reader/writer lock guards the list of input devices.
// The writer lock must be held whenever the list of input devices is modified
// and then promptly released.
// The reader lock must be held whenever the list of input devices is traversed or an
// input device in the list is accessed.
// This lock only protects the registry and prevents inadvertent deletion of device objects
// that are in use. Individual devices are responsible for guarding their own internal state
// as needed for concurrent operation.
RWLock mDeviceRegistryLock;
KeyedVector<int32_t, InputDevice*> mDevices;
// low-level input event decoding and device management
void process(const RawEvent* rawEvent);
void addDevice(int32_t deviceId);
void removeDevice(int32_t deviceId);
void configureExcludedDevices();
void consumeEvent(const RawEvent* rawEvent);
void timeoutExpired(nsecs_t when);
void handleConfigurationChanged(nsecs_t when);
// state management for all devices
Mutex mStateLock;
int32_t mGlobalMetaState;
virtual void updateGlobalMetaState();
virtual int32_t getGlobalMetaState();
virtual void fadePointer();
InputConfiguration mInputConfiguration;
void updateInputConfiguration();
nsecs_t mDisableVirtualKeysTimeout;
virtual void disableVirtualKeysUntil(nsecs_t time);
virtual bool shouldDropVirtualKey(nsecs_t now,
InputDevice* device, int32_t keyCode, int32_t scanCode);
nsecs_t mNextTimeout;
virtual void requestTimeoutAtTime(nsecs_t when);
// state queries
typedef int32_t (InputDevice::*GetStateFunc)(uint32_t sourceMask, int32_t code);
int32_t getState(int32_t deviceId, uint32_t sourceMask, int32_t code,
GetStateFunc getStateFunc);
bool markSupportedKeyCodes(int32_t deviceId, uint32_t sourceMask, size_t numCodes,
const int32_t* keyCodes, uint8_t* outFlags);
};
/* Reads raw events from the event hub and processes them, endlessly. */
class InputReaderThread : public Thread {
public:
InputReaderThread(const sp<InputReaderInterface>& reader);
virtual ~InputReaderThread();
private:
sp<InputReaderInterface> mReader;
virtual bool threadLoop();
};
/* Represents the state of a single input device. */
class InputDevice {
public:
InputDevice(InputReaderContext* context, int32_t id, const String8& name);
~InputDevice();
inline InputReaderContext* getContext() { return mContext; }
inline int32_t getId() { return mId; }
inline const String8& getName() { return mName; }
inline uint32_t getSources() { return mSources; }
inline bool isExternal() { return mIsExternal; }
inline void setExternal(bool external) { mIsExternal = external; }
inline bool isIgnored() { return mMappers.isEmpty(); }
void dump(String8& dump);
void addMapper(InputMapper* mapper);
void configure();
void reset();
void process(const RawEvent* rawEvent);
void timeoutExpired(nsecs_t when);
void getDeviceInfo(InputDeviceInfo* outDeviceInfo);
int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode);
int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode);
int32_t getSwitchState(uint32_t sourceMask, int32_t switchCode);
bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes,
const int32_t* keyCodes, uint8_t* outFlags);
int32_t getMetaState();
void fadePointer();
inline const PropertyMap& getConfiguration() {
return mConfiguration;
}
private:
InputReaderContext* mContext;
int32_t mId;
Vector<InputMapper*> mMappers;
String8 mName;
uint32_t mSources;
bool mIsExternal;
typedef int32_t (InputMapper::*GetStateFunc)(uint32_t sourceMask, int32_t code);
int32_t getState(uint32_t sourceMask, int32_t code, GetStateFunc getStateFunc);
PropertyMap mConfiguration;
};
/* An input mapper transforms raw input events into cooked event data.
* A single input device can have multiple associated input mappers in order to interpret
* different classes of events.
*/
class InputMapper {
public:
InputMapper(InputDevice* device);
virtual ~InputMapper();
inline InputDevice* getDevice() { return mDevice; }
inline int32_t getDeviceId() { return mDevice->getId(); }
inline const String8 getDeviceName() { return mDevice->getName(); }
inline InputReaderContext* getContext() { return mContext; }
inline InputReaderPolicyInterface* getPolicy() { return mContext->getPolicy(); }
inline InputDispatcherInterface* getDispatcher() { return mContext->getDispatcher(); }
inline EventHubInterface* getEventHub() { return mContext->getEventHub(); }
virtual uint32_t getSources() = 0;
virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
virtual void dump(String8& dump);
virtual void configure();
virtual void reset();
virtual void process(const RawEvent* rawEvent) = 0;
virtual void timeoutExpired(nsecs_t when);
virtual int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode);
virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode);
virtual int32_t getSwitchState(uint32_t sourceMask, int32_t switchCode);
virtual bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes,
const int32_t* keyCodes, uint8_t* outFlags);
virtual int32_t getMetaState();
virtual void fadePointer();
protected:
InputDevice* mDevice;
InputReaderContext* mContext;
static void dumpRawAbsoluteAxisInfo(String8& dump,
const RawAbsoluteAxisInfo& axis, const char* name);
};
class SwitchInputMapper : public InputMapper {
public:
SwitchInputMapper(InputDevice* device);
virtual ~SwitchInputMapper();
virtual uint32_t getSources();
virtual void process(const RawEvent* rawEvent);
virtual int32_t getSwitchState(uint32_t sourceMask, int32_t switchCode);
private:
void processSwitch(nsecs_t when, int32_t switchCode, int32_t switchValue);
};
class KeyboardInputMapper : public InputMapper {
public:
KeyboardInputMapper(InputDevice* device, uint32_t source, int32_t keyboardType);
virtual ~KeyboardInputMapper();
virtual uint32_t getSources();
virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
virtual void dump(String8& dump);
virtual void configure();
virtual void reset();
virtual void process(const RawEvent* rawEvent);
virtual int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode);
virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode);
virtual bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes,
const int32_t* keyCodes, uint8_t* outFlags);
virtual int32_t getMetaState();
private:
Mutex mLock;
struct KeyDown {
int32_t keyCode;
int32_t scanCode;
};
uint32_t mSource;
int32_t mKeyboardType;
// Immutable configuration parameters.
struct Parameters {
int32_t associatedDisplayId;
bool orientationAware;
} mParameters;
struct LockedState {
Vector<KeyDown> keyDowns; // keys that are down
int32_t metaState;
nsecs_t downTime; // time of most recent key down
struct LedState {
bool avail; // led is available
bool on; // we think the led is currently on
};
LedState capsLockLedState;
LedState numLockLedState;
LedState scrollLockLedState;
} mLocked;
void initializeLocked();
void configureParameters();
void dumpParameters(String8& dump);
bool isKeyboardOrGamepadKey(int32_t scanCode);
void processKey(nsecs_t when, bool down, int32_t keyCode, int32_t scanCode,
uint32_t policyFlags);
ssize_t findKeyDownLocked(int32_t scanCode);
void resetLedStateLocked();
void initializeLedStateLocked(LockedState::LedState& ledState, int32_t led);
void updateLedStateLocked(bool reset);
void updateLedStateForModifierLocked(LockedState::LedState& ledState, int32_t led,
int32_t modifier, bool reset);
};
class CursorInputMapper : public InputMapper {
public:
CursorInputMapper(InputDevice* device);
virtual ~CursorInputMapper();
virtual uint32_t getSources();
virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
virtual void dump(String8& dump);
virtual void configure();
virtual void reset();
virtual void process(const RawEvent* rawEvent);
virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode);
virtual void fadePointer();
private:
// Amount that trackball needs to move in order to generate a key event.
static const int32_t TRACKBALL_MOVEMENT_THRESHOLD = 6;
Mutex mLock;
// Immutable configuration parameters.
struct Parameters {
enum Mode {
MODE_POINTER,
MODE_NAVIGATION,
};
Mode mode;
int32_t associatedDisplayId;
bool orientationAware;
} mParameters;
struct Accumulator {
enum {
FIELD_BUTTONS = 1,
FIELD_REL_X = 2,
FIELD_REL_Y = 4,
FIELD_REL_WHEEL = 8,
FIELD_REL_HWHEEL = 16,
};
uint32_t fields;
uint32_t buttonDown;
uint32_t buttonUp;
int32_t relX;
int32_t relY;
int32_t relWheel;
int32_t relHWheel;
inline void clear() {
fields = 0;
}
} mAccumulator;
int32_t mSource;
float mXScale;
float mYScale;
float mXPrecision;
float mYPrecision;
bool mHaveVWheel;
bool mHaveHWheel;
float mVWheelScale;
float mHWheelScale;
sp<PointerControllerInterface> mPointerController;
struct LockedState {
uint32_t buttonState;
nsecs_t downTime;
} mLocked;
void initializeLocked();
void configureParameters();
void dumpParameters(String8& dump);
void sync(nsecs_t when);
};
class TouchInputMapper : public InputMapper {
public:
TouchInputMapper(InputDevice* device);
virtual ~TouchInputMapper();
virtual uint32_t getSources();
virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
virtual void dump(String8& dump);
virtual void configure();
virtual void reset();
virtual int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode);
virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode);
virtual bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes,
const int32_t* keyCodes, uint8_t* outFlags);
virtual void fadePointer();
protected:
Mutex mLock;
struct VirtualKey {
int32_t keyCode;
int32_t scanCode;
uint32_t flags;
// computed hit box, specified in touch screen coords based on known display size
int32_t hitLeft;
int32_t hitTop;
int32_t hitRight;
int32_t hitBottom;
inline bool isHit(int32_t x, int32_t y) const {
return x >= hitLeft && x <= hitRight && y >= hitTop && y <= hitBottom;
}
};
// Raw data for a single pointer.
struct PointerData {
uint32_t id;
int32_t x;
int32_t y;
int32_t pressure;
int32_t touchMajor;
int32_t touchMinor;
int32_t toolMajor;
int32_t toolMinor;
int32_t orientation;
inline bool operator== (const PointerData& other) const {
return id == other.id
&& x == other.x
&& y == other.y
&& pressure == other.pressure
&& touchMajor == other.touchMajor
&& touchMinor == other.touchMinor
&& toolMajor == other.toolMajor
&& toolMinor == other.toolMinor
&& orientation == other.orientation;
}
inline bool operator!= (const PointerData& other) const {
return !(*this == other);
}
};
// Raw data for a collection of pointers including a pointer id mapping table.
struct TouchData {
uint32_t pointerCount;
PointerData pointers[MAX_POINTERS];
BitSet32 idBits;
uint32_t idToIndex[MAX_POINTER_ID + 1];
uint32_t buttonState;
void copyFrom(const TouchData& other) {
pointerCount = other.pointerCount;
idBits = other.idBits;
buttonState = other.buttonState;
for (uint32_t i = 0; i < pointerCount; i++) {
pointers[i] = other.pointers[i];
int id = pointers[i].id;
idToIndex[id] = other.idToIndex[id];
}
}
inline void clear() {
pointerCount = 0;
idBits.clear();
buttonState = 0;
}
};
// Input sources supported by the device.
uint32_t mTouchSource; // sources when reporting touch data
uint32_t mPointerSource; // sources when reporting pointer gestures
// Immutable configuration parameters.
struct Parameters {
enum DeviceType {
DEVICE_TYPE_TOUCH_SCREEN,
DEVICE_TYPE_TOUCH_PAD,
DEVICE_TYPE_POINTER,
};
DeviceType deviceType;
int32_t associatedDisplayId;
bool orientationAware;
bool useBadTouchFilter;
bool useJumpyTouchFilter;
bool useAveragingTouchFilter;
nsecs_t virtualKeyQuietTime;
} mParameters;
// Immutable calibration parameters in parsed form.
struct Calibration {
// Touch Size
enum TouchSizeCalibration {
TOUCH_SIZE_CALIBRATION_DEFAULT,
TOUCH_SIZE_CALIBRATION_NONE,
TOUCH_SIZE_CALIBRATION_GEOMETRIC,
TOUCH_SIZE_CALIBRATION_PRESSURE,
};
TouchSizeCalibration touchSizeCalibration;
// Tool Size
enum ToolSizeCalibration {
TOOL_SIZE_CALIBRATION_DEFAULT,
TOOL_SIZE_CALIBRATION_NONE,
TOOL_SIZE_CALIBRATION_GEOMETRIC,
TOOL_SIZE_CALIBRATION_LINEAR,
TOOL_SIZE_CALIBRATION_AREA,
};
ToolSizeCalibration toolSizeCalibration;
bool haveToolSizeLinearScale;
float toolSizeLinearScale;
bool haveToolSizeLinearBias;
float toolSizeLinearBias;
bool haveToolSizeAreaScale;
float toolSizeAreaScale;
bool haveToolSizeAreaBias;
float toolSizeAreaBias;
bool haveToolSizeIsSummed;
bool toolSizeIsSummed;
// Pressure
enum PressureCalibration {
PRESSURE_CALIBRATION_DEFAULT,
PRESSURE_CALIBRATION_NONE,
PRESSURE_CALIBRATION_PHYSICAL,
PRESSURE_CALIBRATION_AMPLITUDE,
};
enum PressureSource {
PRESSURE_SOURCE_DEFAULT,
PRESSURE_SOURCE_PRESSURE,
PRESSURE_SOURCE_TOUCH,
};
PressureCalibration pressureCalibration;
PressureSource pressureSource;
bool havePressureScale;
float pressureScale;
// Size
enum SizeCalibration {
SIZE_CALIBRATION_DEFAULT,
SIZE_CALIBRATION_NONE,
SIZE_CALIBRATION_NORMALIZED,
};
SizeCalibration sizeCalibration;
// Orientation
enum OrientationCalibration {
ORIENTATION_CALIBRATION_DEFAULT,
ORIENTATION_CALIBRATION_NONE,
ORIENTATION_CALIBRATION_INTERPOLATED,
ORIENTATION_CALIBRATION_VECTOR,
};
OrientationCalibration orientationCalibration;
} mCalibration;
// Raw axis information from the driver.
struct RawAxes {
RawAbsoluteAxisInfo x;
RawAbsoluteAxisInfo y;
RawAbsoluteAxisInfo pressure;
RawAbsoluteAxisInfo touchMajor;
RawAbsoluteAxisInfo touchMinor;
RawAbsoluteAxisInfo toolMajor;
RawAbsoluteAxisInfo toolMinor;
RawAbsoluteAxisInfo orientation;
} mRawAxes;
// Current and previous touch sample data.
TouchData mCurrentTouch;
PointerCoords mCurrentTouchCoords[MAX_POINTERS];
TouchData mLastTouch;
PointerCoords mLastTouchCoords[MAX_POINTERS];
// The time the primary pointer last went down.
nsecs_t mDownTime;
// The pointer controller, or null if the device is not a pointer.
sp<PointerControllerInterface> mPointerController;
struct LockedState {
Vector<VirtualKey> virtualKeys;
// The surface orientation and width and height set by configureSurfaceLocked().
int32_t surfaceOrientation;
int32_t surfaceWidth, surfaceHeight;
// The associated display orientation and width and height set by configureSurfaceLocked().
int32_t associatedDisplayOrientation;
int32_t associatedDisplayWidth, associatedDisplayHeight;
// Translation and scaling factors, orientation-independent.
float xScale;
float xPrecision;
float yScale;
float yPrecision;
float geometricScale;
float toolSizeLinearScale;
float toolSizeLinearBias;
float toolSizeAreaScale;
float toolSizeAreaBias;
float pressureScale;
float sizeScale;
float orientationScale;
// Oriented motion ranges for input device info.
struct OrientedRanges {
InputDeviceInfo::MotionRange x;
InputDeviceInfo::MotionRange y;
bool havePressure;
InputDeviceInfo::MotionRange pressure;
bool haveSize;
InputDeviceInfo::MotionRange size;
bool haveTouchSize;
InputDeviceInfo::MotionRange touchMajor;
InputDeviceInfo::MotionRange touchMinor;
bool haveToolSize;
InputDeviceInfo::MotionRange toolMajor;
InputDeviceInfo::MotionRange toolMinor;
bool haveOrientation;
InputDeviceInfo::MotionRange orientation;
} orientedRanges;
// Oriented dimensions and precision.
float orientedSurfaceWidth, orientedSurfaceHeight;
float orientedXPrecision, orientedYPrecision;
struct CurrentVirtualKeyState {
bool down;
nsecs_t downTime;
int32_t keyCode;
int32_t scanCode;
} currentVirtualKey;
// Scale factor for gesture based pointer movements.
float pointerGestureXMovementScale;
float pointerGestureYMovementScale;
// Scale factor for gesture based zooming and other freeform motions.
float pointerGestureXZoomScale;
float pointerGestureYZoomScale;
// The maximum swipe width squared.
int32_t pointerGestureMaxSwipeWidthSquared;
} mLocked;
virtual void configureParameters();
virtual void dumpParameters(String8& dump);
virtual void configureRawAxes();
virtual void dumpRawAxes(String8& dump);
virtual bool configureSurfaceLocked();
virtual void dumpSurfaceLocked(String8& dump);
virtual void configureVirtualKeysLocked();
virtual void dumpVirtualKeysLocked(String8& dump);
virtual void parseCalibration();
virtual void resolveCalibration();
virtual void dumpCalibration(String8& dump);
enum TouchResult {
// Dispatch the touch normally.
DISPATCH_TOUCH,
// Do not dispatch the touch, but keep tracking the current stroke.
SKIP_TOUCH,
// Do not dispatch the touch, and drop all information associated with the current stoke
// so the next movement will appear as a new down.
DROP_STROKE
};
void syncTouch(nsecs_t when, bool havePointerIds);
private:
/* Maximum number of historical samples to average. */
static const uint32_t AVERAGING_HISTORY_SIZE = 5;
/* Slop distance for jumpy pointer detection.
* The vertical range of the screen divided by this is our epsilon value. */
static const uint32_t JUMPY_EPSILON_DIVISOR = 212;
/* Number of jumpy points to drop for touchscreens that need it. */
static const uint32_t JUMPY_TRANSITION_DROPS = 3;
static const uint32_t JUMPY_DROP_LIMIT = 3;
/* Maximum squared distance for averaging.
* If moving farther than this, turn of averaging to avoid lag in response. */
static const uint64_t AVERAGING_DISTANCE_LIMIT = 75 * 75;
struct AveragingTouchFilterState {
// Individual history tracks are stored by pointer id
uint32_t historyStart[MAX_POINTERS];
uint32_t historyEnd[MAX_POINTERS];
struct {
struct {
int32_t x;
int32_t y;
int32_t pressure;
} pointers[MAX_POINTERS];
} historyData[AVERAGING_HISTORY_SIZE];
} mAveragingTouchFilter;
struct JumpyTouchFilterState {
uint32_t jumpyPointsDropped;
} mJumpyTouchFilter;
struct PointerDistanceHeapElement {
uint32_t currentPointerIndex : 8;
uint32_t lastPointerIndex : 8;
uint64_t distance : 48; // squared distance
};
struct PointerGesture {
enum Mode {
// No fingers, button is not pressed.
// Nothing happening.
NEUTRAL,
// No fingers, button is not pressed.
// Tap detected.
// Emits DOWN and UP events at the pointer location.
TAP,
// Button is pressed.
// Pointer follows the active finger if there is one. Other fingers are ignored.
// Emits DOWN, MOVE and UP events at the pointer location.
CLICK_OR_DRAG,
// Exactly one finger, button is not pressed.
// Pointer follows the active finger.
// Emits HOVER_MOVE events at the pointer location.
HOVER,
// More than two fingers involved but they haven't moved enough for us
// to figure out what is intended.
INDETERMINATE_MULTITOUCH,
// Exactly two fingers moving in the same direction, button is not pressed.
// Pointer does not move.
// Emits DOWN, MOVE and UP events with a single pointer coordinate that
// follows the midpoint between both fingers.
// The centroid is fixed when entering this state.
SWIPE,
// Two or more fingers moving in arbitrary directions, button is not pressed.
// Pointer does not move.
// Emits DOWN, POINTER_DOWN, MOVE, POINTER_UP and UP events that follow
// each finger individually relative to the initial centroid of the finger.
// The centroid is fixed when entering this state.
FREEFORM,
// Waiting for quiet time to end before starting the next gesture.
QUIET,
};
// The active pointer id from the raw touch data.
int32_t activeTouchId; // -1 if none
// The active pointer id from the gesture last delivered to the application.
int32_t activeGestureId; // -1 if none
// Pointer coords and ids for the current and previous pointer gesture.
Mode currentGestureMode;
uint32_t currentGesturePointerCount;
BitSet32 currentGestureIdBits;
uint32_t currentGestureIdToIndex[MAX_POINTER_ID + 1];
PointerCoords currentGestureCoords[MAX_POINTERS];
Mode lastGestureMode;
uint32_t lastGesturePointerCount;
BitSet32 lastGestureIdBits;
uint32_t lastGestureIdToIndex[MAX_POINTER_ID + 1];
PointerCoords lastGestureCoords[MAX_POINTERS];
// Tracks for all pointers originally went down.
TouchData touchOrigin;
// Describes how touch ids are mapped to gesture ids for freeform gestures.
uint32_t freeformTouchToGestureIdMap[MAX_POINTER_ID + 1];
// Initial centroid of the movement.
// Used to calculate how far the touch pointers have moved since the gesture started.
int32_t initialCentroidX;
int32_t initialCentroidY;
// Initial pointer location.
// Used to track where the pointer was when the gesture started.
float initialPointerX;
float initialPointerY;
// Time the pointer gesture last went down.
nsecs_t downTime;
// Time we started waiting for a tap gesture.
nsecs_t tapTime;
// Time we started waiting for quiescence.
nsecs_t quietTime;
// A velocity tracker for determining whether to switch active pointers during drags.
VelocityTracker velocityTracker;
void reset() {
activeTouchId = -1;
activeGestureId = -1;
currentGestureMode = NEUTRAL;
currentGesturePointerCount = 0;
currentGestureIdBits.clear();
lastGestureMode = NEUTRAL;
lastGesturePointerCount = 0;
lastGestureIdBits.clear();
touchOrigin.clear();
initialCentroidX = 0;
initialCentroidY = 0;
initialPointerX = 0;
initialPointerY = 0;
downTime = 0;
velocityTracker.clear();
resetTapTime();
resetQuietTime();
}
void resetTapTime() {
tapTime = LLONG_MIN;
}
void resetQuietTime() {
quietTime = LLONG_MIN;
}
} mPointerGesture;
void initializeLocked();
TouchResult consumeOffScreenTouches(nsecs_t when, uint32_t policyFlags);
void dispatchTouches(nsecs_t when, uint32_t policyFlags);
void prepareTouches(int32_t* outEdgeFlags, float* outXPrecision, float* outYPrecision);
void dispatchPointerGestures(nsecs_t when, uint32_t policyFlags);
void preparePointerGestures(nsecs_t when,
bool* outCancelPreviousGesture, bool* outFinishPreviousGesture);
// Dispatches a motion event.
// If the changedId is >= 0 and the action is POINTER_DOWN or POINTER_UP, the
// method will take care of setting the index and transmuting the action to DOWN or UP
// it is the first / last pointer to go down / up.
void dispatchMotion(nsecs_t when, uint32_t policyFlags, uint32_t source,
int32_t action, int32_t flags, uint32_t metaState, int32_t edgeFlags,
const PointerCoords* coords, const uint32_t* idToIndex, BitSet32 idBits,
int32_t changedId, float xPrecision, float yPrecision, nsecs_t downTime);
// Updates pointer coords for pointers with specified ids that have moved.
// Returns true if any of them changed.
bool updateMovedPointerCoords(const PointerCoords* inCoords, const uint32_t* inIdToIndex,
PointerCoords* outCoords, const uint32_t* outIdToIndex, BitSet32 idBits) const;
void suppressSwipeOntoVirtualKeys(nsecs_t when);
bool isPointInsideSurfaceLocked(int32_t x, int32_t y);
const VirtualKey* findVirtualKeyHitLocked(int32_t x, int32_t y);
bool applyBadTouchFilter();
bool applyJumpyTouchFilter();
void applyAveragingTouchFilter();
void calculatePointerIds();
};
class SingleTouchInputMapper : public TouchInputMapper {
public:
SingleTouchInputMapper(InputDevice* device);
virtual ~SingleTouchInputMapper();
virtual void reset();
virtual void process(const RawEvent* rawEvent);
protected:
virtual void configureRawAxes();
private:
struct Accumulator {
enum {
FIELD_BTN_TOUCH = 1,
FIELD_ABS_X = 2,
FIELD_ABS_Y = 4,
FIELD_ABS_PRESSURE = 8,
FIELD_ABS_TOOL_WIDTH = 16,
FIELD_BUTTONS = 32,
};
uint32_t fields;
bool btnTouch;
int32_t absX;
int32_t absY;
int32_t absPressure;
int32_t absToolWidth;
uint32_t buttonDown;
uint32_t buttonUp;
inline void clear() {
fields = 0;
buttonDown = 0;
buttonUp = 0;
}
} mAccumulator;
bool mDown;
int32_t mX;
int32_t mY;
int32_t mPressure;
int32_t mToolWidth;
uint32_t mButtonState;
void initialize();
void sync(nsecs_t when);
};
class MultiTouchInputMapper : public TouchInputMapper {
public:
MultiTouchInputMapper(InputDevice* device);
virtual ~MultiTouchInputMapper();
virtual void reset();
virtual void process(const RawEvent* rawEvent);
protected:
virtual void configureRawAxes();
private:
struct Accumulator {
enum {
FIELD_ABS_MT_POSITION_X = 1,
FIELD_ABS_MT_POSITION_Y = 2,
FIELD_ABS_MT_TOUCH_MAJOR = 4,
FIELD_ABS_MT_TOUCH_MINOR = 8,
FIELD_ABS_MT_WIDTH_MAJOR = 16,
FIELD_ABS_MT_WIDTH_MINOR = 32,
FIELD_ABS_MT_ORIENTATION = 64,
FIELD_ABS_MT_TRACKING_ID = 128,
FIELD_ABS_MT_PRESSURE = 256,
};
uint32_t pointerCount;
struct Pointer {
uint32_t fields;
int32_t absMTPositionX;
int32_t absMTPositionY;
int32_t absMTTouchMajor;
int32_t absMTTouchMinor;
int32_t absMTWidthMajor;
int32_t absMTWidthMinor;
int32_t absMTOrientation;
int32_t absMTTrackingId;
int32_t absMTPressure;
inline void clear() {
fields = 0;
}
} pointers[MAX_POINTERS + 1]; // + 1 to remove the need for extra range checks
// Bitfield of buttons that went down or up.
uint32_t buttonDown;
uint32_t buttonUp;
inline void clear() {
pointerCount = 0;
pointers[0].clear();
buttonDown = 0;
buttonUp = 0;
}
} mAccumulator;
uint32_t mButtonState;
void initialize();
void sync(nsecs_t when);
};
class JoystickInputMapper : public InputMapper {
public:
JoystickInputMapper(InputDevice* device);
virtual ~JoystickInputMapper();
virtual uint32_t getSources();
virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
virtual void dump(String8& dump);
virtual void configure();
virtual void reset();
virtual void process(const RawEvent* rawEvent);
private:
struct Axis {
RawAbsoluteAxisInfo rawAxisInfo;
AxisInfo axisInfo;
bool explicitlyMapped; // true if the axis was explicitly assigned an axis id
float scale; // scale factor from raw to normalized values
float offset; // offset to add after scaling for normalization
float highScale; // scale factor from raw to normalized values of high split
float highOffset; // offset to add after scaling for normalization of high split
float min; // normalized inclusive minimum
float max; // normalized inclusive maximum
float flat; // normalized flat region size
float fuzz; // normalized error tolerance
float filter; // filter out small variations of this size
float currentValue; // current value
float newValue; // most recent value
float highCurrentValue; // current value of high split
float highNewValue; // most recent value of high split
void initialize(const RawAbsoluteAxisInfo& rawAxisInfo, const AxisInfo& axisInfo,
bool explicitlyMapped, float scale, float offset,
float highScale, float highOffset,
float min, float max, float flat, float fuzz) {
this->rawAxisInfo = rawAxisInfo;
this->axisInfo = axisInfo;
this->explicitlyMapped = explicitlyMapped;
this->scale = scale;
this->offset = offset;
this->highScale = highScale;
this->highOffset = highOffset;
this->min = min;
this->max = max;
this->flat = flat;
this->fuzz = fuzz;
this->filter = 0;
resetValue();
}
void resetValue() {
this->currentValue = 0;
this->newValue = 0;
this->highCurrentValue = 0;
this->highNewValue = 0;
}
};
// Axes indexed by raw ABS_* axis index.
KeyedVector<int32_t, Axis> mAxes;
void sync(nsecs_t when, bool force);
bool haveAxis(int32_t axisId);
void pruneAxes(bool ignoreExplicitlyMappedAxes);
bool filterAxes(bool force);
static bool hasValueChangedSignificantly(float filter,
float newValue, float currentValue, float min, float max);
static bool hasMovedNearerToValueWithinFilteredRange(float filter,
float newValue, float currentValue, float thresholdValue);
static bool isCenteredAxis(int32_t axis);
};
} // namespace android
#endif // _UI_INPUT_READER_H
|