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