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