/*
* 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/Input.h>
#include <input/VelocityControl.h>
#include <input/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, int32_t controllerNumber,
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:
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, int32_t
controllerNumber, const InputDeviceIdentifier& identifier, uint32_t classes);
~InputDevice();
inline InputReaderContext* getContext() { return mContext; }
inline int32_t getId() const { return mId; }
inline int32_t getControllerNumber() const { return mControllerNumber; }
inline int32_t getGeneration() const { return mGeneration; }
inline const String8& getName() const { return mIdentifier.name; }
inline uint32_t getClasses() const { return mClasses; }
inline uint32_t getSources() const { 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 mControllerNumber;
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;
bool hasButtonUnderPad;
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;
}
if (*outSize < 0) {
*outSize = 0;
}
}
} 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