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