395 lines
16 KiB
C++
395 lines
16 KiB
C++
/*
|
|
* Copyright (C) 2018 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_BASE_H
|
|
#define _UI_INPUT_READER_BASE_H
|
|
|
|
#include <input/DisplayViewport.h>
|
|
#include <input/Input.h>
|
|
#include <input/InputDevice.h>
|
|
#include <input/VelocityControl.h>
|
|
#include <input/VelocityTracker.h>
|
|
#include <stddef.h>
|
|
#include <unistd.h>
|
|
#include <utils/Errors.h>
|
|
#include <utils/RefBase.h>
|
|
|
|
#include <optional>
|
|
#include <set>
|
|
#include <unordered_map>
|
|
#include <vector>
|
|
|
|
#include "PointerControllerInterface.h"
|
|
#include "VibrationElement.h"
|
|
|
|
// Maximum supported size of a vibration pattern.
|
|
// Must be at least 2.
|
|
#define MAX_VIBRATE_PATTERN_SIZE 100
|
|
|
|
namespace android {
|
|
|
|
// --- InputReaderInterface ---
|
|
|
|
/* The interface for the InputReader shared library.
|
|
*
|
|
* Manages one or more threads that process raw input events and sends cooked event data to an
|
|
* input listener.
|
|
*
|
|
* The implementation must guarantee thread safety for this interface. However, since the input
|
|
* listener is NOT thread safe, all calls to the listener must happen from the same thread.
|
|
*/
|
|
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(std::string& dump) = 0;
|
|
|
|
/* Called by the heartbeat to ensures that the reader has not deadlocked. */
|
|
virtual void monitor() = 0;
|
|
|
|
/* Returns true if the input device is enabled. */
|
|
virtual bool isInputDeviceEnabled(int32_t deviceId) = 0;
|
|
|
|
/* Makes the reader start processing events from the kernel. */
|
|
virtual status_t start() = 0;
|
|
|
|
/* Makes the reader stop processing any more events. */
|
|
virtual status_t stop() = 0;
|
|
|
|
/* Gets information about all input devices.
|
|
*
|
|
* This method may be called on any thread (usually by the input manager).
|
|
*/
|
|
virtual std::vector<InputDeviceInfo> getInputDevices() const = 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;
|
|
|
|
/* Toggle Caps Lock */
|
|
virtual void toggleCapsLockState(int32_t deviceId) = 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 VibrationSequence& sequence, ssize_t repeat,
|
|
int32_t token) = 0;
|
|
virtual void cancelVibrate(int32_t deviceId, int32_t token) = 0;
|
|
|
|
virtual bool isVibrating(int32_t deviceId) = 0;
|
|
|
|
virtual std::vector<int32_t> getVibratorIds(int32_t deviceId) = 0;
|
|
/* Get battery level of a particular input device. */
|
|
virtual std::optional<int32_t> getBatteryCapacity(int32_t deviceId) = 0;
|
|
/* Get battery status of a particular input device. */
|
|
virtual std::optional<int32_t> getBatteryStatus(int32_t deviceId) = 0;
|
|
|
|
virtual std::vector<InputDeviceLightInfo> getLights(int32_t deviceId) = 0;
|
|
|
|
virtual std::vector<InputDeviceSensorInfo> getSensors(int32_t deviceId) = 0;
|
|
|
|
/* Return true if the device can send input events to the specified display. */
|
|
virtual bool canDispatchToDisplay(int32_t deviceId, int32_t displayId) = 0;
|
|
|
|
/* Enable sensor in input reader mapper. */
|
|
virtual bool enableSensor(int32_t deviceId, InputDeviceSensorType sensorType,
|
|
std::chrono::microseconds samplingPeriod,
|
|
std::chrono::microseconds maxBatchReportLatency) = 0;
|
|
|
|
/* Disable sensor in input reader mapper. */
|
|
virtual void disableSensor(int32_t deviceId, InputDeviceSensorType sensorType) = 0;
|
|
|
|
/* Flush sensor data in input reader mapper. */
|
|
virtual void flushSensor(int32_t deviceId, InputDeviceSensorType sensorType) = 0;
|
|
|
|
/* Set color for the light */
|
|
virtual bool setLightColor(int32_t deviceId, int32_t lightId, int32_t color) = 0;
|
|
/* Set player ID for the light */
|
|
virtual bool setLightPlayerId(int32_t deviceId, int32_t lightId, int32_t playerId) = 0;
|
|
/* Get light color */
|
|
virtual std::optional<int32_t> getLightColor(int32_t deviceId, int32_t lightId) = 0;
|
|
/* Get light player ID */
|
|
virtual std::optional<int32_t> getLightPlayerId(int32_t deviceId, int32_t lightId) = 0;
|
|
};
|
|
|
|
// --- InputReaderConfiguration ---
|
|
|
|
/*
|
|
* 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,
|
|
|
|
// The location calibration matrix changed.
|
|
CHANGE_TOUCH_AFFINE_TRANSFORMATION = 1 << 6,
|
|
|
|
// The presence of an external stylus has changed.
|
|
CHANGE_EXTERNAL_STYLUS_PRESENCE = 1 << 7,
|
|
|
|
// The pointer capture mode has changed.
|
|
CHANGE_POINTER_CAPTURE = 1 << 8,
|
|
|
|
// The set of disabled input devices (disabledDevices) has changed.
|
|
CHANGE_ENABLED_STATE = 1 << 9,
|
|
|
|
// 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.
|
|
std::vector<std::string> excludedDeviceNames;
|
|
|
|
// The associations between input ports and display ports.
|
|
// Used to determine which DisplayViewport should be tied to which InputDevice.
|
|
std::unordered_map<std::string, uint8_t> portAssociations;
|
|
|
|
// The associations between input device names and display unique ids.
|
|
// Used to determine which DisplayViewport should be tied to which InputDevice.
|
|
std::unordered_map<std::string, std::string> uniqueIdAssociations;
|
|
|
|
// The suggested display ID to show the cursor.
|
|
int32_t defaultPointerDisplayId;
|
|
|
|
// 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;
|
|
|
|
// The latest request to enable or disable Pointer Capture.
|
|
PointerCaptureRequest pointerCaptureRequest;
|
|
|
|
// The set of currently disabled input devices.
|
|
std::set<int32_t> disabledDevices;
|
|
|
|
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),
|
|
pointerCaptureRequest() {}
|
|
|
|
static std::string changesToString(uint32_t changes);
|
|
|
|
std::optional<DisplayViewport> getDisplayViewportByType(ViewportType type) const;
|
|
std::optional<DisplayViewport> getDisplayViewportByUniqueId(const std::string& uniqueDisplayId)
|
|
const;
|
|
std::optional<DisplayViewport> getDisplayViewportByPort(uint8_t physicalPort) const;
|
|
std::optional<DisplayViewport> getDisplayViewportById(int32_t displayId) const;
|
|
void setDisplayViewports(const std::vector<DisplayViewport>& viewports);
|
|
|
|
|
|
void dump(std::string& dump) const;
|
|
void dumpViewport(std::string& dump, const DisplayViewport& viewport) const;
|
|
|
|
private:
|
|
std::vector<DisplayViewport> mDisplays;
|
|
};
|
|
|
|
// --- TouchAffineTransformation ---
|
|
|
|
struct TouchAffineTransformation {
|
|
float x_scale;
|
|
float x_ymix;
|
|
float x_offset;
|
|
float y_xmix;
|
|
float y_scale;
|
|
float y_offset;
|
|
|
|
TouchAffineTransformation() :
|
|
x_scale(1.0f), x_ymix(0.0f), x_offset(0.0f),
|
|
y_xmix(0.0f), y_scale(1.0f), y_offset(0.0f) {
|
|
}
|
|
|
|
TouchAffineTransformation(float xscale, float xymix, float xoffset,
|
|
float yxmix, float yscale, float yoffset) :
|
|
x_scale(xscale), x_ymix(xymix), x_offset(xoffset),
|
|
y_xmix(yxmix), y_scale(yscale), y_offset(yoffset) {
|
|
}
|
|
|
|
void applyTo(float& x, float& y) const;
|
|
};
|
|
|
|
// --- InputReaderPolicyInterface ---
|
|
|
|
/*
|
|
* 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 will NOT re-enter the input reader interface, so they may be called from
|
|
* any method in the input reader interface.
|
|
*/
|
|
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 std::shared_ptr<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 std::vector<InputDeviceInfo>& inputDevices) = 0;
|
|
|
|
/* Gets the keyboard layout for a particular input device. */
|
|
virtual std::shared_ptr<KeyCharacterMap> getKeyboardLayoutOverlay(
|
|
const InputDeviceIdentifier& identifier) = 0;
|
|
|
|
/* Gets a user-supplied alias for a particular input device, or an empty string if none. */
|
|
virtual std::string getDeviceAlias(const InputDeviceIdentifier& identifier) = 0;
|
|
|
|
/* Gets the affine calibration associated with the specified device. */
|
|
virtual TouchAffineTransformation getTouchAffineTransformation(
|
|
const std::string& inputDeviceDescriptor, int32_t surfaceRotation) = 0;
|
|
};
|
|
|
|
} // namespace android
|
|
|
|
#endif // _UI_INPUT_READER_COMMON_H
|