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