32397c1cd3
See https://android-git.corp.google.com/g/157065 Bug: 5449033 Change-Id: I00a4b904f9449e6f93b7fd35eac28640d7929e69
1224 lines
38 KiB
C++
1224 lines
38 KiB
C++
//
|
|
// Copyright 2010 The Android Open Source Project
|
|
//
|
|
// Provides a pipe-based transport for native events in the NDK.
|
|
//
|
|
#define LOG_TAG "Input"
|
|
|
|
//#define LOG_NDEBUG 0
|
|
|
|
// Log debug messages about keymap probing.
|
|
#define DEBUG_PROBE 0
|
|
|
|
// Log debug messages about velocity tracking.
|
|
#define DEBUG_VELOCITY 0
|
|
|
|
// Log debug messages about least squares fitting.
|
|
#define DEBUG_LEAST_SQUARES 0
|
|
|
|
// Log debug messages about acceleration.
|
|
#define DEBUG_ACCELERATION 0
|
|
|
|
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <ctype.h>
|
|
|
|
#include <ui/Input.h>
|
|
|
|
#include <math.h>
|
|
#include <limits.h>
|
|
|
|
#ifdef HAVE_ANDROID_OS
|
|
#include <binder/Parcel.h>
|
|
|
|
#include "SkPoint.h"
|
|
#include "SkMatrix.h"
|
|
#include "SkScalar.h"
|
|
#endif
|
|
|
|
namespace android {
|
|
|
|
static const char* CONFIGURATION_FILE_DIR[] = {
|
|
"idc/",
|
|
"keylayout/",
|
|
"keychars/",
|
|
};
|
|
|
|
static const char* CONFIGURATION_FILE_EXTENSION[] = {
|
|
".idc",
|
|
".kl",
|
|
".kcm",
|
|
};
|
|
|
|
static bool isValidNameChar(char ch) {
|
|
return isascii(ch) && (isdigit(ch) || isalpha(ch) || ch == '-' || ch == '_');
|
|
}
|
|
|
|
static void appendInputDeviceConfigurationFileRelativePath(String8& path,
|
|
const String8& name, InputDeviceConfigurationFileType type) {
|
|
path.append(CONFIGURATION_FILE_DIR[type]);
|
|
for (size_t i = 0; i < name.length(); i++) {
|
|
char ch = name[i];
|
|
if (!isValidNameChar(ch)) {
|
|
ch = '_';
|
|
}
|
|
path.append(&ch, 1);
|
|
}
|
|
path.append(CONFIGURATION_FILE_EXTENSION[type]);
|
|
}
|
|
|
|
String8 getInputDeviceConfigurationFilePathByDeviceIdentifier(
|
|
const InputDeviceIdentifier& deviceIdentifier,
|
|
InputDeviceConfigurationFileType type) {
|
|
if (deviceIdentifier.vendor !=0 && deviceIdentifier.product != 0) {
|
|
if (deviceIdentifier.version != 0) {
|
|
// Try vendor product version.
|
|
String8 versionPath(getInputDeviceConfigurationFilePathByName(
|
|
String8::format("Vendor_%04x_Product_%04x_Version_%04x",
|
|
deviceIdentifier.vendor, deviceIdentifier.product,
|
|
deviceIdentifier.version),
|
|
type));
|
|
if (!versionPath.isEmpty()) {
|
|
return versionPath;
|
|
}
|
|
}
|
|
|
|
// Try vendor product.
|
|
String8 productPath(getInputDeviceConfigurationFilePathByName(
|
|
String8::format("Vendor_%04x_Product_%04x",
|
|
deviceIdentifier.vendor, deviceIdentifier.product),
|
|
type));
|
|
if (!productPath.isEmpty()) {
|
|
return productPath;
|
|
}
|
|
}
|
|
|
|
// Try device name.
|
|
return getInputDeviceConfigurationFilePathByName(deviceIdentifier.name, type);
|
|
}
|
|
|
|
String8 getInputDeviceConfigurationFilePathByName(
|
|
const String8& name, InputDeviceConfigurationFileType type) {
|
|
// Search system repository.
|
|
String8 path;
|
|
path.setTo(getenv("ANDROID_ROOT"));
|
|
path.append("/usr/");
|
|
appendInputDeviceConfigurationFileRelativePath(path, name, type);
|
|
#if DEBUG_PROBE
|
|
ALOGD("Probing for system provided input device configuration file: path='%s'", path.string());
|
|
#endif
|
|
if (!access(path.string(), R_OK)) {
|
|
#if DEBUG_PROBE
|
|
ALOGD("Found");
|
|
#endif
|
|
return path;
|
|
}
|
|
|
|
// Search user repository.
|
|
// TODO Should only look here if not in safe mode.
|
|
path.setTo(getenv("ANDROID_DATA"));
|
|
path.append("/system/devices/");
|
|
appendInputDeviceConfigurationFileRelativePath(path, name, type);
|
|
#if DEBUG_PROBE
|
|
ALOGD("Probing for system user input device configuration file: path='%s'", path.string());
|
|
#endif
|
|
if (!access(path.string(), R_OK)) {
|
|
#if DEBUG_PROBE
|
|
ALOGD("Found");
|
|
#endif
|
|
return path;
|
|
}
|
|
|
|
// Not found.
|
|
#if DEBUG_PROBE
|
|
ALOGD("Probe failed to find input device configuration file: name='%s', type=%d",
|
|
name.string(), type);
|
|
#endif
|
|
return String8();
|
|
}
|
|
|
|
|
|
// --- InputEvent ---
|
|
|
|
void InputEvent::initialize(int32_t deviceId, int32_t source) {
|
|
mDeviceId = deviceId;
|
|
mSource = source;
|
|
}
|
|
|
|
void InputEvent::initialize(const InputEvent& from) {
|
|
mDeviceId = from.mDeviceId;
|
|
mSource = from.mSource;
|
|
}
|
|
|
|
// --- KeyEvent ---
|
|
|
|
bool KeyEvent::hasDefaultAction(int32_t keyCode) {
|
|
switch (keyCode) {
|
|
case AKEYCODE_HOME:
|
|
case AKEYCODE_BACK:
|
|
case AKEYCODE_CALL:
|
|
case AKEYCODE_ENDCALL:
|
|
case AKEYCODE_VOLUME_UP:
|
|
case AKEYCODE_VOLUME_DOWN:
|
|
case AKEYCODE_VOLUME_MUTE:
|
|
case AKEYCODE_POWER:
|
|
case AKEYCODE_CAMERA:
|
|
case AKEYCODE_HEADSETHOOK:
|
|
case AKEYCODE_MENU:
|
|
case AKEYCODE_NOTIFICATION:
|
|
case AKEYCODE_FOCUS:
|
|
case AKEYCODE_SEARCH:
|
|
case AKEYCODE_MEDIA_PLAY:
|
|
case AKEYCODE_MEDIA_PAUSE:
|
|
case AKEYCODE_MEDIA_PLAY_PAUSE:
|
|
case AKEYCODE_MEDIA_STOP:
|
|
case AKEYCODE_MEDIA_NEXT:
|
|
case AKEYCODE_MEDIA_PREVIOUS:
|
|
case AKEYCODE_MEDIA_REWIND:
|
|
case AKEYCODE_MEDIA_RECORD:
|
|
case AKEYCODE_MEDIA_FAST_FORWARD:
|
|
case AKEYCODE_MUTE:
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool KeyEvent::hasDefaultAction() const {
|
|
return hasDefaultAction(getKeyCode());
|
|
}
|
|
|
|
bool KeyEvent::isSystemKey(int32_t keyCode) {
|
|
switch (keyCode) {
|
|
case AKEYCODE_MENU:
|
|
case AKEYCODE_SOFT_RIGHT:
|
|
case AKEYCODE_HOME:
|
|
case AKEYCODE_BACK:
|
|
case AKEYCODE_CALL:
|
|
case AKEYCODE_ENDCALL:
|
|
case AKEYCODE_VOLUME_UP:
|
|
case AKEYCODE_VOLUME_DOWN:
|
|
case AKEYCODE_VOLUME_MUTE:
|
|
case AKEYCODE_MUTE:
|
|
case AKEYCODE_POWER:
|
|
case AKEYCODE_HEADSETHOOK:
|
|
case AKEYCODE_MEDIA_PLAY:
|
|
case AKEYCODE_MEDIA_PAUSE:
|
|
case AKEYCODE_MEDIA_PLAY_PAUSE:
|
|
case AKEYCODE_MEDIA_STOP:
|
|
case AKEYCODE_MEDIA_NEXT:
|
|
case AKEYCODE_MEDIA_PREVIOUS:
|
|
case AKEYCODE_MEDIA_REWIND:
|
|
case AKEYCODE_MEDIA_RECORD:
|
|
case AKEYCODE_MEDIA_FAST_FORWARD:
|
|
case AKEYCODE_CAMERA:
|
|
case AKEYCODE_FOCUS:
|
|
case AKEYCODE_SEARCH:
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool KeyEvent::isSystemKey() const {
|
|
return isSystemKey(getKeyCode());
|
|
}
|
|
|
|
void KeyEvent::initialize(
|
|
int32_t deviceId,
|
|
int32_t source,
|
|
int32_t action,
|
|
int32_t flags,
|
|
int32_t keyCode,
|
|
int32_t scanCode,
|
|
int32_t metaState,
|
|
int32_t repeatCount,
|
|
nsecs_t downTime,
|
|
nsecs_t eventTime) {
|
|
InputEvent::initialize(deviceId, source);
|
|
mAction = action;
|
|
mFlags = flags;
|
|
mKeyCode = keyCode;
|
|
mScanCode = scanCode;
|
|
mMetaState = metaState;
|
|
mRepeatCount = repeatCount;
|
|
mDownTime = downTime;
|
|
mEventTime = eventTime;
|
|
}
|
|
|
|
void KeyEvent::initialize(const KeyEvent& from) {
|
|
InputEvent::initialize(from);
|
|
mAction = from.mAction;
|
|
mFlags = from.mFlags;
|
|
mKeyCode = from.mKeyCode;
|
|
mScanCode = from.mScanCode;
|
|
mMetaState = from.mMetaState;
|
|
mRepeatCount = from.mRepeatCount;
|
|
mDownTime = from.mDownTime;
|
|
mEventTime = from.mEventTime;
|
|
}
|
|
|
|
|
|
// --- PointerCoords ---
|
|
|
|
float PointerCoords::getAxisValue(int32_t axis) const {
|
|
if (axis < 0 || axis > 63) {
|
|
return 0;
|
|
}
|
|
|
|
uint64_t axisBit = 1LL << axis;
|
|
if (!(bits & axisBit)) {
|
|
return 0;
|
|
}
|
|
uint32_t index = __builtin_popcountll(bits & (axisBit - 1LL));
|
|
return values[index];
|
|
}
|
|
|
|
status_t PointerCoords::setAxisValue(int32_t axis, float value) {
|
|
if (axis < 0 || axis > 63) {
|
|
return NAME_NOT_FOUND;
|
|
}
|
|
|
|
uint64_t axisBit = 1LL << axis;
|
|
uint32_t index = __builtin_popcountll(bits & (axisBit - 1LL));
|
|
if (!(bits & axisBit)) {
|
|
if (value == 0) {
|
|
return OK; // axes with value 0 do not need to be stored
|
|
}
|
|
uint32_t count = __builtin_popcountll(bits);
|
|
if (count >= MAX_AXES) {
|
|
tooManyAxes(axis);
|
|
return NO_MEMORY;
|
|
}
|
|
bits |= axisBit;
|
|
for (uint32_t i = count; i > index; i--) {
|
|
values[i] = values[i - 1];
|
|
}
|
|
}
|
|
values[index] = value;
|
|
return OK;
|
|
}
|
|
|
|
static inline void scaleAxisValue(PointerCoords& c, int axis, float scaleFactor) {
|
|
float value = c.getAxisValue(axis);
|
|
if (value != 0) {
|
|
c.setAxisValue(axis, value * scaleFactor);
|
|
}
|
|
}
|
|
|
|
void PointerCoords::scale(float scaleFactor) {
|
|
// No need to scale pressure or size since they are normalized.
|
|
// No need to scale orientation since it is meaningless to do so.
|
|
scaleAxisValue(*this, AMOTION_EVENT_AXIS_X, scaleFactor);
|
|
scaleAxisValue(*this, AMOTION_EVENT_AXIS_Y, scaleFactor);
|
|
scaleAxisValue(*this, AMOTION_EVENT_AXIS_TOUCH_MAJOR, scaleFactor);
|
|
scaleAxisValue(*this, AMOTION_EVENT_AXIS_TOUCH_MINOR, scaleFactor);
|
|
scaleAxisValue(*this, AMOTION_EVENT_AXIS_TOOL_MAJOR, scaleFactor);
|
|
scaleAxisValue(*this, AMOTION_EVENT_AXIS_TOOL_MINOR, scaleFactor);
|
|
}
|
|
|
|
#ifdef HAVE_ANDROID_OS
|
|
status_t PointerCoords::readFromParcel(Parcel* parcel) {
|
|
bits = parcel->readInt64();
|
|
|
|
uint32_t count = __builtin_popcountll(bits);
|
|
if (count > MAX_AXES) {
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
for (uint32_t i = 0; i < count; i++) {
|
|
values[i] = parcel->readInt32();
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
status_t PointerCoords::writeToParcel(Parcel* parcel) const {
|
|
parcel->writeInt64(bits);
|
|
|
|
uint32_t count = __builtin_popcountll(bits);
|
|
for (uint32_t i = 0; i < count; i++) {
|
|
parcel->writeInt32(values[i]);
|
|
}
|
|
return OK;
|
|
}
|
|
#endif
|
|
|
|
void PointerCoords::tooManyAxes(int axis) {
|
|
ALOGW("Could not set value for axis %d because the PointerCoords structure is full and "
|
|
"cannot contain more than %d axis values.", axis, int(MAX_AXES));
|
|
}
|
|
|
|
bool PointerCoords::operator==(const PointerCoords& other) const {
|
|
if (bits != other.bits) {
|
|
return false;
|
|
}
|
|
uint32_t count = __builtin_popcountll(bits);
|
|
for (uint32_t i = 0; i < count; i++) {
|
|
if (values[i] != other.values[i]) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void PointerCoords::copyFrom(const PointerCoords& other) {
|
|
bits = other.bits;
|
|
uint32_t count = __builtin_popcountll(bits);
|
|
for (uint32_t i = 0; i < count; i++) {
|
|
values[i] = other.values[i];
|
|
}
|
|
}
|
|
|
|
|
|
// --- PointerProperties ---
|
|
|
|
bool PointerProperties::operator==(const PointerProperties& other) const {
|
|
return id == other.id
|
|
&& toolType == other.toolType;
|
|
}
|
|
|
|
void PointerProperties::copyFrom(const PointerProperties& other) {
|
|
id = other.id;
|
|
toolType = other.toolType;
|
|
}
|
|
|
|
|
|
// --- MotionEvent ---
|
|
|
|
void MotionEvent::initialize(
|
|
int32_t deviceId,
|
|
int32_t source,
|
|
int32_t action,
|
|
int32_t flags,
|
|
int32_t edgeFlags,
|
|
int32_t metaState,
|
|
int32_t buttonState,
|
|
float xOffset,
|
|
float yOffset,
|
|
float xPrecision,
|
|
float yPrecision,
|
|
nsecs_t downTime,
|
|
nsecs_t eventTime,
|
|
size_t pointerCount,
|
|
const PointerProperties* pointerProperties,
|
|
const PointerCoords* pointerCoords) {
|
|
InputEvent::initialize(deviceId, source);
|
|
mAction = action;
|
|
mFlags = flags;
|
|
mEdgeFlags = edgeFlags;
|
|
mMetaState = metaState;
|
|
mButtonState = buttonState;
|
|
mXOffset = xOffset;
|
|
mYOffset = yOffset;
|
|
mXPrecision = xPrecision;
|
|
mYPrecision = yPrecision;
|
|
mDownTime = downTime;
|
|
mPointerProperties.clear();
|
|
mPointerProperties.appendArray(pointerProperties, pointerCount);
|
|
mSampleEventTimes.clear();
|
|
mSamplePointerCoords.clear();
|
|
addSample(eventTime, pointerCoords);
|
|
}
|
|
|
|
void MotionEvent::copyFrom(const MotionEvent* other, bool keepHistory) {
|
|
InputEvent::initialize(other->mDeviceId, other->mSource);
|
|
mAction = other->mAction;
|
|
mFlags = other->mFlags;
|
|
mEdgeFlags = other->mEdgeFlags;
|
|
mMetaState = other->mMetaState;
|
|
mButtonState = other->mButtonState;
|
|
mXOffset = other->mXOffset;
|
|
mYOffset = other->mYOffset;
|
|
mXPrecision = other->mXPrecision;
|
|
mYPrecision = other->mYPrecision;
|
|
mDownTime = other->mDownTime;
|
|
mPointerProperties = other->mPointerProperties;
|
|
|
|
if (keepHistory) {
|
|
mSampleEventTimes = other->mSampleEventTimes;
|
|
mSamplePointerCoords = other->mSamplePointerCoords;
|
|
} else {
|
|
mSampleEventTimes.clear();
|
|
mSampleEventTimes.push(other->getEventTime());
|
|
mSamplePointerCoords.clear();
|
|
size_t pointerCount = other->getPointerCount();
|
|
size_t historySize = other->getHistorySize();
|
|
mSamplePointerCoords.appendArray(other->mSamplePointerCoords.array()
|
|
+ (historySize * pointerCount), pointerCount);
|
|
}
|
|
}
|
|
|
|
void MotionEvent::addSample(
|
|
int64_t eventTime,
|
|
const PointerCoords* pointerCoords) {
|
|
mSampleEventTimes.push(eventTime);
|
|
mSamplePointerCoords.appendArray(pointerCoords, getPointerCount());
|
|
}
|
|
|
|
const PointerCoords* MotionEvent::getRawPointerCoords(size_t pointerIndex) const {
|
|
return &mSamplePointerCoords[getHistorySize() * getPointerCount() + pointerIndex];
|
|
}
|
|
|
|
float MotionEvent::getRawAxisValue(int32_t axis, size_t pointerIndex) const {
|
|
return getRawPointerCoords(pointerIndex)->getAxisValue(axis);
|
|
}
|
|
|
|
float MotionEvent::getAxisValue(int32_t axis, size_t pointerIndex) const {
|
|
float value = getRawPointerCoords(pointerIndex)->getAxisValue(axis);
|
|
switch (axis) {
|
|
case AMOTION_EVENT_AXIS_X:
|
|
return value + mXOffset;
|
|
case AMOTION_EVENT_AXIS_Y:
|
|
return value + mYOffset;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
const PointerCoords* MotionEvent::getHistoricalRawPointerCoords(
|
|
size_t pointerIndex, size_t historicalIndex) const {
|
|
return &mSamplePointerCoords[historicalIndex * getPointerCount() + pointerIndex];
|
|
}
|
|
|
|
float MotionEvent::getHistoricalRawAxisValue(int32_t axis, size_t pointerIndex,
|
|
size_t historicalIndex) const {
|
|
return getHistoricalRawPointerCoords(pointerIndex, historicalIndex)->getAxisValue(axis);
|
|
}
|
|
|
|
float MotionEvent::getHistoricalAxisValue(int32_t axis, size_t pointerIndex,
|
|
size_t historicalIndex) const {
|
|
float value = getHistoricalRawPointerCoords(pointerIndex, historicalIndex)->getAxisValue(axis);
|
|
switch (axis) {
|
|
case AMOTION_EVENT_AXIS_X:
|
|
return value + mXOffset;
|
|
case AMOTION_EVENT_AXIS_Y:
|
|
return value + mYOffset;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
ssize_t MotionEvent::findPointerIndex(int32_t pointerId) const {
|
|
size_t pointerCount = mPointerProperties.size();
|
|
for (size_t i = 0; i < pointerCount; i++) {
|
|
if (mPointerProperties.itemAt(i).id == pointerId) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void MotionEvent::offsetLocation(float xOffset, float yOffset) {
|
|
mXOffset += xOffset;
|
|
mYOffset += yOffset;
|
|
}
|
|
|
|
void MotionEvent::scale(float scaleFactor) {
|
|
mXOffset *= scaleFactor;
|
|
mYOffset *= scaleFactor;
|
|
mXPrecision *= scaleFactor;
|
|
mYPrecision *= scaleFactor;
|
|
|
|
size_t numSamples = mSamplePointerCoords.size();
|
|
for (size_t i = 0; i < numSamples; i++) {
|
|
mSamplePointerCoords.editItemAt(i).scale(scaleFactor);
|
|
}
|
|
}
|
|
|
|
#ifdef HAVE_ANDROID_OS
|
|
static inline float transformAngle(const SkMatrix* matrix, float angleRadians) {
|
|
// Construct and transform a vector oriented at the specified clockwise angle from vertical.
|
|
// Coordinate system: down is increasing Y, right is increasing X.
|
|
SkPoint vector;
|
|
vector.fX = SkFloatToScalar(sinf(angleRadians));
|
|
vector.fY = SkFloatToScalar(-cosf(angleRadians));
|
|
matrix->mapVectors(& vector, 1);
|
|
|
|
// Derive the transformed vector's clockwise angle from vertical.
|
|
float result = atan2f(SkScalarToFloat(vector.fX), SkScalarToFloat(-vector.fY));
|
|
if (result < - M_PI_2) {
|
|
result += M_PI;
|
|
} else if (result > M_PI_2) {
|
|
result -= M_PI;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void MotionEvent::transform(const SkMatrix* matrix) {
|
|
float oldXOffset = mXOffset;
|
|
float oldYOffset = mYOffset;
|
|
|
|
// The tricky part of this implementation is to preserve the value of
|
|
// rawX and rawY. So we apply the transformation to the first point
|
|
// then derive an appropriate new X/Y offset that will preserve rawX and rawY.
|
|
SkPoint point;
|
|
float rawX = getRawX(0);
|
|
float rawY = getRawY(0);
|
|
matrix->mapXY(SkFloatToScalar(rawX + oldXOffset), SkFloatToScalar(rawY + oldYOffset),
|
|
& point);
|
|
float newX = SkScalarToFloat(point.fX);
|
|
float newY = SkScalarToFloat(point.fY);
|
|
float newXOffset = newX - rawX;
|
|
float newYOffset = newY - rawY;
|
|
|
|
mXOffset = newXOffset;
|
|
mYOffset = newYOffset;
|
|
|
|
// Apply the transformation to all samples.
|
|
size_t numSamples = mSamplePointerCoords.size();
|
|
for (size_t i = 0; i < numSamples; i++) {
|
|
PointerCoords& c = mSamplePointerCoords.editItemAt(i);
|
|
float x = c.getAxisValue(AMOTION_EVENT_AXIS_X) + oldXOffset;
|
|
float y = c.getAxisValue(AMOTION_EVENT_AXIS_Y) + oldYOffset;
|
|
matrix->mapXY(SkFloatToScalar(x), SkFloatToScalar(y), &point);
|
|
c.setAxisValue(AMOTION_EVENT_AXIS_X, SkScalarToFloat(point.fX) - newXOffset);
|
|
c.setAxisValue(AMOTION_EVENT_AXIS_Y, SkScalarToFloat(point.fY) - newYOffset);
|
|
|
|
float orientation = c.getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION);
|
|
c.setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, transformAngle(matrix, orientation));
|
|
}
|
|
}
|
|
|
|
status_t MotionEvent::readFromParcel(Parcel* parcel) {
|
|
size_t pointerCount = parcel->readInt32();
|
|
size_t sampleCount = parcel->readInt32();
|
|
if (pointerCount == 0 || pointerCount > MAX_POINTERS || sampleCount == 0) {
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
mDeviceId = parcel->readInt32();
|
|
mSource = parcel->readInt32();
|
|
mAction = parcel->readInt32();
|
|
mFlags = parcel->readInt32();
|
|
mEdgeFlags = parcel->readInt32();
|
|
mMetaState = parcel->readInt32();
|
|
mButtonState = parcel->readInt32();
|
|
mXOffset = parcel->readFloat();
|
|
mYOffset = parcel->readFloat();
|
|
mXPrecision = parcel->readFloat();
|
|
mYPrecision = parcel->readFloat();
|
|
mDownTime = parcel->readInt64();
|
|
|
|
mPointerProperties.clear();
|
|
mPointerProperties.setCapacity(pointerCount);
|
|
mSampleEventTimes.clear();
|
|
mSampleEventTimes.setCapacity(sampleCount);
|
|
mSamplePointerCoords.clear();
|
|
mSamplePointerCoords.setCapacity(sampleCount * pointerCount);
|
|
|
|
for (size_t i = 0; i < pointerCount; i++) {
|
|
mPointerProperties.push();
|
|
PointerProperties& properties = mPointerProperties.editTop();
|
|
properties.id = parcel->readInt32();
|
|
properties.toolType = parcel->readInt32();
|
|
}
|
|
|
|
while (sampleCount-- > 0) {
|
|
mSampleEventTimes.push(parcel->readInt64());
|
|
for (size_t i = 0; i < pointerCount; i++) {
|
|
mSamplePointerCoords.push();
|
|
status_t status = mSamplePointerCoords.editTop().readFromParcel(parcel);
|
|
if (status) {
|
|
return status;
|
|
}
|
|
}
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
status_t MotionEvent::writeToParcel(Parcel* parcel) const {
|
|
size_t pointerCount = mPointerProperties.size();
|
|
size_t sampleCount = mSampleEventTimes.size();
|
|
|
|
parcel->writeInt32(pointerCount);
|
|
parcel->writeInt32(sampleCount);
|
|
|
|
parcel->writeInt32(mDeviceId);
|
|
parcel->writeInt32(mSource);
|
|
parcel->writeInt32(mAction);
|
|
parcel->writeInt32(mFlags);
|
|
parcel->writeInt32(mEdgeFlags);
|
|
parcel->writeInt32(mMetaState);
|
|
parcel->writeInt32(mButtonState);
|
|
parcel->writeFloat(mXOffset);
|
|
parcel->writeFloat(mYOffset);
|
|
parcel->writeFloat(mXPrecision);
|
|
parcel->writeFloat(mYPrecision);
|
|
parcel->writeInt64(mDownTime);
|
|
|
|
for (size_t i = 0; i < pointerCount; i++) {
|
|
const PointerProperties& properties = mPointerProperties.itemAt(i);
|
|
parcel->writeInt32(properties.id);
|
|
parcel->writeInt32(properties.toolType);
|
|
}
|
|
|
|
const PointerCoords* pc = mSamplePointerCoords.array();
|
|
for (size_t h = 0; h < sampleCount; h++) {
|
|
parcel->writeInt64(mSampleEventTimes.itemAt(h));
|
|
for (size_t i = 0; i < pointerCount; i++) {
|
|
status_t status = (pc++)->writeToParcel(parcel);
|
|
if (status) {
|
|
return status;
|
|
}
|
|
}
|
|
}
|
|
return OK;
|
|
}
|
|
#endif
|
|
|
|
bool MotionEvent::isTouchEvent(int32_t source, int32_t action) {
|
|
if (source & AINPUT_SOURCE_CLASS_POINTER) {
|
|
// Specifically excludes HOVER_MOVE and SCROLL.
|
|
switch (action & AMOTION_EVENT_ACTION_MASK) {
|
|
case AMOTION_EVENT_ACTION_DOWN:
|
|
case AMOTION_EVENT_ACTION_MOVE:
|
|
case AMOTION_EVENT_ACTION_UP:
|
|
case AMOTION_EVENT_ACTION_POINTER_DOWN:
|
|
case AMOTION_EVENT_ACTION_POINTER_UP:
|
|
case AMOTION_EVENT_ACTION_CANCEL:
|
|
case AMOTION_EVENT_ACTION_OUTSIDE:
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
// --- VelocityTracker ---
|
|
|
|
const uint32_t VelocityTracker::DEFAULT_DEGREE;
|
|
const nsecs_t VelocityTracker::DEFAULT_HORIZON;
|
|
const uint32_t VelocityTracker::HISTORY_SIZE;
|
|
|
|
static inline float vectorDot(const float* a, const float* b, uint32_t m) {
|
|
float r = 0;
|
|
while (m--) {
|
|
r += *(a++) * *(b++);
|
|
}
|
|
return r;
|
|
}
|
|
|
|
static inline float vectorNorm(const float* a, uint32_t m) {
|
|
float r = 0;
|
|
while (m--) {
|
|
float t = *(a++);
|
|
r += t * t;
|
|
}
|
|
return sqrtf(r);
|
|
}
|
|
|
|
#if DEBUG_LEAST_SQUARES || DEBUG_VELOCITY
|
|
static String8 vectorToString(const float* a, uint32_t m) {
|
|
String8 str;
|
|
str.append("[");
|
|
while (m--) {
|
|
str.appendFormat(" %f", *(a++));
|
|
if (m) {
|
|
str.append(",");
|
|
}
|
|
}
|
|
str.append(" ]");
|
|
return str;
|
|
}
|
|
|
|
static String8 matrixToString(const float* a, uint32_t m, uint32_t n, bool rowMajor) {
|
|
String8 str;
|
|
str.append("[");
|
|
for (size_t i = 0; i < m; i++) {
|
|
if (i) {
|
|
str.append(",");
|
|
}
|
|
str.append(" [");
|
|
for (size_t j = 0; j < n; j++) {
|
|
if (j) {
|
|
str.append(",");
|
|
}
|
|
str.appendFormat(" %f", a[rowMajor ? i * n + j : j * m + i]);
|
|
}
|
|
str.append(" ]");
|
|
}
|
|
str.append(" ]");
|
|
return str;
|
|
}
|
|
#endif
|
|
|
|
VelocityTracker::VelocityTracker() {
|
|
clear();
|
|
}
|
|
|
|
void VelocityTracker::clear() {
|
|
mIndex = 0;
|
|
mMovements[0].idBits.clear();
|
|
mActivePointerId = -1;
|
|
}
|
|
|
|
void VelocityTracker::clearPointers(BitSet32 idBits) {
|
|
BitSet32 remainingIdBits(mMovements[mIndex].idBits.value & ~idBits.value);
|
|
mMovements[mIndex].idBits = remainingIdBits;
|
|
|
|
if (mActivePointerId >= 0 && idBits.hasBit(mActivePointerId)) {
|
|
mActivePointerId = !remainingIdBits.isEmpty() ? remainingIdBits.firstMarkedBit() : -1;
|
|
}
|
|
}
|
|
|
|
void VelocityTracker::addMovement(nsecs_t eventTime, BitSet32 idBits, const Position* positions) {
|
|
if (++mIndex == HISTORY_SIZE) {
|
|
mIndex = 0;
|
|
}
|
|
|
|
while (idBits.count() > MAX_POINTERS) {
|
|
idBits.clearLastMarkedBit();
|
|
}
|
|
|
|
Movement& movement = mMovements[mIndex];
|
|
movement.eventTime = eventTime;
|
|
movement.idBits = idBits;
|
|
uint32_t count = idBits.count();
|
|
for (uint32_t i = 0; i < count; i++) {
|
|
movement.positions[i] = positions[i];
|
|
}
|
|
|
|
if (mActivePointerId < 0 || !idBits.hasBit(mActivePointerId)) {
|
|
mActivePointerId = count != 0 ? idBits.firstMarkedBit() : -1;
|
|
}
|
|
|
|
#if DEBUG_VELOCITY
|
|
ALOGD("VelocityTracker: addMovement eventTime=%lld, idBits=0x%08x, activePointerId=%d",
|
|
eventTime, idBits.value, mActivePointerId);
|
|
for (BitSet32 iterBits(idBits); !iterBits.isEmpty(); ) {
|
|
uint32_t id = iterBits.firstMarkedBit();
|
|
uint32_t index = idBits.getIndexOfBit(id);
|
|
iterBits.clearBit(id);
|
|
Estimator estimator;
|
|
getEstimator(id, DEFAULT_DEGREE, DEFAULT_HORIZON, &estimator);
|
|
ALOGD(" %d: position (%0.3f, %0.3f), "
|
|
"estimator (degree=%d, xCoeff=%s, yCoeff=%s, confidence=%f)",
|
|
id, positions[index].x, positions[index].y,
|
|
int(estimator.degree),
|
|
vectorToString(estimator.xCoeff, estimator.degree).string(),
|
|
vectorToString(estimator.yCoeff, estimator.degree).string(),
|
|
estimator.confidence);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void VelocityTracker::addMovement(const MotionEvent* event) {
|
|
int32_t actionMasked = event->getActionMasked();
|
|
|
|
switch (actionMasked) {
|
|
case AMOTION_EVENT_ACTION_DOWN:
|
|
case AMOTION_EVENT_ACTION_HOVER_ENTER:
|
|
// Clear all pointers on down before adding the new movement.
|
|
clear();
|
|
break;
|
|
case AMOTION_EVENT_ACTION_POINTER_DOWN: {
|
|
// Start a new movement trace for a pointer that just went down.
|
|
// We do this on down instead of on up because the client may want to query the
|
|
// final velocity for a pointer that just went up.
|
|
BitSet32 downIdBits;
|
|
downIdBits.markBit(event->getPointerId(event->getActionIndex()));
|
|
clearPointers(downIdBits);
|
|
break;
|
|
}
|
|
case AMOTION_EVENT_ACTION_MOVE:
|
|
case AMOTION_EVENT_ACTION_HOVER_MOVE:
|
|
break;
|
|
default:
|
|
// Ignore all other actions because they do not convey any new information about
|
|
// pointer movement. We also want to preserve the last known velocity of the pointers.
|
|
// Note that ACTION_UP and ACTION_POINTER_UP always report the last known position
|
|
// of the pointers that went up. ACTION_POINTER_UP does include the new position of
|
|
// pointers that remained down but we will also receive an ACTION_MOVE with this
|
|
// information if any of them actually moved. Since we don't know how many pointers
|
|
// will be going up at once it makes sense to just wait for the following ACTION_MOVE
|
|
// before adding the movement.
|
|
return;
|
|
}
|
|
|
|
size_t pointerCount = event->getPointerCount();
|
|
if (pointerCount > MAX_POINTERS) {
|
|
pointerCount = MAX_POINTERS;
|
|
}
|
|
|
|
BitSet32 idBits;
|
|
for (size_t i = 0; i < pointerCount; i++) {
|
|
idBits.markBit(event->getPointerId(i));
|
|
}
|
|
|
|
nsecs_t eventTime;
|
|
Position positions[pointerCount];
|
|
|
|
size_t historySize = event->getHistorySize();
|
|
for (size_t h = 0; h < historySize; h++) {
|
|
eventTime = event->getHistoricalEventTime(h);
|
|
for (size_t i = 0; i < pointerCount; i++) {
|
|
positions[i].x = event->getHistoricalX(i, h);
|
|
positions[i].y = event->getHistoricalY(i, h);
|
|
}
|
|
addMovement(eventTime, idBits, positions);
|
|
}
|
|
|
|
eventTime = event->getEventTime();
|
|
for (size_t i = 0; i < pointerCount; i++) {
|
|
positions[i].x = event->getX(i);
|
|
positions[i].y = event->getY(i);
|
|
}
|
|
addMovement(eventTime, idBits, positions);
|
|
}
|
|
|
|
/**
|
|
* Solves a linear least squares problem to obtain a N degree polynomial that fits
|
|
* the specified input data as nearly as possible.
|
|
*
|
|
* Returns true if a solution is found, false otherwise.
|
|
*
|
|
* The input consists of two vectors of data points X and Y with indices 0..m-1.
|
|
* The output is a vector B with indices 0..n-1 that describes a polynomial
|
|
* that fits the data, such the sum of abs(Y[i] - (B[0] + B[1] X[i] + B[2] X[i]^2 ... B[n] X[i]^n))
|
|
* for all i between 0 and m-1 is minimized.
|
|
*
|
|
* That is to say, the function that generated the input data can be approximated
|
|
* by y(x) ~= B[0] + B[1] x + B[2] x^2 + ... + B[n] x^n.
|
|
*
|
|
* The coefficient of determination (R^2) is also returned to describe the goodness
|
|
* of fit of the model for the given data. It is a value between 0 and 1, where 1
|
|
* indicates perfect correspondence.
|
|
*
|
|
* This function first expands the X vector to a m by n matrix A such that
|
|
* A[i][0] = 1, A[i][1] = X[i], A[i][2] = X[i]^2, ..., A[i][n] = X[i]^n.
|
|
*
|
|
* Then it calculates the QR decomposition of A yielding an m by m orthonormal matrix Q
|
|
* and an m by n upper triangular matrix R. Because R is upper triangular (lower
|
|
* part is all zeroes), we can simplify the decomposition into an m by n matrix
|
|
* Q1 and a n by n matrix R1 such that A = Q1 R1.
|
|
*
|
|
* Finally we solve the system of linear equations given by R1 B = (Qtranspose Y)
|
|
* to find B.
|
|
*
|
|
* For efficiency, we lay out A and Q column-wise in memory because we frequently
|
|
* operate on the column vectors. Conversely, we lay out R row-wise.
|
|
*
|
|
* http://en.wikipedia.org/wiki/Numerical_methods_for_linear_least_squares
|
|
* http://en.wikipedia.org/wiki/Gram-Schmidt
|
|
*/
|
|
static bool solveLeastSquares(const float* x, const float* y, uint32_t m, uint32_t n,
|
|
float* outB, float* outDet) {
|
|
#if DEBUG_LEAST_SQUARES
|
|
ALOGD("solveLeastSquares: m=%d, n=%d, x=%s, y=%s", int(m), int(n),
|
|
vectorToString(x, m).string(), vectorToString(y, m).string());
|
|
#endif
|
|
|
|
// Expand the X vector to a matrix A.
|
|
float a[n][m]; // column-major order
|
|
for (uint32_t h = 0; h < m; h++) {
|
|
a[0][h] = 1;
|
|
for (uint32_t i = 1; i < n; i++) {
|
|
a[i][h] = a[i - 1][h] * x[h];
|
|
}
|
|
}
|
|
#if DEBUG_LEAST_SQUARES
|
|
ALOGD(" - a=%s", matrixToString(&a[0][0], m, n, false /*rowMajor*/).string());
|
|
#endif
|
|
|
|
// Apply the Gram-Schmidt process to A to obtain its QR decomposition.
|
|
float q[n][m]; // orthonormal basis, column-major order
|
|
float r[n][n]; // upper triangular matrix, row-major order
|
|
for (uint32_t j = 0; j < n; j++) {
|
|
for (uint32_t h = 0; h < m; h++) {
|
|
q[j][h] = a[j][h];
|
|
}
|
|
for (uint32_t i = 0; i < j; i++) {
|
|
float dot = vectorDot(&q[j][0], &q[i][0], m);
|
|
for (uint32_t h = 0; h < m; h++) {
|
|
q[j][h] -= dot * q[i][h];
|
|
}
|
|
}
|
|
|
|
float norm = vectorNorm(&q[j][0], m);
|
|
if (norm < 0.000001f) {
|
|
// vectors are linearly dependent or zero so no solution
|
|
#if DEBUG_LEAST_SQUARES
|
|
ALOGD(" - no solution, norm=%f", norm);
|
|
#endif
|
|
return false;
|
|
}
|
|
|
|
float invNorm = 1.0f / norm;
|
|
for (uint32_t h = 0; h < m; h++) {
|
|
q[j][h] *= invNorm;
|
|
}
|
|
for (uint32_t i = 0; i < n; i++) {
|
|
r[j][i] = i < j ? 0 : vectorDot(&q[j][0], &a[i][0], m);
|
|
}
|
|
}
|
|
#if DEBUG_LEAST_SQUARES
|
|
ALOGD(" - q=%s", matrixToString(&q[0][0], m, n, false /*rowMajor*/).string());
|
|
ALOGD(" - r=%s", matrixToString(&r[0][0], n, n, true /*rowMajor*/).string());
|
|
|
|
// calculate QR, if we factored A correctly then QR should equal A
|
|
float qr[n][m];
|
|
for (uint32_t h = 0; h < m; h++) {
|
|
for (uint32_t i = 0; i < n; i++) {
|
|
qr[i][h] = 0;
|
|
for (uint32_t j = 0; j < n; j++) {
|
|
qr[i][h] += q[j][h] * r[j][i];
|
|
}
|
|
}
|
|
}
|
|
ALOGD(" - qr=%s", matrixToString(&qr[0][0], m, n, false /*rowMajor*/).string());
|
|
#endif
|
|
|
|
// Solve R B = Qt Y to find B. This is easy because R is upper triangular.
|
|
// We just work from bottom-right to top-left calculating B's coefficients.
|
|
for (uint32_t i = n; i-- != 0; ) {
|
|
outB[i] = vectorDot(&q[i][0], y, m);
|
|
for (uint32_t j = n - 1; j > i; j--) {
|
|
outB[i] -= r[i][j] * outB[j];
|
|
}
|
|
outB[i] /= r[i][i];
|
|
}
|
|
#if DEBUG_LEAST_SQUARES
|
|
ALOGD(" - b=%s", vectorToString(outB, n).string());
|
|
#endif
|
|
|
|
// Calculate the coefficient of determination as 1 - (SSerr / SStot) where
|
|
// SSerr is the residual sum of squares (squared variance of the error),
|
|
// and SStot is the total sum of squares (squared variance of the data).
|
|
float ymean = 0;
|
|
for (uint32_t h = 0; h < m; h++) {
|
|
ymean += y[h];
|
|
}
|
|
ymean /= m;
|
|
|
|
float sserr = 0;
|
|
float sstot = 0;
|
|
for (uint32_t h = 0; h < m; h++) {
|
|
float err = y[h] - outB[0];
|
|
float term = 1;
|
|
for (uint32_t i = 1; i < n; i++) {
|
|
term *= x[h];
|
|
err -= term * outB[i];
|
|
}
|
|
sserr += err * err;
|
|
float var = y[h] - ymean;
|
|
sstot += var * var;
|
|
}
|
|
*outDet = sstot > 0.000001f ? 1.0f - (sserr / sstot) : 1;
|
|
#if DEBUG_LEAST_SQUARES
|
|
ALOGD(" - sserr=%f", sserr);
|
|
ALOGD(" - sstot=%f", sstot);
|
|
ALOGD(" - det=%f", *outDet);
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
bool VelocityTracker::getVelocity(uint32_t id, float* outVx, float* outVy) const {
|
|
Estimator estimator;
|
|
if (getEstimator(id, DEFAULT_DEGREE, DEFAULT_HORIZON, &estimator)) {
|
|
if (estimator.degree >= 1) {
|
|
*outVx = estimator.xCoeff[1];
|
|
*outVy = estimator.yCoeff[1];
|
|
return true;
|
|
}
|
|
}
|
|
*outVx = 0;
|
|
*outVy = 0;
|
|
return false;
|
|
}
|
|
|
|
bool VelocityTracker::getEstimator(uint32_t id, uint32_t degree, nsecs_t horizon,
|
|
Estimator* outEstimator) const {
|
|
outEstimator->clear();
|
|
|
|
// Iterate over movement samples in reverse time order and collect samples.
|
|
float x[HISTORY_SIZE];
|
|
float y[HISTORY_SIZE];
|
|
float time[HISTORY_SIZE];
|
|
uint32_t m = 0;
|
|
uint32_t index = mIndex;
|
|
const Movement& newestMovement = mMovements[mIndex];
|
|
do {
|
|
const Movement& movement = mMovements[index];
|
|
if (!movement.idBits.hasBit(id)) {
|
|
break;
|
|
}
|
|
|
|
nsecs_t age = newestMovement.eventTime - movement.eventTime;
|
|
if (age > horizon) {
|
|
break;
|
|
}
|
|
|
|
const Position& position = movement.getPosition(id);
|
|
x[m] = position.x;
|
|
y[m] = position.y;
|
|
time[m] = -age * 0.000000001f;
|
|
index = (index == 0 ? HISTORY_SIZE : index) - 1;
|
|
} while (++m < HISTORY_SIZE);
|
|
|
|
if (m == 0) {
|
|
return false; // no data
|
|
}
|
|
|
|
// Calculate a least squares polynomial fit.
|
|
if (degree > Estimator::MAX_DEGREE) {
|
|
degree = Estimator::MAX_DEGREE;
|
|
}
|
|
if (degree > m - 1) {
|
|
degree = m - 1;
|
|
}
|
|
if (degree >= 1) {
|
|
float xdet, ydet;
|
|
uint32_t n = degree + 1;
|
|
if (solveLeastSquares(time, x, m, n, outEstimator->xCoeff, &xdet)
|
|
&& solveLeastSquares(time, y, m, n, outEstimator->yCoeff, &ydet)) {
|
|
outEstimator->degree = degree;
|
|
outEstimator->confidence = xdet * ydet;
|
|
#if DEBUG_LEAST_SQUARES
|
|
ALOGD("estimate: degree=%d, xCoeff=%s, yCoeff=%s, confidence=%f",
|
|
int(outEstimator->degree),
|
|
vectorToString(outEstimator->xCoeff, n).string(),
|
|
vectorToString(outEstimator->yCoeff, n).string(),
|
|
outEstimator->confidence);
|
|
#endif
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// No velocity data available for this pointer, but we do have its current position.
|
|
outEstimator->xCoeff[0] = x[0];
|
|
outEstimator->yCoeff[0] = y[0];
|
|
outEstimator->degree = 0;
|
|
outEstimator->confidence = 1;
|
|
return true;
|
|
}
|
|
|
|
|
|
// --- VelocityControl ---
|
|
|
|
const nsecs_t VelocityControl::STOP_TIME;
|
|
|
|
VelocityControl::VelocityControl() {
|
|
reset();
|
|
}
|
|
|
|
void VelocityControl::setParameters(const VelocityControlParameters& parameters) {
|
|
mParameters = parameters;
|
|
reset();
|
|
}
|
|
|
|
void VelocityControl::reset() {
|
|
mLastMovementTime = LLONG_MIN;
|
|
mRawPosition.x = 0;
|
|
mRawPosition.y = 0;
|
|
mVelocityTracker.clear();
|
|
}
|
|
|
|
void VelocityControl::move(nsecs_t eventTime, float* deltaX, float* deltaY) {
|
|
if ((deltaX && *deltaX) || (deltaY && *deltaY)) {
|
|
if (eventTime >= mLastMovementTime + STOP_TIME) {
|
|
#if DEBUG_ACCELERATION
|
|
ALOGD("VelocityControl: stopped, last movement was %0.3fms ago",
|
|
(eventTime - mLastMovementTime) * 0.000001f);
|
|
#endif
|
|
reset();
|
|
}
|
|
|
|
mLastMovementTime = eventTime;
|
|
if (deltaX) {
|
|
mRawPosition.x += *deltaX;
|
|
}
|
|
if (deltaY) {
|
|
mRawPosition.y += *deltaY;
|
|
}
|
|
mVelocityTracker.addMovement(eventTime, BitSet32(BitSet32::valueForBit(0)), &mRawPosition);
|
|
|
|
float vx, vy;
|
|
float scale = mParameters.scale;
|
|
if (mVelocityTracker.getVelocity(0, &vx, &vy)) {
|
|
float speed = hypotf(vx, vy) * scale;
|
|
if (speed >= mParameters.highThreshold) {
|
|
// Apply full acceleration above the high speed threshold.
|
|
scale *= mParameters.acceleration;
|
|
} else if (speed > mParameters.lowThreshold) {
|
|
// Linearly interpolate the acceleration to apply between the low and high
|
|
// speed thresholds.
|
|
scale *= 1 + (speed - mParameters.lowThreshold)
|
|
/ (mParameters.highThreshold - mParameters.lowThreshold)
|
|
* (mParameters.acceleration - 1);
|
|
}
|
|
|
|
#if DEBUG_ACCELERATION
|
|
ALOGD("VelocityControl(%0.3f, %0.3f, %0.3f, %0.3f): "
|
|
"vx=%0.3f, vy=%0.3f, speed=%0.3f, accel=%0.3f",
|
|
mParameters.scale, mParameters.lowThreshold, mParameters.highThreshold,
|
|
mParameters.acceleration,
|
|
vx, vy, speed, scale / mParameters.scale);
|
|
#endif
|
|
} else {
|
|
#if DEBUG_ACCELERATION
|
|
ALOGD("VelocityControl(%0.3f, %0.3f, %0.3f, %0.3f): unknown velocity",
|
|
mParameters.scale, mParameters.lowThreshold, mParameters.highThreshold,
|
|
mParameters.acceleration);
|
|
#endif
|
|
}
|
|
|
|
if (deltaX) {
|
|
*deltaX *= scale;
|
|
}
|
|
if (deltaY) {
|
|
*deltaY *= scale;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// --- InputDeviceInfo ---
|
|
|
|
InputDeviceInfo::InputDeviceInfo() {
|
|
initialize(-1, String8("uninitialized device info"));
|
|
}
|
|
|
|
InputDeviceInfo::InputDeviceInfo(const InputDeviceInfo& other) :
|
|
mId(other.mId), mName(other.mName), mSources(other.mSources),
|
|
mKeyboardType(other.mKeyboardType),
|
|
mMotionRanges(other.mMotionRanges) {
|
|
}
|
|
|
|
InputDeviceInfo::~InputDeviceInfo() {
|
|
}
|
|
|
|
void InputDeviceInfo::initialize(int32_t id, const String8& name) {
|
|
mId = id;
|
|
mName = name;
|
|
mSources = 0;
|
|
mKeyboardType = AINPUT_KEYBOARD_TYPE_NONE;
|
|
mMotionRanges.clear();
|
|
}
|
|
|
|
const InputDeviceInfo::MotionRange* InputDeviceInfo::getMotionRange(
|
|
int32_t axis, uint32_t source) const {
|
|
size_t numRanges = mMotionRanges.size();
|
|
for (size_t i = 0; i < numRanges; i++) {
|
|
const MotionRange& range = mMotionRanges.itemAt(i);
|
|
if (range.axis == axis && range.source == source) {
|
|
return ⦥
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
void InputDeviceInfo::addSource(uint32_t source) {
|
|
mSources |= source;
|
|
}
|
|
|
|
void InputDeviceInfo::addMotionRange(int32_t axis, uint32_t source, float min, float max,
|
|
float flat, float fuzz) {
|
|
MotionRange range = { axis, source, min, max, flat, fuzz };
|
|
mMotionRanges.add(range);
|
|
}
|
|
|
|
void InputDeviceInfo::addMotionRange(const MotionRange& range) {
|
|
mMotionRanges.add(range);
|
|
}
|
|
|
|
} // namespace android
|