1 /*
2  * Copyright (C) 2010 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #ifndef _UI_INPUT_READER_H
18 #define _UI_INPUT_READER_H
19 
20 #include "EventHub.h"
21 #include "PointerControllerInterface.h"
22 #include "InputListener.h"
23 
24 #include <input/DisplayViewport.h>
25 #include <input/Input.h>
26 #include <input/VelocityControl.h>
27 #include <input/VelocityTracker.h>
28 #include <ui/DisplayInfo.h>
29 #include <utils/KeyedVector.h>
30 #include <utils/Condition.h>
31 #include <utils/Thread.h>
32 #include <utils/Mutex.h>
33 #include <utils/Timers.h>
34 #include <utils/RefBase.h>
35 #include <utils/BitSet.h>
36 #include <utils/SortedVector.h>
37 
38 #include <stddef.h>
39 #include <unistd.h>
40 
41 // Maximum supported size of a vibration pattern.
42 // Must be at least 2.
43 #define MAX_VIBRATE_PATTERN_SIZE 100
44 
45 // Maximum allowable delay value in a vibration pattern before
46 // which the delay will be truncated.
47 #define MAX_VIBRATE_PATTERN_DELAY_NSECS (1000000 * 1000000000LL)
48 
49 namespace android {
50 
51 class InputDevice;
52 class InputMapper;
53 
54 /*
55  * Input reader configuration.
56  *
57  * Specifies various options that modify the behavior of the input reader.
58  */
59 struct InputReaderConfiguration {
60     // Describes changes that have occurred.
61     enum {
62         // The pointer speed changed.
63         CHANGE_POINTER_SPEED = 1 << 0,
64 
65         // The pointer gesture control changed.
66         CHANGE_POINTER_GESTURE_ENABLEMENT = 1 << 1,
67 
68         // The display size or orientation changed.
69         CHANGE_DISPLAY_INFO = 1 << 2,
70 
71         // The visible touches option changed.
72         CHANGE_SHOW_TOUCHES = 1 << 3,
73 
74         // The keyboard layouts must be reloaded.
75         CHANGE_KEYBOARD_LAYOUTS = 1 << 4,
76 
77         // The device name alias supplied by the may have changed for some devices.
78         CHANGE_DEVICE_ALIAS = 1 << 5,
79 
80         // The location calibration matrix changed.
81         CHANGE_TOUCH_AFFINE_TRANSFORMATION = 1 << 6,
82 
83         // The presence of an external stylus has changed.
84         CHANGE_EXTERNAL_STYLUS_PRESENCE = 1 << 7,
85 
86         // The pointer capture mode has changed.
87         CHANGE_POINTER_CAPTURE = 1 << 8,
88 
89         // The set of disabled input devices (disabledDevices) has changed.
90         CHANGE_ENABLED_STATE = 1 << 9,
91 
92         // All devices must be reopened.
93         CHANGE_MUST_REOPEN = 1 << 31,
94     };
95 
96     // Gets the amount of time to disable virtual keys after the screen is touched
97     // in order to filter out accidental virtual key presses due to swiping gestures
98     // or taps near the edge of the display.  May be 0 to disable the feature.
99     nsecs_t virtualKeyQuietTime;
100 
101     // The excluded device names for the platform.
102     // Devices with these names will be ignored.
103     Vector<String8> excludedDeviceNames;
104 
105     // Velocity control parameters for mouse pointer movements.
106     VelocityControlParameters pointerVelocityControlParameters;
107 
108     // Velocity control parameters for mouse wheel movements.
109     VelocityControlParameters wheelVelocityControlParameters;
110 
111     // True if pointer gestures are enabled.
112     bool pointerGesturesEnabled;
113 
114     // Quiet time between certain pointer gesture transitions.
115     // Time to allow for all fingers or buttons to settle into a stable state before
116     // starting a new gesture.
117     nsecs_t pointerGestureQuietInterval;
118 
119     // The minimum speed that a pointer must travel for us to consider switching the active
120     // touch pointer to it during a drag.  This threshold is set to avoid switching due
121     // to noise from a finger resting on the touch pad (perhaps just pressing it down).
122     float pointerGestureDragMinSwitchSpeed; // in pixels per second
123 
124     // Tap gesture delay time.
125     // The time between down and up must be less than this to be considered a tap.
126     nsecs_t pointerGestureTapInterval;
127 
128     // Tap drag gesture delay time.
129     // The time between the previous tap's up and the next down must be less than
130     // this to be considered a drag.  Otherwise, the previous tap is finished and a
131     // new tap begins.
132     //
133     // Note that the previous tap will be held down for this entire duration so this
134     // interval must be shorter than the long press timeout.
135     nsecs_t pointerGestureTapDragInterval;
136 
137     // The distance in pixels that the pointer is allowed to move from initial down
138     // to up and still be called a tap.
139     float pointerGestureTapSlop; // in pixels
140 
141     // Time after the first touch points go down to settle on an initial centroid.
142     // This is intended to be enough time to handle cases where the user puts down two
143     // fingers at almost but not quite exactly the same time.
144     nsecs_t pointerGestureMultitouchSettleInterval;
145 
146     // The transition from PRESS to SWIPE or FREEFORM gesture mode is made when
147     // at least two pointers have moved at least this far from their starting place.
148     float pointerGestureMultitouchMinDistance; // in pixels
149 
150     // The transition from PRESS to SWIPE gesture mode can only occur when the
151     // cosine of the angle between the two vectors is greater than or equal to than this value
152     // which indicates that the vectors are oriented in the same direction.
153     // When the vectors are oriented in the exactly same direction, the cosine is 1.0.
154     // (In exactly opposite directions, the cosine is -1.0.)
155     float pointerGestureSwipeTransitionAngleCosine;
156 
157     // The transition from PRESS to SWIPE gesture mode can only occur when the
158     // fingers are no more than this far apart relative to the diagonal size of
159     // the touch pad.  For example, a ratio of 0.5 means that the fingers must be
160     // no more than half the diagonal size of the touch pad apart.
161     float pointerGestureSwipeMaxWidthRatio;
162 
163     // The gesture movement speed factor relative to the size of the display.
164     // Movement speed applies when the fingers are moving in the same direction.
165     // Without acceleration, a full swipe of the touch pad diagonal in movement mode
166     // will cover this portion of the display diagonal.
167     float pointerGestureMovementSpeedRatio;
168 
169     // The gesture zoom speed factor relative to the size of the display.
170     // Zoom speed applies when the fingers are mostly moving relative to each other
171     // to execute a scale gesture or similar.
172     // Without acceleration, a full swipe of the touch pad diagonal in zoom mode
173     // will cover this portion of the display diagonal.
174     float pointerGestureZoomSpeedRatio;
175 
176     // True to show the location of touches on the touch screen as spots.
177     bool showTouches;
178 
179     // True if pointer capture is enabled.
180     bool pointerCapture;
181 
182     // The set of currently disabled input devices.
183     SortedVector<int32_t> disabledDevices;
184 
InputReaderConfigurationInputReaderConfiguration185     InputReaderConfiguration() :
186             virtualKeyQuietTime(0),
187             pointerVelocityControlParameters(1.0f, 500.0f, 3000.0f, 3.0f),
188             wheelVelocityControlParameters(1.0f, 15.0f, 50.0f, 4.0f),
189             pointerGesturesEnabled(true),
190             pointerGestureQuietInterval(100 * 1000000LL), // 100 ms
191             pointerGestureDragMinSwitchSpeed(50), // 50 pixels per second
192             pointerGestureTapInterval(150 * 1000000LL), // 150 ms
193             pointerGestureTapDragInterval(150 * 1000000LL), // 150 ms
194             pointerGestureTapSlop(10.0f), // 10 pixels
195             pointerGestureMultitouchSettleInterval(100 * 1000000LL), // 100 ms
196             pointerGestureMultitouchMinDistance(15), // 15 pixels
197             pointerGestureSwipeTransitionAngleCosine(0.2588f), // cosine of 75 degrees
198             pointerGestureSwipeMaxWidthRatio(0.25f),
199             pointerGestureMovementSpeedRatio(0.8f),
200             pointerGestureZoomSpeedRatio(0.3f),
201             showTouches(false) { }
202 
203     bool getDisplayViewport(ViewportType viewportType, const String8* displayId,
204             DisplayViewport* outViewport) const;
205     void setPhysicalDisplayViewport(ViewportType viewportType, const DisplayViewport& viewport);
206     void setVirtualDisplayViewports(const Vector<DisplayViewport>& viewports);
207 
208 
209     void dump(std::string& dump) const;
210     void dumpViewport(std::string& dump, const DisplayViewport& viewport) const;
211 
212 private:
213     DisplayViewport mInternalDisplay;
214     DisplayViewport mExternalDisplay;
215     Vector<DisplayViewport> mVirtualDisplays;
216 };
217 
218 
219 struct TouchAffineTransformation {
220     float x_scale;
221     float x_ymix;
222     float x_offset;
223     float y_xmix;
224     float y_scale;
225     float y_offset;
226 
TouchAffineTransformationTouchAffineTransformation227     TouchAffineTransformation() :
228         x_scale(1.0f), x_ymix(0.0f), x_offset(0.0f),
229         y_xmix(0.0f), y_scale(1.0f), y_offset(0.0f) {
230     }
231 
TouchAffineTransformationTouchAffineTransformation232     TouchAffineTransformation(float xscale, float xymix, float xoffset,
233             float yxmix, float yscale, float yoffset) :
234         x_scale(xscale), x_ymix(xymix), x_offset(xoffset),
235         y_xmix(yxmix), y_scale(yscale), y_offset(yoffset) {
236     }
237 
238     void applyTo(float& x, float& y) const;
239 };
240 
241 
242 /*
243  * Input reader policy interface.
244  *
245  * The input reader policy is used by the input reader to interact with the Window Manager
246  * and other system components.
247  *
248  * The actual implementation is partially supported by callbacks into the DVM
249  * via JNI.  This interface is also mocked in the unit tests.
250  *
251  * These methods must NOT re-enter the input reader since they may be called while
252  * holding the input reader lock.
253  */
254 class InputReaderPolicyInterface : public virtual RefBase {
255 protected:
InputReaderPolicyInterface()256     InputReaderPolicyInterface() { }
~InputReaderPolicyInterface()257     virtual ~InputReaderPolicyInterface() { }
258 
259 public:
260     /* Gets the input reader configuration. */
261     virtual void getReaderConfiguration(InputReaderConfiguration* outConfig) = 0;
262 
263     /* Gets a pointer controller associated with the specified cursor device (ie. a mouse). */
264     virtual sp<PointerControllerInterface> obtainPointerController(int32_t deviceId) = 0;
265 
266     /* Notifies the input reader policy that some input devices have changed
267      * and provides information about all current input devices.
268      */
269     virtual void notifyInputDevicesChanged(const Vector<InputDeviceInfo>& inputDevices) = 0;
270 
271     /* Gets the keyboard layout for a particular input device. */
272     virtual sp<KeyCharacterMap> getKeyboardLayoutOverlay(
273             const InputDeviceIdentifier& identifier) = 0;
274 
275     /* Gets a user-supplied alias for a particular input device, or an empty string if none. */
276     virtual String8 getDeviceAlias(const InputDeviceIdentifier& identifier) = 0;
277 
278     /* Gets the affine calibration associated with the specified device. */
279     virtual TouchAffineTransformation getTouchAffineTransformation(
280             const String8& inputDeviceDescriptor, int32_t surfaceRotation) = 0;
281 };
282 
283 
284 /* Processes raw input events and sends cooked event data to an input listener. */
285 class InputReaderInterface : public virtual RefBase {
286 protected:
InputReaderInterface()287     InputReaderInterface() { }
~InputReaderInterface()288     virtual ~InputReaderInterface() { }
289 
290 public:
291     /* Dumps the state of the input reader.
292      *
293      * This method may be called on any thread (usually by the input manager). */
294     virtual void dump(std::string& dump) = 0;
295 
296     /* Called by the heatbeat to ensures that the reader has not deadlocked. */
297     virtual void monitor() = 0;
298 
299     /* Returns true if the input device is enabled. */
300     virtual bool isInputDeviceEnabled(int32_t deviceId) = 0;
301 
302     /* Runs a single iteration of the processing loop.
303      * Nominally reads and processes one incoming message from the EventHub.
304      *
305      * This method should be called on the input reader thread.
306      */
307     virtual void loopOnce() = 0;
308 
309     /* Gets information about all input devices.
310      *
311      * This method may be called on any thread (usually by the input manager).
312      */
313     virtual void getInputDevices(Vector<InputDeviceInfo>& outInputDevices) = 0;
314 
315     /* Query current input state. */
316     virtual int32_t getScanCodeState(int32_t deviceId, uint32_t sourceMask,
317             int32_t scanCode) = 0;
318     virtual int32_t getKeyCodeState(int32_t deviceId, uint32_t sourceMask,
319             int32_t keyCode) = 0;
320     virtual int32_t getSwitchState(int32_t deviceId, uint32_t sourceMask,
321             int32_t sw) = 0;
322 
323     /* Toggle Caps Lock */
324     virtual void toggleCapsLockState(int32_t deviceId) = 0;
325 
326     /* Determine whether physical keys exist for the given framework-domain key codes. */
327     virtual bool hasKeys(int32_t deviceId, uint32_t sourceMask,
328             size_t numCodes, const int32_t* keyCodes, uint8_t* outFlags) = 0;
329 
330     /* Requests that a reconfiguration of all input devices.
331      * The changes flag is a bitfield that indicates what has changed and whether
332      * the input devices must all be reopened. */
333     virtual void requestRefreshConfiguration(uint32_t changes) = 0;
334 
335     /* Controls the vibrator of a particular input device. */
336     virtual void vibrate(int32_t deviceId, const nsecs_t* pattern, size_t patternSize,
337             ssize_t repeat, int32_t token) = 0;
338     virtual void cancelVibrate(int32_t deviceId, int32_t token) = 0;
339 };
340 
341 struct StylusState {
342     /* Time the stylus event was received. */
343     nsecs_t when;
344     /* Pressure as reported by the stylus, normalized to the range [0, 1.0]. */
345     float pressure;
346     /* The state of the stylus buttons as a bitfield (e.g. AMOTION_EVENT_BUTTON_SECONDARY). */
347     uint32_t buttons;
348     /* Which tool type the stylus is currently using (e.g. AMOTION_EVENT_TOOL_TYPE_ERASER). */
349     int32_t toolType;
350 
copyFromStylusState351     void copyFrom(const StylusState& other) {
352         when = other.when;
353         pressure = other.pressure;
354         buttons = other.buttons;
355         toolType = other.toolType;
356     }
357 
clearStylusState358     void clear() {
359         when = LLONG_MAX;
360         pressure = 0.f;
361         buttons = 0;
362         toolType = AMOTION_EVENT_TOOL_TYPE_UNKNOWN;
363     }
364 };
365 
366 
367 /* Internal interface used by individual input devices to access global input device state
368  * and parameters maintained by the input reader.
369  */
370 class InputReaderContext {
371 public:
InputReaderContext()372     InputReaderContext() { }
~InputReaderContext()373     virtual ~InputReaderContext() { }
374 
375     virtual void updateGlobalMetaState() = 0;
376     virtual int32_t getGlobalMetaState() = 0;
377 
378     virtual void disableVirtualKeysUntil(nsecs_t time) = 0;
379     virtual bool shouldDropVirtualKey(nsecs_t now,
380             InputDevice* device, int32_t keyCode, int32_t scanCode) = 0;
381 
382     virtual void fadePointer() = 0;
383 
384     virtual void requestTimeoutAtTime(nsecs_t when) = 0;
385     virtual int32_t bumpGeneration() = 0;
386 
387     virtual void getExternalStylusDevices(Vector<InputDeviceInfo>& outDevices) = 0;
388     virtual void dispatchExternalStylusState(const StylusState& outState) = 0;
389 
390     virtual InputReaderPolicyInterface* getPolicy() = 0;
391     virtual InputListenerInterface* getListener() = 0;
392     virtual EventHubInterface* getEventHub() = 0;
393 };
394 
395 
396 /* The input reader reads raw event data from the event hub and processes it into input events
397  * that it sends to the input listener.  Some functions of the input reader, such as early
398  * event filtering in low power states, are controlled by a separate policy object.
399  *
400  * The InputReader owns a collection of InputMappers.  Most of the work it does happens
401  * on the input reader thread but the InputReader can receive queries from other system
402  * components running on arbitrary threads.  To keep things manageable, the InputReader
403  * uses a single Mutex to guard its state.  The Mutex may be held while calling into the
404  * EventHub or the InputReaderPolicy but it is never held while calling into the
405  * InputListener.
406  */
407 class InputReader : public InputReaderInterface {
408 public:
409     InputReader(const sp<EventHubInterface>& eventHub,
410             const sp<InputReaderPolicyInterface>& policy,
411             const sp<InputListenerInterface>& listener);
412     virtual ~InputReader();
413 
414     virtual void dump(std::string& dump);
415     virtual void monitor();
416 
417     virtual void loopOnce();
418 
419     virtual void getInputDevices(Vector<InputDeviceInfo>& outInputDevices);
420 
421     virtual bool isInputDeviceEnabled(int32_t deviceId);
422 
423     virtual int32_t getScanCodeState(int32_t deviceId, uint32_t sourceMask,
424             int32_t scanCode);
425     virtual int32_t getKeyCodeState(int32_t deviceId, uint32_t sourceMask,
426             int32_t keyCode);
427     virtual int32_t getSwitchState(int32_t deviceId, uint32_t sourceMask,
428             int32_t sw);
429 
430     virtual void toggleCapsLockState(int32_t deviceId);
431 
432     virtual bool hasKeys(int32_t deviceId, uint32_t sourceMask,
433             size_t numCodes, const int32_t* keyCodes, uint8_t* outFlags);
434 
435     virtual void requestRefreshConfiguration(uint32_t changes);
436 
437     virtual void vibrate(int32_t deviceId, const nsecs_t* pattern, size_t patternSize,
438             ssize_t repeat, int32_t token);
439     virtual void cancelVibrate(int32_t deviceId, int32_t token);
440 
441 protected:
442     // These members are protected so they can be instrumented by test cases.
443     virtual InputDevice* createDeviceLocked(int32_t deviceId, int32_t controllerNumber,
444             const InputDeviceIdentifier& identifier, uint32_t classes);
445 
446     class ContextImpl : public InputReaderContext {
447         InputReader* mReader;
448 
449     public:
450         explicit ContextImpl(InputReader* reader);
451 
452         virtual void updateGlobalMetaState();
453         virtual int32_t getGlobalMetaState();
454         virtual void disableVirtualKeysUntil(nsecs_t time);
455         virtual bool shouldDropVirtualKey(nsecs_t now,
456                 InputDevice* device, int32_t keyCode, int32_t scanCode);
457         virtual void fadePointer();
458         virtual void requestTimeoutAtTime(nsecs_t when);
459         virtual int32_t bumpGeneration();
460         virtual void getExternalStylusDevices(Vector<InputDeviceInfo>& outDevices);
461         virtual void dispatchExternalStylusState(const StylusState& outState);
462         virtual InputReaderPolicyInterface* getPolicy();
463         virtual InputListenerInterface* getListener();
464         virtual EventHubInterface* getEventHub();
465     } mContext;
466 
467     friend class ContextImpl;
468 
469 private:
470     Mutex mLock;
471 
472     Condition mReaderIsAliveCondition;
473 
474     sp<EventHubInterface> mEventHub;
475     sp<InputReaderPolicyInterface> mPolicy;
476     sp<QueuedInputListener> mQueuedListener;
477 
478     InputReaderConfiguration mConfig;
479 
480     // The event queue.
481     static const int EVENT_BUFFER_SIZE = 256;
482     RawEvent mEventBuffer[EVENT_BUFFER_SIZE];
483 
484     KeyedVector<int32_t, InputDevice*> mDevices;
485 
486     // low-level input event decoding and device management
487     void processEventsLocked(const RawEvent* rawEvents, size_t count);
488 
489     void addDeviceLocked(nsecs_t when, int32_t deviceId);
490     void removeDeviceLocked(nsecs_t when, int32_t deviceId);
491     void processEventsForDeviceLocked(int32_t deviceId, const RawEvent* rawEvents, size_t count);
492     void timeoutExpiredLocked(nsecs_t when);
493 
494     void handleConfigurationChangedLocked(nsecs_t when);
495 
496     int32_t mGlobalMetaState;
497     void updateGlobalMetaStateLocked();
498     int32_t getGlobalMetaStateLocked();
499 
500     void notifyExternalStylusPresenceChanged();
501     void getExternalStylusDevicesLocked(Vector<InputDeviceInfo>& outDevices);
502     void dispatchExternalStylusState(const StylusState& state);
503 
504     void fadePointerLocked();
505 
506     int32_t mGeneration;
507     int32_t bumpGenerationLocked();
508 
509     void getInputDevicesLocked(Vector<InputDeviceInfo>& outInputDevices);
510 
511     nsecs_t mDisableVirtualKeysTimeout;
512     void disableVirtualKeysUntilLocked(nsecs_t time);
513     bool shouldDropVirtualKeyLocked(nsecs_t now,
514             InputDevice* device, int32_t keyCode, int32_t scanCode);
515 
516     nsecs_t mNextTimeout;
517     void requestTimeoutAtTimeLocked(nsecs_t when);
518 
519     uint32_t mConfigurationChangesToRefresh;
520     void refreshConfigurationLocked(uint32_t changes);
521 
522     // state queries
523     typedef int32_t (InputDevice::*GetStateFunc)(uint32_t sourceMask, int32_t code);
524     int32_t getStateLocked(int32_t deviceId, uint32_t sourceMask, int32_t code,
525             GetStateFunc getStateFunc);
526     bool markSupportedKeyCodesLocked(int32_t deviceId, uint32_t sourceMask, size_t numCodes,
527             const int32_t* keyCodes, uint8_t* outFlags);
528 };
529 
530 
531 /* Reads raw events from the event hub and processes them, endlessly. */
532 class InputReaderThread : public Thread {
533 public:
534     explicit InputReaderThread(const sp<InputReaderInterface>& reader);
535     virtual ~InputReaderThread();
536 
537 private:
538     sp<InputReaderInterface> mReader;
539 
540     virtual bool threadLoop();
541 };
542 
543 
544 /* Represents the state of a single input device. */
545 class InputDevice {
546 public:
547     InputDevice(InputReaderContext* context, int32_t id, int32_t generation, int32_t
548             controllerNumber, const InputDeviceIdentifier& identifier, uint32_t classes);
549     ~InputDevice();
550 
getContext()551     inline InputReaderContext* getContext() { return mContext; }
getId()552     inline int32_t getId() const { return mId; }
getControllerNumber()553     inline int32_t getControllerNumber() const { return mControllerNumber; }
getGeneration()554     inline int32_t getGeneration() const { return mGeneration; }
getName()555     inline const String8& getName() const { return mIdentifier.name; }
getDescriptor()556     inline const String8& getDescriptor() { return mIdentifier.descriptor; }
getClasses()557     inline uint32_t getClasses() const { return mClasses; }
getSources()558     inline uint32_t getSources() const { return mSources; }
559 
isExternal()560     inline bool isExternal() { return mIsExternal; }
setExternal(bool external)561     inline void setExternal(bool external) { mIsExternal = external; }
562 
setMic(bool hasMic)563     inline void setMic(bool hasMic) { mHasMic = hasMic; }
hasMic()564     inline bool hasMic() const { return mHasMic; }
565 
isIgnored()566     inline bool isIgnored() { return mMappers.isEmpty(); }
567 
568     bool isEnabled();
569     void setEnabled(bool enabled, nsecs_t when);
570 
571     void dump(std::string& dump);
572     void addMapper(InputMapper* mapper);
573     void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);
574     void reset(nsecs_t when);
575     void process(const RawEvent* rawEvents, size_t count);
576     void timeoutExpired(nsecs_t when);
577     void updateExternalStylusState(const StylusState& state);
578 
579     void getDeviceInfo(InputDeviceInfo* outDeviceInfo);
580     int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode);
581     int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode);
582     int32_t getSwitchState(uint32_t sourceMask, int32_t switchCode);
583     bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes,
584             const int32_t* keyCodes, uint8_t* outFlags);
585     void vibrate(const nsecs_t* pattern, size_t patternSize, ssize_t repeat, int32_t token);
586     void cancelVibrate(int32_t token);
587     void cancelTouch(nsecs_t when);
588 
589     int32_t getMetaState();
590     void updateMetaState(int32_t keyCode);
591 
592     void fadePointer();
593 
594     void bumpGeneration();
595 
596     void notifyReset(nsecs_t when);
597 
getConfiguration()598     inline const PropertyMap& getConfiguration() { return mConfiguration; }
getEventHub()599     inline EventHubInterface* getEventHub() { return mContext->getEventHub(); }
600 
hasKey(int32_t code)601     bool hasKey(int32_t code) {
602         return getEventHub()->hasScanCode(mId, code);
603     }
604 
hasAbsoluteAxis(int32_t code)605     bool hasAbsoluteAxis(int32_t code) {
606         RawAbsoluteAxisInfo info;
607         getEventHub()->getAbsoluteAxisInfo(mId, code, &info);
608         return info.valid;
609     }
610 
isKeyPressed(int32_t code)611     bool isKeyPressed(int32_t code) {
612         return getEventHub()->getScanCodeState(mId, code) == AKEY_STATE_DOWN;
613     }
614 
getAbsoluteAxisValue(int32_t code)615     int32_t getAbsoluteAxisValue(int32_t code) {
616         int32_t value;
617         getEventHub()->getAbsoluteAxisValue(mId, code, &value);
618         return value;
619     }
620 
621 private:
622     InputReaderContext* mContext;
623     int32_t mId;
624     int32_t mGeneration;
625     int32_t mControllerNumber;
626     InputDeviceIdentifier mIdentifier;
627     String8 mAlias;
628     uint32_t mClasses;
629 
630     Vector<InputMapper*> mMappers;
631 
632     uint32_t mSources;
633     bool mIsExternal;
634     bool mHasMic;
635     bool mDropUntilNextSync;
636 
637     typedef int32_t (InputMapper::*GetStateFunc)(uint32_t sourceMask, int32_t code);
638     int32_t getState(uint32_t sourceMask, int32_t code, GetStateFunc getStateFunc);
639 
640     PropertyMap mConfiguration;
641 };
642 
643 
644 /* Keeps track of the state of mouse or touch pad buttons. */
645 class CursorButtonAccumulator {
646 public:
647     CursorButtonAccumulator();
648     void reset(InputDevice* device);
649 
650     void process(const RawEvent* rawEvent);
651 
652     uint32_t getButtonState() const;
653 
654 private:
655     bool mBtnLeft;
656     bool mBtnRight;
657     bool mBtnMiddle;
658     bool mBtnBack;
659     bool mBtnSide;
660     bool mBtnForward;
661     bool mBtnExtra;
662     bool mBtnTask;
663 
664     void clearButtons();
665 };
666 
667 
668 /* Keeps track of cursor movements. */
669 
670 class CursorMotionAccumulator {
671 public:
672     CursorMotionAccumulator();
673     void reset(InputDevice* device);
674 
675     void process(const RawEvent* rawEvent);
676     void finishSync();
677 
getRelativeX()678     inline int32_t getRelativeX() const { return mRelX; }
getRelativeY()679     inline int32_t getRelativeY() const { return mRelY; }
680 
681 private:
682     int32_t mRelX;
683     int32_t mRelY;
684 
685     void clearRelativeAxes();
686 };
687 
688 
689 /* Keeps track of cursor scrolling motions. */
690 
691 class CursorScrollAccumulator {
692 public:
693     CursorScrollAccumulator();
694     void configure(InputDevice* device);
695     void reset(InputDevice* device);
696 
697     void process(const RawEvent* rawEvent);
698     void finishSync();
699 
haveRelativeVWheel()700     inline bool haveRelativeVWheel() const { return mHaveRelWheel; }
haveRelativeHWheel()701     inline bool haveRelativeHWheel() const { return mHaveRelHWheel; }
702 
getRelativeX()703     inline int32_t getRelativeX() const { return mRelX; }
getRelativeY()704     inline int32_t getRelativeY() const { return mRelY; }
getRelativeVWheel()705     inline int32_t getRelativeVWheel() const { return mRelWheel; }
getRelativeHWheel()706     inline int32_t getRelativeHWheel() const { return mRelHWheel; }
707 
708 private:
709     bool mHaveRelWheel;
710     bool mHaveRelHWheel;
711 
712     int32_t mRelX;
713     int32_t mRelY;
714     int32_t mRelWheel;
715     int32_t mRelHWheel;
716 
717     void clearRelativeAxes();
718 };
719 
720 
721 /* Keeps track of the state of touch, stylus and tool buttons. */
722 class TouchButtonAccumulator {
723 public:
724     TouchButtonAccumulator();
725     void configure(InputDevice* device);
726     void reset(InputDevice* device);
727 
728     void process(const RawEvent* rawEvent);
729 
730     uint32_t getButtonState() const;
731     int32_t getToolType() const;
732     bool isToolActive() const;
733     bool isHovering() const;
734     bool hasStylus() const;
735 
736 private:
737     bool mHaveBtnTouch;
738     bool mHaveStylus;
739 
740     bool mBtnTouch;
741     bool mBtnStylus;
742     bool mBtnStylus2;
743     bool mBtnToolFinger;
744     bool mBtnToolPen;
745     bool mBtnToolRubber;
746     bool mBtnToolBrush;
747     bool mBtnToolPencil;
748     bool mBtnToolAirbrush;
749     bool mBtnToolMouse;
750     bool mBtnToolLens;
751     bool mBtnToolDoubleTap;
752     bool mBtnToolTripleTap;
753     bool mBtnToolQuadTap;
754 
755     void clearButtons();
756 };
757 
758 
759 /* Raw axis information from the driver. */
760 struct RawPointerAxes {
761     RawAbsoluteAxisInfo x;
762     RawAbsoluteAxisInfo y;
763     RawAbsoluteAxisInfo pressure;
764     RawAbsoluteAxisInfo touchMajor;
765     RawAbsoluteAxisInfo touchMinor;
766     RawAbsoluteAxisInfo toolMajor;
767     RawAbsoluteAxisInfo toolMinor;
768     RawAbsoluteAxisInfo orientation;
769     RawAbsoluteAxisInfo distance;
770     RawAbsoluteAxisInfo tiltX;
771     RawAbsoluteAxisInfo tiltY;
772     RawAbsoluteAxisInfo trackingId;
773     RawAbsoluteAxisInfo slot;
774 
775     RawPointerAxes();
776     void clear();
777 };
778 
779 
780 /* Raw data for a collection of pointers including a pointer id mapping table. */
781 struct RawPointerData {
782     struct Pointer {
783         uint32_t id;
784         int32_t x;
785         int32_t y;
786         int32_t pressure;
787         int32_t touchMajor;
788         int32_t touchMinor;
789         int32_t toolMajor;
790         int32_t toolMinor;
791         int32_t orientation;
792         int32_t distance;
793         int32_t tiltX;
794         int32_t tiltY;
795         int32_t toolType; // a fully decoded AMOTION_EVENT_TOOL_TYPE constant
796         bool isHovering;
797     };
798 
799     uint32_t pointerCount;
800     Pointer pointers[MAX_POINTERS];
801     BitSet32 hoveringIdBits, touchingIdBits;
802     uint32_t idToIndex[MAX_POINTER_ID + 1];
803 
804     RawPointerData();
805     void clear();
806     void copyFrom(const RawPointerData& other);
807     void getCentroidOfTouchingPointers(float* outX, float* outY) const;
808 
markIdBitRawPointerData809     inline void markIdBit(uint32_t id, bool isHovering) {
810         if (isHovering) {
811             hoveringIdBits.markBit(id);
812         } else {
813             touchingIdBits.markBit(id);
814         }
815     }
816 
clearIdBitsRawPointerData817     inline void clearIdBits() {
818         hoveringIdBits.clear();
819         touchingIdBits.clear();
820     }
821 
pointerForIdRawPointerData822     inline const Pointer& pointerForId(uint32_t id) const {
823         return pointers[idToIndex[id]];
824     }
825 
isHoveringRawPointerData826     inline bool isHovering(uint32_t pointerIndex) {
827         return pointers[pointerIndex].isHovering;
828     }
829 };
830 
831 
832 /* Cooked data for a collection of pointers including a pointer id mapping table. */
833 struct CookedPointerData {
834     uint32_t pointerCount;
835     PointerProperties pointerProperties[MAX_POINTERS];
836     PointerCoords pointerCoords[MAX_POINTERS];
837     BitSet32 hoveringIdBits, touchingIdBits;
838     uint32_t idToIndex[MAX_POINTER_ID + 1];
839 
840     CookedPointerData();
841     void clear();
842     void copyFrom(const CookedPointerData& other);
843 
pointerCoordsForIdCookedPointerData844     inline const PointerCoords& pointerCoordsForId(uint32_t id) const {
845         return pointerCoords[idToIndex[id]];
846     }
847 
editPointerCoordsWithIdCookedPointerData848     inline PointerCoords& editPointerCoordsWithId(uint32_t id) {
849         return pointerCoords[idToIndex[id]];
850     }
851 
editPointerPropertiesWithIdCookedPointerData852     inline PointerProperties& editPointerPropertiesWithId(uint32_t id) {
853         return pointerProperties[idToIndex[id]];
854     }
855 
isHoveringCookedPointerData856     inline bool isHovering(uint32_t pointerIndex) const {
857         return hoveringIdBits.hasBit(pointerProperties[pointerIndex].id);
858     }
859 
isTouchingCookedPointerData860     inline bool isTouching(uint32_t pointerIndex) const {
861         return touchingIdBits.hasBit(pointerProperties[pointerIndex].id);
862     }
863 };
864 
865 
866 /* Keeps track of the state of single-touch protocol. */
867 class SingleTouchMotionAccumulator {
868 public:
869     SingleTouchMotionAccumulator();
870 
871     void process(const RawEvent* rawEvent);
872     void reset(InputDevice* device);
873 
getAbsoluteX()874     inline int32_t getAbsoluteX() const { return mAbsX; }
getAbsoluteY()875     inline int32_t getAbsoluteY() const { return mAbsY; }
getAbsolutePressure()876     inline int32_t getAbsolutePressure() const { return mAbsPressure; }
getAbsoluteToolWidth()877     inline int32_t getAbsoluteToolWidth() const { return mAbsToolWidth; }
getAbsoluteDistance()878     inline int32_t getAbsoluteDistance() const { return mAbsDistance; }
getAbsoluteTiltX()879     inline int32_t getAbsoluteTiltX() const { return mAbsTiltX; }
getAbsoluteTiltY()880     inline int32_t getAbsoluteTiltY() const { return mAbsTiltY; }
881 
882 private:
883     int32_t mAbsX;
884     int32_t mAbsY;
885     int32_t mAbsPressure;
886     int32_t mAbsToolWidth;
887     int32_t mAbsDistance;
888     int32_t mAbsTiltX;
889     int32_t mAbsTiltY;
890 
891     void clearAbsoluteAxes();
892 };
893 
894 
895 /* Keeps track of the state of multi-touch protocol. */
896 class MultiTouchMotionAccumulator {
897 public:
898     class Slot {
899     public:
isInUse()900         inline bool isInUse() const { return mInUse; }
getX()901         inline int32_t getX() const { return mAbsMTPositionX; }
getY()902         inline int32_t getY() const { return mAbsMTPositionY; }
getTouchMajor()903         inline int32_t getTouchMajor() const { return mAbsMTTouchMajor; }
getTouchMinor()904         inline int32_t getTouchMinor() const {
905             return mHaveAbsMTTouchMinor ? mAbsMTTouchMinor : mAbsMTTouchMajor; }
getToolMajor()906         inline int32_t getToolMajor() const { return mAbsMTWidthMajor; }
getToolMinor()907         inline int32_t getToolMinor() const {
908             return mHaveAbsMTWidthMinor ? mAbsMTWidthMinor : mAbsMTWidthMajor; }
getOrientation()909         inline int32_t getOrientation() const { return mAbsMTOrientation; }
getTrackingId()910         inline int32_t getTrackingId() const { return mAbsMTTrackingId; }
getPressure()911         inline int32_t getPressure() const { return mAbsMTPressure; }
getDistance()912         inline int32_t getDistance() const { return mAbsMTDistance; }
913         inline int32_t getToolType() const;
914 
915     private:
916         friend class MultiTouchMotionAccumulator;
917 
918         bool mInUse;
919         bool mHaveAbsMTTouchMinor;
920         bool mHaveAbsMTWidthMinor;
921         bool mHaveAbsMTToolType;
922 
923         int32_t mAbsMTPositionX;
924         int32_t mAbsMTPositionY;
925         int32_t mAbsMTTouchMajor;
926         int32_t mAbsMTTouchMinor;
927         int32_t mAbsMTWidthMajor;
928         int32_t mAbsMTWidthMinor;
929         int32_t mAbsMTOrientation;
930         int32_t mAbsMTTrackingId;
931         int32_t mAbsMTPressure;
932         int32_t mAbsMTDistance;
933         int32_t mAbsMTToolType;
934 
935         Slot();
936         void clear();
937     };
938 
939     MultiTouchMotionAccumulator();
940     ~MultiTouchMotionAccumulator();
941 
942     void configure(InputDevice* device, size_t slotCount, bool usingSlotsProtocol);
943     void reset(InputDevice* device);
944     void process(const RawEvent* rawEvent);
945     void finishSync();
946     bool hasStylus() const;
947 
getSlotCount()948     inline size_t getSlotCount() const { return mSlotCount; }
getSlot(size_t index)949     inline const Slot* getSlot(size_t index) const { return &mSlots[index]; }
getDeviceTimestamp()950     inline uint32_t getDeviceTimestamp() const { return mDeviceTimestamp; }
951 
952 private:
953     int32_t mCurrentSlot;
954     Slot* mSlots;
955     size_t mSlotCount;
956     bool mUsingSlotsProtocol;
957     bool mHaveStylus;
958     uint32_t mDeviceTimestamp;
959 
960     void clearSlots(int32_t initialSlot);
961 };
962 
963 
964 /* An input mapper transforms raw input events into cooked event data.
965  * A single input device can have multiple associated input mappers in order to interpret
966  * different classes of events.
967  *
968  * InputMapper lifecycle:
969  * - create
970  * - configure with 0 changes
971  * - reset
972  * - process, process, process (may occasionally reconfigure with non-zero changes or reset)
973  * - reset
974  * - destroy
975  */
976 class InputMapper {
977 public:
978     explicit InputMapper(InputDevice* device);
979     virtual ~InputMapper();
980 
getDevice()981     inline InputDevice* getDevice() { return mDevice; }
getDeviceId()982     inline int32_t getDeviceId() { return mDevice->getId(); }
getDeviceName()983     inline const String8 getDeviceName() { return mDevice->getName(); }
getContext()984     inline InputReaderContext* getContext() { return mContext; }
getPolicy()985     inline InputReaderPolicyInterface* getPolicy() { return mContext->getPolicy(); }
getListener()986     inline InputListenerInterface* getListener() { return mContext->getListener(); }
getEventHub()987     inline EventHubInterface* getEventHub() { return mContext->getEventHub(); }
988 
989     virtual uint32_t getSources() = 0;
990     virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
991     virtual void dump(std::string& dump);
992     virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);
993     virtual void reset(nsecs_t when);
994     virtual void process(const RawEvent* rawEvent) = 0;
995     virtual void timeoutExpired(nsecs_t when);
996 
997     virtual int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode);
998     virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode);
999     virtual int32_t getSwitchState(uint32_t sourceMask, int32_t switchCode);
1000     virtual bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes,
1001             const int32_t* keyCodes, uint8_t* outFlags);
1002     virtual void vibrate(const nsecs_t* pattern, size_t patternSize, ssize_t repeat,
1003             int32_t token);
1004     virtual void cancelVibrate(int32_t token);
1005     virtual void cancelTouch(nsecs_t when);
1006 
1007     virtual int32_t getMetaState();
1008     virtual void updateMetaState(int32_t keyCode);
1009 
1010     virtual void updateExternalStylusState(const StylusState& state);
1011 
1012     virtual void fadePointer();
1013 
1014 protected:
1015     InputDevice* mDevice;
1016     InputReaderContext* mContext;
1017 
1018     status_t getAbsoluteAxisInfo(int32_t axis, RawAbsoluteAxisInfo* axisInfo);
1019     void bumpGeneration();
1020 
1021     static void dumpRawAbsoluteAxisInfo(std::string& dump,
1022             const RawAbsoluteAxisInfo& axis, const char* name);
1023     static void dumpStylusState(std::string& dump, const StylusState& state);
1024 };
1025 
1026 
1027 class SwitchInputMapper : public InputMapper {
1028 public:
1029     explicit SwitchInputMapper(InputDevice* device);
1030     virtual ~SwitchInputMapper();
1031 
1032     virtual uint32_t getSources();
1033     virtual void process(const RawEvent* rawEvent);
1034 
1035     virtual int32_t getSwitchState(uint32_t sourceMask, int32_t switchCode);
1036     virtual void dump(std::string& dump);
1037 
1038 private:
1039     uint32_t mSwitchValues;
1040     uint32_t mUpdatedSwitchMask;
1041 
1042     void processSwitch(int32_t switchCode, int32_t switchValue);
1043     void sync(nsecs_t when);
1044 };
1045 
1046 
1047 class VibratorInputMapper : public InputMapper {
1048 public:
1049     explicit VibratorInputMapper(InputDevice* device);
1050     virtual ~VibratorInputMapper();
1051 
1052     virtual uint32_t getSources();
1053     virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
1054     virtual void process(const RawEvent* rawEvent);
1055 
1056     virtual void vibrate(const nsecs_t* pattern, size_t patternSize, ssize_t repeat,
1057             int32_t token);
1058     virtual void cancelVibrate(int32_t token);
1059     virtual void timeoutExpired(nsecs_t when);
1060     virtual void dump(std::string& dump);
1061 
1062 private:
1063     bool mVibrating;
1064     nsecs_t mPattern[MAX_VIBRATE_PATTERN_SIZE];
1065     size_t mPatternSize;
1066     ssize_t mRepeat;
1067     int32_t mToken;
1068     ssize_t mIndex;
1069     nsecs_t mNextStepTime;
1070 
1071     void nextStep();
1072     void stopVibrating();
1073 };
1074 
1075 
1076 class KeyboardInputMapper : public InputMapper {
1077 public:
1078     KeyboardInputMapper(InputDevice* device, uint32_t source, int32_t keyboardType);
1079     virtual ~KeyboardInputMapper();
1080 
1081     virtual uint32_t getSources();
1082     virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
1083     virtual void dump(std::string& dump);
1084     virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);
1085     virtual void reset(nsecs_t when);
1086     virtual void process(const RawEvent* rawEvent);
1087 
1088     virtual int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode);
1089     virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode);
1090     virtual bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes,
1091             const int32_t* keyCodes, uint8_t* outFlags);
1092 
1093     virtual int32_t getMetaState();
1094     virtual void updateMetaState(int32_t keyCode);
1095 
1096 private:
1097     struct KeyDown {
1098         int32_t keyCode;
1099         int32_t scanCode;
1100     };
1101 
1102     uint32_t mSource;
1103     int32_t mKeyboardType;
1104 
1105     int32_t mOrientation; // orientation for dpad keys
1106 
1107     Vector<KeyDown> mKeyDowns; // keys that are down
1108     int32_t mMetaState;
1109     nsecs_t mDownTime; // time of most recent key down
1110 
1111     int32_t mCurrentHidUsage; // most recent HID usage seen this packet, or 0 if none
1112 
1113     struct LedState {
1114         bool avail; // led is available
1115         bool on;    // we think the led is currently on
1116     };
1117     LedState mCapsLockLedState;
1118     LedState mNumLockLedState;
1119     LedState mScrollLockLedState;
1120 
1121     // Immutable configuration parameters.
1122     struct Parameters {
1123         bool hasAssociatedDisplay;
1124         bool orientationAware;
1125         bool handlesKeyRepeat;
1126     } mParameters;
1127 
1128     void configureParameters();
1129     void dumpParameters(std::string& dump);
1130 
1131     bool isKeyboardOrGamepadKey(int32_t scanCode);
1132     bool isMediaKey(int32_t keyCode);
1133 
1134     void processKey(nsecs_t when, bool down, int32_t scanCode, int32_t usageCode);
1135 
1136     bool updateMetaStateIfNeeded(int32_t keyCode, bool down);
1137 
1138     ssize_t findKeyDown(int32_t scanCode);
1139 
1140     void resetLedState();
1141     void initializeLedState(LedState& ledState, int32_t led);
1142     void updateLedState(bool reset);
1143     void updateLedStateForModifier(LedState& ledState, int32_t led,
1144             int32_t modifier, bool reset);
1145 };
1146 
1147 
1148 class CursorInputMapper : public InputMapper {
1149 public:
1150     explicit CursorInputMapper(InputDevice* device);
1151     virtual ~CursorInputMapper();
1152 
1153     virtual uint32_t getSources();
1154     virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
1155     virtual void dump(std::string& dump);
1156     virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);
1157     virtual void reset(nsecs_t when);
1158     virtual void process(const RawEvent* rawEvent);
1159 
1160     virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode);
1161 
1162     virtual void fadePointer();
1163 
1164 private:
1165     // Amount that trackball needs to move in order to generate a key event.
1166     static const int32_t TRACKBALL_MOVEMENT_THRESHOLD = 6;
1167 
1168     // Immutable configuration parameters.
1169     struct Parameters {
1170         enum Mode {
1171             MODE_POINTER,
1172             MODE_POINTER_RELATIVE,
1173             MODE_NAVIGATION,
1174         };
1175 
1176         Mode mode;
1177         bool hasAssociatedDisplay;
1178         bool orientationAware;
1179     } mParameters;
1180 
1181     CursorButtonAccumulator mCursorButtonAccumulator;
1182     CursorMotionAccumulator mCursorMotionAccumulator;
1183     CursorScrollAccumulator mCursorScrollAccumulator;
1184 
1185     int32_t mSource;
1186     float mXScale;
1187     float mYScale;
1188     float mXPrecision;
1189     float mYPrecision;
1190 
1191     float mVWheelScale;
1192     float mHWheelScale;
1193 
1194     // Velocity controls for mouse pointer and wheel movements.
1195     // The controls for X and Y wheel movements are separate to keep them decoupled.
1196     VelocityControl mPointerVelocityControl;
1197     VelocityControl mWheelXVelocityControl;
1198     VelocityControl mWheelYVelocityControl;
1199 
1200     int32_t mOrientation;
1201 
1202     sp<PointerControllerInterface> mPointerController;
1203 
1204     int32_t mButtonState;
1205     nsecs_t mDownTime;
1206 
1207     void configureParameters();
1208     void dumpParameters(std::string& dump);
1209 
1210     void sync(nsecs_t when);
1211 };
1212 
1213 
1214 class RotaryEncoderInputMapper : public InputMapper {
1215 public:
1216     explicit RotaryEncoderInputMapper(InputDevice* device);
1217     virtual ~RotaryEncoderInputMapper();
1218 
1219     virtual uint32_t getSources();
1220     virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
1221     virtual void dump(std::string& dump);
1222     virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);
1223     virtual void reset(nsecs_t when);
1224     virtual void process(const RawEvent* rawEvent);
1225 
1226 private:
1227     CursorScrollAccumulator mRotaryEncoderScrollAccumulator;
1228 
1229     int32_t mSource;
1230     float mScalingFactor;
1231     int32_t mOrientation;
1232 
1233     void sync(nsecs_t when);
1234 };
1235 
1236 class TouchInputMapper : public InputMapper {
1237 public:
1238     explicit TouchInputMapper(InputDevice* device);
1239     virtual ~TouchInputMapper();
1240 
1241     virtual uint32_t getSources();
1242     virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
1243     virtual void dump(std::string& dump);
1244     virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);
1245     virtual void reset(nsecs_t when);
1246     virtual void process(const RawEvent* rawEvent);
1247 
1248     virtual int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode);
1249     virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode);
1250     virtual bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes,
1251             const int32_t* keyCodes, uint8_t* outFlags);
1252 
1253     virtual void fadePointer();
1254     virtual void cancelTouch(nsecs_t when);
1255     virtual void timeoutExpired(nsecs_t when);
1256     virtual void updateExternalStylusState(const StylusState& state);
1257 
1258 protected:
1259     CursorButtonAccumulator mCursorButtonAccumulator;
1260     CursorScrollAccumulator mCursorScrollAccumulator;
1261     TouchButtonAccumulator mTouchButtonAccumulator;
1262 
1263     struct VirtualKey {
1264         int32_t keyCode;
1265         int32_t scanCode;
1266         uint32_t flags;
1267 
1268         // computed hit box, specified in touch screen coords based on known display size
1269         int32_t hitLeft;
1270         int32_t hitTop;
1271         int32_t hitRight;
1272         int32_t hitBottom;
1273 
isHitVirtualKey1274         inline bool isHit(int32_t x, int32_t y) const {
1275             return x >= hitLeft && x <= hitRight && y >= hitTop && y <= hitBottom;
1276         }
1277     };
1278 
1279     // Input sources and device mode.
1280     uint32_t mSource;
1281 
1282     enum DeviceMode {
1283         DEVICE_MODE_DISABLED, // input is disabled
1284         DEVICE_MODE_DIRECT, // direct mapping (touchscreen)
1285         DEVICE_MODE_UNSCALED, // unscaled mapping (touchpad)
1286         DEVICE_MODE_NAVIGATION, // unscaled mapping with assist gesture (touch navigation)
1287         DEVICE_MODE_POINTER, // pointer mapping (pointer)
1288     };
1289     DeviceMode mDeviceMode;
1290 
1291     // The reader's configuration.
1292     InputReaderConfiguration mConfig;
1293 
1294     // Immutable configuration parameters.
1295     struct Parameters {
1296         enum DeviceType {
1297             DEVICE_TYPE_TOUCH_SCREEN,
1298             DEVICE_TYPE_TOUCH_PAD,
1299             DEVICE_TYPE_TOUCH_NAVIGATION,
1300             DEVICE_TYPE_POINTER,
1301         };
1302 
1303         DeviceType deviceType;
1304         bool hasAssociatedDisplay;
1305         bool associatedDisplayIsExternal;
1306         bool orientationAware;
1307         bool hasButtonUnderPad;
1308         String8 uniqueDisplayId;
1309 
1310         enum GestureMode {
1311             GESTURE_MODE_SINGLE_TOUCH,
1312             GESTURE_MODE_MULTI_TOUCH,
1313         };
1314         GestureMode gestureMode;
1315 
1316         bool wake;
1317     } mParameters;
1318 
1319     // Immutable calibration parameters in parsed form.
1320     struct Calibration {
1321         // Size
1322         enum SizeCalibration {
1323             SIZE_CALIBRATION_DEFAULT,
1324             SIZE_CALIBRATION_NONE,
1325             SIZE_CALIBRATION_GEOMETRIC,
1326             SIZE_CALIBRATION_DIAMETER,
1327             SIZE_CALIBRATION_BOX,
1328             SIZE_CALIBRATION_AREA,
1329         };
1330 
1331         SizeCalibration sizeCalibration;
1332 
1333         bool haveSizeScale;
1334         float sizeScale;
1335         bool haveSizeBias;
1336         float sizeBias;
1337         bool haveSizeIsSummed;
1338         bool sizeIsSummed;
1339 
1340         // Pressure
1341         enum PressureCalibration {
1342             PRESSURE_CALIBRATION_DEFAULT,
1343             PRESSURE_CALIBRATION_NONE,
1344             PRESSURE_CALIBRATION_PHYSICAL,
1345             PRESSURE_CALIBRATION_AMPLITUDE,
1346         };
1347 
1348         PressureCalibration pressureCalibration;
1349         bool havePressureScale;
1350         float pressureScale;
1351 
1352         // Orientation
1353         enum OrientationCalibration {
1354             ORIENTATION_CALIBRATION_DEFAULT,
1355             ORIENTATION_CALIBRATION_NONE,
1356             ORIENTATION_CALIBRATION_INTERPOLATED,
1357             ORIENTATION_CALIBRATION_VECTOR,
1358         };
1359 
1360         OrientationCalibration orientationCalibration;
1361 
1362         // Distance
1363         enum DistanceCalibration {
1364             DISTANCE_CALIBRATION_DEFAULT,
1365             DISTANCE_CALIBRATION_NONE,
1366             DISTANCE_CALIBRATION_SCALED,
1367         };
1368 
1369         DistanceCalibration distanceCalibration;
1370         bool haveDistanceScale;
1371         float distanceScale;
1372 
1373         enum CoverageCalibration {
1374             COVERAGE_CALIBRATION_DEFAULT,
1375             COVERAGE_CALIBRATION_NONE,
1376             COVERAGE_CALIBRATION_BOX,
1377         };
1378 
1379         CoverageCalibration coverageCalibration;
1380 
applySizeScaleAndBiasCalibration1381         inline void applySizeScaleAndBias(float* outSize) const {
1382             if (haveSizeScale) {
1383                 *outSize *= sizeScale;
1384             }
1385             if (haveSizeBias) {
1386                 *outSize += sizeBias;
1387             }
1388             if (*outSize < 0) {
1389                 *outSize = 0;
1390             }
1391         }
1392     } mCalibration;
1393 
1394     // Affine location transformation/calibration
1395     struct TouchAffineTransformation mAffineTransform;
1396 
1397     RawPointerAxes mRawPointerAxes;
1398 
1399     struct RawState {
1400         nsecs_t when;
1401         uint32_t deviceTimestamp;
1402 
1403         // Raw pointer sample data.
1404         RawPointerData rawPointerData;
1405 
1406         int32_t buttonState;
1407 
1408         // Scroll state.
1409         int32_t rawVScroll;
1410         int32_t rawHScroll;
1411 
copyFromRawState1412         void copyFrom(const RawState& other) {
1413             when = other.when;
1414             deviceTimestamp = other.deviceTimestamp;
1415             rawPointerData.copyFrom(other.rawPointerData);
1416             buttonState = other.buttonState;
1417             rawVScroll = other.rawVScroll;
1418             rawHScroll = other.rawHScroll;
1419         }
1420 
clearRawState1421         void clear() {
1422             when = 0;
1423             deviceTimestamp = 0;
1424             rawPointerData.clear();
1425             buttonState = 0;
1426             rawVScroll = 0;
1427             rawHScroll = 0;
1428         }
1429     };
1430 
1431     struct CookedState {
1432         uint32_t deviceTimestamp;
1433         // Cooked pointer sample data.
1434         CookedPointerData cookedPointerData;
1435 
1436         // Id bits used to differentiate fingers, stylus and mouse tools.
1437         BitSet32 fingerIdBits;
1438         BitSet32 stylusIdBits;
1439         BitSet32 mouseIdBits;
1440 
1441         int32_t buttonState;
1442 
copyFromCookedState1443         void copyFrom(const CookedState& other) {
1444             deviceTimestamp = other.deviceTimestamp;
1445             cookedPointerData.copyFrom(other.cookedPointerData);
1446             fingerIdBits = other.fingerIdBits;
1447             stylusIdBits = other.stylusIdBits;
1448             mouseIdBits = other.mouseIdBits;
1449             buttonState = other.buttonState;
1450         }
1451 
clearCookedState1452         void clear() {
1453             deviceTimestamp = 0;
1454             cookedPointerData.clear();
1455             fingerIdBits.clear();
1456             stylusIdBits.clear();
1457             mouseIdBits.clear();
1458             buttonState = 0;
1459         }
1460     };
1461 
1462     Vector<RawState> mRawStatesPending;
1463     RawState mCurrentRawState;
1464     CookedState mCurrentCookedState;
1465     RawState mLastRawState;
1466     CookedState mLastCookedState;
1467 
1468     // State provided by an external stylus
1469     StylusState mExternalStylusState;
1470     int64_t mExternalStylusId;
1471     nsecs_t mExternalStylusFusionTimeout;
1472     bool mExternalStylusDataPending;
1473 
1474     // True if we sent a HOVER_ENTER event.
1475     bool mSentHoverEnter;
1476 
1477     // Have we assigned pointer IDs for this stream
1478     bool mHavePointerIds;
1479 
1480     // Is the current stream of direct touch events aborted
1481     bool mCurrentMotionAborted;
1482 
1483     // The time the primary pointer last went down.
1484     nsecs_t mDownTime;
1485 
1486     // The pointer controller, or null if the device is not a pointer.
1487     sp<PointerControllerInterface> mPointerController;
1488 
1489     Vector<VirtualKey> mVirtualKeys;
1490 
1491     virtual void configureParameters();
1492     virtual void dumpParameters(std::string& dump);
1493     virtual void configureRawPointerAxes();
1494     virtual void dumpRawPointerAxes(std::string& dump);
1495     virtual void configureSurface(nsecs_t when, bool* outResetNeeded);
1496     virtual void dumpSurface(std::string& dump);
1497     virtual void configureVirtualKeys();
1498     virtual void dumpVirtualKeys(std::string& dump);
1499     virtual void parseCalibration();
1500     virtual void resolveCalibration();
1501     virtual void dumpCalibration(std::string& dump);
1502     virtual void updateAffineTransformation();
1503     virtual void dumpAffineTransformation(std::string& dump);
1504     virtual void resolveExternalStylusPresence();
1505     virtual bool hasStylus() const = 0;
1506     virtual bool hasExternalStylus() const;
1507 
1508     virtual void syncTouch(nsecs_t when, RawState* outState) = 0;
1509 
1510 private:
1511     // The current viewport.
1512     // The components of the viewport are specified in the display's rotated orientation.
1513     DisplayViewport mViewport;
1514 
1515     // The surface orientation, width and height set by configureSurface().
1516     // The width and height are derived from the viewport but are specified
1517     // in the natural orientation.
1518     // The surface origin specifies how the surface coordinates should be translated
1519     // to align with the logical display coordinate space.
1520     // The orientation may be different from the viewport orientation as it specifies
1521     // the rotation of the surface coordinates required to produce the viewport's
1522     // requested orientation, so it will depend on whether the device is orientation aware.
1523     int32_t mSurfaceWidth;
1524     int32_t mSurfaceHeight;
1525     int32_t mSurfaceLeft;
1526     int32_t mSurfaceTop;
1527     int32_t mSurfaceOrientation;
1528 
1529     // Translation and scaling factors, orientation-independent.
1530     float mXTranslate;
1531     float mXScale;
1532     float mXPrecision;
1533 
1534     float mYTranslate;
1535     float mYScale;
1536     float mYPrecision;
1537 
1538     float mGeometricScale;
1539 
1540     float mPressureScale;
1541 
1542     float mSizeScale;
1543 
1544     float mOrientationScale;
1545 
1546     float mDistanceScale;
1547 
1548     bool mHaveTilt;
1549     float mTiltXCenter;
1550     float mTiltXScale;
1551     float mTiltYCenter;
1552     float mTiltYScale;
1553 
1554     bool mExternalStylusConnected;
1555 
1556     // Oriented motion ranges for input device info.
1557     struct OrientedRanges {
1558         InputDeviceInfo::MotionRange x;
1559         InputDeviceInfo::MotionRange y;
1560         InputDeviceInfo::MotionRange pressure;
1561 
1562         bool haveSize;
1563         InputDeviceInfo::MotionRange size;
1564 
1565         bool haveTouchSize;
1566         InputDeviceInfo::MotionRange touchMajor;
1567         InputDeviceInfo::MotionRange touchMinor;
1568 
1569         bool haveToolSize;
1570         InputDeviceInfo::MotionRange toolMajor;
1571         InputDeviceInfo::MotionRange toolMinor;
1572 
1573         bool haveOrientation;
1574         InputDeviceInfo::MotionRange orientation;
1575 
1576         bool haveDistance;
1577         InputDeviceInfo::MotionRange distance;
1578 
1579         bool haveTilt;
1580         InputDeviceInfo::MotionRange tilt;
1581 
OrientedRangesOrientedRanges1582         OrientedRanges() {
1583             clear();
1584         }
1585 
clearOrientedRanges1586         void clear() {
1587             haveSize = false;
1588             haveTouchSize = false;
1589             haveToolSize = false;
1590             haveOrientation = false;
1591             haveDistance = false;
1592             haveTilt = false;
1593         }
1594     } mOrientedRanges;
1595 
1596     // Oriented dimensions and precision.
1597     float mOrientedXPrecision;
1598     float mOrientedYPrecision;
1599 
1600     struct CurrentVirtualKeyState {
1601         bool down;
1602         bool ignored;
1603         nsecs_t downTime;
1604         int32_t keyCode;
1605         int32_t scanCode;
1606     } mCurrentVirtualKey;
1607 
1608     // Scale factor for gesture or mouse based pointer movements.
1609     float mPointerXMovementScale;
1610     float mPointerYMovementScale;
1611 
1612     // Scale factor for gesture based zooming and other freeform motions.
1613     float mPointerXZoomScale;
1614     float mPointerYZoomScale;
1615 
1616     // The maximum swipe width.
1617     float mPointerGestureMaxSwipeWidth;
1618 
1619     struct PointerDistanceHeapElement {
1620         uint32_t currentPointerIndex : 8;
1621         uint32_t lastPointerIndex : 8;
1622         uint64_t distance : 48; // squared distance
1623     };
1624 
1625     enum PointerUsage {
1626         POINTER_USAGE_NONE,
1627         POINTER_USAGE_GESTURES,
1628         POINTER_USAGE_STYLUS,
1629         POINTER_USAGE_MOUSE,
1630     };
1631     PointerUsage mPointerUsage;
1632 
1633     struct PointerGesture {
1634         enum Mode {
1635             // No fingers, button is not pressed.
1636             // Nothing happening.
1637             NEUTRAL,
1638 
1639             // No fingers, button is not pressed.
1640             // Tap detected.
1641             // Emits DOWN and UP events at the pointer location.
1642             TAP,
1643 
1644             // Exactly one finger dragging following a tap.
1645             // Pointer follows the active finger.
1646             // Emits DOWN, MOVE and UP events at the pointer location.
1647             //
1648             // Detect double-taps when the finger goes up while in TAP_DRAG mode.
1649             TAP_DRAG,
1650 
1651             // Button is pressed.
1652             // Pointer follows the active finger if there is one.  Other fingers are ignored.
1653             // Emits DOWN, MOVE and UP events at the pointer location.
1654             BUTTON_CLICK_OR_DRAG,
1655 
1656             // Exactly one finger, button is not pressed.
1657             // Pointer follows the active finger.
1658             // Emits HOVER_MOVE events at the pointer location.
1659             //
1660             // Detect taps when the finger goes up while in HOVER mode.
1661             HOVER,
1662 
1663             // Exactly two fingers but neither have moved enough to clearly indicate
1664             // whether a swipe or freeform gesture was intended.  We consider the
1665             // pointer to be pressed so this enables clicking or long-pressing on buttons.
1666             // Pointer does not move.
1667             // Emits DOWN, MOVE and UP events with a single stationary pointer coordinate.
1668             PRESS,
1669 
1670             // Exactly two fingers moving in the same direction, button is not pressed.
1671             // Pointer does not move.
1672             // Emits DOWN, MOVE and UP events with a single pointer coordinate that
1673             // follows the midpoint between both fingers.
1674             SWIPE,
1675 
1676             // Two or more fingers moving in arbitrary directions, button is not pressed.
1677             // Pointer does not move.
1678             // Emits DOWN, POINTER_DOWN, MOVE, POINTER_UP and UP events that follow
1679             // each finger individually relative to the initial centroid of the finger.
1680             FREEFORM,
1681 
1682             // Waiting for quiet time to end before starting the next gesture.
1683             QUIET,
1684         };
1685 
1686         // Time the first finger went down.
1687         nsecs_t firstTouchTime;
1688 
1689         // The active pointer id from the raw touch data.
1690         int32_t activeTouchId; // -1 if none
1691 
1692         // The active pointer id from the gesture last delivered to the application.
1693         int32_t activeGestureId; // -1 if none
1694 
1695         // Pointer coords and ids for the current and previous pointer gesture.
1696         Mode currentGestureMode;
1697         BitSet32 currentGestureIdBits;
1698         uint32_t currentGestureIdToIndex[MAX_POINTER_ID + 1];
1699         PointerProperties currentGestureProperties[MAX_POINTERS];
1700         PointerCoords currentGestureCoords[MAX_POINTERS];
1701 
1702         Mode lastGestureMode;
1703         BitSet32 lastGestureIdBits;
1704         uint32_t lastGestureIdToIndex[MAX_POINTER_ID + 1];
1705         PointerProperties lastGestureProperties[MAX_POINTERS];
1706         PointerCoords lastGestureCoords[MAX_POINTERS];
1707 
1708         // Time the pointer gesture last went down.
1709         nsecs_t downTime;
1710 
1711         // Time when the pointer went down for a TAP.
1712         nsecs_t tapDownTime;
1713 
1714         // Time when the pointer went up for a TAP.
1715         nsecs_t tapUpTime;
1716 
1717         // Location of initial tap.
1718         float tapX, tapY;
1719 
1720         // Time we started waiting for quiescence.
1721         nsecs_t quietTime;
1722 
1723         // Reference points for multitouch gestures.
1724         float referenceTouchX;    // reference touch X/Y coordinates in surface units
1725         float referenceTouchY;
1726         float referenceGestureX;  // reference gesture X/Y coordinates in pixels
1727         float referenceGestureY;
1728 
1729         // Distance that each pointer has traveled which has not yet been
1730         // subsumed into the reference gesture position.
1731         BitSet32 referenceIdBits;
1732         struct Delta {
1733             float dx, dy;
1734         };
1735         Delta referenceDeltas[MAX_POINTER_ID + 1];
1736 
1737         // Describes how touch ids are mapped to gesture ids for freeform gestures.
1738         uint32_t freeformTouchToGestureIdMap[MAX_POINTER_ID + 1];
1739 
1740         // A velocity tracker for determining whether to switch active pointers during drags.
1741         VelocityTracker velocityTracker;
1742 
resetPointerGesture1743         void reset() {
1744             firstTouchTime = LLONG_MIN;
1745             activeTouchId = -1;
1746             activeGestureId = -1;
1747             currentGestureMode = NEUTRAL;
1748             currentGestureIdBits.clear();
1749             lastGestureMode = NEUTRAL;
1750             lastGestureIdBits.clear();
1751             downTime = 0;
1752             velocityTracker.clear();
1753             resetTap();
1754             resetQuietTime();
1755         }
1756 
resetTapPointerGesture1757         void resetTap() {
1758             tapDownTime = LLONG_MIN;
1759             tapUpTime = LLONG_MIN;
1760         }
1761 
resetQuietTimePointerGesture1762         void resetQuietTime() {
1763             quietTime = LLONG_MIN;
1764         }
1765     } mPointerGesture;
1766 
1767     struct PointerSimple {
1768         PointerCoords currentCoords;
1769         PointerProperties currentProperties;
1770         PointerCoords lastCoords;
1771         PointerProperties lastProperties;
1772 
1773         // True if the pointer is down.
1774         bool down;
1775 
1776         // True if the pointer is hovering.
1777         bool hovering;
1778 
1779         // Time the pointer last went down.
1780         nsecs_t downTime;
1781 
resetPointerSimple1782         void reset() {
1783             currentCoords.clear();
1784             currentProperties.clear();
1785             lastCoords.clear();
1786             lastProperties.clear();
1787             down = false;
1788             hovering = false;
1789             downTime = 0;
1790         }
1791     } mPointerSimple;
1792 
1793     // The pointer and scroll velocity controls.
1794     VelocityControl mPointerVelocityControl;
1795     VelocityControl mWheelXVelocityControl;
1796     VelocityControl mWheelYVelocityControl;
1797 
1798     void resetExternalStylus();
1799     void clearStylusDataPendingFlags();
1800 
1801     void sync(nsecs_t when);
1802 
1803     bool consumeRawTouches(nsecs_t when, uint32_t policyFlags);
1804     void processRawTouches(bool timeout);
1805     void cookAndDispatch(nsecs_t when);
1806     void dispatchVirtualKey(nsecs_t when, uint32_t policyFlags,
1807             int32_t keyEventAction, int32_t keyEventFlags);
1808 
1809     void dispatchTouches(nsecs_t when, uint32_t policyFlags);
1810     void dispatchHoverExit(nsecs_t when, uint32_t policyFlags);
1811     void dispatchHoverEnterAndMove(nsecs_t when, uint32_t policyFlags);
1812     void dispatchButtonRelease(nsecs_t when, uint32_t policyFlags);
1813     void dispatchButtonPress(nsecs_t when, uint32_t policyFlags);
1814     const BitSet32& findActiveIdBits(const CookedPointerData& cookedPointerData);
1815     void cookPointerData();
1816     void abortTouches(nsecs_t when, uint32_t policyFlags);
1817 
1818     void dispatchPointerUsage(nsecs_t when, uint32_t policyFlags, PointerUsage pointerUsage);
1819     void abortPointerUsage(nsecs_t when, uint32_t policyFlags);
1820 
1821     void dispatchPointerGestures(nsecs_t when, uint32_t policyFlags, bool isTimeout);
1822     void abortPointerGestures(nsecs_t when, uint32_t policyFlags);
1823     bool preparePointerGestures(nsecs_t when,
1824             bool* outCancelPreviousGesture, bool* outFinishPreviousGesture,
1825             bool isTimeout);
1826 
1827     void dispatchPointerStylus(nsecs_t when, uint32_t policyFlags);
1828     void abortPointerStylus(nsecs_t when, uint32_t policyFlags);
1829 
1830     void dispatchPointerMouse(nsecs_t when, uint32_t policyFlags);
1831     void abortPointerMouse(nsecs_t when, uint32_t policyFlags);
1832 
1833     void dispatchPointerSimple(nsecs_t when, uint32_t policyFlags,
1834             bool down, bool hovering);
1835     void abortPointerSimple(nsecs_t when, uint32_t policyFlags);
1836 
1837     bool assignExternalStylusId(const RawState& state, bool timeout);
1838     void applyExternalStylusButtonState(nsecs_t when);
1839     void applyExternalStylusTouchState(nsecs_t when);
1840 
1841     // Dispatches a motion event.
1842     // If the changedId is >= 0 and the action is POINTER_DOWN or POINTER_UP, the
1843     // method will take care of setting the index and transmuting the action to DOWN or UP
1844     // it is the first / last pointer to go down / up.
1845     void dispatchMotion(nsecs_t when, uint32_t policyFlags, uint32_t source,
1846             int32_t action, int32_t actionButton,
1847             int32_t flags, int32_t metaState, int32_t buttonState, int32_t edgeFlags,
1848             uint32_t deviceTimestamp,
1849             const PointerProperties* properties, const PointerCoords* coords,
1850             const uint32_t* idToIndex, BitSet32 idBits,
1851             int32_t changedId, float xPrecision, float yPrecision, nsecs_t downTime);
1852 
1853     // Updates pointer coords and properties for pointers with specified ids that have moved.
1854     // Returns true if any of them changed.
1855     bool updateMovedPointers(const PointerProperties* inProperties,
1856             const PointerCoords* inCoords, const uint32_t* inIdToIndex,
1857             PointerProperties* outProperties, PointerCoords* outCoords,
1858             const uint32_t* outIdToIndex, BitSet32 idBits) const;
1859 
1860     bool isPointInsideSurface(int32_t x, int32_t y);
1861     const VirtualKey* findVirtualKeyHit(int32_t x, int32_t y);
1862 
1863     static void assignPointerIds(const RawState* last, RawState* current);
1864 
1865     const char* modeToString(DeviceMode deviceMode);
1866 };
1867 
1868 
1869 class SingleTouchInputMapper : public TouchInputMapper {
1870 public:
1871     explicit SingleTouchInputMapper(InputDevice* device);
1872     virtual ~SingleTouchInputMapper();
1873 
1874     virtual void reset(nsecs_t when);
1875     virtual void process(const RawEvent* rawEvent);
1876 
1877 protected:
1878     virtual void syncTouch(nsecs_t when, RawState* outState);
1879     virtual void configureRawPointerAxes();
1880     virtual bool hasStylus() const;
1881 
1882 private:
1883     SingleTouchMotionAccumulator mSingleTouchMotionAccumulator;
1884 };
1885 
1886 
1887 class MultiTouchInputMapper : public TouchInputMapper {
1888 public:
1889     explicit MultiTouchInputMapper(InputDevice* device);
1890     virtual ~MultiTouchInputMapper();
1891 
1892     virtual void reset(nsecs_t when);
1893     virtual void process(const RawEvent* rawEvent);
1894 
1895 protected:
1896     virtual void syncTouch(nsecs_t when, RawState* outState);
1897     virtual void configureRawPointerAxes();
1898     virtual bool hasStylus() const;
1899 
1900 private:
1901     MultiTouchMotionAccumulator mMultiTouchMotionAccumulator;
1902 
1903     // Specifies the pointer id bits that are in use, and their associated tracking id.
1904     BitSet32 mPointerIdBits;
1905     int32_t mPointerTrackingIdMap[MAX_POINTER_ID + 1];
1906 };
1907 
1908 class ExternalStylusInputMapper : public InputMapper {
1909 public:
1910     explicit ExternalStylusInputMapper(InputDevice* device);
1911     virtual ~ExternalStylusInputMapper() = default;
1912 
1913     virtual uint32_t getSources();
1914     virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
1915     virtual void dump(std::string& dump);
1916     virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);
1917     virtual void reset(nsecs_t when);
1918     virtual void process(const RawEvent* rawEvent);
1919     virtual void sync(nsecs_t when);
1920 
1921 private:
1922     SingleTouchMotionAccumulator mSingleTouchMotionAccumulator;
1923     RawAbsoluteAxisInfo mRawPressureAxis;
1924     TouchButtonAccumulator mTouchButtonAccumulator;
1925 
1926     StylusState mStylusState;
1927 };
1928 
1929 
1930 class JoystickInputMapper : public InputMapper {
1931 public:
1932     explicit JoystickInputMapper(InputDevice* device);
1933     virtual ~JoystickInputMapper();
1934 
1935     virtual uint32_t getSources();
1936     virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
1937     virtual void dump(std::string& dump);
1938     virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);
1939     virtual void reset(nsecs_t when);
1940     virtual void process(const RawEvent* rawEvent);
1941 
1942 private:
1943     struct Axis {
1944         RawAbsoluteAxisInfo rawAxisInfo;
1945         AxisInfo axisInfo;
1946 
1947         bool explicitlyMapped; // true if the axis was explicitly assigned an axis id
1948 
1949         float scale;   // scale factor from raw to normalized values
1950         float offset;  // offset to add after scaling for normalization
1951         float highScale;  // scale factor from raw to normalized values of high split
1952         float highOffset; // offset to add after scaling for normalization of high split
1953 
1954         float min;        // normalized inclusive minimum
1955         float max;        // normalized inclusive maximum
1956         float flat;       // normalized flat region size
1957         float fuzz;       // normalized error tolerance
1958         float resolution; // normalized resolution in units/mm
1959 
1960         float filter;  // filter out small variations of this size
1961         float currentValue; // current value
1962         float newValue; // most recent value
1963         float highCurrentValue; // current value of high split
1964         float highNewValue; // most recent value of high split
1965 
initializeAxis1966         void initialize(const RawAbsoluteAxisInfo& rawAxisInfo, const AxisInfo& axisInfo,
1967                 bool explicitlyMapped, float scale, float offset,
1968                 float highScale, float highOffset,
1969                 float min, float max, float flat, float fuzz, float resolution) {
1970             this->rawAxisInfo = rawAxisInfo;
1971             this->axisInfo = axisInfo;
1972             this->explicitlyMapped = explicitlyMapped;
1973             this->scale = scale;
1974             this->offset = offset;
1975             this->highScale = highScale;
1976             this->highOffset = highOffset;
1977             this->min = min;
1978             this->max = max;
1979             this->flat = flat;
1980             this->fuzz = fuzz;
1981             this->resolution = resolution;
1982             this->filter = 0;
1983             resetValue();
1984         }
1985 
resetValueAxis1986         void resetValue() {
1987             this->currentValue = 0;
1988             this->newValue = 0;
1989             this->highCurrentValue = 0;
1990             this->highNewValue = 0;
1991         }
1992     };
1993 
1994     // Axes indexed by raw ABS_* axis index.
1995     KeyedVector<int32_t, Axis> mAxes;
1996 
1997     void sync(nsecs_t when, bool force);
1998 
1999     bool haveAxis(int32_t axisId);
2000     void pruneAxes(bool ignoreExplicitlyMappedAxes);
2001     bool filterAxes(bool force);
2002 
2003     static bool hasValueChangedSignificantly(float filter,
2004             float newValue, float currentValue, float min, float max);
2005     static bool hasMovedNearerToValueWithinFilteredRange(float filter,
2006             float newValue, float currentValue, float thresholdValue);
2007 
2008     static bool isCenteredAxis(int32_t axis);
2009     static int32_t getCompatAxis(int32_t axis);
2010 
2011     static void addMotionRange(int32_t axisId, const Axis& axis, InputDeviceInfo* info);
2012     static void setPointerCoordsAxisValue(PointerCoords* pointerCoords, int32_t axis,
2013             float value);
2014 };
2015 
2016 } // namespace android
2017 
2018 #endif // _UI_INPUT_READER_H
2019