The Tor Browser / file revision

 /*

  * Copyright (C) 2010 The Android Open Source Project

  *

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  *

  *      http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 #ifndef _UI_INPUT_READER_H

 #define _UI_INPUT_READER_H

 #include "EventHub.h"

 #include "PointerController.h"

 #include "InputListener.h"

 #include "Input.h"

 #include "VelocityControl.h"

 #include "VelocityTracker.h"

 #include <utils/KeyedVector.h>

 #include <utils/threads.h>

 #include <utils/Timers.h>

 #include <utils/RefBase.h>

 #include <utils/String8.h>

 #include <utils/BitSet.h>

 #include <stddef.h>

 #include <unistd.h>

 // Maximum supported size of a vibration pattern.

 // Must be at least 2.

 #define MAX_VIBRATE_PATTERN_SIZE 100

 // Maximum allowable delay value in a vibration pattern before

 // which the delay will be truncated.

 #define MAX_VIBRATE_PATTERN_DELAY_NSECS (1000000 * 1000000000LL)

 namespace android {

 class InputDevice;

 class InputMapper;

 /*

  * Describes how coordinates are mapped on a physical display.

  * See com.android.server.display.DisplayViewport.

  */

 struct DisplayViewport {

     int32_t displayId; // -1 if invalid

     int32_t orientation;

     int32_t logicalLeft;

     int32_t logicalTop;

     int32_t logicalRight;

     int32_t logicalBottom;

     int32_t physicalLeft;

     int32_t physicalTop;

     int32_t physicalRight;

     int32_t physicalBottom;

     int32_t deviceWidth;

     int32_t deviceHeight;

     DisplayViewport() :

             displayId(ADISPLAY_ID_NONE), orientation(DISPLAY_ORIENTATION_0),

             logicalLeft(0), logicalTop(0), logicalRight(0), logicalBottom(0),

             physicalLeft(0), physicalTop(0), physicalRight(0), physicalBottom(0),

             deviceWidth(0), deviceHeight(0) {

     }

     bool operator==(const DisplayViewport& other) const {

         return displayId == other.displayId

                 && orientation == other.orientation

                 && logicalLeft == other.logicalLeft

                 && logicalTop == other.logicalTop

                 && logicalRight == other.logicalRight

                 && logicalBottom == other.logicalBottom

                 && physicalLeft == other.physicalLeft

                 && physicalTop == other.physicalTop

                 && physicalRight == other.physicalRight

                 && physicalBottom == other.physicalBottom

                 && deviceWidth == other.deviceWidth

                 && deviceHeight == other.deviceHeight;

     }

     bool operator!=(const DisplayViewport& other) const {

         return !(*this == other);

     }

     inline bool isValid() const {

         return displayId >= 0;

     }

     void setNonDisplayViewport(int32_t width, int32_t height) {

         displayId = ADISPLAY_ID_NONE;

         orientation = DISPLAY_ORIENTATION_0;

         logicalLeft = 0;

         logicalTop = 0;

         logicalRight = width;

         logicalBottom = height;

         physicalLeft = 0;

         physicalTop = 0;

         physicalRight = width;

         physicalBottom = height;

         deviceWidth = width;

         deviceHeight = height;

     }

 };

 /*

  * Input reader configuration.

  *

  * Specifies various options that modify the behavior of the input reader.

  */

 struct InputReaderConfiguration {

     // Describes changes that have occurred.

     enum {

         // The pointer speed changed.

         CHANGE_POINTER_SPEED = 1 << 0,

         // The pointer gesture control changed.

         CHANGE_POINTER_GESTURE_ENABLEMENT = 1 << 1,

         // The display size or orientation changed.

         CHANGE_DISPLAY_INFO = 1 << 2,

         // The visible touches option changed.

         CHANGE_SHOW_TOUCHES = 1 << 3,

         // The keyboard layouts must be reloaded.

         CHANGE_KEYBOARD_LAYOUTS = 1 << 4,

         // The device name alias supplied by the may have changed for some devices.

         CHANGE_DEVICE_ALIAS = 1 << 5,

         // All devices must be reopened.

         CHANGE_MUST_REOPEN = 1 << 31,

     };

     // Gets the amount of time to disable virtual keys after the screen is touched

     // in order to filter out accidental virtual key presses due to swiping gestures

     // or taps near the edge of the display.  May be 0 to disable the feature.

     nsecs_t virtualKeyQuietTime;

     // The excluded device names for the platform.

     // Devices with these names will be ignored.

     Vector<String8> excludedDeviceNames;

     // Velocity control parameters for mouse pointer movements.

     VelocityControlParameters pointerVelocityControlParameters;

     // Velocity control parameters for mouse wheel movements.

     VelocityControlParameters wheelVelocityControlParameters;

     // True if pointer gestures are enabled.

     bool pointerGesturesEnabled;

     // Quiet time between certain pointer gesture transitions.

     // Time to allow for all fingers or buttons to settle into a stable state before

     // starting a new gesture.

     nsecs_t pointerGestureQuietInterval;

     // The minimum speed that a pointer must travel for us to consider switching the active

     // touch pointer to it during a drag.  This threshold is set to avoid switching due

     // to noise from a finger resting on the touch pad (perhaps just pressing it down).

     float pointerGestureDragMinSwitchSpeed; // in pixels per second

     // Tap gesture delay time.

     // The time between down and up must be less than this to be considered a tap.

     nsecs_t pointerGestureTapInterval;

     // Tap drag gesture delay time.

     // The time between the previous tap's up and the next down must be less than

     // this to be considered a drag.  Otherwise, the previous tap is finished and a

     // new tap begins.

     //

     // Note that the previous tap will be held down for this entire duration so this

     // interval must be shorter than the long press timeout.

     nsecs_t pointerGestureTapDragInterval;

     // The distance in pixels that the pointer is allowed to move from initial down

     // to up and still be called a tap.

     float pointerGestureTapSlop; // in pixels

     // Time after the first touch points go down to settle on an initial centroid.

     // This is intended to be enough time to handle cases where the user puts down two

     // fingers at almost but not quite exactly the same time.

     nsecs_t pointerGestureMultitouchSettleInterval;

     // The transition from PRESS to SWIPE or FREEFORM gesture mode is made when

     // at least two pointers have moved at least this far from their starting place.

     float pointerGestureMultitouchMinDistance; // in pixels

     // The transition from PRESS to SWIPE gesture mode can only occur when the

     // cosine of the angle between the two vectors is greater than or equal to than this value

     // which indicates that the vectors are oriented in the same direction.

     // When the vectors are oriented in the exactly same direction, the cosine is 1.0.

     // (In exactly opposite directions, the cosine is -1.0.)

     float pointerGestureSwipeTransitionAngleCosine;

     // The transition from PRESS to SWIPE gesture mode can only occur when the

     // fingers are no more than this far apart relative to the diagonal size of

     // the touch pad.  For example, a ratio of 0.5 means that the fingers must be

     // no more than half the diagonal size of the touch pad apart.

     float pointerGestureSwipeMaxWidthRatio;

     // The gesture movement speed factor relative to the size of the display.

     // Movement speed applies when the fingers are moving in the same direction.

     // Without acceleration, a full swipe of the touch pad diagonal in movement mode

     // will cover this portion of the display diagonal.

     float pointerGestureMovementSpeedRatio;

     // The gesture zoom speed factor relative to the size of the display.

     // Zoom speed applies when the fingers are mostly moving relative to each other

     // to execute a scale gesture or similar.

     // Without acceleration, a full swipe of the touch pad diagonal in zoom mode

     // will cover this portion of the display diagonal.

     float pointerGestureZoomSpeedRatio;

     // True to show the location of touches on the touch screen as spots.

     bool showTouches;

     InputReaderConfiguration() :

             virtualKeyQuietTime(0),

             pointerVelocityControlParameters(1.0f, 500.0f, 3000.0f, 3.0f),

             wheelVelocityControlParameters(1.0f, 15.0f, 50.0f, 4.0f),

             pointerGesturesEnabled(true),

             pointerGestureQuietInterval(100 * 1000000LL), // 100 ms

             pointerGestureDragMinSwitchSpeed(50), // 50 pixels per second

             pointerGestureTapInterval(150 * 1000000LL), // 150 ms

             pointerGestureTapDragInterval(150 * 1000000LL), // 150 ms

             pointerGestureTapSlop(10.0f), // 10 pixels

             pointerGestureMultitouchSettleInterval(100 * 1000000LL), // 100 ms

             pointerGestureMultitouchMinDistance(15), // 15 pixels

             pointerGestureSwipeTransitionAngleCosine(0.2588f), // cosine of 75 degrees

             pointerGestureSwipeMaxWidthRatio(0.25f),

             pointerGestureMovementSpeedRatio(0.8f),

             pointerGestureZoomSpeedRatio(0.3f),

             showTouches(false) { }

     bool getDisplayInfo(bool external, DisplayViewport* outViewport) const;

     void setDisplayInfo(bool external, const DisplayViewport& viewport);

 private:

     DisplayViewport mInternalDisplay;

     DisplayViewport mExternalDisplay;

 };

 /*

  * Input reader policy interface.

  *

  * The input reader policy is used by the input reader to interact with the Window Manager

  * and other system components.

  *

  * The actual implementation is partially supported by callbacks into the DVM

  * via JNI.  This interface is also mocked in the unit tests.

  *

  * These methods must NOT re-enter the input reader since they may be called while

  * holding the input reader lock.

  */

 class InputReaderPolicyInterface : public virtual RefBase {

 protected:

     InputReaderPolicyInterface() { }

     virtual ~InputReaderPolicyInterface() { }

 public:

     /* Gets the input reader configuration. */

     virtual void getReaderConfiguration(InputReaderConfiguration* outConfig) = 0;

     /* Gets a pointer controller associated with the specified cursor device (ie. a mouse). */

     virtual sp<PointerControllerInterface> obtainPointerController(int32_t deviceId) = 0;

     /* Notifies the input reader policy that some input devices have changed

      * and provides information about all current input devices.

      */

     virtual void notifyInputDevicesChanged(const Vector<InputDeviceInfo>& inputDevices) = 0;

     /* Gets the keyboard layout for a particular input device. */

     virtual sp<KeyCharacterMap> getKeyboardLayoutOverlay(const String8& inputDeviceDescriptor) = 0;

     /* Gets a user-supplied alias for a particular input device, or an empty string if none. */

     virtual String8 getDeviceAlias(const InputDeviceIdentifier& identifier) = 0;

 };

 /* Processes raw input events and sends cooked event data to an input listener. */

 class InputReaderInterface : public virtual RefBase {

 protected:

     InputReaderInterface() { }

     virtual ~InputReaderInterface() { }

 public:

     /* Dumps the state of the input reader.

      *

      * This method may be called on any thread (usually by the input manager). */

     virtual void dump(String8& dump) = 0;

     /* Called by the heatbeat to ensures that the reader has not deadlocked. */

     virtual void monitor() = 0;

     /* Runs a single iteration of the processing loop.

      * Nominally reads and processes one incoming message from the EventHub.

      *

      * This method should be called on the input reader thread.

      */

     virtual void loopOnce() = 0;

     /* Gets information about all input devices.

      *

      * This method may be called on any thread (usually by the input manager).

      */

     virtual void getInputDevices(Vector<InputDeviceInfo>& outInputDevices) = 0;

     /* Query current input state. */

     virtual int32_t getScanCodeState(int32_t deviceId, uint32_t sourceMask,

             int32_t scanCode) = 0;

     virtual int32_t getKeyCodeState(int32_t deviceId, uint32_t sourceMask,

             int32_t keyCode) = 0;

     virtual int32_t getSwitchState(int32_t deviceId, uint32_t sourceMask,

             int32_t sw) = 0;

     /* Determine whether physical keys exist for the given framework-domain key codes. */

     virtual bool hasKeys(int32_t deviceId, uint32_t sourceMask,

             size_t numCodes, const int32_t* keyCodes, uint8_t* outFlags) = 0;

     /* Requests that a reconfiguration of all input devices.

      * The changes flag is a bitfield that indicates what has changed and whether

      * the input devices must all be reopened. */

     virtual void requestRefreshConfiguration(uint32_t changes) = 0;

     /* Controls the vibrator of a particular input device. */

     virtual void vibrate(int32_t deviceId, const nsecs_t* pattern, size_t patternSize,

             ssize_t repeat, int32_t token) = 0;

     virtual void cancelVibrate(int32_t deviceId, int32_t token) = 0;

 };

 /* Internal interface used by individual input devices to access global input device state

  * and parameters maintained by the input reader.

  */

 class InputReaderContext {

 public:

     InputReaderContext() { }

     virtual ~InputReaderContext() { }

     virtual void updateGlobalMetaState() = 0;

     virtual int32_t getGlobalMetaState() = 0;

     virtual void disableVirtualKeysUntil(nsecs_t time) = 0;

     virtual bool shouldDropVirtualKey(nsecs_t now,

             InputDevice* device, int32_t keyCode, int32_t scanCode) = 0;

     virtual void fadePointer() = 0;

     virtual void requestTimeoutAtTime(nsecs_t when) = 0;

     virtual int32_t bumpGeneration() = 0;

     virtual InputReaderPolicyInterface* getPolicy() = 0;

     virtual InputListenerInterface* getListener() = 0;

     virtual EventHubInterface* getEventHub() = 0;

 };

 /* The input reader reads raw event data from the event hub and processes it into input events

  * that it sends to the input listener.  Some functions of the input reader, such as early

  * event filtering in low power states, are controlled by a separate policy object.

  *

  * The InputReader owns a collection of InputMappers.  Most of the work it does happens

  * on the input reader thread but the InputReader can receive queries from other system

  * components running on arbitrary threads.  To keep things manageable, the InputReader

  * uses a single Mutex to guard its state.  The Mutex may be held while calling into the

  * EventHub or the InputReaderPolicy but it is never held while calling into the

  * InputListener.

  */

 class InputReader : public InputReaderInterface {

 public:

     InputReader(const sp<EventHubInterface>& eventHub,

             const sp<InputReaderPolicyInterface>& policy,

             const sp<InputListenerInterface>& listener);

     virtual ~InputReader();

     virtual void dump(String8& dump);

     virtual void monitor();

     virtual void loopOnce();

     virtual void getInputDevices(Vector<InputDeviceInfo>& outInputDevices);

     virtual int32_t getScanCodeState(int32_t deviceId, uint32_t sourceMask,

             int32_t scanCode);

     virtual int32_t getKeyCodeState(int32_t deviceId, uint32_t sourceMask,

             int32_t keyCode);

     virtual int32_t getSwitchState(int32_t deviceId, uint32_t sourceMask,

             int32_t sw);

     virtual bool hasKeys(int32_t deviceId, uint32_t sourceMask,

             size_t numCodes, const int32_t* keyCodes, uint8_t* outFlags);

     virtual void requestRefreshConfiguration(uint32_t changes);

     virtual void vibrate(int32_t deviceId, const nsecs_t* pattern, size_t patternSize,

             ssize_t repeat, int32_t token);

     virtual void cancelVibrate(int32_t deviceId, int32_t token);

 protected:

     // These members are protected so they can be instrumented by test cases.

     virtual InputDevice* createDeviceLocked(int32_t deviceId,

             const InputDeviceIdentifier& identifier, uint32_t classes);

     class ContextImpl : public InputReaderContext {

         InputReader* mReader;

     public:

         ContextImpl(InputReader* reader);

         virtual void updateGlobalMetaState();

         virtual int32_t getGlobalMetaState();

         virtual void disableVirtualKeysUntil(nsecs_t time);

         virtual bool shouldDropVirtualKey(nsecs_t now,

                 InputDevice* device, int32_t keyCode, int32_t scanCode);

         virtual void fadePointer();

         virtual void requestTimeoutAtTime(nsecs_t when);

         virtual int32_t bumpGeneration();

         virtual InputReaderPolicyInterface* getPolicy();

         virtual InputListenerInterface* getListener();

         virtual EventHubInterface* getEventHub();

     } mContext;

     friend class ContextImpl;

 private:

     Mutex mLock;

     Condition mReaderIsAliveCondition;

     sp<EventHubInterface> mEventHub;

     sp<InputReaderPolicyInterface> mPolicy;

     sp<QueuedInputListener> mQueuedListener;

     InputReaderConfiguration mConfig;

     // The event queue.

     static const int EVENT_BUFFER_SIZE = 256;

     RawEvent mEventBuffer[EVENT_BUFFER_SIZE];

     KeyedVector<int32_t, InputDevice*> mDevices;

     // low-level input event decoding and device management

     void processEventsLocked(const RawEvent* rawEvents, size_t count);

     void addDeviceLocked(nsecs_t when, int32_t deviceId);

     void removeDeviceLocked(nsecs_t when, int32_t deviceId);

     void processEventsForDeviceLocked(int32_t deviceId, const RawEvent* rawEvents, size_t count);

     void timeoutExpiredLocked(nsecs_t when);

     void handleConfigurationChangedLocked(nsecs_t when);

     int32_t mGlobalMetaState;

     void updateGlobalMetaStateLocked();

     int32_t getGlobalMetaStateLocked();

     void fadePointerLocked();

     int32_t mGeneration;

     int32_t bumpGenerationLocked();

     void getInputDevicesLocked(Vector<InputDeviceInfo>& outInputDevices);

     nsecs_t mDisableVirtualKeysTimeout;

     void disableVirtualKeysUntilLocked(nsecs_t time);

     bool shouldDropVirtualKeyLocked(nsecs_t now,

             InputDevice* device, int32_t keyCode, int32_t scanCode);

     nsecs_t mNextTimeout;

     void requestTimeoutAtTimeLocked(nsecs_t when);

     uint32_t mConfigurationChangesToRefresh;

     void refreshConfigurationLocked(uint32_t changes);

     // state queries

     typedef int32_t (InputDevice::*GetStateFunc)(uint32_t sourceMask, int32_t code);

     int32_t getStateLocked(int32_t deviceId, uint32_t sourceMask, int32_t code,

             GetStateFunc getStateFunc);

     bool markSupportedKeyCodesLocked(int32_t deviceId, uint32_t sourceMask, size_t numCodes,

             const int32_t* keyCodes, uint8_t* outFlags);

 };

 /* Reads raw events from the event hub and processes them, endlessly. */

 class InputReaderThread : public Thread {

 public:

     InputReaderThread(const sp<InputReaderInterface>& reader);

     virtual ~InputReaderThread();

 private:

     uint32_t mFoo;

     sp<InputReaderInterface> mReader;

     virtual bool threadLoop();

 };

 /* Represents the state of a single input device. */

 class InputDevice {

 public:

     InputDevice(InputReaderContext* context, int32_t id, int32_t generation,

             const InputDeviceIdentifier& identifier, uint32_t classes);

     ~InputDevice();

     inline InputReaderContext* getContext() { return mContext; }

     inline int32_t getId() { return mId; }

     inline int32_t getGeneration() { return mGeneration; }

     inline const String8& getName() { return mIdentifier.name; }

     inline uint32_t getClasses() { return mClasses; }

     inline uint32_t getSources() { return mSources; }

     inline bool isExternal() { return mIsExternal; }

     inline void setExternal(bool external) { mIsExternal = external; }

     inline bool isIgnored() { return mMappers.isEmpty(); }

     void dump(String8& dump);

     void addMapper(InputMapper* mapper);

     void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);

     void reset(nsecs_t when);

     void process(const RawEvent* rawEvents, size_t count);

     void timeoutExpired(nsecs_t when);

     void getDeviceInfo(InputDeviceInfo* outDeviceInfo);

     int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode);

     int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode);

     int32_t getSwitchState(uint32_t sourceMask, int32_t switchCode);

     bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes,

             const int32_t* keyCodes, uint8_t* outFlags);

     void vibrate(const nsecs_t* pattern, size_t patternSize, ssize_t repeat, int32_t token);

     void cancelVibrate(int32_t token);

     int32_t getMetaState();

     void fadePointer();

     void bumpGeneration();

     void notifyReset(nsecs_t when);

     inline const PropertyMap& getConfiguration() { return mConfiguration; }

     inline EventHubInterface* getEventHub() { return mContext->getEventHub(); }

     bool hasKey(int32_t code) {

         return getEventHub()->hasScanCode(mId, code);

     }

     bool hasAbsoluteAxis(int32_t code) {

         RawAbsoluteAxisInfo info;

         getEventHub()->getAbsoluteAxisInfo(mId, code, &info);

         return info.valid;

     }

     bool isKeyPressed(int32_t code) {

         return getEventHub()->getScanCodeState(mId, code) == AKEY_STATE_DOWN;

     }

     int32_t getAbsoluteAxisValue(int32_t code) {

         int32_t value;

         getEventHub()->getAbsoluteAxisValue(mId, code, &value);

         return value;

     }

 private:

     InputReaderContext* mContext;

     int32_t mId;

     int32_t mGeneration;

     InputDeviceIdentifier mIdentifier;

     String8 mAlias;

     uint32_t mClasses;

     Vector<InputMapper*> mMappers;

     uint32_t mSources;

     bool mIsExternal;

     bool mDropUntilNextSync;

     typedef int32_t (InputMapper::*GetStateFunc)(uint32_t sourceMask, int32_t code);

     int32_t getState(uint32_t sourceMask, int32_t code, GetStateFunc getStateFunc);

     PropertyMap mConfiguration;

 };

 /* Keeps track of the state of mouse or touch pad buttons. */

 class CursorButtonAccumulator {

 public:

     CursorButtonAccumulator();

     void reset(InputDevice* device);

     void process(const RawEvent* rawEvent);

     uint32_t getButtonState() const;

 private:

     bool mBtnLeft;

     bool mBtnRight;

     bool mBtnMiddle;

     bool mBtnBack;

     bool mBtnSide;

     bool mBtnForward;

     bool mBtnExtra;

     bool mBtnTask;

     void clearButtons();

 };

 /* Keeps track of cursor movements. */

 class CursorMotionAccumulator {

 public:

     CursorMotionAccumulator();

     void reset(InputDevice* device);

     void process(const RawEvent* rawEvent);

     void finishSync();

     inline int32_t getRelativeX() const { return mRelX; }

     inline int32_t getRelativeY() const { return mRelY; }

 private:

     int32_t mRelX;

     int32_t mRelY;

     void clearRelativeAxes();

 };

 /* Keeps track of cursor scrolling motions. */

 class CursorScrollAccumulator {

 public:

     CursorScrollAccumulator();

     void configure(InputDevice* device);

     void reset(InputDevice* device);

     void process(const RawEvent* rawEvent);

     void finishSync();

     inline bool haveRelativeVWheel() const { return mHaveRelWheel; }

     inline bool haveRelativeHWheel() const { return mHaveRelHWheel; }

     inline int32_t getRelativeX() const { return mRelX; }

     inline int32_t getRelativeY() const { return mRelY; }

     inline int32_t getRelativeVWheel() const { return mRelWheel; }

     inline int32_t getRelativeHWheel() const { return mRelHWheel; }

 private:

     bool mHaveRelWheel;

     bool mHaveRelHWheel;

     int32_t mRelX;

     int32_t mRelY;

     int32_t mRelWheel;

     int32_t mRelHWheel;

     void clearRelativeAxes();

 };

 /* Keeps track of the state of touch, stylus and tool buttons. */

 class TouchButtonAccumulator {

 public:

     TouchButtonAccumulator();

     void configure(InputDevice* device);

     void reset(InputDevice* device);

     void process(const RawEvent* rawEvent);

     uint32_t getButtonState() const;

     int32_t getToolType() const;

     bool isToolActive() const;

     bool isHovering() const;

     bool hasStylus() const;

 private:

     bool mHaveBtnTouch;

     bool mHaveStylus;

     bool mBtnTouch;

     bool mBtnStylus;

     bool mBtnStylus2;

     bool mBtnToolFinger;

     bool mBtnToolPen;

     bool mBtnToolRubber;

     bool mBtnToolBrush;

     bool mBtnToolPencil;

     bool mBtnToolAirbrush;

     bool mBtnToolMouse;

     bool mBtnToolLens;

     bool mBtnToolDoubleTap;

     bool mBtnToolTripleTap;

     bool mBtnToolQuadTap;

     void clearButtons();

 };

 /* Raw axis information from the driver. */

 struct RawPointerAxes {

     RawAbsoluteAxisInfo x;

     RawAbsoluteAxisInfo y;

     RawAbsoluteAxisInfo pressure;

     RawAbsoluteAxisInfo touchMajor;

     RawAbsoluteAxisInfo touchMinor;

     RawAbsoluteAxisInfo toolMajor;

     RawAbsoluteAxisInfo toolMinor;

     RawAbsoluteAxisInfo orientation;

     RawAbsoluteAxisInfo distance;

     RawAbsoluteAxisInfo tiltX;

     RawAbsoluteAxisInfo tiltY;

     RawAbsoluteAxisInfo trackingId;

     RawAbsoluteAxisInfo slot;

     RawPointerAxes();

     void clear();

 };

 /* Raw data for a collection of pointers including a pointer id mapping table. */

 struct RawPointerData {

     struct Pointer {

         uint32_t id;

         int32_t x;

         int32_t y;

         int32_t pressure;

         int32_t touchMajor;

         int32_t touchMinor;

         int32_t toolMajor;

         int32_t toolMinor;

         int32_t orientation;

         int32_t distance;

         int32_t tiltX;

         int32_t tiltY;

         int32_t toolType; // a fully decoded AMOTION_EVENT_TOOL_TYPE constant

         bool isHovering;

     };

     uint32_t pointerCount;

     Pointer pointers[MAX_POINTERS];

     BitSet32 hoveringIdBits, touchingIdBits;

     uint32_t idToIndex[MAX_POINTER_ID + 1];

     RawPointerData();

     void clear();

     void copyFrom(const RawPointerData& other);

     void getCentroidOfTouchingPointers(float* outX, float* outY) const;

     inline void markIdBit(uint32_t id, bool isHovering) {

         if (isHovering) {

             hoveringIdBits.markBit(id);

         } else {

             touchingIdBits.markBit(id);

         }

     }

     inline void clearIdBits() {

         hoveringIdBits.clear();

         touchingIdBits.clear();

     }

     inline const Pointer& pointerForId(uint32_t id) const {

         return pointers[idToIndex[id]];

     }

     inline bool isHovering(uint32_t pointerIndex) {

         return pointers[pointerIndex].isHovering;

     }

 };

 /* Cooked data for a collection of pointers including a pointer id mapping table. */

 struct CookedPointerData {

     uint32_t pointerCount;

     PointerProperties pointerProperties[MAX_POINTERS];

     PointerCoords pointerCoords[MAX_POINTERS];

     BitSet32 hoveringIdBits, touchingIdBits;

     uint32_t idToIndex[MAX_POINTER_ID + 1];

     CookedPointerData();

     void clear();

     void copyFrom(const CookedPointerData& other);

     inline const PointerCoords& pointerCoordsForId(uint32_t id) const {

         return pointerCoords[idToIndex[id]];

     }

     inline bool isHovering(uint32_t pointerIndex) {

         return hoveringIdBits.hasBit(pointerProperties[pointerIndex].id);

     }

 };

 /* Keeps track of the state of single-touch protocol. */

 class SingleTouchMotionAccumulator {

 public:

     SingleTouchMotionAccumulator();

     void process(const RawEvent* rawEvent);

     void reset(InputDevice* device);

     inline int32_t getAbsoluteX() const { return mAbsX; }

     inline int32_t getAbsoluteY() const { return mAbsY; }

     inline int32_t getAbsolutePressure() const { return mAbsPressure; }

     inline int32_t getAbsoluteToolWidth() const { return mAbsToolWidth; }

     inline int32_t getAbsoluteDistance() const { return mAbsDistance; }

     inline int32_t getAbsoluteTiltX() const { return mAbsTiltX; }

     inline int32_t getAbsoluteTiltY() const { return mAbsTiltY; }

 private:

     int32_t mAbsX;

     int32_t mAbsY;

     int32_t mAbsPressure;

     int32_t mAbsToolWidth;

     int32_t mAbsDistance;

     int32_t mAbsTiltX;

     int32_t mAbsTiltY;

     void clearAbsoluteAxes();

 };

 /* Keeps track of the state of multi-touch protocol. */

 class MultiTouchMotionAccumulator {

 public:

     class Slot {

     public:

         inline bool isInUse() const { return mInUse; }

         inline int32_t getX() const { return mAbsMTPositionX; }

         inline int32_t getY() const { return mAbsMTPositionY; }

         inline int32_t getTouchMajor() const { return mAbsMTTouchMajor; }

         inline int32_t getTouchMinor() const {

             return mHaveAbsMTTouchMinor ? mAbsMTTouchMinor : mAbsMTTouchMajor; }

         inline int32_t getToolMajor() const { return mAbsMTWidthMajor; }

         inline int32_t getToolMinor() const {

             return mHaveAbsMTWidthMinor ? mAbsMTWidthMinor : mAbsMTWidthMajor; }

         inline int32_t getOrientation() const { return mAbsMTOrientation; }

         inline int32_t getTrackingId() const { return mAbsMTTrackingId; }

         inline int32_t getPressure() const { return mAbsMTPressure; }

         inline int32_t getDistance() const { return mAbsMTDistance; }

         inline int32_t getToolType() const;

     private:

         friend class MultiTouchMotionAccumulator;

         bool mInUse;

         bool mHaveAbsMTTouchMinor;

         bool mHaveAbsMTWidthMinor;

         bool mHaveAbsMTToolType;

         int32_t mAbsMTPositionX;

         int32_t mAbsMTPositionY;

         int32_t mAbsMTTouchMajor;

         int32_t mAbsMTTouchMinor;

         int32_t mAbsMTWidthMajor;

         int32_t mAbsMTWidthMinor;

         int32_t mAbsMTOrientation;

         int32_t mAbsMTTrackingId;

         int32_t mAbsMTPressure;

         int32_t mAbsMTDistance;

         int32_t mAbsMTToolType;

         Slot();

         void clear();

     };

     MultiTouchMotionAccumulator();

     ~MultiTouchMotionAccumulator();

     void configure(InputDevice* device, size_t slotCount, bool usingSlotsProtocol);

     void reset(InputDevice* device);

     void process(const RawEvent* rawEvent);

     void finishSync();

     bool hasStylus() const;

     inline size_t getSlotCount() const { return mSlotCount; }

     inline const Slot* getSlot(size_t index) const { return &mSlots[index]; }

 private:

     int32_t mCurrentSlot;

     Slot* mSlots;

     size_t mSlotCount;

     bool mUsingSlotsProtocol;

     bool mHaveStylus;

     void clearSlots(int32_t initialSlot);

 };

 /* An input mapper transforms raw input events into cooked event data.

  * A single input device can have multiple associated input mappers in order to interpret

  * different classes of events.

  *

  * InputMapper lifecycle:

  * - create

  * - configure with 0 changes

  * - reset

  * - process, process, process (may occasionally reconfigure with non-zero changes or reset)

  * - reset

  * - destroy

  */

 class InputMapper {

 public:

     InputMapper(InputDevice* device);

     virtual ~InputMapper();

     inline InputDevice* getDevice() { return mDevice; }

     inline int32_t getDeviceId() { return mDevice->getId(); }

     inline const String8 getDeviceName() { return mDevice->getName(); }

     inline InputReaderContext* getContext() { return mContext; }

     inline InputReaderPolicyInterface* getPolicy() { return mContext->getPolicy(); }

     inline InputListenerInterface* getListener() { return mContext->getListener(); }

     inline EventHubInterface* getEventHub() { return mContext->getEventHub(); }

     virtual uint32_t getSources() = 0;

     virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);

     virtual void dump(String8& dump);

     virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);

     virtual void reset(nsecs_t when);

     virtual void process(const RawEvent* rawEvent) = 0;

     virtual void timeoutExpired(nsecs_t when);

     virtual int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode);

     virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode);

     virtual int32_t getSwitchState(uint32_t sourceMask, int32_t switchCode);

     virtual bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes,

             const int32_t* keyCodes, uint8_t* outFlags);

     virtual void vibrate(const nsecs_t* pattern, size_t patternSize, ssize_t repeat,

             int32_t token);

     virtual void cancelVibrate(int32_t token);

     virtual int32_t getMetaState();

     virtual void fadePointer();

 protected:

     InputDevice* mDevice;

     InputReaderContext* mContext;

     status_t getAbsoluteAxisInfo(int32_t axis, RawAbsoluteAxisInfo* axisInfo);

     void bumpGeneration();

     static void dumpRawAbsoluteAxisInfo(String8& dump,

             const RawAbsoluteAxisInfo& axis, const char* name);

 };

 class SwitchInputMapper : public InputMapper {

 public:

     SwitchInputMapper(InputDevice* device);

     virtual ~SwitchInputMapper();

     virtual uint32_t getSources();

     virtual void process(const RawEvent* rawEvent);

     virtual int32_t getSwitchState(uint32_t sourceMask, int32_t switchCode);

 private:

     uint32_t mUpdatedSwitchValues;

     uint32_t mUpdatedSwitchMask;

     void processSwitch(int32_t switchCode, int32_t switchValue);

     void sync(nsecs_t when);

 };

 class VibratorInputMapper : public InputMapper {

 public:

     VibratorInputMapper(InputDevice* device);

     virtual ~VibratorInputMapper();

     virtual uint32_t getSources();

     virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);

     virtual void process(const RawEvent* rawEvent);

     virtual void vibrate(const nsecs_t* pattern, size_t patternSize, ssize_t repeat,

             int32_t token);

     virtual void cancelVibrate(int32_t token);

     virtual void timeoutExpired(nsecs_t when);

     virtual void dump(String8& dump);

 private:

     bool mVibrating;

     nsecs_t mPattern[MAX_VIBRATE_PATTERN_SIZE];

     size_t mPatternSize;

     ssize_t mRepeat;

     int32_t mToken;

     ssize_t mIndex;

     nsecs_t mNextStepTime;

     void nextStep();

     void stopVibrating();

 };

 class KeyboardInputMapper : public InputMapper {

 public:

     KeyboardInputMapper(InputDevice* device, uint32_t source, int32_t keyboardType);

     virtual ~KeyboardInputMapper();

     virtual uint32_t getSources();

     virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);

     virtual void dump(String8& dump);

     virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);

     virtual void reset(nsecs_t when);

     virtual void process(const RawEvent* rawEvent);

     virtual int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode);

     virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode);

     virtual bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes,

             const int32_t* keyCodes, uint8_t* outFlags);

     virtual int32_t getMetaState();

 private:

     struct KeyDown {

         int32_t keyCode;

         int32_t scanCode;

     };

     uint32_t mSource;

     int32_t mKeyboardType;

     int32_t mOrientation; // orientation for dpad keys

     Vector<KeyDown> mKeyDowns; // keys that are down

     int32_t mMetaState;

     nsecs_t mDownTime; // time of most recent key down

     int32_t mCurrentHidUsage; // most recent HID usage seen this packet, or 0 if none

     struct LedState {

         bool avail; // led is available

         bool on;    // we think the led is currently on

     };

     LedState mCapsLockLedState;

     LedState mNumLockLedState;

     LedState mScrollLockLedState;

     // Immutable configuration parameters.

     struct Parameters {

         bool hasAssociatedDisplay;

         bool orientationAware;

     } mParameters;

     void configureParameters();

     void dumpParameters(String8& dump);

     bool isKeyboardOrGamepadKey(int32_t scanCode);

     void processKey(nsecs_t when, bool down, int32_t keyCode, int32_t scanCode,

             uint32_t policyFlags);

     ssize_t findKeyDown(int32_t scanCode);

     void resetLedState();

     void initializeLedState(LedState& ledState, int32_t led);

     void updateLedState(bool reset);

     void updateLedStateForModifier(LedState& ledState, int32_t led,

             int32_t modifier, bool reset);

 };

 class CursorInputMapper : public InputMapper {

 public:

     CursorInputMapper(InputDevice* device);

     virtual ~CursorInputMapper();

     virtual uint32_t getSources();

     virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);

     virtual void dump(String8& dump);

     virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);

     virtual void reset(nsecs_t when);

     virtual void process(const RawEvent* rawEvent);

     virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode);

     virtual void fadePointer();

 private:

     // Amount that trackball needs to move in order to generate a key event.

     static const int32_t TRACKBALL_MOVEMENT_THRESHOLD = 6;

     // Immutable configuration parameters.

     struct Parameters {

         enum Mode {

             MODE_POINTER,

             MODE_NAVIGATION,

         };

         Mode mode;

         bool hasAssociatedDisplay;

         bool orientationAware;

     } mParameters;

     CursorButtonAccumulator mCursorButtonAccumulator;

     CursorMotionAccumulator mCursorMotionAccumulator;

     CursorScrollAccumulator mCursorScrollAccumulator;

     int32_t mSource;

     float mXScale;

     float mYScale;

     float mXPrecision;

     float mYPrecision;

     float mVWheelScale;

     float mHWheelScale;

     // Velocity controls for mouse pointer and wheel movements.

     // The controls for X and Y wheel movements are separate to keep them decoupled.

     VelocityControl mPointerVelocityControl;

     VelocityControl mWheelXVelocityControl;

     VelocityControl mWheelYVelocityControl;

     int32_t mOrientation;

     sp<PointerControllerInterface> mPointerController;

     int32_t mButtonState;

     nsecs_t mDownTime;

     void configureParameters();

     void dumpParameters(String8& dump);

     void sync(nsecs_t when);

 };

 class TouchInputMapper : public InputMapper {

 public:

     TouchInputMapper(InputDevice* device);

     virtual ~TouchInputMapper();

     virtual uint32_t getSources();

     virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);

     virtual void dump(String8& dump);

     virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);

     virtual void reset(nsecs_t when);

     virtual void process(const RawEvent* rawEvent);

     virtual int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode);

     virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode);

     virtual bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes,

             const int32_t* keyCodes, uint8_t* outFlags);

     virtual void fadePointer();

     virtual void timeoutExpired(nsecs_t when);

 protected:

     CursorButtonAccumulator mCursorButtonAccumulator;

     CursorScrollAccumulator mCursorScrollAccumulator;

     TouchButtonAccumulator mTouchButtonAccumulator;

     struct VirtualKey {

         int32_t keyCode;

         int32_t scanCode;

         uint32_t flags;

         // computed hit box, specified in touch screen coords based on known display size

         int32_t hitLeft;

         int32_t hitTop;

         int32_t hitRight;

         int32_t hitBottom;

         inline bool isHit(int32_t x, int32_t y) const {

             return x >= hitLeft && x <= hitRight && y >= hitTop && y <= hitBottom;

         }

     };

     // Input sources and device mode.

     uint32_t mSource;

     enum DeviceMode {

         DEVICE_MODE_DISABLED, // input is disabled

         DEVICE_MODE_DIRECT, // direct mapping (touchscreen)

         DEVICE_MODE_UNSCALED, // unscaled mapping (touchpad)

         DEVICE_MODE_NAVIGATION, // unscaled mapping with assist gesture (touch navigation)

         DEVICE_MODE_POINTER, // pointer mapping (pointer)

     };

     DeviceMode mDeviceMode;

     // The reader's configuration.

     InputReaderConfiguration mConfig;

     // Immutable configuration parameters.

     struct Parameters {

         enum DeviceType {

             DEVICE_TYPE_TOUCH_SCREEN,

             DEVICE_TYPE_TOUCH_PAD,

             DEVICE_TYPE_TOUCH_NAVIGATION,

             DEVICE_TYPE_POINTER,

         };

         DeviceType deviceType;

         bool hasAssociatedDisplay;

         bool associatedDisplayIsExternal;

         bool orientationAware;

         enum GestureMode {

             GESTURE_MODE_POINTER,

             GESTURE_MODE_SPOTS,

         };

         GestureMode gestureMode;

     } mParameters;

     // Immutable calibration parameters in parsed form.

     struct Calibration {

         // Size

         enum SizeCalibration {

             SIZE_CALIBRATION_DEFAULT,

             SIZE_CALIBRATION_NONE,

             SIZE_CALIBRATION_GEOMETRIC,

             SIZE_CALIBRATION_DIAMETER,

             SIZE_CALIBRATION_BOX,

             SIZE_CALIBRATION_AREA,

         };

         SizeCalibration sizeCalibration;

         bool haveSizeScale;

         float sizeScale;

         bool haveSizeBias;

         float sizeBias;

         bool haveSizeIsSummed;

         bool sizeIsSummed;

         // Pressure

         enum PressureCalibration {

             PRESSURE_CALIBRATION_DEFAULT,

             PRESSURE_CALIBRATION_NONE,

             PRESSURE_CALIBRATION_PHYSICAL,

             PRESSURE_CALIBRATION_AMPLITUDE,

         };

         PressureCalibration pressureCalibration;

         bool havePressureScale;

         float pressureScale;

         // Orientation

         enum OrientationCalibration {

             ORIENTATION_CALIBRATION_DEFAULT,

             ORIENTATION_CALIBRATION_NONE,

             ORIENTATION_CALIBRATION_INTERPOLATED,

             ORIENTATION_CALIBRATION_VECTOR,

         };

         OrientationCalibration orientationCalibration;

         // Distance

         enum DistanceCalibration {

             DISTANCE_CALIBRATION_DEFAULT,

             DISTANCE_CALIBRATION_NONE,

             DISTANCE_CALIBRATION_SCALED,

         };

         DistanceCalibration distanceCalibration;

         bool haveDistanceScale;

         float distanceScale;

         enum CoverageCalibration {

             COVERAGE_CALIBRATION_DEFAULT,

             COVERAGE_CALIBRATION_NONE,

             COVERAGE_CALIBRATION_BOX,

         };

         CoverageCalibration coverageCalibration;

         inline void applySizeScaleAndBias(float* outSize) const {

             if (haveSizeScale) {

                 *outSize *= sizeScale;

             }

             if (haveSizeBias) {

                 *outSize += sizeBias;

             }

         }

     } mCalibration;

     // Raw pointer axis information from the driver.

     RawPointerAxes mRawPointerAxes;

     // Raw pointer sample data.

     RawPointerData mCurrentRawPointerData;

     RawPointerData mLastRawPointerData;

     // Cooked pointer sample data.

     CookedPointerData mCurrentCookedPointerData;

     CookedPointerData mLastCookedPointerData;

     // Button state.

     int32_t mCurrentButtonState;

     int32_t mLastButtonState;

     // Scroll state.

     int32_t mCurrentRawVScroll;

     int32_t mCurrentRawHScroll;

     // Id bits used to differentiate fingers, stylus and mouse tools.

     BitSet32 mCurrentFingerIdBits; // finger or unknown

     BitSet32 mLastFingerIdBits;

     BitSet32 mCurrentStylusIdBits; // stylus or eraser

     BitSet32 mLastStylusIdBits;

     BitSet32 mCurrentMouseIdBits; // mouse or lens

     BitSet32 mLastMouseIdBits;

     // True if we sent a HOVER_ENTER event.

     bool mSentHoverEnter;

     // The time the primary pointer last went down.

     nsecs_t mDownTime;

     // The pointer controller, or null if the device is not a pointer.

     sp<PointerControllerInterface> mPointerController;

     Vector<VirtualKey> mVirtualKeys;

     virtual void configureParameters();

     virtual void dumpParameters(String8& dump);

     virtual void configureRawPointerAxes();

     virtual void dumpRawPointerAxes(String8& dump);

     virtual void configureSurface(nsecs_t when, bool* outResetNeeded);

     virtual void dumpSurface(String8& dump);

     virtual void configureVirtualKeys();

     virtual void dumpVirtualKeys(String8& dump);

     virtual void parseCalibration();

     virtual void resolveCalibration();

     virtual void dumpCalibration(String8& dump);

     virtual bool hasStylus() const = 0;

     virtual void syncTouch(nsecs_t when, bool* outHavePointerIds) = 0;

 private:

     // The current viewport.

     // The components of the viewport are specified in the display's rotated orientation.

     DisplayViewport mViewport;

     // The surface orientation, width and height set by configureSurface().

     // The width and height are derived from the viewport but are specified

     // in the natural orientation.

     // The surface origin specifies how the surface coordinates should be translated

     // to align with the logical display coordinate space.

     // The orientation may be different from the viewport orientation as it specifies

     // the rotation of the surface coordinates required to produce the viewport's

     // requested orientation, so it will depend on whether the device is orientation aware.

     int32_t mSurfaceWidth;

     int32_t mSurfaceHeight;

     int32_t mSurfaceLeft;

     int32_t mSurfaceTop;

     int32_t mSurfaceOrientation;

     // Translation and scaling factors, orientation-independent.

     float mXTranslate;

     float mXScale;

     float mXPrecision;

     float mYTranslate;

     float mYScale;

     float mYPrecision;

     float mGeometricScale;

     float mPressureScale;

     float mSizeScale;

     float mOrientationScale;

     float mDistanceScale;

     bool mHaveTilt;

     float mTiltXCenter;

     float mTiltXScale;

     float mTiltYCenter;

     float mTiltYScale;

     // Oriented motion ranges for input device info.

     struct OrientedRanges {

         InputDeviceInfo::MotionRange x;

         InputDeviceInfo::MotionRange y;

         InputDeviceInfo::MotionRange pressure;

         bool haveSize;

         InputDeviceInfo::MotionRange size;

         bool haveTouchSize;

         InputDeviceInfo::MotionRange touchMajor;

         InputDeviceInfo::MotionRange touchMinor;

         bool haveToolSize;

         InputDeviceInfo::MotionRange toolMajor;

         InputDeviceInfo::MotionRange toolMinor;

         bool haveOrientation;

         InputDeviceInfo::MotionRange orientation;

         bool haveDistance;

         InputDeviceInfo::MotionRange distance;

         bool haveTilt;

         InputDeviceInfo::MotionRange tilt;

         OrientedRanges() {

             clear();

         }

         void clear() {

             haveSize = false;

             haveTouchSize = false;

             haveToolSize = false;

             haveOrientation = false;

             haveDistance = false;

             haveTilt = false;

         }

     } mOrientedRanges;

     // Oriented dimensions and precision.

     float mOrientedXPrecision;

     float mOrientedYPrecision;

     struct CurrentVirtualKeyState {

         bool down;

         bool ignored;

         nsecs_t downTime;

         int32_t keyCode;

         int32_t scanCode;

     } mCurrentVirtualKey;

     // Scale factor for gesture or mouse based pointer movements.

     float mPointerXMovementScale;

     float mPointerYMovementScale;

     // Scale factor for gesture based zooming and other freeform motions.

     float mPointerXZoomScale;

     float mPointerYZoomScale;

     // The maximum swipe width.

     float mPointerGestureMaxSwipeWidth;

     struct PointerDistanceHeapElement {

         uint32_t currentPointerIndex : 8;

         uint32_t lastPointerIndex : 8;

         uint64_t distance : 48; // squared distance

     };

     enum PointerUsage {

         POINTER_USAGE_NONE,

         POINTER_USAGE_GESTURES,

         POINTER_USAGE_STYLUS,

         POINTER_USAGE_MOUSE,

     };

     PointerUsage mPointerUsage;

     struct PointerGesture {

         enum Mode {

             // No fingers, button is not pressed.

             // Nothing happening.

             NEUTRAL,

             // No fingers, button is not pressed.

             // Tap detected.

             // Emits DOWN and UP events at the pointer location.

             TAP,

             // Exactly one finger dragging following a tap.

             // Pointer follows the active finger.

             // Emits DOWN, MOVE and UP events at the pointer location.

             //

             // Detect double-taps when the finger goes up while in TAP_DRAG mode.

             TAP_DRAG,

             // Button is pressed.

             // Pointer follows the active finger if there is one.  Other fingers are ignored.

             // Emits DOWN, MOVE and UP events at the pointer location.

             BUTTON_CLICK_OR_DRAG,

             // Exactly one finger, button is not pressed.

             // Pointer follows the active finger.

             // Emits HOVER_MOVE events at the pointer location.

             //

             // Detect taps when the finger goes up while in HOVER mode.

             HOVER,

             // Exactly two fingers but neither have moved enough to clearly indicate

             // whether a swipe or freeform gesture was intended.  We consider the

             // pointer to be pressed so this enables clicking or long-pressing on buttons.

             // Pointer does not move.

             // Emits DOWN, MOVE and UP events with a single stationary pointer coordinate.

             PRESS,

             // Exactly two fingers moving in the same direction, button is not pressed.

             // Pointer does not move.

             // Emits DOWN, MOVE and UP events with a single pointer coordinate that

             // follows the midpoint between both fingers.

             SWIPE,

             // Two or more fingers moving in arbitrary directions, button is not pressed.

             // Pointer does not move.

             // Emits DOWN, POINTER_DOWN, MOVE, POINTER_UP and UP events that follow

             // each finger individually relative to the initial centroid of the finger.

             FREEFORM,

             // Waiting for quiet time to end before starting the next gesture.

             QUIET,

         };

         // Time the first finger went down.

         nsecs_t firstTouchTime;

         // The active pointer id from the raw touch data.

         int32_t activeTouchId; // -1 if none

         // The active pointer id from the gesture last delivered to the application.

         int32_t activeGestureId; // -1 if none

         // Pointer coords and ids for the current and previous pointer gesture.

         Mode currentGestureMode;

         BitSet32 currentGestureIdBits;

         uint32_t currentGestureIdToIndex[MAX_POINTER_ID + 1];

         PointerProperties currentGestureProperties[MAX_POINTERS];

         PointerCoords currentGestureCoords[MAX_POINTERS];

         Mode lastGestureMode;

         BitSet32 lastGestureIdBits;

         uint32_t lastGestureIdToIndex[MAX_POINTER_ID + 1];

         PointerProperties lastGestureProperties[MAX_POINTERS];

         PointerCoords lastGestureCoords[MAX_POINTERS];

         // Time the pointer gesture last went down.

         nsecs_t downTime;

         // Time when the pointer went down for a TAP.

         nsecs_t tapDownTime;

         // Time when the pointer went up for a TAP.

         nsecs_t tapUpTime;

         // Location of initial tap.

         float tapX, tapY;

         // Time we started waiting for quiescence.

         nsecs_t quietTime;

         // Reference points for multitouch gestures.

         float referenceTouchX;    // reference touch X/Y coordinates in surface units

         float referenceTouchY;

         float referenceGestureX;  // reference gesture X/Y coordinates in pixels

         float referenceGestureY;

         // Distance that each pointer has traveled which has not yet been

         // subsumed into the reference gesture position.

         BitSet32 referenceIdBits;

         struct Delta {

             float dx, dy;

         };

         Delta referenceDeltas[MAX_POINTER_ID + 1];

         // Describes how touch ids are mapped to gesture ids for freeform gestures.

         uint32_t freeformTouchToGestureIdMap[MAX_POINTER_ID + 1];

         // A velocity tracker for determining whether to switch active pointers during drags.

         VelocityTracker velocityTracker;

         void reset() {

             firstTouchTime = LLONG_MIN;

             activeTouchId = -1;

             activeGestureId = -1;

             currentGestureMode = NEUTRAL;

             currentGestureIdBits.clear();

             lastGestureMode = NEUTRAL;

             lastGestureIdBits.clear();

             downTime = 0;

             velocityTracker.clear();

             resetTap();

             resetQuietTime();

         }

         void resetTap() {

             tapDownTime = LLONG_MIN;

             tapUpTime = LLONG_MIN;

         }

         void resetQuietTime() {

             quietTime = LLONG_MIN;

         }

     } mPointerGesture;

     struct PointerSimple {

         PointerCoords currentCoords;

         PointerProperties currentProperties;

         PointerCoords lastCoords;

         PointerProperties lastProperties;

         // True if the pointer is down.

         bool down;

         // True if the pointer is hovering.

         bool hovering;

         // Time the pointer last went down.

         nsecs_t downTime;

         void reset() {

             currentCoords.clear();

             currentProperties.clear();

             lastCoords.clear();

             lastProperties.clear();

             down = false;

             hovering = false;

             downTime = 0;

         }

     } mPointerSimple;

     // The pointer and scroll velocity controls.

     VelocityControl mPointerVelocityControl;

     VelocityControl mWheelXVelocityControl;

     VelocityControl mWheelYVelocityControl;

     void sync(nsecs_t when);

     bool consumeRawTouches(nsecs_t when, uint32_t policyFlags);

     void dispatchVirtualKey(nsecs_t when, uint32_t policyFlags,

             int32_t keyEventAction, int32_t keyEventFlags);

     void dispatchTouches(nsecs_t when, uint32_t policyFlags);

     void dispatchHoverExit(nsecs_t when, uint32_t policyFlags);

     void dispatchHoverEnterAndMove(nsecs_t when, uint32_t policyFlags);

     void cookPointerData();

     void dispatchPointerUsage(nsecs_t when, uint32_t policyFlags, PointerUsage pointerUsage);

     void abortPointerUsage(nsecs_t when, uint32_t policyFlags);

     void dispatchPointerGestures(nsecs_t when, uint32_t policyFlags, bool isTimeout);

     void abortPointerGestures(nsecs_t when, uint32_t policyFlags);

     bool preparePointerGestures(nsecs_t when,

             bool* outCancelPreviousGesture, bool* outFinishPreviousGesture,

             bool isTimeout);

     void dispatchPointerStylus(nsecs_t when, uint32_t policyFlags);

     void abortPointerStylus(nsecs_t when, uint32_t policyFlags);

     void dispatchPointerMouse(nsecs_t when, uint32_t policyFlags);

     void abortPointerMouse(nsecs_t when, uint32_t policyFlags);

     void dispatchPointerSimple(nsecs_t when, uint32_t policyFlags,

             bool down, bool hovering);

     void abortPointerSimple(nsecs_t when, uint32_t policyFlags);

     // Dispatches a motion event.

     // If the changedId is >= 0 and the action is POINTER_DOWN or POINTER_UP, the

     // method will take care of setting the index and transmuting the action to DOWN or UP

     // it is the first / last pointer to go down / up.

     void dispatchMotion(nsecs_t when, uint32_t policyFlags, uint32_t source,

             int32_t action, int32_t flags, int32_t metaState, int32_t buttonState,

             int32_t edgeFlags,

             const PointerProperties* properties, const PointerCoords* coords,

             const uint32_t* idToIndex, BitSet32 idBits,

             int32_t changedId, float xPrecision, float yPrecision, nsecs_t downTime);

     // Updates pointer coords and properties for pointers with specified ids that have moved.

     // Returns true if any of them changed.

     bool updateMovedPointers(const PointerProperties* inProperties,

             const PointerCoords* inCoords, const uint32_t* inIdToIndex,

             PointerProperties* outProperties, PointerCoords* outCoords,

             const uint32_t* outIdToIndex, BitSet32 idBits) const;

     bool isPointInsideSurface(int32_t x, int32_t y);

     const VirtualKey* findVirtualKeyHit(int32_t x, int32_t y);

     void assignPointerIds();

 };

 class SingleTouchInputMapper : public TouchInputMapper {

 public:

     SingleTouchInputMapper(InputDevice* device);

     virtual ~SingleTouchInputMapper();

     virtual void reset(nsecs_t when);

     virtual void process(const RawEvent* rawEvent);

 protected:

     virtual void syncTouch(nsecs_t when, bool* outHavePointerIds);

     virtual void configureRawPointerAxes();

     virtual bool hasStylus() const;

 private:

     SingleTouchMotionAccumulator mSingleTouchMotionAccumulator;

 };

 class MultiTouchInputMapper : public TouchInputMapper {

 public:

     MultiTouchInputMapper(InputDevice* device);

     virtual ~MultiTouchInputMapper();

     virtual void reset(nsecs_t when);

     virtual void process(const RawEvent* rawEvent);

 protected:

     virtual void syncTouch(nsecs_t when, bool* outHavePointerIds);

     virtual void configureRawPointerAxes();

     virtual bool hasStylus() const;

 private:

     MultiTouchMotionAccumulator mMultiTouchMotionAccumulator;

     // Specifies the pointer id bits that are in use, and their associated tracking id.

     BitSet32 mPointerIdBits;

     int32_t mPointerTrackingIdMap[MAX_POINTER_ID + 1];

 };

 class JoystickInputMapper : public InputMapper {

 public:

     JoystickInputMapper(InputDevice* device);

     virtual ~JoystickInputMapper();

     virtual uint32_t getSources();

     virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);

     virtual void dump(String8& dump);

     virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);

     virtual void reset(nsecs_t when);

     virtual void process(const RawEvent* rawEvent);

 private:

     struct Axis {

         RawAbsoluteAxisInfo rawAxisInfo;

         AxisInfo axisInfo;

         bool explicitlyMapped; // true if the axis was explicitly assigned an axis id

         float scale;   // scale factor from raw to normalized values

         float offset;  // offset to add after scaling for normalization

         float highScale;  // scale factor from raw to normalized values of high split

         float highOffset; // offset to add after scaling for normalization of high split

         float min;        // normalized inclusive minimum

         float max;        // normalized inclusive maximum

         float flat;       // normalized flat region size

         float fuzz;       // normalized error tolerance

         float resolution; // normalized resolution in units/mm

         float filter;  // filter out small variations of this size

         float currentValue; // current value

         float newValue; // most recent value

         float highCurrentValue; // current value of high split

         float highNewValue; // most recent value of high split

         void initialize(const RawAbsoluteAxisInfo& rawAxisInfo, const AxisInfo& axisInfo,

                 bool explicitlyMapped, float scale, float offset,

                 float highScale, float highOffset,

                 float min, float max, float flat, float fuzz, float resolution) {

             this->rawAxisInfo = rawAxisInfo;

             this->axisInfo = axisInfo;

             this->explicitlyMapped = explicitlyMapped;

             this->scale = scale;

             this->offset = offset;

             this->highScale = highScale;

             this->highOffset = highOffset;

             this->min = min;

             this->max = max;

             this->flat = flat;

             this->fuzz = fuzz;

             this->resolution = resolution;

             this->filter = 0;

             resetValue();

         }

         void resetValue() {

             this->currentValue = 0;

             this->newValue = 0;

             this->highCurrentValue = 0;

             this->highNewValue = 0;

         }

     };

     // Axes indexed by raw ABS_* axis index.

     KeyedVector<int32_t, Axis> mAxes;

     void sync(nsecs_t when, bool force);

     bool haveAxis(int32_t axisId);

     void pruneAxes(bool ignoreExplicitlyMappedAxes);

     bool filterAxes(bool force);

     static bool hasValueChangedSignificantly(float filter,

             float newValue, float currentValue, float min, float max);

     static bool hasMovedNearerToValueWithinFilteredRange(float filter,

             float newValue, float currentValue, float thresholdValue);

     static bool isCenteredAxis(int32_t axis);

     static int32_t getCompatAxis(int32_t axis);

     static void addMotionRange(int32_t axisId, const Axis& axis, InputDeviceInfo* info);

     static void setPointerCoordsAxisValue(PointerCoords* pointerCoords, int32_t axis,

             float value);

 };

 } // namespace android

 #endif // _UI_INPUT_READER_H