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