InputReader.h revision efd3266b719eed5f1b217021c0a9e76e4b274b06 
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
561protected:
562    Mutex mLock;
563
564    struct VirtualKey {
565        int32_t keyCode;
566        int32_t scanCode;
567        uint32_t flags;
568
569        // computed hit box, specified in touch screen coords based on known display size
570        int32_t hitLeft;
571        int32_t hitTop;
572        int32_t hitRight;
573        int32_t hitBottom;
574
575        inline bool isHit(int32_t x, int32_t y) const {
576            return x >= hitLeft && x <= hitRight && y >= hitTop && y <= hitBottom;
577        }
578    };
579
580    // Raw data for a single pointer.
581    struct PointerData {
582        uint32_t id;
583        int32_t x;
584        int32_t y;
585        int32_t pressure;
586        int32_t touchMajor;
587        int32_t touchMinor;
588        int32_t toolMajor;
589        int32_t toolMinor;
590        int32_t orientation;
591
592        inline bool operator== (const PointerData& other) const {
593            return id == other.id
594                    && x == other.x
595                    && y == other.y
596                    && pressure == other.pressure
597                    && touchMajor == other.touchMajor
598                    && touchMinor == other.touchMinor
599                    && toolMajor == other.toolMajor
600                    && toolMinor == other.toolMinor
601                    && orientation == other.orientation;
602        }
603        inline bool operator!= (const PointerData& other) const {
604            return !(*this == other);
605        }
606    };
607
608    // Raw data for a collection of pointers including a pointer id mapping table.
609    struct TouchData {
610        uint32_t pointerCount;
611        PointerData pointers[MAX_POINTERS];
612        BitSet32 idBits;
613        uint32_t idToIndex[MAX_POINTER_ID + 1];
614
615        void copyFrom(const TouchData& other) {
616            pointerCount = other.pointerCount;
617            idBits = other.idBits;
618
619            for (uint32_t i = 0; i < pointerCount; i++) {
620                pointers[i] = other.pointers[i];
621
622                int id = pointers[i].id;
623                idToIndex[id] = other.idToIndex[id];
624            }
625        }
626
627        inline void clear() {
628            pointerCount = 0;
629            idBits.clear();
630        }
631    };
632
633    // Input sources supported by the device.
634    uint32_t mTouchSource; // sources when reporting touch data
635
636    // Immutable configuration parameters.
637    struct Parameters {
638        enum DeviceType {
639            DEVICE_TYPE_TOUCH_SCREEN,
640            DEVICE_TYPE_TOUCH_PAD,
641        };
642
643        DeviceType deviceType;
644        int32_t associatedDisplayId;
645        bool orientationAware;
646
647        bool useBadTouchFilter;
648        bool useJumpyTouchFilter;
649        bool useAveragingTouchFilter;
650        nsecs_t virtualKeyQuietTime;
651    } mParameters;
652
653    // Immutable calibration parameters in parsed form.
654    struct Calibration {
655        // Touch Size
656        enum TouchSizeCalibration {
657            TOUCH_SIZE_CALIBRATION_DEFAULT,
658            TOUCH_SIZE_CALIBRATION_NONE,
659            TOUCH_SIZE_CALIBRATION_GEOMETRIC,
660            TOUCH_SIZE_CALIBRATION_PRESSURE,
661        };
662
663        TouchSizeCalibration touchSizeCalibration;
664
665        // Tool Size
666        enum ToolSizeCalibration {
667            TOOL_SIZE_CALIBRATION_DEFAULT,
668            TOOL_SIZE_CALIBRATION_NONE,
669            TOOL_SIZE_CALIBRATION_GEOMETRIC,
670            TOOL_SIZE_CALIBRATION_LINEAR,
671            TOOL_SIZE_CALIBRATION_AREA,
672        };
673
674        ToolSizeCalibration toolSizeCalibration;
675        bool haveToolSizeLinearScale;
676        float toolSizeLinearScale;
677        bool haveToolSizeLinearBias;
678        float toolSizeLinearBias;
679        bool haveToolSizeAreaScale;
680        float toolSizeAreaScale;
681        bool haveToolSizeAreaBias;
682        float toolSizeAreaBias;
683        bool haveToolSizeIsSummed;
684        bool toolSizeIsSummed;
685
686        // Pressure
687        enum PressureCalibration {
688            PRESSURE_CALIBRATION_DEFAULT,
689            PRESSURE_CALIBRATION_NONE,
690            PRESSURE_CALIBRATION_PHYSICAL,
691            PRESSURE_CALIBRATION_AMPLITUDE,
692        };
693        enum PressureSource {
694            PRESSURE_SOURCE_DEFAULT,
695            PRESSURE_SOURCE_PRESSURE,
696            PRESSURE_SOURCE_TOUCH,
697        };
698
699        PressureCalibration pressureCalibration;
700        PressureSource pressureSource;
701        bool havePressureScale;
702        float pressureScale;
703
704        // Size
705        enum SizeCalibration {
706            SIZE_CALIBRATION_DEFAULT,
707            SIZE_CALIBRATION_NONE,
708            SIZE_CALIBRATION_NORMALIZED,
709        };
710
711        SizeCalibration sizeCalibration;
712
713        // Orientation
714        enum OrientationCalibration {
715            ORIENTATION_CALIBRATION_DEFAULT,
716            ORIENTATION_CALIBRATION_NONE,
717            ORIENTATION_CALIBRATION_INTERPOLATED,
718            ORIENTATION_CALIBRATION_VECTOR,
719        };
720
721        OrientationCalibration orientationCalibration;
722    } mCalibration;
723
724    // Raw axis information from the driver.
725    struct RawAxes {
726        RawAbsoluteAxisInfo x;
727        RawAbsoluteAxisInfo y;
728        RawAbsoluteAxisInfo pressure;
729        RawAbsoluteAxisInfo touchMajor;
730        RawAbsoluteAxisInfo touchMinor;
731        RawAbsoluteAxisInfo toolMajor;
732        RawAbsoluteAxisInfo toolMinor;
733        RawAbsoluteAxisInfo orientation;
734    } mRawAxes;
735
736    // Current and previous touch sample data.
737    TouchData mCurrentTouch;
738    TouchData mLastTouch;
739
740    // The time the primary pointer last went down.
741    nsecs_t mDownTime;
742
743    struct LockedState {
744        Vector<VirtualKey> virtualKeys;
745
746        // The surface orientation and width and height set by configureSurfaceLocked().
747        int32_t surfaceOrientation;
748        int32_t surfaceWidth, surfaceHeight;
749
750        // The associated display orientation and width and height set by configureSurfaceLocked().
751        int32_t associatedDisplayOrientation;
752        int32_t associatedDisplayWidth, associatedDisplayHeight;
753
754        // Translation and scaling factors, orientation-independent.
755        float xScale;
756        float xPrecision;
757
758        float yScale;
759        float yPrecision;
760
761        float geometricScale;
762
763        float toolSizeLinearScale;
764        float toolSizeLinearBias;
765        float toolSizeAreaScale;
766        float toolSizeAreaBias;
767
768        float pressureScale;
769
770        float sizeScale;
771
772        float orientationScale;
773
774        // Oriented motion ranges for input device info.
775        struct OrientedRanges {
776            InputDeviceInfo::MotionRange x;
777            InputDeviceInfo::MotionRange y;
778
779            bool havePressure;
780            InputDeviceInfo::MotionRange pressure;
781
782            bool haveSize;
783            InputDeviceInfo::MotionRange size;
784
785            bool haveTouchSize;
786            InputDeviceInfo::MotionRange touchMajor;
787            InputDeviceInfo::MotionRange touchMinor;
788
789            bool haveToolSize;
790            InputDeviceInfo::MotionRange toolMajor;
791            InputDeviceInfo::MotionRange toolMinor;
792
793            bool haveOrientation;
794            InputDeviceInfo::MotionRange orientation;
795        } orientedRanges;
796
797        // Oriented dimensions and precision.
798        float orientedSurfaceWidth, orientedSurfaceHeight;
799        float orientedXPrecision, orientedYPrecision;
800
801        struct CurrentVirtualKeyState {
802            bool down;
803            nsecs_t downTime;
804            int32_t keyCode;
805            int32_t scanCode;
806        } currentVirtualKey;
807    } mLocked;
808
809    virtual void configureParameters();
810    virtual void dumpParameters(String8& dump);
811    virtual void configureRawAxes();
812    virtual void dumpRawAxes(String8& dump);
813    virtual bool configureSurfaceLocked();
814    virtual void dumpSurfaceLocked(String8& dump);
815    virtual void configureVirtualKeysLocked();
816    virtual void dumpVirtualKeysLocked(String8& dump);
817    virtual void parseCalibration();
818    virtual void resolveCalibration();
819    virtual void dumpCalibration(String8& dump);
820
821    enum TouchResult {
822        // Dispatch the touch normally.
823        DISPATCH_TOUCH,
824        // Do not dispatch the touch, but keep tracking the current stroke.
825        SKIP_TOUCH,
826        // Do not dispatch the touch, and drop all information associated with the current stoke
827        // so the next movement will appear as a new down.
828        DROP_STROKE
829    };
830
831    void syncTouch(nsecs_t when, bool havePointerIds);
832
833private:
834    /* Maximum number of historical samples to average. */
835    static const uint32_t AVERAGING_HISTORY_SIZE = 5;
836
837    /* Slop distance for jumpy pointer detection.
838     * The vertical range of the screen divided by this is our epsilon value. */
839    static const uint32_t JUMPY_EPSILON_DIVISOR = 212;
840
841    /* Number of jumpy points to drop for touchscreens that need it. */
842    static const uint32_t JUMPY_TRANSITION_DROPS = 3;
843    static const uint32_t JUMPY_DROP_LIMIT = 3;
844
845    /* Maximum squared distance for averaging.
846     * If moving farther than this, turn of averaging to avoid lag in response. */
847    static const uint64_t AVERAGING_DISTANCE_LIMIT = 75 * 75;
848
849    struct AveragingTouchFilterState {
850        // Individual history tracks are stored by pointer id
851        uint32_t historyStart[MAX_POINTERS];
852        uint32_t historyEnd[MAX_POINTERS];
853        struct {
854            struct {
855                int32_t x;
856                int32_t y;
857                int32_t pressure;
858            } pointers[MAX_POINTERS];
859        } historyData[AVERAGING_HISTORY_SIZE];
860    } mAveragingTouchFilter;
861
862    struct JumpyTouchFilterState {
863        uint32_t jumpyPointsDropped;
864    } mJumpyTouchFilter;
865
866    struct PointerDistanceHeapElement {
867        uint32_t currentPointerIndex : 8;
868        uint32_t lastPointerIndex : 8;
869        uint64_t distance : 48; // squared distance
870    };
871
872    void initializeLocked();
873
874    TouchResult consumeOffScreenTouches(nsecs_t when, uint32_t policyFlags);
875    void dispatchTouches(nsecs_t when, uint32_t policyFlags);
876    void dispatchTouch(nsecs_t when, uint32_t policyFlags, TouchData* touch,
877            BitSet32 idBits, uint32_t changedId, uint32_t pointerCount,
878            int32_t motionEventAction);
879    void suppressSwipeOntoVirtualKeys(nsecs_t when);
880
881    bool isPointInsideSurfaceLocked(int32_t x, int32_t y);
882    const VirtualKey* findVirtualKeyHitLocked(int32_t x, int32_t y);
883
884    bool applyBadTouchFilter();
885    bool applyJumpyTouchFilter();
886    void applyAveragingTouchFilter();
887    void calculatePointerIds();
888};
889
890
891class SingleTouchInputMapper : public TouchInputMapper {
892public:
893    SingleTouchInputMapper(InputDevice* device);
894    virtual ~SingleTouchInputMapper();
895
896    virtual void reset();
897    virtual void process(const RawEvent* rawEvent);
898
899protected:
900    virtual void configureRawAxes();
901
902private:
903    struct Accumulator {
904        enum {
905            FIELD_BTN_TOUCH = 1,
906            FIELD_ABS_X = 2,
907            FIELD_ABS_Y = 4,
908            FIELD_ABS_PRESSURE = 8,
909            FIELD_ABS_TOOL_WIDTH = 16,
910        };
911
912        uint32_t fields;
913
914        bool btnTouch;
915        int32_t absX;
916        int32_t absY;
917        int32_t absPressure;
918        int32_t absToolWidth;
919
920        inline void clear() {
921            fields = 0;
922        }
923    } mAccumulator;
924
925    bool mDown;
926    int32_t mX;
927    int32_t mY;
928    int32_t mPressure;
929    int32_t mToolWidth;
930
931    void initialize();
932
933    void sync(nsecs_t when);
934};
935
936
937class MultiTouchInputMapper : public TouchInputMapper {
938public:
939    MultiTouchInputMapper(InputDevice* device);
940    virtual ~MultiTouchInputMapper();
941
942    virtual void reset();
943    virtual void process(const RawEvent* rawEvent);
944
945protected:
946    virtual void configureRawAxes();
947
948private:
949    struct Accumulator {
950        enum {
951            FIELD_ABS_MT_POSITION_X = 1,
952            FIELD_ABS_MT_POSITION_Y = 2,
953            FIELD_ABS_MT_TOUCH_MAJOR = 4,
954            FIELD_ABS_MT_TOUCH_MINOR = 8,
955            FIELD_ABS_MT_WIDTH_MAJOR = 16,
956            FIELD_ABS_MT_WIDTH_MINOR = 32,
957            FIELD_ABS_MT_ORIENTATION = 64,
958            FIELD_ABS_MT_TRACKING_ID = 128,
959            FIELD_ABS_MT_PRESSURE = 256,
960        };
961
962        uint32_t pointerCount;
963        struct Pointer {
964            uint32_t fields;
965
966            int32_t absMTPositionX;
967            int32_t absMTPositionY;
968            int32_t absMTTouchMajor;
969            int32_t absMTTouchMinor;
970            int32_t absMTWidthMajor;
971            int32_t absMTWidthMinor;
972            int32_t absMTOrientation;
973            int32_t absMTTrackingId;
974            int32_t absMTPressure;
975
976            inline void clear() {
977                fields = 0;
978            }
979        } pointers[MAX_POINTERS + 1]; // + 1 to remove the need for extra range checks
980
981        inline void clear() {
982            pointerCount = 0;
983            pointers[0].clear();
984        }
985    } mAccumulator;
986
987    void initialize();
988
989    void sync(nsecs_t when);
990};
991
992
993class JoystickInputMapper : public InputMapper {
994public:
995    JoystickInputMapper(InputDevice* device);
996    virtual ~JoystickInputMapper();
997
998    virtual uint32_t getSources();
999    virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
1000    virtual void dump(String8& dump);
1001    virtual void configure();
1002    virtual void reset();
1003    virtual void process(const RawEvent* rawEvent);
1004
1005private:
1006    struct Axis {
1007        RawAbsoluteAxisInfo rawAxisInfo;
1008        AxisInfo axisInfo;
1009
1010        bool explicitlyMapped; // true if the axis was explicitly assigned an axis id
1011
1012        float scale;   // scale factor from raw to normalized values
1013        float offset;  // offset to add after scaling for normalization
1014        float highScale;  // scale factor from raw to normalized values of high split
1015        float highOffset; // offset to add after scaling for normalization of high split
1016
1017        float min;     // normalized inclusive minimum
1018        float max;     // normalized inclusive maximum
1019        float flat;    // normalized flat region size
1020        float fuzz;    // normalized error tolerance
1021
1022        float filter;  // filter out small variations of this size
1023        float currentValue; // current value
1024        float newValue; // most recent value
1025        float highCurrentValue; // current value of high split
1026        float highNewValue; // most recent value of high split
1027
1028        void initialize(const RawAbsoluteAxisInfo& rawAxisInfo, const AxisInfo& axisInfo,
1029                bool explicitlyMapped, float scale, float offset,
1030                float highScale, float highOffset,
1031                float min, float max, float flat, float fuzz) {
1032            this->rawAxisInfo = rawAxisInfo;
1033            this->axisInfo = axisInfo;
1034            this->explicitlyMapped = explicitlyMapped;
1035            this->scale = scale;
1036            this->offset = offset;
1037            this->highScale = highScale;
1038            this->highOffset = highOffset;
1039            this->min = min;
1040            this->max = max;
1041            this->flat = flat;
1042            this->fuzz = fuzz;
1043            this->filter = 0;
1044            resetValue();
1045        }
1046
1047        void resetValue() {
1048            this->currentValue = 0;
1049            this->newValue = 0;
1050            this->highCurrentValue = 0;
1051            this->highNewValue = 0;
1052        }
1053    };
1054
1055    // Axes indexed by raw ABS_* axis index.
1056    KeyedVector<int32_t, Axis> mAxes;
1057
1058    void sync(nsecs_t when, bool force);
1059
1060    bool haveAxis(int32_t axisId);
1061    void pruneAxes(bool ignoreExplicitlyMappedAxes);
1062    bool filterAxes(bool force);
1063
1064    static bool hasValueChangedSignificantly(float filter,
1065            float newValue, float currentValue, float min, float max);
1066    static bool hasMovedNearerToValueWithinFilteredRange(float filter,
1067            float newValue, float currentValue, float thresholdValue);
1068
1069    static bool isCenteredAxis(int32_t axis);
1070};
1071
1072} // namespace android
1073
1074#endif // _UI_INPUT_READER_H
1075