d02c5b6aac
Add all of the underlying input system pieces, minux PointerController and SpriteController, to inputflinger. This is in preparation for moving input to its own process and the addition of the input HAL. Try 2. Change-Id: I5f571fe86eb570885ae994e1f0552fb558930346
6531 lines
254 KiB
C++
6531 lines
254 KiB
C++
/*
|
|
* 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.
|
|
*/
|
|
|
|
#define LOG_TAG "InputReader"
|
|
|
|
//#define LOG_NDEBUG 0
|
|
|
|
// Log debug messages for each raw event received from the EventHub.
|
|
#define DEBUG_RAW_EVENTS 0
|
|
|
|
// Log debug messages about touch screen filtering hacks.
|
|
#define DEBUG_HACKS 0
|
|
|
|
// Log debug messages about virtual key processing.
|
|
#define DEBUG_VIRTUAL_KEYS 0
|
|
|
|
// Log debug messages about pointers.
|
|
#define DEBUG_POINTERS 0
|
|
|
|
// Log debug messages about pointer assignment calculations.
|
|
#define DEBUG_POINTER_ASSIGNMENT 0
|
|
|
|
// Log debug messages about gesture detection.
|
|
#define DEBUG_GESTURES 0
|
|
|
|
// Log debug messages about the vibrator.
|
|
#define DEBUG_VIBRATOR 0
|
|
|
|
#include "InputReader.h"
|
|
|
|
#include <cutils/log.h>
|
|
#include <input/Keyboard.h>
|
|
#include <input/VirtualKeyMap.h>
|
|
|
|
#include <stddef.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <errno.h>
|
|
#include <limits.h>
|
|
#include <math.h>
|
|
|
|
#define INDENT " "
|
|
#define INDENT2 " "
|
|
#define INDENT3 " "
|
|
#define INDENT4 " "
|
|
#define INDENT5 " "
|
|
|
|
namespace android {
|
|
|
|
// --- Constants ---
|
|
|
|
// Maximum number of slots supported when using the slot-based Multitouch Protocol B.
|
|
static const size_t MAX_SLOTS = 32;
|
|
|
|
// --- Static Functions ---
|
|
|
|
template<typename T>
|
|
inline static T abs(const T& value) {
|
|
return value < 0 ? - value : value;
|
|
}
|
|
|
|
template<typename T>
|
|
inline static T min(const T& a, const T& b) {
|
|
return a < b ? a : b;
|
|
}
|
|
|
|
template<typename T>
|
|
inline static void swap(T& a, T& b) {
|
|
T temp = a;
|
|
a = b;
|
|
b = temp;
|
|
}
|
|
|
|
inline static float avg(float x, float y) {
|
|
return (x + y) / 2;
|
|
}
|
|
|
|
inline static float distance(float x1, float y1, float x2, float y2) {
|
|
return hypotf(x1 - x2, y1 - y2);
|
|
}
|
|
|
|
inline static int32_t signExtendNybble(int32_t value) {
|
|
return value >= 8 ? value - 16 : value;
|
|
}
|
|
|
|
static inline const char* toString(bool value) {
|
|
return value ? "true" : "false";
|
|
}
|
|
|
|
static int32_t rotateValueUsingRotationMap(int32_t value, int32_t orientation,
|
|
const int32_t map[][4], size_t mapSize) {
|
|
if (orientation != DISPLAY_ORIENTATION_0) {
|
|
for (size_t i = 0; i < mapSize; i++) {
|
|
if (value == map[i][0]) {
|
|
return map[i][orientation];
|
|
}
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
|
|
static const int32_t keyCodeRotationMap[][4] = {
|
|
// key codes enumerated counter-clockwise with the original (unrotated) key first
|
|
// no rotation, 90 degree rotation, 180 degree rotation, 270 degree rotation
|
|
{ AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_LEFT },
|
|
{ AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_DOWN },
|
|
{ AKEYCODE_DPAD_UP, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_RIGHT },
|
|
{ AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_UP },
|
|
};
|
|
static const size_t keyCodeRotationMapSize =
|
|
sizeof(keyCodeRotationMap) / sizeof(keyCodeRotationMap[0]);
|
|
|
|
static int32_t rotateKeyCode(int32_t keyCode, int32_t orientation) {
|
|
return rotateValueUsingRotationMap(keyCode, orientation,
|
|
keyCodeRotationMap, keyCodeRotationMapSize);
|
|
}
|
|
|
|
static void rotateDelta(int32_t orientation, float* deltaX, float* deltaY) {
|
|
float temp;
|
|
switch (orientation) {
|
|
case DISPLAY_ORIENTATION_90:
|
|
temp = *deltaX;
|
|
*deltaX = *deltaY;
|
|
*deltaY = -temp;
|
|
break;
|
|
|
|
case DISPLAY_ORIENTATION_180:
|
|
*deltaX = -*deltaX;
|
|
*deltaY = -*deltaY;
|
|
break;
|
|
|
|
case DISPLAY_ORIENTATION_270:
|
|
temp = *deltaX;
|
|
*deltaX = -*deltaY;
|
|
*deltaY = temp;
|
|
break;
|
|
}
|
|
}
|
|
|
|
static inline bool sourcesMatchMask(uint32_t sources, uint32_t sourceMask) {
|
|
return (sources & sourceMask & ~ AINPUT_SOURCE_CLASS_MASK) != 0;
|
|
}
|
|
|
|
// Returns true if the pointer should be reported as being down given the specified
|
|
// button states. This determines whether the event is reported as a touch event.
|
|
static bool isPointerDown(int32_t buttonState) {
|
|
return buttonState &
|
|
(AMOTION_EVENT_BUTTON_PRIMARY | AMOTION_EVENT_BUTTON_SECONDARY
|
|
| AMOTION_EVENT_BUTTON_TERTIARY);
|
|
}
|
|
|
|
static float calculateCommonVector(float a, float b) {
|
|
if (a > 0 && b > 0) {
|
|
return a < b ? a : b;
|
|
} else if (a < 0 && b < 0) {
|
|
return a > b ? a : b;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
static void synthesizeButtonKey(InputReaderContext* context, int32_t action,
|
|
nsecs_t when, int32_t deviceId, uint32_t source,
|
|
uint32_t policyFlags, int32_t lastButtonState, int32_t currentButtonState,
|
|
int32_t buttonState, int32_t keyCode) {
|
|
if (
|
|
(action == AKEY_EVENT_ACTION_DOWN
|
|
&& !(lastButtonState & buttonState)
|
|
&& (currentButtonState & buttonState))
|
|
|| (action == AKEY_EVENT_ACTION_UP
|
|
&& (lastButtonState & buttonState)
|
|
&& !(currentButtonState & buttonState))) {
|
|
NotifyKeyArgs args(when, deviceId, source, policyFlags,
|
|
action, 0, keyCode, 0, context->getGlobalMetaState(), when);
|
|
context->getListener()->notifyKey(&args);
|
|
}
|
|
}
|
|
|
|
static void synthesizeButtonKeys(InputReaderContext* context, int32_t action,
|
|
nsecs_t when, int32_t deviceId, uint32_t source,
|
|
uint32_t policyFlags, int32_t lastButtonState, int32_t currentButtonState) {
|
|
synthesizeButtonKey(context, action, when, deviceId, source, policyFlags,
|
|
lastButtonState, currentButtonState,
|
|
AMOTION_EVENT_BUTTON_BACK, AKEYCODE_BACK);
|
|
synthesizeButtonKey(context, action, when, deviceId, source, policyFlags,
|
|
lastButtonState, currentButtonState,
|
|
AMOTION_EVENT_BUTTON_FORWARD, AKEYCODE_FORWARD);
|
|
}
|
|
|
|
|
|
// --- InputReaderConfiguration ---
|
|
|
|
bool InputReaderConfiguration::getDisplayInfo(bool external, DisplayViewport* outViewport) const {
|
|
const DisplayViewport& viewport = external ? mExternalDisplay : mInternalDisplay;
|
|
if (viewport.displayId >= 0) {
|
|
*outViewport = viewport;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void InputReaderConfiguration::setDisplayInfo(bool external, const DisplayViewport& viewport) {
|
|
DisplayViewport& v = external ? mExternalDisplay : mInternalDisplay;
|
|
v = viewport;
|
|
}
|
|
|
|
|
|
// --- InputReader ---
|
|
|
|
InputReader::InputReader(const sp<EventHubInterface>& eventHub,
|
|
const sp<InputReaderPolicyInterface>& policy,
|
|
const sp<InputListenerInterface>& listener) :
|
|
mContext(this), mEventHub(eventHub), mPolicy(policy),
|
|
mGlobalMetaState(0), mGeneration(1),
|
|
mDisableVirtualKeysTimeout(LLONG_MIN), mNextTimeout(LLONG_MAX),
|
|
mConfigurationChangesToRefresh(0) {
|
|
mQueuedListener = new QueuedInputListener(listener);
|
|
|
|
{ // acquire lock
|
|
AutoMutex _l(mLock);
|
|
|
|
refreshConfigurationLocked(0);
|
|
updateGlobalMetaStateLocked();
|
|
} // release lock
|
|
}
|
|
|
|
InputReader::~InputReader() {
|
|
for (size_t i = 0; i < mDevices.size(); i++) {
|
|
delete mDevices.valueAt(i);
|
|
}
|
|
}
|
|
|
|
void InputReader::loopOnce() {
|
|
int32_t oldGeneration;
|
|
int32_t timeoutMillis;
|
|
bool inputDevicesChanged = false;
|
|
Vector<InputDeviceInfo> inputDevices;
|
|
{ // acquire lock
|
|
AutoMutex _l(mLock);
|
|
|
|
oldGeneration = mGeneration;
|
|
timeoutMillis = -1;
|
|
|
|
uint32_t changes = mConfigurationChangesToRefresh;
|
|
if (changes) {
|
|
mConfigurationChangesToRefresh = 0;
|
|
timeoutMillis = 0;
|
|
refreshConfigurationLocked(changes);
|
|
} else if (mNextTimeout != LLONG_MAX) {
|
|
nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
|
|
timeoutMillis = toMillisecondTimeoutDelay(now, mNextTimeout);
|
|
}
|
|
} // release lock
|
|
|
|
size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);
|
|
|
|
{ // acquire lock
|
|
AutoMutex _l(mLock);
|
|
mReaderIsAliveCondition.broadcast();
|
|
|
|
if (count) {
|
|
processEventsLocked(mEventBuffer, count);
|
|
}
|
|
|
|
if (mNextTimeout != LLONG_MAX) {
|
|
nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
|
|
if (now >= mNextTimeout) {
|
|
#if DEBUG_RAW_EVENTS
|
|
ALOGD("Timeout expired, latency=%0.3fms", (now - mNextTimeout) * 0.000001f);
|
|
#endif
|
|
mNextTimeout = LLONG_MAX;
|
|
timeoutExpiredLocked(now);
|
|
}
|
|
}
|
|
|
|
if (oldGeneration != mGeneration) {
|
|
inputDevicesChanged = true;
|
|
getInputDevicesLocked(inputDevices);
|
|
}
|
|
} // release lock
|
|
|
|
// Send out a message that the describes the changed input devices.
|
|
if (inputDevicesChanged) {
|
|
mPolicy->notifyInputDevicesChanged(inputDevices);
|
|
}
|
|
|
|
// Flush queued events out to the listener.
|
|
// This must happen outside of the lock because the listener could potentially call
|
|
// back into the InputReader's methods, such as getScanCodeState, or become blocked
|
|
// on another thread similarly waiting to acquire the InputReader lock thereby
|
|
// resulting in a deadlock. This situation is actually quite plausible because the
|
|
// listener is actually the input dispatcher, which calls into the window manager,
|
|
// which occasionally calls into the input reader.
|
|
mQueuedListener->flush();
|
|
}
|
|
|
|
void InputReader::processEventsLocked(const RawEvent* rawEvents, size_t count) {
|
|
for (const RawEvent* rawEvent = rawEvents; count;) {
|
|
int32_t type = rawEvent->type;
|
|
size_t batchSize = 1;
|
|
if (type < EventHubInterface::FIRST_SYNTHETIC_EVENT) {
|
|
int32_t deviceId = rawEvent->deviceId;
|
|
while (batchSize < count) {
|
|
if (rawEvent[batchSize].type >= EventHubInterface::FIRST_SYNTHETIC_EVENT
|
|
|| rawEvent[batchSize].deviceId != deviceId) {
|
|
break;
|
|
}
|
|
batchSize += 1;
|
|
}
|
|
#if DEBUG_RAW_EVENTS
|
|
ALOGD("BatchSize: %d Count: %d", batchSize, count);
|
|
#endif
|
|
processEventsForDeviceLocked(deviceId, rawEvent, batchSize);
|
|
} else {
|
|
switch (rawEvent->type) {
|
|
case EventHubInterface::DEVICE_ADDED:
|
|
addDeviceLocked(rawEvent->when, rawEvent->deviceId);
|
|
break;
|
|
case EventHubInterface::DEVICE_REMOVED:
|
|
removeDeviceLocked(rawEvent->when, rawEvent->deviceId);
|
|
break;
|
|
case EventHubInterface::FINISHED_DEVICE_SCAN:
|
|
handleConfigurationChangedLocked(rawEvent->when);
|
|
break;
|
|
default:
|
|
ALOG_ASSERT(false); // can't happen
|
|
break;
|
|
}
|
|
}
|
|
count -= batchSize;
|
|
rawEvent += batchSize;
|
|
}
|
|
}
|
|
|
|
void InputReader::addDeviceLocked(nsecs_t when, int32_t deviceId) {
|
|
ssize_t deviceIndex = mDevices.indexOfKey(deviceId);
|
|
if (deviceIndex >= 0) {
|
|
ALOGW("Ignoring spurious device added event for deviceId %d.", deviceId);
|
|
return;
|
|
}
|
|
|
|
InputDeviceIdentifier identifier = mEventHub->getDeviceIdentifier(deviceId);
|
|
uint32_t classes = mEventHub->getDeviceClasses(deviceId);
|
|
int32_t controllerNumber = mEventHub->getDeviceControllerNumber(deviceId);
|
|
|
|
InputDevice* device = createDeviceLocked(deviceId, controllerNumber, identifier, classes);
|
|
device->configure(when, &mConfig, 0);
|
|
device->reset(when);
|
|
|
|
if (device->isIgnored()) {
|
|
ALOGI("Device added: id=%d, name='%s' (ignored non-input device)", deviceId,
|
|
identifier.name.string());
|
|
} else {
|
|
ALOGI("Device added: id=%d, name='%s', sources=0x%08x", deviceId,
|
|
identifier.name.string(), device->getSources());
|
|
}
|
|
|
|
mDevices.add(deviceId, device);
|
|
bumpGenerationLocked();
|
|
}
|
|
|
|
void InputReader::removeDeviceLocked(nsecs_t when, int32_t deviceId) {
|
|
InputDevice* device = NULL;
|
|
ssize_t deviceIndex = mDevices.indexOfKey(deviceId);
|
|
if (deviceIndex < 0) {
|
|
ALOGW("Ignoring spurious device removed event for deviceId %d.", deviceId);
|
|
return;
|
|
}
|
|
|
|
device = mDevices.valueAt(deviceIndex);
|
|
mDevices.removeItemsAt(deviceIndex, 1);
|
|
bumpGenerationLocked();
|
|
|
|
if (device->isIgnored()) {
|
|
ALOGI("Device removed: id=%d, name='%s' (ignored non-input device)",
|
|
device->getId(), device->getName().string());
|
|
} else {
|
|
ALOGI("Device removed: id=%d, name='%s', sources=0x%08x",
|
|
device->getId(), device->getName().string(), device->getSources());
|
|
}
|
|
|
|
device->reset(when);
|
|
delete device;
|
|
}
|
|
|
|
InputDevice* InputReader::createDeviceLocked(int32_t deviceId, int32_t controllerNumber,
|
|
const InputDeviceIdentifier& identifier, uint32_t classes) {
|
|
InputDevice* device = new InputDevice(&mContext, deviceId, bumpGenerationLocked(),
|
|
controllerNumber, identifier, classes);
|
|
|
|
// External devices.
|
|
if (classes & INPUT_DEVICE_CLASS_EXTERNAL) {
|
|
device->setExternal(true);
|
|
}
|
|
|
|
// Switch-like devices.
|
|
if (classes & INPUT_DEVICE_CLASS_SWITCH) {
|
|
device->addMapper(new SwitchInputMapper(device));
|
|
}
|
|
|
|
// Vibrator-like devices.
|
|
if (classes & INPUT_DEVICE_CLASS_VIBRATOR) {
|
|
device->addMapper(new VibratorInputMapper(device));
|
|
}
|
|
|
|
// Keyboard-like devices.
|
|
uint32_t keyboardSource = 0;
|
|
int32_t keyboardType = AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC;
|
|
if (classes & INPUT_DEVICE_CLASS_KEYBOARD) {
|
|
keyboardSource |= AINPUT_SOURCE_KEYBOARD;
|
|
}
|
|
if (classes & INPUT_DEVICE_CLASS_ALPHAKEY) {
|
|
keyboardType = AINPUT_KEYBOARD_TYPE_ALPHABETIC;
|
|
}
|
|
if (classes & INPUT_DEVICE_CLASS_DPAD) {
|
|
keyboardSource |= AINPUT_SOURCE_DPAD;
|
|
}
|
|
if (classes & INPUT_DEVICE_CLASS_GAMEPAD) {
|
|
keyboardSource |= AINPUT_SOURCE_GAMEPAD;
|
|
}
|
|
|
|
if (keyboardSource != 0) {
|
|
device->addMapper(new KeyboardInputMapper(device, keyboardSource, keyboardType));
|
|
}
|
|
|
|
// Cursor-like devices.
|
|
if (classes & INPUT_DEVICE_CLASS_CURSOR) {
|
|
device->addMapper(new CursorInputMapper(device));
|
|
}
|
|
|
|
// Touchscreens and touchpad devices.
|
|
if (classes & INPUT_DEVICE_CLASS_TOUCH_MT) {
|
|
device->addMapper(new MultiTouchInputMapper(device));
|
|
} else if (classes & INPUT_DEVICE_CLASS_TOUCH) {
|
|
device->addMapper(new SingleTouchInputMapper(device));
|
|
}
|
|
|
|
// Joystick-like devices.
|
|
if (classes & INPUT_DEVICE_CLASS_JOYSTICK) {
|
|
device->addMapper(new JoystickInputMapper(device));
|
|
}
|
|
|
|
return device;
|
|
}
|
|
|
|
void InputReader::processEventsForDeviceLocked(int32_t deviceId,
|
|
const RawEvent* rawEvents, size_t count) {
|
|
ssize_t deviceIndex = mDevices.indexOfKey(deviceId);
|
|
if (deviceIndex < 0) {
|
|
ALOGW("Discarding event for unknown deviceId %d.", deviceId);
|
|
return;
|
|
}
|
|
|
|
InputDevice* device = mDevices.valueAt(deviceIndex);
|
|
if (device->isIgnored()) {
|
|
//ALOGD("Discarding event for ignored deviceId %d.", deviceId);
|
|
return;
|
|
}
|
|
|
|
device->process(rawEvents, count);
|
|
}
|
|
|
|
void InputReader::timeoutExpiredLocked(nsecs_t when) {
|
|
for (size_t i = 0; i < mDevices.size(); i++) {
|
|
InputDevice* device = mDevices.valueAt(i);
|
|
if (!device->isIgnored()) {
|
|
device->timeoutExpired(when);
|
|
}
|
|
}
|
|
}
|
|
|
|
void InputReader::handleConfigurationChangedLocked(nsecs_t when) {
|
|
// Reset global meta state because it depends on the list of all configured devices.
|
|
updateGlobalMetaStateLocked();
|
|
|
|
// Enqueue configuration changed.
|
|
NotifyConfigurationChangedArgs args(when);
|
|
mQueuedListener->notifyConfigurationChanged(&args);
|
|
}
|
|
|
|
void InputReader::refreshConfigurationLocked(uint32_t changes) {
|
|
mPolicy->getReaderConfiguration(&mConfig);
|
|
mEventHub->setExcludedDevices(mConfig.excludedDeviceNames);
|
|
|
|
if (changes) {
|
|
ALOGI("Reconfiguring input devices. changes=0x%08x", changes);
|
|
nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
|
|
|
|
if (changes & InputReaderConfiguration::CHANGE_MUST_REOPEN) {
|
|
mEventHub->requestReopenDevices();
|
|
} else {
|
|
for (size_t i = 0; i < mDevices.size(); i++) {
|
|
InputDevice* device = mDevices.valueAt(i);
|
|
device->configure(now, &mConfig, changes);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void InputReader::updateGlobalMetaStateLocked() {
|
|
mGlobalMetaState = 0;
|
|
|
|
for (size_t i = 0; i < mDevices.size(); i++) {
|
|
InputDevice* device = mDevices.valueAt(i);
|
|
mGlobalMetaState |= device->getMetaState();
|
|
}
|
|
}
|
|
|
|
int32_t InputReader::getGlobalMetaStateLocked() {
|
|
return mGlobalMetaState;
|
|
}
|
|
|
|
void InputReader::disableVirtualKeysUntilLocked(nsecs_t time) {
|
|
mDisableVirtualKeysTimeout = time;
|
|
}
|
|
|
|
bool InputReader::shouldDropVirtualKeyLocked(nsecs_t now,
|
|
InputDevice* device, int32_t keyCode, int32_t scanCode) {
|
|
if (now < mDisableVirtualKeysTimeout) {
|
|
ALOGI("Dropping virtual key from device %s because virtual keys are "
|
|
"temporarily disabled for the next %0.3fms. keyCode=%d, scanCode=%d",
|
|
device->getName().string(),
|
|
(mDisableVirtualKeysTimeout - now) * 0.000001,
|
|
keyCode, scanCode);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void InputReader::fadePointerLocked() {
|
|
for (size_t i = 0; i < mDevices.size(); i++) {
|
|
InputDevice* device = mDevices.valueAt(i);
|
|
device->fadePointer();
|
|
}
|
|
}
|
|
|
|
void InputReader::requestTimeoutAtTimeLocked(nsecs_t when) {
|
|
if (when < mNextTimeout) {
|
|
mNextTimeout = when;
|
|
mEventHub->wake();
|
|
}
|
|
}
|
|
|
|
int32_t InputReader::bumpGenerationLocked() {
|
|
return ++mGeneration;
|
|
}
|
|
|
|
void InputReader::getInputDevices(Vector<InputDeviceInfo>& outInputDevices) {
|
|
AutoMutex _l(mLock);
|
|
getInputDevicesLocked(outInputDevices);
|
|
}
|
|
|
|
void InputReader::getInputDevicesLocked(Vector<InputDeviceInfo>& outInputDevices) {
|
|
outInputDevices.clear();
|
|
|
|
size_t numDevices = mDevices.size();
|
|
for (size_t i = 0; i < numDevices; i++) {
|
|
InputDevice* device = mDevices.valueAt(i);
|
|
if (!device->isIgnored()) {
|
|
outInputDevices.push();
|
|
device->getDeviceInfo(&outInputDevices.editTop());
|
|
}
|
|
}
|
|
}
|
|
|
|
int32_t InputReader::getKeyCodeState(int32_t deviceId, uint32_t sourceMask,
|
|
int32_t keyCode) {
|
|
AutoMutex _l(mLock);
|
|
|
|
return getStateLocked(deviceId, sourceMask, keyCode, &InputDevice::getKeyCodeState);
|
|
}
|
|
|
|
int32_t InputReader::getScanCodeState(int32_t deviceId, uint32_t sourceMask,
|
|
int32_t scanCode) {
|
|
AutoMutex _l(mLock);
|
|
|
|
return getStateLocked(deviceId, sourceMask, scanCode, &InputDevice::getScanCodeState);
|
|
}
|
|
|
|
int32_t InputReader::getSwitchState(int32_t deviceId, uint32_t sourceMask, int32_t switchCode) {
|
|
AutoMutex _l(mLock);
|
|
|
|
return getStateLocked(deviceId, sourceMask, switchCode, &InputDevice::getSwitchState);
|
|
}
|
|
|
|
int32_t InputReader::getStateLocked(int32_t deviceId, uint32_t sourceMask, int32_t code,
|
|
GetStateFunc getStateFunc) {
|
|
int32_t result = AKEY_STATE_UNKNOWN;
|
|
if (deviceId >= 0) {
|
|
ssize_t deviceIndex = mDevices.indexOfKey(deviceId);
|
|
if (deviceIndex >= 0) {
|
|
InputDevice* device = mDevices.valueAt(deviceIndex);
|
|
if (! device->isIgnored() && sourcesMatchMask(device->getSources(), sourceMask)) {
|
|
result = (device->*getStateFunc)(sourceMask, code);
|
|
}
|
|
}
|
|
} else {
|
|
size_t numDevices = mDevices.size();
|
|
for (size_t i = 0; i < numDevices; i++) {
|
|
InputDevice* device = mDevices.valueAt(i);
|
|
if (! device->isIgnored() && sourcesMatchMask(device->getSources(), sourceMask)) {
|
|
// If any device reports AKEY_STATE_DOWN or AKEY_STATE_VIRTUAL, return that
|
|
// value. Otherwise, return AKEY_STATE_UP as long as one device reports it.
|
|
int32_t currentResult = (device->*getStateFunc)(sourceMask, code);
|
|
if (currentResult >= AKEY_STATE_DOWN) {
|
|
return currentResult;
|
|
} else if (currentResult == AKEY_STATE_UP) {
|
|
result = currentResult;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
bool InputReader::hasKeys(int32_t deviceId, uint32_t sourceMask,
|
|
size_t numCodes, const int32_t* keyCodes, uint8_t* outFlags) {
|
|
AutoMutex _l(mLock);
|
|
|
|
memset(outFlags, 0, numCodes);
|
|
return markSupportedKeyCodesLocked(deviceId, sourceMask, numCodes, keyCodes, outFlags);
|
|
}
|
|
|
|
bool InputReader::markSupportedKeyCodesLocked(int32_t deviceId, uint32_t sourceMask,
|
|
size_t numCodes, const int32_t* keyCodes, uint8_t* outFlags) {
|
|
bool result = false;
|
|
if (deviceId >= 0) {
|
|
ssize_t deviceIndex = mDevices.indexOfKey(deviceId);
|
|
if (deviceIndex >= 0) {
|
|
InputDevice* device = mDevices.valueAt(deviceIndex);
|
|
if (! device->isIgnored() && sourcesMatchMask(device->getSources(), sourceMask)) {
|
|
result = device->markSupportedKeyCodes(sourceMask,
|
|
numCodes, keyCodes, outFlags);
|
|
}
|
|
}
|
|
} else {
|
|
size_t numDevices = mDevices.size();
|
|
for (size_t i = 0; i < numDevices; i++) {
|
|
InputDevice* device = mDevices.valueAt(i);
|
|
if (! device->isIgnored() && sourcesMatchMask(device->getSources(), sourceMask)) {
|
|
result |= device->markSupportedKeyCodes(sourceMask,
|
|
numCodes, keyCodes, outFlags);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void InputReader::requestRefreshConfiguration(uint32_t changes) {
|
|
AutoMutex _l(mLock);
|
|
|
|
if (changes) {
|
|
bool needWake = !mConfigurationChangesToRefresh;
|
|
mConfigurationChangesToRefresh |= changes;
|
|
|
|
if (needWake) {
|
|
mEventHub->wake();
|
|
}
|
|
}
|
|
}
|
|
|
|
void InputReader::vibrate(int32_t deviceId, const nsecs_t* pattern, size_t patternSize,
|
|
ssize_t repeat, int32_t token) {
|
|
AutoMutex _l(mLock);
|
|
|
|
ssize_t deviceIndex = mDevices.indexOfKey(deviceId);
|
|
if (deviceIndex >= 0) {
|
|
InputDevice* device = mDevices.valueAt(deviceIndex);
|
|
device->vibrate(pattern, patternSize, repeat, token);
|
|
}
|
|
}
|
|
|
|
void InputReader::cancelVibrate(int32_t deviceId, int32_t token) {
|
|
AutoMutex _l(mLock);
|
|
|
|
ssize_t deviceIndex = mDevices.indexOfKey(deviceId);
|
|
if (deviceIndex >= 0) {
|
|
InputDevice* device = mDevices.valueAt(deviceIndex);
|
|
device->cancelVibrate(token);
|
|
}
|
|
}
|
|
|
|
void InputReader::dump(String8& dump) {
|
|
AutoMutex _l(mLock);
|
|
|
|
mEventHub->dump(dump);
|
|
dump.append("\n");
|
|
|
|
dump.append("Input Reader State:\n");
|
|
|
|
for (size_t i = 0; i < mDevices.size(); i++) {
|
|
mDevices.valueAt(i)->dump(dump);
|
|
}
|
|
|
|
dump.append(INDENT "Configuration:\n");
|
|
dump.append(INDENT2 "ExcludedDeviceNames: [");
|
|
for (size_t i = 0; i < mConfig.excludedDeviceNames.size(); i++) {
|
|
if (i != 0) {
|
|
dump.append(", ");
|
|
}
|
|
dump.append(mConfig.excludedDeviceNames.itemAt(i).string());
|
|
}
|
|
dump.append("]\n");
|
|
dump.appendFormat(INDENT2 "VirtualKeyQuietTime: %0.1fms\n",
|
|
mConfig.virtualKeyQuietTime * 0.000001f);
|
|
|
|
dump.appendFormat(INDENT2 "PointerVelocityControlParameters: "
|
|
"scale=%0.3f, lowThreshold=%0.3f, highThreshold=%0.3f, acceleration=%0.3f\n",
|
|
mConfig.pointerVelocityControlParameters.scale,
|
|
mConfig.pointerVelocityControlParameters.lowThreshold,
|
|
mConfig.pointerVelocityControlParameters.highThreshold,
|
|
mConfig.pointerVelocityControlParameters.acceleration);
|
|
|
|
dump.appendFormat(INDENT2 "WheelVelocityControlParameters: "
|
|
"scale=%0.3f, lowThreshold=%0.3f, highThreshold=%0.3f, acceleration=%0.3f\n",
|
|
mConfig.wheelVelocityControlParameters.scale,
|
|
mConfig.wheelVelocityControlParameters.lowThreshold,
|
|
mConfig.wheelVelocityControlParameters.highThreshold,
|
|
mConfig.wheelVelocityControlParameters.acceleration);
|
|
|
|
dump.appendFormat(INDENT2 "PointerGesture:\n");
|
|
dump.appendFormat(INDENT3 "Enabled: %s\n",
|
|
toString(mConfig.pointerGesturesEnabled));
|
|
dump.appendFormat(INDENT3 "QuietInterval: %0.1fms\n",
|
|
mConfig.pointerGestureQuietInterval * 0.000001f);
|
|
dump.appendFormat(INDENT3 "DragMinSwitchSpeed: %0.1fpx/s\n",
|
|
mConfig.pointerGestureDragMinSwitchSpeed);
|
|
dump.appendFormat(INDENT3 "TapInterval: %0.1fms\n",
|
|
mConfig.pointerGestureTapInterval * 0.000001f);
|
|
dump.appendFormat(INDENT3 "TapDragInterval: %0.1fms\n",
|
|
mConfig.pointerGestureTapDragInterval * 0.000001f);
|
|
dump.appendFormat(INDENT3 "TapSlop: %0.1fpx\n",
|
|
mConfig.pointerGestureTapSlop);
|
|
dump.appendFormat(INDENT3 "MultitouchSettleInterval: %0.1fms\n",
|
|
mConfig.pointerGestureMultitouchSettleInterval * 0.000001f);
|
|
dump.appendFormat(INDENT3 "MultitouchMinDistance: %0.1fpx\n",
|
|
mConfig.pointerGestureMultitouchMinDistance);
|
|
dump.appendFormat(INDENT3 "SwipeTransitionAngleCosine: %0.1f\n",
|
|
mConfig.pointerGestureSwipeTransitionAngleCosine);
|
|
dump.appendFormat(INDENT3 "SwipeMaxWidthRatio: %0.1f\n",
|
|
mConfig.pointerGestureSwipeMaxWidthRatio);
|
|
dump.appendFormat(INDENT3 "MovementSpeedRatio: %0.1f\n",
|
|
mConfig.pointerGestureMovementSpeedRatio);
|
|
dump.appendFormat(INDENT3 "ZoomSpeedRatio: %0.1f\n",
|
|
mConfig.pointerGestureZoomSpeedRatio);
|
|
}
|
|
|
|
void InputReader::monitor() {
|
|
// Acquire and release the lock to ensure that the reader has not deadlocked.
|
|
mLock.lock();
|
|
mEventHub->wake();
|
|
mReaderIsAliveCondition.wait(mLock);
|
|
mLock.unlock();
|
|
|
|
// Check the EventHub
|
|
mEventHub->monitor();
|
|
}
|
|
|
|
|
|
// --- InputReader::ContextImpl ---
|
|
|
|
InputReader::ContextImpl::ContextImpl(InputReader* reader) :
|
|
mReader(reader) {
|
|
}
|
|
|
|
void InputReader::ContextImpl::updateGlobalMetaState() {
|
|
// lock is already held by the input loop
|
|
mReader->updateGlobalMetaStateLocked();
|
|
}
|
|
|
|
int32_t InputReader::ContextImpl::getGlobalMetaState() {
|
|
// lock is already held by the input loop
|
|
return mReader->getGlobalMetaStateLocked();
|
|
}
|
|
|
|
void InputReader::ContextImpl::disableVirtualKeysUntil(nsecs_t time) {
|
|
// lock is already held by the input loop
|
|
mReader->disableVirtualKeysUntilLocked(time);
|
|
}
|
|
|
|
bool InputReader::ContextImpl::shouldDropVirtualKey(nsecs_t now,
|
|
InputDevice* device, int32_t keyCode, int32_t scanCode) {
|
|
// lock is already held by the input loop
|
|
return mReader->shouldDropVirtualKeyLocked(now, device, keyCode, scanCode);
|
|
}
|
|
|
|
void InputReader::ContextImpl::fadePointer() {
|
|
// lock is already held by the input loop
|
|
mReader->fadePointerLocked();
|
|
}
|
|
|
|
void InputReader::ContextImpl::requestTimeoutAtTime(nsecs_t when) {
|
|
// lock is already held by the input loop
|
|
mReader->requestTimeoutAtTimeLocked(when);
|
|
}
|
|
|
|
int32_t InputReader::ContextImpl::bumpGeneration() {
|
|
// lock is already held by the input loop
|
|
return mReader->bumpGenerationLocked();
|
|
}
|
|
|
|
InputReaderPolicyInterface* InputReader::ContextImpl::getPolicy() {
|
|
return mReader->mPolicy.get();
|
|
}
|
|
|
|
InputListenerInterface* InputReader::ContextImpl::getListener() {
|
|
return mReader->mQueuedListener.get();
|
|
}
|
|
|
|
EventHubInterface* InputReader::ContextImpl::getEventHub() {
|
|
return mReader->mEventHub.get();
|
|
}
|
|
|
|
|
|
// --- InputReaderThread ---
|
|
|
|
InputReaderThread::InputReaderThread(const sp<InputReaderInterface>& reader) :
|
|
Thread(/*canCallJava*/ true), mReader(reader) {
|
|
}
|
|
|
|
InputReaderThread::~InputReaderThread() {
|
|
}
|
|
|
|
bool InputReaderThread::threadLoop() {
|
|
mReader->loopOnce();
|
|
return true;
|
|
}
|
|
|
|
|
|
// --- InputDevice ---
|
|
|
|
InputDevice::InputDevice(InputReaderContext* context, int32_t id, int32_t generation,
|
|
int32_t controllerNumber, const InputDeviceIdentifier& identifier, uint32_t classes) :
|
|
mContext(context), mId(id), mGeneration(generation), mControllerNumber(controllerNumber),
|
|
mIdentifier(identifier), mClasses(classes),
|
|
mSources(0), mIsExternal(false), mDropUntilNextSync(false) {
|
|
}
|
|
|
|
InputDevice::~InputDevice() {
|
|
size_t numMappers = mMappers.size();
|
|
for (size_t i = 0; i < numMappers; i++) {
|
|
delete mMappers[i];
|
|
}
|
|
mMappers.clear();
|
|
}
|
|
|
|
void InputDevice::dump(String8& dump) {
|
|
InputDeviceInfo deviceInfo;
|
|
getDeviceInfo(& deviceInfo);
|
|
|
|
dump.appendFormat(INDENT "Device %d: %s\n", deviceInfo.getId(),
|
|
deviceInfo.getDisplayName().string());
|
|
dump.appendFormat(INDENT2 "Generation: %d\n", mGeneration);
|
|
dump.appendFormat(INDENT2 "IsExternal: %s\n", toString(mIsExternal));
|
|
dump.appendFormat(INDENT2 "Sources: 0x%08x\n", deviceInfo.getSources());
|
|
dump.appendFormat(INDENT2 "KeyboardType: %d\n", deviceInfo.getKeyboardType());
|
|
|
|
const Vector<InputDeviceInfo::MotionRange>& ranges = deviceInfo.getMotionRanges();
|
|
if (!ranges.isEmpty()) {
|
|
dump.append(INDENT2 "Motion Ranges:\n");
|
|
for (size_t i = 0; i < ranges.size(); i++) {
|
|
const InputDeviceInfo::MotionRange& range = ranges.itemAt(i);
|
|
const char* label = getAxisLabel(range.axis);
|
|
char name[32];
|
|
if (label) {
|
|
strncpy(name, label, sizeof(name));
|
|
name[sizeof(name) - 1] = '\0';
|
|
} else {
|
|
snprintf(name, sizeof(name), "%d", range.axis);
|
|
}
|
|
dump.appendFormat(INDENT3 "%s: source=0x%08x, "
|
|
"min=%0.3f, max=%0.3f, flat=%0.3f, fuzz=%0.3f, resolution=%0.3f\n",
|
|
name, range.source, range.min, range.max, range.flat, range.fuzz,
|
|
range.resolution);
|
|
}
|
|
}
|
|
|
|
size_t numMappers = mMappers.size();
|
|
for (size_t i = 0; i < numMappers; i++) {
|
|
InputMapper* mapper = mMappers[i];
|
|
mapper->dump(dump);
|
|
}
|
|
}
|
|
|
|
void InputDevice::addMapper(InputMapper* mapper) {
|
|
mMappers.add(mapper);
|
|
}
|
|
|
|
void InputDevice::configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes) {
|
|
mSources = 0;
|
|
|
|
if (!isIgnored()) {
|
|
if (!changes) { // first time only
|
|
mContext->getEventHub()->getConfiguration(mId, &mConfiguration);
|
|
}
|
|
|
|
if (!changes || (changes & InputReaderConfiguration::CHANGE_KEYBOARD_LAYOUTS)) {
|
|
if (!(mClasses & INPUT_DEVICE_CLASS_VIRTUAL)) {
|
|
sp<KeyCharacterMap> keyboardLayout =
|
|
mContext->getPolicy()->getKeyboardLayoutOverlay(mIdentifier);
|
|
if (mContext->getEventHub()->setKeyboardLayoutOverlay(mId, keyboardLayout)) {
|
|
bumpGeneration();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!changes || (changes & InputReaderConfiguration::CHANGE_DEVICE_ALIAS)) {
|
|
if (!(mClasses & INPUT_DEVICE_CLASS_VIRTUAL)) {
|
|
String8 alias = mContext->getPolicy()->getDeviceAlias(mIdentifier);
|
|
if (mAlias != alias) {
|
|
mAlias = alias;
|
|
bumpGeneration();
|
|
}
|
|
}
|
|
}
|
|
|
|
size_t numMappers = mMappers.size();
|
|
for (size_t i = 0; i < numMappers; i++) {
|
|
InputMapper* mapper = mMappers[i];
|
|
mapper->configure(when, config, changes);
|
|
mSources |= mapper->getSources();
|
|
}
|
|
}
|
|
}
|
|
|
|
void InputDevice::reset(nsecs_t when) {
|
|
size_t numMappers = mMappers.size();
|
|
for (size_t i = 0; i < numMappers; i++) {
|
|
InputMapper* mapper = mMappers[i];
|
|
mapper->reset(when);
|
|
}
|
|
|
|
mContext->updateGlobalMetaState();
|
|
|
|
notifyReset(when);
|
|
}
|
|
|
|
void InputDevice::process(const RawEvent* rawEvents, size_t count) {
|
|
// Process all of the events in order for each mapper.
|
|
// We cannot simply ask each mapper to process them in bulk because mappers may
|
|
// have side-effects that must be interleaved. For example, joystick movement events and
|
|
// gamepad button presses are handled by different mappers but they should be dispatched
|
|
// in the order received.
|
|
size_t numMappers = mMappers.size();
|
|
for (const RawEvent* rawEvent = rawEvents; count--; rawEvent++) {
|
|
#if DEBUG_RAW_EVENTS
|
|
ALOGD("Input event: device=%d type=0x%04x code=0x%04x value=0x%08x when=%lld",
|
|
rawEvent->deviceId, rawEvent->type, rawEvent->code, rawEvent->value,
|
|
rawEvent->when);
|
|
#endif
|
|
|
|
if (mDropUntilNextSync) {
|
|
if (rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT) {
|
|
mDropUntilNextSync = false;
|
|
#if DEBUG_RAW_EVENTS
|
|
ALOGD("Recovered from input event buffer overrun.");
|
|
#endif
|
|
} else {
|
|
#if DEBUG_RAW_EVENTS
|
|
ALOGD("Dropped input event while waiting for next input sync.");
|
|
#endif
|
|
}
|
|
} else if (rawEvent->type == EV_SYN && rawEvent->code == SYN_DROPPED) {
|
|
ALOGI("Detected input event buffer overrun for device %s.", getName().string());
|
|
mDropUntilNextSync = true;
|
|
reset(rawEvent->when);
|
|
} else {
|
|
for (size_t i = 0; i < numMappers; i++) {
|
|
InputMapper* mapper = mMappers[i];
|
|
mapper->process(rawEvent);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void InputDevice::timeoutExpired(nsecs_t when) {
|
|
size_t numMappers = mMappers.size();
|
|
for (size_t i = 0; i < numMappers; i++) {
|
|
InputMapper* mapper = mMappers[i];
|
|
mapper->timeoutExpired(when);
|
|
}
|
|
}
|
|
|
|
void InputDevice::getDeviceInfo(InputDeviceInfo* outDeviceInfo) {
|
|
outDeviceInfo->initialize(mId, mGeneration, mControllerNumber, mIdentifier, mAlias,
|
|
mIsExternal);
|
|
|
|
size_t numMappers = mMappers.size();
|
|
for (size_t i = 0; i < numMappers; i++) {
|
|
InputMapper* mapper = mMappers[i];
|
|
mapper->populateDeviceInfo(outDeviceInfo);
|
|
}
|
|
}
|
|
|
|
int32_t InputDevice::getKeyCodeState(uint32_t sourceMask, int32_t keyCode) {
|
|
return getState(sourceMask, keyCode, & InputMapper::getKeyCodeState);
|
|
}
|
|
|
|
int32_t InputDevice::getScanCodeState(uint32_t sourceMask, int32_t scanCode) {
|
|
return getState(sourceMask, scanCode, & InputMapper::getScanCodeState);
|
|
}
|
|
|
|
int32_t InputDevice::getSwitchState(uint32_t sourceMask, int32_t switchCode) {
|
|
return getState(sourceMask, switchCode, & InputMapper::getSwitchState);
|
|
}
|
|
|
|
int32_t InputDevice::getState(uint32_t sourceMask, int32_t code, GetStateFunc getStateFunc) {
|
|
int32_t result = AKEY_STATE_UNKNOWN;
|
|
size_t numMappers = mMappers.size();
|
|
for (size_t i = 0; i < numMappers; i++) {
|
|
InputMapper* mapper = mMappers[i];
|
|
if (sourcesMatchMask(mapper->getSources(), sourceMask)) {
|
|
// If any mapper reports AKEY_STATE_DOWN or AKEY_STATE_VIRTUAL, return that
|
|
// value. Otherwise, return AKEY_STATE_UP as long as one mapper reports it.
|
|
int32_t currentResult = (mapper->*getStateFunc)(sourceMask, code);
|
|
if (currentResult >= AKEY_STATE_DOWN) {
|
|
return currentResult;
|
|
} else if (currentResult == AKEY_STATE_UP) {
|
|
result = currentResult;
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
bool InputDevice::markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes,
|
|
const int32_t* keyCodes, uint8_t* outFlags) {
|
|
bool result = false;
|
|
size_t numMappers = mMappers.size();
|
|
for (size_t i = 0; i < numMappers; i++) {
|
|
InputMapper* mapper = mMappers[i];
|
|
if (sourcesMatchMask(mapper->getSources(), sourceMask)) {
|
|
result |= mapper->markSupportedKeyCodes(sourceMask, numCodes, keyCodes, outFlags);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void InputDevice::vibrate(const nsecs_t* pattern, size_t patternSize, ssize_t repeat,
|
|
int32_t token) {
|
|
size_t numMappers = mMappers.size();
|
|
for (size_t i = 0; i < numMappers; i++) {
|
|
InputMapper* mapper = mMappers[i];
|
|
mapper->vibrate(pattern, patternSize, repeat, token);
|
|
}
|
|
}
|
|
|
|
void InputDevice::cancelVibrate(int32_t token) {
|
|
size_t numMappers = mMappers.size();
|
|
for (size_t i = 0; i < numMappers; i++) {
|
|
InputMapper* mapper = mMappers[i];
|
|
mapper->cancelVibrate(token);
|
|
}
|
|
}
|
|
|
|
int32_t InputDevice::getMetaState() {
|
|
int32_t result = 0;
|
|
size_t numMappers = mMappers.size();
|
|
for (size_t i = 0; i < numMappers; i++) {
|
|
InputMapper* mapper = mMappers[i];
|
|
result |= mapper->getMetaState();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void InputDevice::fadePointer() {
|
|
size_t numMappers = mMappers.size();
|
|
for (size_t i = 0; i < numMappers; i++) {
|
|
InputMapper* mapper = mMappers[i];
|
|
mapper->fadePointer();
|
|
}
|
|
}
|
|
|
|
void InputDevice::bumpGeneration() {
|
|
mGeneration = mContext->bumpGeneration();
|
|
}
|
|
|
|
void InputDevice::notifyReset(nsecs_t when) {
|
|
NotifyDeviceResetArgs args(when, mId);
|
|
mContext->getListener()->notifyDeviceReset(&args);
|
|
}
|
|
|
|
|
|
// --- CursorButtonAccumulator ---
|
|
|
|
CursorButtonAccumulator::CursorButtonAccumulator() {
|
|
clearButtons();
|
|
}
|
|
|
|
void CursorButtonAccumulator::reset(InputDevice* device) {
|
|
mBtnLeft = device->isKeyPressed(BTN_LEFT);
|
|
mBtnRight = device->isKeyPressed(BTN_RIGHT);
|
|
mBtnMiddle = device->isKeyPressed(BTN_MIDDLE);
|
|
mBtnBack = device->isKeyPressed(BTN_BACK);
|
|
mBtnSide = device->isKeyPressed(BTN_SIDE);
|
|
mBtnForward = device->isKeyPressed(BTN_FORWARD);
|
|
mBtnExtra = device->isKeyPressed(BTN_EXTRA);
|
|
mBtnTask = device->isKeyPressed(BTN_TASK);
|
|
}
|
|
|
|
void CursorButtonAccumulator::clearButtons() {
|
|
mBtnLeft = 0;
|
|
mBtnRight = 0;
|
|
mBtnMiddle = 0;
|
|
mBtnBack = 0;
|
|
mBtnSide = 0;
|
|
mBtnForward = 0;
|
|
mBtnExtra = 0;
|
|
mBtnTask = 0;
|
|
}
|
|
|
|
void CursorButtonAccumulator::process(const RawEvent* rawEvent) {
|
|
if (rawEvent->type == EV_KEY) {
|
|
switch (rawEvent->code) {
|
|
case BTN_LEFT:
|
|
mBtnLeft = rawEvent->value;
|
|
break;
|
|
case BTN_RIGHT:
|
|
mBtnRight = rawEvent->value;
|
|
break;
|
|
case BTN_MIDDLE:
|
|
mBtnMiddle = rawEvent->value;
|
|
break;
|
|
case BTN_BACK:
|
|
mBtnBack = rawEvent->value;
|
|
break;
|
|
case BTN_SIDE:
|
|
mBtnSide = rawEvent->value;
|
|
break;
|
|
case BTN_FORWARD:
|
|
mBtnForward = rawEvent->value;
|
|
break;
|
|
case BTN_EXTRA:
|
|
mBtnExtra = rawEvent->value;
|
|
break;
|
|
case BTN_TASK:
|
|
mBtnTask = rawEvent->value;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
uint32_t CursorButtonAccumulator::getButtonState() const {
|
|
uint32_t result = 0;
|
|
if (mBtnLeft) {
|
|
result |= AMOTION_EVENT_BUTTON_PRIMARY;
|
|
}
|
|
if (mBtnRight) {
|
|
result |= AMOTION_EVENT_BUTTON_SECONDARY;
|
|
}
|
|
if (mBtnMiddle) {
|
|
result |= AMOTION_EVENT_BUTTON_TERTIARY;
|
|
}
|
|
if (mBtnBack || mBtnSide) {
|
|
result |= AMOTION_EVENT_BUTTON_BACK;
|
|
}
|
|
if (mBtnForward || mBtnExtra) {
|
|
result |= AMOTION_EVENT_BUTTON_FORWARD;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
// --- CursorMotionAccumulator ---
|
|
|
|
CursorMotionAccumulator::CursorMotionAccumulator() {
|
|
clearRelativeAxes();
|
|
}
|
|
|
|
void CursorMotionAccumulator::reset(InputDevice* device) {
|
|
clearRelativeAxes();
|
|
}
|
|
|
|
void CursorMotionAccumulator::clearRelativeAxes() {
|
|
mRelX = 0;
|
|
mRelY = 0;
|
|
}
|
|
|
|
void CursorMotionAccumulator::process(const RawEvent* rawEvent) {
|
|
if (rawEvent->type == EV_REL) {
|
|
switch (rawEvent->code) {
|
|
case REL_X:
|
|
mRelX = rawEvent->value;
|
|
break;
|
|
case REL_Y:
|
|
mRelY = rawEvent->value;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CursorMotionAccumulator::finishSync() {
|
|
clearRelativeAxes();
|
|
}
|
|
|
|
|
|
// --- CursorScrollAccumulator ---
|
|
|
|
CursorScrollAccumulator::CursorScrollAccumulator() :
|
|
mHaveRelWheel(false), mHaveRelHWheel(false) {
|
|
clearRelativeAxes();
|
|
}
|
|
|
|
void CursorScrollAccumulator::configure(InputDevice* device) {
|
|
mHaveRelWheel = device->getEventHub()->hasRelativeAxis(device->getId(), REL_WHEEL);
|
|
mHaveRelHWheel = device->getEventHub()->hasRelativeAxis(device->getId(), REL_HWHEEL);
|
|
}
|
|
|
|
void CursorScrollAccumulator::reset(InputDevice* device) {
|
|
clearRelativeAxes();
|
|
}
|
|
|
|
void CursorScrollAccumulator::clearRelativeAxes() {
|
|
mRelWheel = 0;
|
|
mRelHWheel = 0;
|
|
}
|
|
|
|
void CursorScrollAccumulator::process(const RawEvent* rawEvent) {
|
|
if (rawEvent->type == EV_REL) {
|
|
switch (rawEvent->code) {
|
|
case REL_WHEEL:
|
|
mRelWheel = rawEvent->value;
|
|
break;
|
|
case REL_HWHEEL:
|
|
mRelHWheel = rawEvent->value;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CursorScrollAccumulator::finishSync() {
|
|
clearRelativeAxes();
|
|
}
|
|
|
|
|
|
// --- TouchButtonAccumulator ---
|
|
|
|
TouchButtonAccumulator::TouchButtonAccumulator() :
|
|
mHaveBtnTouch(false), mHaveStylus(false) {
|
|
clearButtons();
|
|
}
|
|
|
|
void TouchButtonAccumulator::configure(InputDevice* device) {
|
|
mHaveBtnTouch = device->hasKey(BTN_TOUCH);
|
|
mHaveStylus = device->hasKey(BTN_TOOL_PEN)
|
|
|| device->hasKey(BTN_TOOL_RUBBER)
|
|
|| device->hasKey(BTN_TOOL_BRUSH)
|
|
|| device->hasKey(BTN_TOOL_PENCIL)
|
|
|| device->hasKey(BTN_TOOL_AIRBRUSH);
|
|
}
|
|
|
|
void TouchButtonAccumulator::reset(InputDevice* device) {
|
|
mBtnTouch = device->isKeyPressed(BTN_TOUCH);
|
|
mBtnStylus = device->isKeyPressed(BTN_STYLUS);
|
|
mBtnStylus2 = device->isKeyPressed(BTN_STYLUS);
|
|
mBtnToolFinger = device->isKeyPressed(BTN_TOOL_FINGER);
|
|
mBtnToolPen = device->isKeyPressed(BTN_TOOL_PEN);
|
|
mBtnToolRubber = device->isKeyPressed(BTN_TOOL_RUBBER);
|
|
mBtnToolBrush = device->isKeyPressed(BTN_TOOL_BRUSH);
|
|
mBtnToolPencil = device->isKeyPressed(BTN_TOOL_PENCIL);
|
|
mBtnToolAirbrush = device->isKeyPressed(BTN_TOOL_AIRBRUSH);
|
|
mBtnToolMouse = device->isKeyPressed(BTN_TOOL_MOUSE);
|
|
mBtnToolLens = device->isKeyPressed(BTN_TOOL_LENS);
|
|
mBtnToolDoubleTap = device->isKeyPressed(BTN_TOOL_DOUBLETAP);
|
|
mBtnToolTripleTap = device->isKeyPressed(BTN_TOOL_TRIPLETAP);
|
|
mBtnToolQuadTap = device->isKeyPressed(BTN_TOOL_QUADTAP);
|
|
}
|
|
|
|
void TouchButtonAccumulator::clearButtons() {
|
|
mBtnTouch = 0;
|
|
mBtnStylus = 0;
|
|
mBtnStylus2 = 0;
|
|
mBtnToolFinger = 0;
|
|
mBtnToolPen = 0;
|
|
mBtnToolRubber = 0;
|
|
mBtnToolBrush = 0;
|
|
mBtnToolPencil = 0;
|
|
mBtnToolAirbrush = 0;
|
|
mBtnToolMouse = 0;
|
|
mBtnToolLens = 0;
|
|
mBtnToolDoubleTap = 0;
|
|
mBtnToolTripleTap = 0;
|
|
mBtnToolQuadTap = 0;
|
|
}
|
|
|
|
void TouchButtonAccumulator::process(const RawEvent* rawEvent) {
|
|
if (rawEvent->type == EV_KEY) {
|
|
switch (rawEvent->code) {
|
|
case BTN_TOUCH:
|
|
mBtnTouch = rawEvent->value;
|
|
break;
|
|
case BTN_STYLUS:
|
|
mBtnStylus = rawEvent->value;
|
|
break;
|
|
case BTN_STYLUS2:
|
|
mBtnStylus2 = rawEvent->value;
|
|
break;
|
|
case BTN_TOOL_FINGER:
|
|
mBtnToolFinger = rawEvent->value;
|
|
break;
|
|
case BTN_TOOL_PEN:
|
|
mBtnToolPen = rawEvent->value;
|
|
break;
|
|
case BTN_TOOL_RUBBER:
|
|
mBtnToolRubber = rawEvent->value;
|
|
break;
|
|
case BTN_TOOL_BRUSH:
|
|
mBtnToolBrush = rawEvent->value;
|
|
break;
|
|
case BTN_TOOL_PENCIL:
|
|
mBtnToolPencil = rawEvent->value;
|
|
break;
|
|
case BTN_TOOL_AIRBRUSH:
|
|
mBtnToolAirbrush = rawEvent->value;
|
|
break;
|
|
case BTN_TOOL_MOUSE:
|
|
mBtnToolMouse = rawEvent->value;
|
|
break;
|
|
case BTN_TOOL_LENS:
|
|
mBtnToolLens = rawEvent->value;
|
|
break;
|
|
case BTN_TOOL_DOUBLETAP:
|
|
mBtnToolDoubleTap = rawEvent->value;
|
|
break;
|
|
case BTN_TOOL_TRIPLETAP:
|
|
mBtnToolTripleTap = rawEvent->value;
|
|
break;
|
|
case BTN_TOOL_QUADTAP:
|
|
mBtnToolQuadTap = rawEvent->value;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
uint32_t TouchButtonAccumulator::getButtonState() const {
|
|
uint32_t result = 0;
|
|
if (mBtnStylus) {
|
|
result |= AMOTION_EVENT_BUTTON_SECONDARY;
|
|
}
|
|
if (mBtnStylus2) {
|
|
result |= AMOTION_EVENT_BUTTON_TERTIARY;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
int32_t TouchButtonAccumulator::getToolType() const {
|
|
if (mBtnToolMouse || mBtnToolLens) {
|
|
return AMOTION_EVENT_TOOL_TYPE_MOUSE;
|
|
}
|
|
if (mBtnToolRubber) {
|
|
return AMOTION_EVENT_TOOL_TYPE_ERASER;
|
|
}
|
|
if (mBtnToolPen || mBtnToolBrush || mBtnToolPencil || mBtnToolAirbrush) {
|
|
return AMOTION_EVENT_TOOL_TYPE_STYLUS;
|
|
}
|
|
if (mBtnToolFinger || mBtnToolDoubleTap || mBtnToolTripleTap || mBtnToolQuadTap) {
|
|
return AMOTION_EVENT_TOOL_TYPE_FINGER;
|
|
}
|
|
return AMOTION_EVENT_TOOL_TYPE_UNKNOWN;
|
|
}
|
|
|
|
bool TouchButtonAccumulator::isToolActive() const {
|
|
return mBtnTouch || mBtnToolFinger || mBtnToolPen || mBtnToolRubber
|
|
|| mBtnToolBrush || mBtnToolPencil || mBtnToolAirbrush
|
|
|| mBtnToolMouse || mBtnToolLens
|
|
|| mBtnToolDoubleTap || mBtnToolTripleTap || mBtnToolQuadTap;
|
|
}
|
|
|
|
bool TouchButtonAccumulator::isHovering() const {
|
|
return mHaveBtnTouch && !mBtnTouch;
|
|
}
|
|
|
|
bool TouchButtonAccumulator::hasStylus() const {
|
|
return mHaveStylus;
|
|
}
|
|
|
|
|
|
// --- RawPointerAxes ---
|
|
|
|
RawPointerAxes::RawPointerAxes() {
|
|
clear();
|
|
}
|
|
|
|
void RawPointerAxes::clear() {
|
|
x.clear();
|
|
y.clear();
|
|
pressure.clear();
|
|
touchMajor.clear();
|
|
touchMinor.clear();
|
|
toolMajor.clear();
|
|
toolMinor.clear();
|
|
orientation.clear();
|
|
distance.clear();
|
|
tiltX.clear();
|
|
tiltY.clear();
|
|
trackingId.clear();
|
|
slot.clear();
|
|
}
|
|
|
|
|
|
// --- RawPointerData ---
|
|
|
|
RawPointerData::RawPointerData() {
|
|
clear();
|
|
}
|
|
|
|
void RawPointerData::clear() {
|
|
pointerCount = 0;
|
|
clearIdBits();
|
|
}
|
|
|
|
void RawPointerData::copyFrom(const RawPointerData& other) {
|
|
pointerCount = other.pointerCount;
|
|
hoveringIdBits = other.hoveringIdBits;
|
|
touchingIdBits = other.touchingIdBits;
|
|
|
|
for (uint32_t i = 0; i < pointerCount; i++) {
|
|
pointers[i] = other.pointers[i];
|
|
|
|
int id = pointers[i].id;
|
|
idToIndex[id] = other.idToIndex[id];
|
|
}
|
|
}
|
|
|
|
void RawPointerData::getCentroidOfTouchingPointers(float* outX, float* outY) const {
|
|
float x = 0, y = 0;
|
|
uint32_t count = touchingIdBits.count();
|
|
if (count) {
|
|
for (BitSet32 idBits(touchingIdBits); !idBits.isEmpty(); ) {
|
|
uint32_t id = idBits.clearFirstMarkedBit();
|
|
const Pointer& pointer = pointerForId(id);
|
|
x += pointer.x;
|
|
y += pointer.y;
|
|
}
|
|
x /= count;
|
|
y /= count;
|
|
}
|
|
*outX = x;
|
|
*outY = y;
|
|
}
|
|
|
|
|
|
// --- CookedPointerData ---
|
|
|
|
CookedPointerData::CookedPointerData() {
|
|
clear();
|
|
}
|
|
|
|
void CookedPointerData::clear() {
|
|
pointerCount = 0;
|
|
hoveringIdBits.clear();
|
|
touchingIdBits.clear();
|
|
}
|
|
|
|
void CookedPointerData::copyFrom(const CookedPointerData& other) {
|
|
pointerCount = other.pointerCount;
|
|
hoveringIdBits = other.hoveringIdBits;
|
|
touchingIdBits = other.touchingIdBits;
|
|
|
|
for (uint32_t i = 0; i < pointerCount; i++) {
|
|
pointerProperties[i].copyFrom(other.pointerProperties[i]);
|
|
pointerCoords[i].copyFrom(other.pointerCoords[i]);
|
|
|
|
int id = pointerProperties[i].id;
|
|
idToIndex[id] = other.idToIndex[id];
|
|
}
|
|
}
|
|
|
|
|
|
// --- SingleTouchMotionAccumulator ---
|
|
|
|
SingleTouchMotionAccumulator::SingleTouchMotionAccumulator() {
|
|
clearAbsoluteAxes();
|
|
}
|
|
|
|
void SingleTouchMotionAccumulator::reset(InputDevice* device) {
|
|
mAbsX = device->getAbsoluteAxisValue(ABS_X);
|
|
mAbsY = device->getAbsoluteAxisValue(ABS_Y);
|
|
mAbsPressure = device->getAbsoluteAxisValue(ABS_PRESSURE);
|
|
mAbsToolWidth = device->getAbsoluteAxisValue(ABS_TOOL_WIDTH);
|
|
mAbsDistance = device->getAbsoluteAxisValue(ABS_DISTANCE);
|
|
mAbsTiltX = device->getAbsoluteAxisValue(ABS_TILT_X);
|
|
mAbsTiltY = device->getAbsoluteAxisValue(ABS_TILT_Y);
|
|
}
|
|
|
|
void SingleTouchMotionAccumulator::clearAbsoluteAxes() {
|
|
mAbsX = 0;
|
|
mAbsY = 0;
|
|
mAbsPressure = 0;
|
|
mAbsToolWidth = 0;
|
|
mAbsDistance = 0;
|
|
mAbsTiltX = 0;
|
|
mAbsTiltY = 0;
|
|
}
|
|
|
|
void SingleTouchMotionAccumulator::process(const RawEvent* rawEvent) {
|
|
if (rawEvent->type == EV_ABS) {
|
|
switch (rawEvent->code) {
|
|
case ABS_X:
|
|
mAbsX = rawEvent->value;
|
|
break;
|
|
case ABS_Y:
|
|
mAbsY = rawEvent->value;
|
|
break;
|
|
case ABS_PRESSURE:
|
|
mAbsPressure = rawEvent->value;
|
|
break;
|
|
case ABS_TOOL_WIDTH:
|
|
mAbsToolWidth = rawEvent->value;
|
|
break;
|
|
case ABS_DISTANCE:
|
|
mAbsDistance = rawEvent->value;
|
|
break;
|
|
case ABS_TILT_X:
|
|
mAbsTiltX = rawEvent->value;
|
|
break;
|
|
case ABS_TILT_Y:
|
|
mAbsTiltY = rawEvent->value;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// --- MultiTouchMotionAccumulator ---
|
|
|
|
MultiTouchMotionAccumulator::MultiTouchMotionAccumulator() :
|
|
mCurrentSlot(-1), mSlots(NULL), mSlotCount(0), mUsingSlotsProtocol(false),
|
|
mHaveStylus(false) {
|
|
}
|
|
|
|
MultiTouchMotionAccumulator::~MultiTouchMotionAccumulator() {
|
|
delete[] mSlots;
|
|
}
|
|
|
|
void MultiTouchMotionAccumulator::configure(InputDevice* device,
|
|
size_t slotCount, bool usingSlotsProtocol) {
|
|
mSlotCount = slotCount;
|
|
mUsingSlotsProtocol = usingSlotsProtocol;
|
|
mHaveStylus = device->hasAbsoluteAxis(ABS_MT_TOOL_TYPE);
|
|
|
|
delete[] mSlots;
|
|
mSlots = new Slot[slotCount];
|
|
}
|
|
|
|
void MultiTouchMotionAccumulator::reset(InputDevice* device) {
|
|
// Unfortunately there is no way to read the initial contents of the slots.
|
|
// So when we reset the accumulator, we must assume they are all zeroes.
|
|
if (mUsingSlotsProtocol) {
|
|
// Query the driver for the current slot index and use it as the initial slot
|
|
// before we start reading events from the device. It is possible that the
|
|
// current slot index will not be the same as it was when the first event was
|
|
// written into the evdev buffer, which means the input mapper could start
|
|
// out of sync with the initial state of the events in the evdev buffer.
|
|
// In the extremely unlikely case that this happens, the data from
|
|
// two slots will be confused until the next ABS_MT_SLOT event is received.
|
|
// This can cause the touch point to "jump", but at least there will be
|
|
// no stuck touches.
|
|
int32_t initialSlot;
|
|
status_t status = device->getEventHub()->getAbsoluteAxisValue(device->getId(),
|
|
ABS_MT_SLOT, &initialSlot);
|
|
if (status) {
|
|
ALOGD("Could not retrieve current multitouch slot index. status=%d", status);
|
|
initialSlot = -1;
|
|
}
|
|
clearSlots(initialSlot);
|
|
} else {
|
|
clearSlots(-1);
|
|
}
|
|
}
|
|
|
|
void MultiTouchMotionAccumulator::clearSlots(int32_t initialSlot) {
|
|
if (mSlots) {
|
|
for (size_t i = 0; i < mSlotCount; i++) {
|
|
mSlots[i].clear();
|
|
}
|
|
}
|
|
mCurrentSlot = initialSlot;
|
|
}
|
|
|
|
void MultiTouchMotionAccumulator::process(const RawEvent* rawEvent) {
|
|
if (rawEvent->type == EV_ABS) {
|
|
bool newSlot = false;
|
|
if (mUsingSlotsProtocol) {
|
|
if (rawEvent->code == ABS_MT_SLOT) {
|
|
mCurrentSlot = rawEvent->value;
|
|
newSlot = true;
|
|
}
|
|
} else if (mCurrentSlot < 0) {
|
|
mCurrentSlot = 0;
|
|
}
|
|
|
|
if (mCurrentSlot < 0 || size_t(mCurrentSlot) >= mSlotCount) {
|
|
#if DEBUG_POINTERS
|
|
if (newSlot) {
|
|
ALOGW("MultiTouch device emitted invalid slot index %d but it "
|
|
"should be between 0 and %d; ignoring this slot.",
|
|
mCurrentSlot, mSlotCount - 1);
|
|
}
|
|
#endif
|
|
} else {
|
|
Slot* slot = &mSlots[mCurrentSlot];
|
|
|
|
switch (rawEvent->code) {
|
|
case ABS_MT_POSITION_X:
|
|
slot->mInUse = true;
|
|
slot->mAbsMTPositionX = rawEvent->value;
|
|
break;
|
|
case ABS_MT_POSITION_Y:
|
|
slot->mInUse = true;
|
|
slot->mAbsMTPositionY = rawEvent->value;
|
|
break;
|
|
case ABS_MT_TOUCH_MAJOR:
|
|
slot->mInUse = true;
|
|
slot->mAbsMTTouchMajor = rawEvent->value;
|
|
break;
|
|
case ABS_MT_TOUCH_MINOR:
|
|
slot->mInUse = true;
|
|
slot->mAbsMTTouchMinor = rawEvent->value;
|
|
slot->mHaveAbsMTTouchMinor = true;
|
|
break;
|
|
case ABS_MT_WIDTH_MAJOR:
|
|
slot->mInUse = true;
|
|
slot->mAbsMTWidthMajor = rawEvent->value;
|
|
break;
|
|
case ABS_MT_WIDTH_MINOR:
|
|
slot->mInUse = true;
|
|
slot->mAbsMTWidthMinor = rawEvent->value;
|
|
slot->mHaveAbsMTWidthMinor = true;
|
|
break;
|
|
case ABS_MT_ORIENTATION:
|
|
slot->mInUse = true;
|
|
slot->mAbsMTOrientation = rawEvent->value;
|
|
break;
|
|
case ABS_MT_TRACKING_ID:
|
|
if (mUsingSlotsProtocol && rawEvent->value < 0) {
|
|
// The slot is no longer in use but it retains its previous contents,
|
|
// which may be reused for subsequent touches.
|
|
slot->mInUse = false;
|
|
} else {
|
|
slot->mInUse = true;
|
|
slot->mAbsMTTrackingId = rawEvent->value;
|
|
}
|
|
break;
|
|
case ABS_MT_PRESSURE:
|
|
slot->mInUse = true;
|
|
slot->mAbsMTPressure = rawEvent->value;
|
|
break;
|
|
case ABS_MT_DISTANCE:
|
|
slot->mInUse = true;
|
|
slot->mAbsMTDistance = rawEvent->value;
|
|
break;
|
|
case ABS_MT_TOOL_TYPE:
|
|
slot->mInUse = true;
|
|
slot->mAbsMTToolType = rawEvent->value;
|
|
slot->mHaveAbsMTToolType = true;
|
|
break;
|
|
}
|
|
}
|
|
} else if (rawEvent->type == EV_SYN && rawEvent->code == SYN_MT_REPORT) {
|
|
// MultiTouch Sync: The driver has returned all data for *one* of the pointers.
|
|
mCurrentSlot += 1;
|
|
}
|
|
}
|
|
|
|
void MultiTouchMotionAccumulator::finishSync() {
|
|
if (!mUsingSlotsProtocol) {
|
|
clearSlots(-1);
|
|
}
|
|
}
|
|
|
|
bool MultiTouchMotionAccumulator::hasStylus() const {
|
|
return mHaveStylus;
|
|
}
|
|
|
|
|
|
// --- MultiTouchMotionAccumulator::Slot ---
|
|
|
|
MultiTouchMotionAccumulator::Slot::Slot() {
|
|
clear();
|
|
}
|
|
|
|
void MultiTouchMotionAccumulator::Slot::clear() {
|
|
mInUse = false;
|
|
mHaveAbsMTTouchMinor = false;
|
|
mHaveAbsMTWidthMinor = false;
|
|
mHaveAbsMTToolType = false;
|
|
mAbsMTPositionX = 0;
|
|
mAbsMTPositionY = 0;
|
|
mAbsMTTouchMajor = 0;
|
|
mAbsMTTouchMinor = 0;
|
|
mAbsMTWidthMajor = 0;
|
|
mAbsMTWidthMinor = 0;
|
|
mAbsMTOrientation = 0;
|
|
mAbsMTTrackingId = -1;
|
|
mAbsMTPressure = 0;
|
|
mAbsMTDistance = 0;
|
|
mAbsMTToolType = 0;
|
|
}
|
|
|
|
int32_t MultiTouchMotionAccumulator::Slot::getToolType() const {
|
|
if (mHaveAbsMTToolType) {
|
|
switch (mAbsMTToolType) {
|
|
case MT_TOOL_FINGER:
|
|
return AMOTION_EVENT_TOOL_TYPE_FINGER;
|
|
case MT_TOOL_PEN:
|
|
return AMOTION_EVENT_TOOL_TYPE_STYLUS;
|
|
}
|
|
}
|
|
return AMOTION_EVENT_TOOL_TYPE_UNKNOWN;
|
|
}
|
|
|
|
|
|
// --- InputMapper ---
|
|
|
|
InputMapper::InputMapper(InputDevice* device) :
|
|
mDevice(device), mContext(device->getContext()) {
|
|
}
|
|
|
|
InputMapper::~InputMapper() {
|
|
}
|
|
|
|
void InputMapper::populateDeviceInfo(InputDeviceInfo* info) {
|
|
info->addSource(getSources());
|
|
}
|
|
|
|
void InputMapper::dump(String8& dump) {
|
|
}
|
|
|
|
void InputMapper::configure(nsecs_t when,
|
|
const InputReaderConfiguration* config, uint32_t changes) {
|
|
}
|
|
|
|
void InputMapper::reset(nsecs_t when) {
|
|
}
|
|
|
|
void InputMapper::timeoutExpired(nsecs_t when) {
|
|
}
|
|
|
|
int32_t InputMapper::getKeyCodeState(uint32_t sourceMask, int32_t keyCode) {
|
|
return AKEY_STATE_UNKNOWN;
|
|
}
|
|
|
|
int32_t InputMapper::getScanCodeState(uint32_t sourceMask, int32_t scanCode) {
|
|
return AKEY_STATE_UNKNOWN;
|
|
}
|
|
|
|
int32_t InputMapper::getSwitchState(uint32_t sourceMask, int32_t switchCode) {
|
|
return AKEY_STATE_UNKNOWN;
|
|
}
|
|
|
|
bool InputMapper::markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes,
|
|
const int32_t* keyCodes, uint8_t* outFlags) {
|
|
return false;
|
|
}
|
|
|
|
void InputMapper::vibrate(const nsecs_t* pattern, size_t patternSize, ssize_t repeat,
|
|
int32_t token) {
|
|
}
|
|
|
|
void InputMapper::cancelVibrate(int32_t token) {
|
|
}
|
|
|
|
int32_t InputMapper::getMetaState() {
|
|
return 0;
|
|
}
|
|
|
|
void InputMapper::fadePointer() {
|
|
}
|
|
|
|
status_t InputMapper::getAbsoluteAxisInfo(int32_t axis, RawAbsoluteAxisInfo* axisInfo) {
|
|
return getEventHub()->getAbsoluteAxisInfo(getDeviceId(), axis, axisInfo);
|
|
}
|
|
|
|
void InputMapper::bumpGeneration() {
|
|
mDevice->bumpGeneration();
|
|
}
|
|
|
|
void InputMapper::dumpRawAbsoluteAxisInfo(String8& dump,
|
|
const RawAbsoluteAxisInfo& axis, const char* name) {
|
|
if (axis.valid) {
|
|
dump.appendFormat(INDENT4 "%s: min=%d, max=%d, flat=%d, fuzz=%d, resolution=%d\n",
|
|
name, axis.minValue, axis.maxValue, axis.flat, axis.fuzz, axis.resolution);
|
|
} else {
|
|
dump.appendFormat(INDENT4 "%s: unknown range\n", name);
|
|
}
|
|
}
|
|
|
|
|
|
// --- SwitchInputMapper ---
|
|
|
|
SwitchInputMapper::SwitchInputMapper(InputDevice* device) :
|
|
InputMapper(device), mUpdatedSwitchValues(0), mUpdatedSwitchMask(0) {
|
|
}
|
|
|
|
SwitchInputMapper::~SwitchInputMapper() {
|
|
}
|
|
|
|
uint32_t SwitchInputMapper::getSources() {
|
|
return AINPUT_SOURCE_SWITCH;
|
|
}
|
|
|
|
void SwitchInputMapper::process(const RawEvent* rawEvent) {
|
|
switch (rawEvent->type) {
|
|
case EV_SW:
|
|
processSwitch(rawEvent->code, rawEvent->value);
|
|
break;
|
|
|
|
case EV_SYN:
|
|
if (rawEvent->code == SYN_REPORT) {
|
|
sync(rawEvent->when);
|
|
}
|
|
}
|
|
}
|
|
|
|
void SwitchInputMapper::processSwitch(int32_t switchCode, int32_t switchValue) {
|
|
if (switchCode >= 0 && switchCode < 32) {
|
|
if (switchValue) {
|
|
mUpdatedSwitchValues |= 1 << switchCode;
|
|
}
|
|
mUpdatedSwitchMask |= 1 << switchCode;
|
|
}
|
|
}
|
|
|
|
void SwitchInputMapper::sync(nsecs_t when) {
|
|
if (mUpdatedSwitchMask) {
|
|
NotifySwitchArgs args(when, 0, mUpdatedSwitchValues, mUpdatedSwitchMask);
|
|
getListener()->notifySwitch(&args);
|
|
|
|
mUpdatedSwitchValues = 0;
|
|
mUpdatedSwitchMask = 0;
|
|
}
|
|
}
|
|
|
|
int32_t SwitchInputMapper::getSwitchState(uint32_t sourceMask, int32_t switchCode) {
|
|
return getEventHub()->getSwitchState(getDeviceId(), switchCode);
|
|
}
|
|
|
|
|
|
// --- VibratorInputMapper ---
|
|
|
|
VibratorInputMapper::VibratorInputMapper(InputDevice* device) :
|
|
InputMapper(device), mVibrating(false) {
|
|
}
|
|
|
|
VibratorInputMapper::~VibratorInputMapper() {
|
|
}
|
|
|
|
uint32_t VibratorInputMapper::getSources() {
|
|
return 0;
|
|
}
|
|
|
|
void VibratorInputMapper::populateDeviceInfo(InputDeviceInfo* info) {
|
|
InputMapper::populateDeviceInfo(info);
|
|
|
|
info->setVibrator(true);
|
|
}
|
|
|
|
void VibratorInputMapper::process(const RawEvent* rawEvent) {
|
|
// TODO: Handle FF_STATUS, although it does not seem to be widely supported.
|
|
}
|
|
|
|
void VibratorInputMapper::vibrate(const nsecs_t* pattern, size_t patternSize, ssize_t repeat,
|
|
int32_t token) {
|
|
#if DEBUG_VIBRATOR
|
|
String8 patternStr;
|
|
for (size_t i = 0; i < patternSize; i++) {
|
|
if (i != 0) {
|
|
patternStr.append(", ");
|
|
}
|
|
patternStr.appendFormat("%lld", pattern[i]);
|
|
}
|
|
ALOGD("vibrate: deviceId=%d, pattern=[%s], repeat=%ld, token=%d",
|
|
getDeviceId(), patternStr.string(), repeat, token);
|
|
#endif
|
|
|
|
mVibrating = true;
|
|
memcpy(mPattern, pattern, patternSize * sizeof(nsecs_t));
|
|
mPatternSize = patternSize;
|
|
mRepeat = repeat;
|
|
mToken = token;
|
|
mIndex = -1;
|
|
|
|
nextStep();
|
|
}
|
|
|
|
void VibratorInputMapper::cancelVibrate(int32_t token) {
|
|
#if DEBUG_VIBRATOR
|
|
ALOGD("cancelVibrate: deviceId=%d, token=%d", getDeviceId(), token);
|
|
#endif
|
|
|
|
if (mVibrating && mToken == token) {
|
|
stopVibrating();
|
|
}
|
|
}
|
|
|
|
void VibratorInputMapper::timeoutExpired(nsecs_t when) {
|
|
if (mVibrating) {
|
|
if (when >= mNextStepTime) {
|
|
nextStep();
|
|
} else {
|
|
getContext()->requestTimeoutAtTime(mNextStepTime);
|
|
}
|
|
}
|
|
}
|
|
|
|
void VibratorInputMapper::nextStep() {
|
|
mIndex += 1;
|
|
if (size_t(mIndex) >= mPatternSize) {
|
|
if (mRepeat < 0) {
|
|
// We are done.
|
|
stopVibrating();
|
|
return;
|
|
}
|
|
mIndex = mRepeat;
|
|
}
|
|
|
|
bool vibratorOn = mIndex & 1;
|
|
nsecs_t duration = mPattern[mIndex];
|
|
if (vibratorOn) {
|
|
#if DEBUG_VIBRATOR
|
|
ALOGD("nextStep: sending vibrate deviceId=%d, duration=%lld",
|
|
getDeviceId(), duration);
|
|
#endif
|
|
getEventHub()->vibrate(getDeviceId(), duration);
|
|
} else {
|
|
#if DEBUG_VIBRATOR
|
|
ALOGD("nextStep: sending cancel vibrate deviceId=%d", getDeviceId());
|
|
#endif
|
|
getEventHub()->cancelVibrate(getDeviceId());
|
|
}
|
|
nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
|
|
mNextStepTime = now + duration;
|
|
getContext()->requestTimeoutAtTime(mNextStepTime);
|
|
#if DEBUG_VIBRATOR
|
|
ALOGD("nextStep: scheduled timeout in %0.3fms", duration * 0.000001f);
|
|
#endif
|
|
}
|
|
|
|
void VibratorInputMapper::stopVibrating() {
|
|
mVibrating = false;
|
|
#if DEBUG_VIBRATOR
|
|
ALOGD("stopVibrating: sending cancel vibrate deviceId=%d", getDeviceId());
|
|
#endif
|
|
getEventHub()->cancelVibrate(getDeviceId());
|
|
}
|
|
|
|
void VibratorInputMapper::dump(String8& dump) {
|
|
dump.append(INDENT2 "Vibrator Input Mapper:\n");
|
|
dump.appendFormat(INDENT3 "Vibrating: %s\n", toString(mVibrating));
|
|
}
|
|
|
|
|
|
// --- KeyboardInputMapper ---
|
|
|
|
KeyboardInputMapper::KeyboardInputMapper(InputDevice* device,
|
|
uint32_t source, int32_t keyboardType) :
|
|
InputMapper(device), mSource(source),
|
|
mKeyboardType(keyboardType) {
|
|
}
|
|
|
|
KeyboardInputMapper::~KeyboardInputMapper() {
|
|
}
|
|
|
|
uint32_t KeyboardInputMapper::getSources() {
|
|
return mSource;
|
|
}
|
|
|
|
void KeyboardInputMapper::populateDeviceInfo(InputDeviceInfo* info) {
|
|
InputMapper::populateDeviceInfo(info);
|
|
|
|
info->setKeyboardType(mKeyboardType);
|
|
info->setKeyCharacterMap(getEventHub()->getKeyCharacterMap(getDeviceId()));
|
|
}
|
|
|
|
void KeyboardInputMapper::dump(String8& dump) {
|
|
dump.append(INDENT2 "Keyboard Input Mapper:\n");
|
|
dumpParameters(dump);
|
|
dump.appendFormat(INDENT3 "KeyboardType: %d\n", mKeyboardType);
|
|
dump.appendFormat(INDENT3 "Orientation: %d\n", mOrientation);
|
|
dump.appendFormat(INDENT3 "KeyDowns: %d keys currently down\n", mKeyDowns.size());
|
|
dump.appendFormat(INDENT3 "MetaState: 0x%0x\n", mMetaState);
|
|
dump.appendFormat(INDENT3 "DownTime: %lld\n", mDownTime);
|
|
}
|
|
|
|
|
|
void KeyboardInputMapper::configure(nsecs_t when,
|
|
const InputReaderConfiguration* config, uint32_t changes) {
|
|
InputMapper::configure(when, config, changes);
|
|
|
|
if (!changes) { // first time only
|
|
// Configure basic parameters.
|
|
configureParameters();
|
|
}
|
|
|
|
if (!changes || (changes & InputReaderConfiguration::CHANGE_DISPLAY_INFO)) {
|
|
if (mParameters.orientationAware && mParameters.hasAssociatedDisplay) {
|
|
DisplayViewport v;
|
|
if (config->getDisplayInfo(false /*external*/, &v)) {
|
|
mOrientation = v.orientation;
|
|
} else {
|
|
mOrientation = DISPLAY_ORIENTATION_0;
|
|
}
|
|
} else {
|
|
mOrientation = DISPLAY_ORIENTATION_0;
|
|
}
|
|
}
|
|
}
|
|
|
|
void KeyboardInputMapper::configureParameters() {
|
|
mParameters.orientationAware = false;
|
|
getDevice()->getConfiguration().tryGetProperty(String8("keyboard.orientationAware"),
|
|
mParameters.orientationAware);
|
|
|
|
mParameters.hasAssociatedDisplay = false;
|
|
if (mParameters.orientationAware) {
|
|
mParameters.hasAssociatedDisplay = true;
|
|
}
|
|
}
|
|
|
|
void KeyboardInputMapper::dumpParameters(String8& dump) {
|
|
dump.append(INDENT3 "Parameters:\n");
|
|
dump.appendFormat(INDENT4 "HasAssociatedDisplay: %s\n",
|
|
toString(mParameters.hasAssociatedDisplay));
|
|
dump.appendFormat(INDENT4 "OrientationAware: %s\n",
|
|
toString(mParameters.orientationAware));
|
|
}
|
|
|
|
void KeyboardInputMapper::reset(nsecs_t when) {
|
|
mMetaState = AMETA_NONE;
|
|
mDownTime = 0;
|
|
mKeyDowns.clear();
|
|
mCurrentHidUsage = 0;
|
|
|
|
resetLedState();
|
|
|
|
InputMapper::reset(when);
|
|
}
|
|
|
|
void KeyboardInputMapper::process(const RawEvent* rawEvent) {
|
|
switch (rawEvent->type) {
|
|
case EV_KEY: {
|
|
int32_t scanCode = rawEvent->code;
|
|
int32_t usageCode = mCurrentHidUsage;
|
|
mCurrentHidUsage = 0;
|
|
|
|
if (isKeyboardOrGamepadKey(scanCode)) {
|
|
int32_t keyCode;
|
|
uint32_t flags;
|
|
if (getEventHub()->mapKey(getDeviceId(), scanCode, usageCode, &keyCode, &flags)) {
|
|
keyCode = AKEYCODE_UNKNOWN;
|
|
flags = 0;
|
|
}
|
|
processKey(rawEvent->when, rawEvent->value != 0, keyCode, scanCode, flags);
|
|
}
|
|
break;
|
|
}
|
|
case EV_MSC: {
|
|
if (rawEvent->code == MSC_SCAN) {
|
|
mCurrentHidUsage = rawEvent->value;
|
|
}
|
|
break;
|
|
}
|
|
case EV_SYN: {
|
|
if (rawEvent->code == SYN_REPORT) {
|
|
mCurrentHidUsage = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool KeyboardInputMapper::isKeyboardOrGamepadKey(int32_t scanCode) {
|
|
return scanCode < BTN_MOUSE
|
|
|| scanCode >= KEY_OK
|
|
|| (scanCode >= BTN_MISC && scanCode < BTN_MOUSE)
|
|
|| (scanCode >= BTN_JOYSTICK && scanCode < BTN_DIGI);
|
|
}
|
|
|
|
void KeyboardInputMapper::processKey(nsecs_t when, bool down, int32_t keyCode,
|
|
int32_t scanCode, uint32_t policyFlags) {
|
|
|
|
if (down) {
|
|
// Rotate key codes according to orientation if needed.
|
|
if (mParameters.orientationAware && mParameters.hasAssociatedDisplay) {
|
|
keyCode = rotateKeyCode(keyCode, mOrientation);
|
|
}
|
|
|
|
// Add key down.
|
|
ssize_t keyDownIndex = findKeyDown(scanCode);
|
|
if (keyDownIndex >= 0) {
|
|
// key repeat, be sure to use same keycode as before in case of rotation
|
|
keyCode = mKeyDowns.itemAt(keyDownIndex).keyCode;
|
|
} else {
|
|
// key down
|
|
if ((policyFlags & POLICY_FLAG_VIRTUAL)
|
|
&& mContext->shouldDropVirtualKey(when,
|
|
getDevice(), keyCode, scanCode)) {
|
|
return;
|
|
}
|
|
|
|
mKeyDowns.push();
|
|
KeyDown& keyDown = mKeyDowns.editTop();
|
|
keyDown.keyCode = keyCode;
|
|
keyDown.scanCode = scanCode;
|
|
}
|
|
|
|
mDownTime = when;
|
|
} else {
|
|
// Remove key down.
|
|
ssize_t keyDownIndex = findKeyDown(scanCode);
|
|
if (keyDownIndex >= 0) {
|
|
// key up, be sure to use same keycode as before in case of rotation
|
|
keyCode = mKeyDowns.itemAt(keyDownIndex).keyCode;
|
|
mKeyDowns.removeAt(size_t(keyDownIndex));
|
|
} else {
|
|
// key was not actually down
|
|
ALOGI("Dropping key up from device %s because the key was not down. "
|
|
"keyCode=%d, scanCode=%d",
|
|
getDeviceName().string(), keyCode, scanCode);
|
|
return;
|
|
}
|
|
}
|
|
|
|
int32_t oldMetaState = mMetaState;
|
|
int32_t newMetaState = updateMetaState(keyCode, down, oldMetaState);
|
|
bool metaStateChanged = oldMetaState != newMetaState;
|
|
if (metaStateChanged) {
|
|
mMetaState = newMetaState;
|
|
updateLedState(false);
|
|
}
|
|
|
|
nsecs_t downTime = mDownTime;
|
|
|
|
// Key down on external an keyboard should wake the device.
|
|
// We don't do this for internal keyboards to prevent them from waking up in your pocket.
|
|
// For internal keyboards, the key layout file should specify the policy flags for
|
|
// each wake key individually.
|
|
// TODO: Use the input device configuration to control this behavior more finely.
|
|
if (down && getDevice()->isExternal()
|
|
&& !(policyFlags & (POLICY_FLAG_WAKE | POLICY_FLAG_WAKE_DROPPED))) {
|
|
policyFlags |= POLICY_FLAG_WAKE_DROPPED;
|
|
}
|
|
|
|
if (metaStateChanged) {
|
|
getContext()->updateGlobalMetaState();
|
|
}
|
|
|
|
if (down && !isMetaKey(keyCode)) {
|
|
getContext()->fadePointer();
|
|
}
|
|
|
|
NotifyKeyArgs args(when, getDeviceId(), mSource, policyFlags,
|
|
down ? AKEY_EVENT_ACTION_DOWN : AKEY_EVENT_ACTION_UP,
|
|
AKEY_EVENT_FLAG_FROM_SYSTEM, keyCode, scanCode, newMetaState, downTime);
|
|
getListener()->notifyKey(&args);
|
|
}
|
|
|
|
ssize_t KeyboardInputMapper::findKeyDown(int32_t scanCode) {
|
|
size_t n = mKeyDowns.size();
|
|
for (size_t i = 0; i < n; i++) {
|
|
if (mKeyDowns[i].scanCode == scanCode) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
int32_t KeyboardInputMapper::getKeyCodeState(uint32_t sourceMask, int32_t keyCode) {
|
|
return getEventHub()->getKeyCodeState(getDeviceId(), keyCode);
|
|
}
|
|
|
|
int32_t KeyboardInputMapper::getScanCodeState(uint32_t sourceMask, int32_t scanCode) {
|
|
return getEventHub()->getScanCodeState(getDeviceId(), scanCode);
|
|
}
|
|
|
|
bool KeyboardInputMapper::markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes,
|
|
const int32_t* keyCodes, uint8_t* outFlags) {
|
|
return getEventHub()->markSupportedKeyCodes(getDeviceId(), numCodes, keyCodes, outFlags);
|
|
}
|
|
|
|
int32_t KeyboardInputMapper::getMetaState() {
|
|
return mMetaState;
|
|
}
|
|
|
|
void KeyboardInputMapper::resetLedState() {
|
|
initializeLedState(mCapsLockLedState, ALED_CAPS_LOCK);
|
|
initializeLedState(mNumLockLedState, ALED_NUM_LOCK);
|
|
initializeLedState(mScrollLockLedState, ALED_SCROLL_LOCK);
|
|
|
|
updateLedState(true);
|
|
}
|
|
|
|
void KeyboardInputMapper::initializeLedState(LedState& ledState, int32_t led) {
|
|
ledState.avail = getEventHub()->hasLed(getDeviceId(), led);
|
|
ledState.on = false;
|
|
}
|
|
|
|
void KeyboardInputMapper::updateLedState(bool reset) {
|
|
updateLedStateForModifier(mCapsLockLedState, ALED_CAPS_LOCK,
|
|
AMETA_CAPS_LOCK_ON, reset);
|
|
updateLedStateForModifier(mNumLockLedState, ALED_NUM_LOCK,
|
|
AMETA_NUM_LOCK_ON, reset);
|
|
updateLedStateForModifier(mScrollLockLedState, ALED_SCROLL_LOCK,
|
|
AMETA_SCROLL_LOCK_ON, reset);
|
|
}
|
|
|
|
void KeyboardInputMapper::updateLedStateForModifier(LedState& ledState,
|
|
int32_t led, int32_t modifier, bool reset) {
|
|
if (ledState.avail) {
|
|
bool desiredState = (mMetaState & modifier) != 0;
|
|
if (reset || ledState.on != desiredState) {
|
|
getEventHub()->setLedState(getDeviceId(), led, desiredState);
|
|
ledState.on = desiredState;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// --- CursorInputMapper ---
|
|
|
|
CursorInputMapper::CursorInputMapper(InputDevice* device) :
|
|
InputMapper(device) {
|
|
}
|
|
|
|
CursorInputMapper::~CursorInputMapper() {
|
|
}
|
|
|
|
uint32_t CursorInputMapper::getSources() {
|
|
return mSource;
|
|
}
|
|
|
|
void CursorInputMapper::populateDeviceInfo(InputDeviceInfo* info) {
|
|
InputMapper::populateDeviceInfo(info);
|
|
|
|
if (mParameters.mode == Parameters::MODE_POINTER) {
|
|
float minX, minY, maxX, maxY;
|
|
if (mPointerController->getBounds(&minX, &minY, &maxX, &maxY)) {
|
|
info->addMotionRange(AMOTION_EVENT_AXIS_X, mSource, minX, maxX, 0.0f, 0.0f, 0.0f);
|
|
info->addMotionRange(AMOTION_EVENT_AXIS_Y, mSource, minY, maxY, 0.0f, 0.0f, 0.0f);
|
|
}
|
|
} else {
|
|
info->addMotionRange(AMOTION_EVENT_AXIS_X, mSource, -1.0f, 1.0f, 0.0f, mXScale, 0.0f);
|
|
info->addMotionRange(AMOTION_EVENT_AXIS_Y, mSource, -1.0f, 1.0f, 0.0f, mYScale, 0.0f);
|
|
}
|
|
info->addMotionRange(AMOTION_EVENT_AXIS_PRESSURE, mSource, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f);
|
|
|
|
if (mCursorScrollAccumulator.haveRelativeVWheel()) {
|
|
info->addMotionRange(AMOTION_EVENT_AXIS_VSCROLL, mSource, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f);
|
|
}
|
|
if (mCursorScrollAccumulator.haveRelativeHWheel()) {
|
|
info->addMotionRange(AMOTION_EVENT_AXIS_HSCROLL, mSource, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f);
|
|
}
|
|
}
|
|
|
|
void CursorInputMapper::dump(String8& dump) {
|
|
dump.append(INDENT2 "Cursor Input Mapper:\n");
|
|
dumpParameters(dump);
|
|
dump.appendFormat(INDENT3 "XScale: %0.3f\n", mXScale);
|
|
dump.appendFormat(INDENT3 "YScale: %0.3f\n", mYScale);
|
|
dump.appendFormat(INDENT3 "XPrecision: %0.3f\n", mXPrecision);
|
|
dump.appendFormat(INDENT3 "YPrecision: %0.3f\n", mYPrecision);
|
|
dump.appendFormat(INDENT3 "HaveVWheel: %s\n",
|
|
toString(mCursorScrollAccumulator.haveRelativeVWheel()));
|
|
dump.appendFormat(INDENT3 "HaveHWheel: %s\n",
|
|
toString(mCursorScrollAccumulator.haveRelativeHWheel()));
|
|
dump.appendFormat(INDENT3 "VWheelScale: %0.3f\n", mVWheelScale);
|
|
dump.appendFormat(INDENT3 "HWheelScale: %0.3f\n", mHWheelScale);
|
|
dump.appendFormat(INDENT3 "Orientation: %d\n", mOrientation);
|
|
dump.appendFormat(INDENT3 "ButtonState: 0x%08x\n", mButtonState);
|
|
dump.appendFormat(INDENT3 "Down: %s\n", toString(isPointerDown(mButtonState)));
|
|
dump.appendFormat(INDENT3 "DownTime: %lld\n", mDownTime);
|
|
}
|
|
|
|
void CursorInputMapper::configure(nsecs_t when,
|
|
const InputReaderConfiguration* config, uint32_t changes) {
|
|
InputMapper::configure(when, config, changes);
|
|
|
|
if (!changes) { // first time only
|
|
mCursorScrollAccumulator.configure(getDevice());
|
|
|
|
// Configure basic parameters.
|
|
configureParameters();
|
|
|
|
// Configure device mode.
|
|
switch (mParameters.mode) {
|
|
case Parameters::MODE_POINTER:
|
|
mSource = AINPUT_SOURCE_MOUSE;
|
|
mXPrecision = 1.0f;
|
|
mYPrecision = 1.0f;
|
|
mXScale = 1.0f;
|
|
mYScale = 1.0f;
|
|
mPointerController = getPolicy()->obtainPointerController(getDeviceId());
|
|
break;
|
|
case Parameters::MODE_NAVIGATION:
|
|
mSource = AINPUT_SOURCE_TRACKBALL;
|
|
mXPrecision = TRACKBALL_MOVEMENT_THRESHOLD;
|
|
mYPrecision = TRACKBALL_MOVEMENT_THRESHOLD;
|
|
mXScale = 1.0f / TRACKBALL_MOVEMENT_THRESHOLD;
|
|
mYScale = 1.0f / TRACKBALL_MOVEMENT_THRESHOLD;
|
|
break;
|
|
}
|
|
|
|
mVWheelScale = 1.0f;
|
|
mHWheelScale = 1.0f;
|
|
}
|
|
|
|
if (!changes || (changes & InputReaderConfiguration::CHANGE_POINTER_SPEED)) {
|
|
mPointerVelocityControl.setParameters(config->pointerVelocityControlParameters);
|
|
mWheelXVelocityControl.setParameters(config->wheelVelocityControlParameters);
|
|
mWheelYVelocityControl.setParameters(config->wheelVelocityControlParameters);
|
|
}
|
|
|
|
if (!changes || (changes & InputReaderConfiguration::CHANGE_DISPLAY_INFO)) {
|
|
if (mParameters.orientationAware && mParameters.hasAssociatedDisplay) {
|
|
DisplayViewport v;
|
|
if (config->getDisplayInfo(false /*external*/, &v)) {
|
|
mOrientation = v.orientation;
|
|
} else {
|
|
mOrientation = DISPLAY_ORIENTATION_0;
|
|
}
|
|
} else {
|
|
mOrientation = DISPLAY_ORIENTATION_0;
|
|
}
|
|
bumpGeneration();
|
|
}
|
|
}
|
|
|
|
void CursorInputMapper::configureParameters() {
|
|
mParameters.mode = Parameters::MODE_POINTER;
|
|
String8 cursorModeString;
|
|
if (getDevice()->getConfiguration().tryGetProperty(String8("cursor.mode"), cursorModeString)) {
|
|
if (cursorModeString == "navigation") {
|
|
mParameters.mode = Parameters::MODE_NAVIGATION;
|
|
} else if (cursorModeString != "pointer" && cursorModeString != "default") {
|
|
ALOGW("Invalid value for cursor.mode: '%s'", cursorModeString.string());
|
|
}
|
|
}
|
|
|
|
mParameters.orientationAware = false;
|
|
getDevice()->getConfiguration().tryGetProperty(String8("cursor.orientationAware"),
|
|
mParameters.orientationAware);
|
|
|
|
mParameters.hasAssociatedDisplay = false;
|
|
if (mParameters.mode == Parameters::MODE_POINTER || mParameters.orientationAware) {
|
|
mParameters.hasAssociatedDisplay = true;
|
|
}
|
|
}
|
|
|
|
void CursorInputMapper::dumpParameters(String8& dump) {
|
|
dump.append(INDENT3 "Parameters:\n");
|
|
dump.appendFormat(INDENT4 "HasAssociatedDisplay: %s\n",
|
|
toString(mParameters.hasAssociatedDisplay));
|
|
|
|
switch (mParameters.mode) {
|
|
case Parameters::MODE_POINTER:
|
|
dump.append(INDENT4 "Mode: pointer\n");
|
|
break;
|
|
case Parameters::MODE_NAVIGATION:
|
|
dump.append(INDENT4 "Mode: navigation\n");
|
|
break;
|
|
default:
|
|
ALOG_ASSERT(false);
|
|
}
|
|
|
|
dump.appendFormat(INDENT4 "OrientationAware: %s\n",
|
|
toString(mParameters.orientationAware));
|
|
}
|
|
|
|
void CursorInputMapper::reset(nsecs_t when) {
|
|
mButtonState = 0;
|
|
mDownTime = 0;
|
|
|
|
mPointerVelocityControl.reset();
|
|
mWheelXVelocityControl.reset();
|
|
mWheelYVelocityControl.reset();
|
|
|
|
mCursorButtonAccumulator.reset(getDevice());
|
|
mCursorMotionAccumulator.reset(getDevice());
|
|
mCursorScrollAccumulator.reset(getDevice());
|
|
|
|
InputMapper::reset(when);
|
|
}
|
|
|
|
void CursorInputMapper::process(const RawEvent* rawEvent) {
|
|
mCursorButtonAccumulator.process(rawEvent);
|
|
mCursorMotionAccumulator.process(rawEvent);
|
|
mCursorScrollAccumulator.process(rawEvent);
|
|
|
|
if (rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT) {
|
|
sync(rawEvent->when);
|
|
}
|
|
}
|
|
|
|
void CursorInputMapper::sync(nsecs_t when) {
|
|
int32_t lastButtonState = mButtonState;
|
|
int32_t currentButtonState = mCursorButtonAccumulator.getButtonState();
|
|
mButtonState = currentButtonState;
|
|
|
|
bool wasDown = isPointerDown(lastButtonState);
|
|
bool down = isPointerDown(currentButtonState);
|
|
bool downChanged;
|
|
if (!wasDown && down) {
|
|
mDownTime = when;
|
|
downChanged = true;
|
|
} else if (wasDown && !down) {
|
|
downChanged = true;
|
|
} else {
|
|
downChanged = false;
|
|
}
|
|
nsecs_t downTime = mDownTime;
|
|
bool buttonsChanged = currentButtonState != lastButtonState;
|
|
bool buttonsPressed = currentButtonState & ~lastButtonState;
|
|
|
|
float deltaX = mCursorMotionAccumulator.getRelativeX() * mXScale;
|
|
float deltaY = mCursorMotionAccumulator.getRelativeY() * mYScale;
|
|
bool moved = deltaX != 0 || deltaY != 0;
|
|
|
|
// Rotate delta according to orientation if needed.
|
|
if (mParameters.orientationAware && mParameters.hasAssociatedDisplay
|
|
&& (deltaX != 0.0f || deltaY != 0.0f)) {
|
|
rotateDelta(mOrientation, &deltaX, &deltaY);
|
|
}
|
|
|
|
// Move the pointer.
|
|
PointerProperties pointerProperties;
|
|
pointerProperties.clear();
|
|
pointerProperties.id = 0;
|
|
pointerProperties.toolType = AMOTION_EVENT_TOOL_TYPE_MOUSE;
|
|
|
|
PointerCoords pointerCoords;
|
|
pointerCoords.clear();
|
|
|
|
float vscroll = mCursorScrollAccumulator.getRelativeVWheel();
|
|
float hscroll = mCursorScrollAccumulator.getRelativeHWheel();
|
|
bool scrolled = vscroll != 0 || hscroll != 0;
|
|
|
|
mWheelYVelocityControl.move(when, NULL, &vscroll);
|
|
mWheelXVelocityControl.move(when, &hscroll, NULL);
|
|
|
|
mPointerVelocityControl.move(when, &deltaX, &deltaY);
|
|
|
|
int32_t displayId;
|
|
if (mPointerController != NULL) {
|
|
if (moved || scrolled || buttonsChanged) {
|
|
mPointerController->setPresentation(
|
|
PointerControllerInterface::PRESENTATION_POINTER);
|
|
|
|
if (moved) {
|
|
mPointerController->move(deltaX, deltaY);
|
|
}
|
|
|
|
if (buttonsChanged) {
|
|
mPointerController->setButtonState(currentButtonState);
|
|
}
|
|
|
|
mPointerController->unfade(PointerControllerInterface::TRANSITION_IMMEDIATE);
|
|
}
|
|
|
|
float x, y;
|
|
mPointerController->getPosition(&x, &y);
|
|
pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_X, x);
|
|
pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_Y, y);
|
|
displayId = ADISPLAY_ID_DEFAULT;
|
|
} else {
|
|
pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_X, deltaX);
|
|
pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_Y, deltaY);
|
|
displayId = ADISPLAY_ID_NONE;
|
|
}
|
|
|
|
pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, down ? 1.0f : 0.0f);
|
|
|
|
// Moving an external trackball or mouse should wake the device.
|
|
// We don't do this for internal cursor devices to prevent them from waking up
|
|
// the device in your pocket.
|
|
// TODO: Use the input device configuration to control this behavior more finely.
|
|
uint32_t policyFlags = 0;
|
|
if ((buttonsPressed || moved || scrolled) && getDevice()->isExternal()) {
|
|
policyFlags |= POLICY_FLAG_WAKE_DROPPED;
|
|
}
|
|
|
|
// Synthesize key down from buttons if needed.
|
|
synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_DOWN, when, getDeviceId(), mSource,
|
|
policyFlags, lastButtonState, currentButtonState);
|
|
|
|
// Send motion event.
|
|
if (downChanged || moved || scrolled || buttonsChanged) {
|
|
int32_t metaState = mContext->getGlobalMetaState();
|
|
int32_t motionEventAction;
|
|
if (downChanged) {
|
|
motionEventAction = down ? AMOTION_EVENT_ACTION_DOWN : AMOTION_EVENT_ACTION_UP;
|
|
} else if (down || mPointerController == NULL) {
|
|
motionEventAction = AMOTION_EVENT_ACTION_MOVE;
|
|
} else {
|
|
motionEventAction = AMOTION_EVENT_ACTION_HOVER_MOVE;
|
|
}
|
|
|
|
NotifyMotionArgs args(when, getDeviceId(), mSource, policyFlags,
|
|
motionEventAction, 0, metaState, currentButtonState, 0,
|
|
displayId, 1, &pointerProperties, &pointerCoords,
|
|
mXPrecision, mYPrecision, downTime);
|
|
getListener()->notifyMotion(&args);
|
|
|
|
// Send hover move after UP to tell the application that the mouse is hovering now.
|
|
if (motionEventAction == AMOTION_EVENT_ACTION_UP
|
|
&& mPointerController != NULL) {
|
|
NotifyMotionArgs hoverArgs(when, getDeviceId(), mSource, policyFlags,
|
|
AMOTION_EVENT_ACTION_HOVER_MOVE, 0,
|
|
metaState, currentButtonState, AMOTION_EVENT_EDGE_FLAG_NONE,
|
|
displayId, 1, &pointerProperties, &pointerCoords,
|
|
mXPrecision, mYPrecision, downTime);
|
|
getListener()->notifyMotion(&hoverArgs);
|
|
}
|
|
|
|
// Send scroll events.
|
|
if (scrolled) {
|
|
pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_VSCROLL, vscroll);
|
|
pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_HSCROLL, hscroll);
|
|
|
|
NotifyMotionArgs scrollArgs(when, getDeviceId(), mSource, policyFlags,
|
|
AMOTION_EVENT_ACTION_SCROLL, 0, metaState, currentButtonState,
|
|
AMOTION_EVENT_EDGE_FLAG_NONE,
|
|
displayId, 1, &pointerProperties, &pointerCoords,
|
|
mXPrecision, mYPrecision, downTime);
|
|
getListener()->notifyMotion(&scrollArgs);
|
|
}
|
|
}
|
|
|
|
// Synthesize key up from buttons if needed.
|
|
synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_UP, when, getDeviceId(), mSource,
|
|
policyFlags, lastButtonState, currentButtonState);
|
|
|
|
mCursorMotionAccumulator.finishSync();
|
|
mCursorScrollAccumulator.finishSync();
|
|
}
|
|
|
|
int32_t CursorInputMapper::getScanCodeState(uint32_t sourceMask, int32_t scanCode) {
|
|
if (scanCode >= BTN_MOUSE && scanCode < BTN_JOYSTICK) {
|
|
return getEventHub()->getScanCodeState(getDeviceId(), scanCode);
|
|
} else {
|
|
return AKEY_STATE_UNKNOWN;
|
|
}
|
|
}
|
|
|
|
void CursorInputMapper::fadePointer() {
|
|
if (mPointerController != NULL) {
|
|
mPointerController->fade(PointerControllerInterface::TRANSITION_GRADUAL);
|
|
}
|
|
}
|
|
|
|
|
|
// --- TouchInputMapper ---
|
|
|
|
TouchInputMapper::TouchInputMapper(InputDevice* device) :
|
|
InputMapper(device),
|
|
mSource(0), mDeviceMode(DEVICE_MODE_DISABLED),
|
|
mSurfaceWidth(-1), mSurfaceHeight(-1), mSurfaceLeft(0), mSurfaceTop(0),
|
|
mSurfaceOrientation(DISPLAY_ORIENTATION_0) {
|
|
}
|
|
|
|
TouchInputMapper::~TouchInputMapper() {
|
|
}
|
|
|
|
uint32_t TouchInputMapper::getSources() {
|
|
return mSource;
|
|
}
|
|
|
|
void TouchInputMapper::populateDeviceInfo(InputDeviceInfo* info) {
|
|
InputMapper::populateDeviceInfo(info);
|
|
|
|
if (mDeviceMode != DEVICE_MODE_DISABLED) {
|
|
info->addMotionRange(mOrientedRanges.x);
|
|
info->addMotionRange(mOrientedRanges.y);
|
|
info->addMotionRange(mOrientedRanges.pressure);
|
|
|
|
if (mOrientedRanges.haveSize) {
|
|
info->addMotionRange(mOrientedRanges.size);
|
|
}
|
|
|
|
if (mOrientedRanges.haveTouchSize) {
|
|
info->addMotionRange(mOrientedRanges.touchMajor);
|
|
info->addMotionRange(mOrientedRanges.touchMinor);
|
|
}
|
|
|
|
if (mOrientedRanges.haveToolSize) {
|
|
info->addMotionRange(mOrientedRanges.toolMajor);
|
|
info->addMotionRange(mOrientedRanges.toolMinor);
|
|
}
|
|
|
|
if (mOrientedRanges.haveOrientation) {
|
|
info->addMotionRange(mOrientedRanges.orientation);
|
|
}
|
|
|
|
if (mOrientedRanges.haveDistance) {
|
|
info->addMotionRange(mOrientedRanges.distance);
|
|
}
|
|
|
|
if (mOrientedRanges.haveTilt) {
|
|
info->addMotionRange(mOrientedRanges.tilt);
|
|
}
|
|
|
|
if (mCursorScrollAccumulator.haveRelativeVWheel()) {
|
|
info->addMotionRange(AMOTION_EVENT_AXIS_VSCROLL, mSource, -1.0f, 1.0f, 0.0f, 0.0f,
|
|
0.0f);
|
|
}
|
|
if (mCursorScrollAccumulator.haveRelativeHWheel()) {
|
|
info->addMotionRange(AMOTION_EVENT_AXIS_HSCROLL, mSource, -1.0f, 1.0f, 0.0f, 0.0f,
|
|
0.0f);
|
|
}
|
|
if (mCalibration.coverageCalibration == Calibration::COVERAGE_CALIBRATION_BOX) {
|
|
const InputDeviceInfo::MotionRange& x = mOrientedRanges.x;
|
|
const InputDeviceInfo::MotionRange& y = mOrientedRanges.y;
|
|
info->addMotionRange(AMOTION_EVENT_AXIS_GENERIC_1, mSource, x.min, x.max, x.flat,
|
|
x.fuzz, x.resolution);
|
|
info->addMotionRange(AMOTION_EVENT_AXIS_GENERIC_2, mSource, y.min, y.max, y.flat,
|
|
y.fuzz, y.resolution);
|
|
info->addMotionRange(AMOTION_EVENT_AXIS_GENERIC_3, mSource, x.min, x.max, x.flat,
|
|
x.fuzz, x.resolution);
|
|
info->addMotionRange(AMOTION_EVENT_AXIS_GENERIC_4, mSource, y.min, y.max, y.flat,
|
|
y.fuzz, y.resolution);
|
|
}
|
|
info->setButtonUnderPad(mParameters.hasButtonUnderPad);
|
|
}
|
|
}
|
|
|
|
void TouchInputMapper::dump(String8& dump) {
|
|
dump.append(INDENT2 "Touch Input Mapper:\n");
|
|
dumpParameters(dump);
|
|
dumpVirtualKeys(dump);
|
|
dumpRawPointerAxes(dump);
|
|
dumpCalibration(dump);
|
|
dumpSurface(dump);
|
|
|
|
dump.appendFormat(INDENT3 "Translation and Scaling Factors:\n");
|
|
dump.appendFormat(INDENT4 "XTranslate: %0.3f\n", mXTranslate);
|
|
dump.appendFormat(INDENT4 "YTranslate: %0.3f\n", mYTranslate);
|
|
dump.appendFormat(INDENT4 "XScale: %0.3f\n", mXScale);
|
|
dump.appendFormat(INDENT4 "YScale: %0.3f\n", mYScale);
|
|
dump.appendFormat(INDENT4 "XPrecision: %0.3f\n", mXPrecision);
|
|
dump.appendFormat(INDENT4 "YPrecision: %0.3f\n", mYPrecision);
|
|
dump.appendFormat(INDENT4 "GeometricScale: %0.3f\n", mGeometricScale);
|
|
dump.appendFormat(INDENT4 "PressureScale: %0.3f\n", mPressureScale);
|
|
dump.appendFormat(INDENT4 "SizeScale: %0.3f\n", mSizeScale);
|
|
dump.appendFormat(INDENT4 "OrientationScale: %0.3f\n", mOrientationScale);
|
|
dump.appendFormat(INDENT4 "DistanceScale: %0.3f\n", mDistanceScale);
|
|
dump.appendFormat(INDENT4 "HaveTilt: %s\n", toString(mHaveTilt));
|
|
dump.appendFormat(INDENT4 "TiltXCenter: %0.3f\n", mTiltXCenter);
|
|
dump.appendFormat(INDENT4 "TiltXScale: %0.3f\n", mTiltXScale);
|
|
dump.appendFormat(INDENT4 "TiltYCenter: %0.3f\n", mTiltYCenter);
|
|
dump.appendFormat(INDENT4 "TiltYScale: %0.3f\n", mTiltYScale);
|
|
|
|
dump.appendFormat(INDENT3 "Last Button State: 0x%08x\n", mLastButtonState);
|
|
|
|
dump.appendFormat(INDENT3 "Last Raw Touch: pointerCount=%d\n",
|
|
mLastRawPointerData.pointerCount);
|
|
for (uint32_t i = 0; i < mLastRawPointerData.pointerCount; i++) {
|
|
const RawPointerData::Pointer& pointer = mLastRawPointerData.pointers[i];
|
|
dump.appendFormat(INDENT4 "[%d]: id=%d, x=%d, y=%d, pressure=%d, "
|
|
"touchMajor=%d, touchMinor=%d, toolMajor=%d, toolMinor=%d, "
|
|
"orientation=%d, tiltX=%d, tiltY=%d, distance=%d, "
|
|
"toolType=%d, isHovering=%s\n", i,
|
|
pointer.id, pointer.x, pointer.y, pointer.pressure,
|
|
pointer.touchMajor, pointer.touchMinor,
|
|
pointer.toolMajor, pointer.toolMinor,
|
|
pointer.orientation, pointer.tiltX, pointer.tiltY, pointer.distance,
|
|
pointer.toolType, toString(pointer.isHovering));
|
|
}
|
|
|
|
dump.appendFormat(INDENT3 "Last Cooked Touch: pointerCount=%d\n",
|
|
mLastCookedPointerData.pointerCount);
|
|
for (uint32_t i = 0; i < mLastCookedPointerData.pointerCount; i++) {
|
|
const PointerProperties& pointerProperties = mLastCookedPointerData.pointerProperties[i];
|
|
const PointerCoords& pointerCoords = mLastCookedPointerData.pointerCoords[i];
|
|
dump.appendFormat(INDENT4 "[%d]: id=%d, x=%0.3f, y=%0.3f, pressure=%0.3f, "
|
|
"touchMajor=%0.3f, touchMinor=%0.3f, toolMajor=%0.3f, toolMinor=%0.3f, "
|
|
"orientation=%0.3f, tilt=%0.3f, distance=%0.3f, "
|
|
"toolType=%d, isHovering=%s\n", i,
|
|
pointerProperties.id,
|
|
pointerCoords.getX(),
|
|
pointerCoords.getY(),
|
|
pointerCoords.getAxisValue(AMOTION_EVENT_AXIS_PRESSURE),
|
|
pointerCoords.getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR),
|
|
pointerCoords.getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR),
|
|
pointerCoords.getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR),
|
|
pointerCoords.getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR),
|
|
pointerCoords.getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION),
|
|
pointerCoords.getAxisValue(AMOTION_EVENT_AXIS_TILT),
|
|
pointerCoords.getAxisValue(AMOTION_EVENT_AXIS_DISTANCE),
|
|
pointerProperties.toolType,
|
|
toString(mLastCookedPointerData.isHovering(i)));
|
|
}
|
|
|
|
if (mDeviceMode == DEVICE_MODE_POINTER) {
|
|
dump.appendFormat(INDENT3 "Pointer Gesture Detector:\n");
|
|
dump.appendFormat(INDENT4 "XMovementScale: %0.3f\n",
|
|
mPointerXMovementScale);
|
|
dump.appendFormat(INDENT4 "YMovementScale: %0.3f\n",
|
|
mPointerYMovementScale);
|
|
dump.appendFormat(INDENT4 "XZoomScale: %0.3f\n",
|
|
mPointerXZoomScale);
|
|
dump.appendFormat(INDENT4 "YZoomScale: %0.3f\n",
|
|
mPointerYZoomScale);
|
|
dump.appendFormat(INDENT4 "MaxSwipeWidth: %f\n",
|
|
mPointerGestureMaxSwipeWidth);
|
|
}
|
|
}
|
|
|
|
void TouchInputMapper::configure(nsecs_t when,
|
|
const InputReaderConfiguration* config, uint32_t changes) {
|
|
InputMapper::configure(when, config, changes);
|
|
|
|
mConfig = *config;
|
|
|
|
if (!changes) { // first time only
|
|
// Configure basic parameters.
|
|
configureParameters();
|
|
|
|
// Configure common accumulators.
|
|
mCursorScrollAccumulator.configure(getDevice());
|
|
mTouchButtonAccumulator.configure(getDevice());
|
|
|
|
// Configure absolute axis information.
|
|
configureRawPointerAxes();
|
|
|
|
// Prepare input device calibration.
|
|
parseCalibration();
|
|
resolveCalibration();
|
|
}
|
|
|
|
if (!changes || (changes & InputReaderConfiguration::CHANGE_POINTER_SPEED)) {
|
|
// Update pointer speed.
|
|
mPointerVelocityControl.setParameters(mConfig.pointerVelocityControlParameters);
|
|
mWheelXVelocityControl.setParameters(mConfig.wheelVelocityControlParameters);
|
|
mWheelYVelocityControl.setParameters(mConfig.wheelVelocityControlParameters);
|
|
}
|
|
|
|
bool resetNeeded = false;
|
|
if (!changes || (changes & (InputReaderConfiguration::CHANGE_DISPLAY_INFO
|
|
| InputReaderConfiguration::CHANGE_POINTER_GESTURE_ENABLEMENT
|
|
| InputReaderConfiguration::CHANGE_SHOW_TOUCHES))) {
|
|
// Configure device sources, surface dimensions, orientation and
|
|
// scaling factors.
|
|
configureSurface(when, &resetNeeded);
|
|
}
|
|
|
|
if (changes && resetNeeded) {
|
|
// Send reset, unless this is the first time the device has been configured,
|
|
// in which case the reader will call reset itself after all mappers are ready.
|
|
getDevice()->notifyReset(when);
|
|
}
|
|
}
|
|
|
|
void TouchInputMapper::configureParameters() {
|
|
// Use the pointer presentation mode for devices that do not support distinct
|
|
// multitouch. The spot-based presentation relies on being able to accurately
|
|
// locate two or more fingers on the touch pad.
|
|
mParameters.gestureMode = getEventHub()->hasInputProperty(getDeviceId(), INPUT_PROP_SEMI_MT)
|
|
? Parameters::GESTURE_MODE_POINTER : Parameters::GESTURE_MODE_SPOTS;
|
|
|
|
String8 gestureModeString;
|
|
if (getDevice()->getConfiguration().tryGetProperty(String8("touch.gestureMode"),
|
|
gestureModeString)) {
|
|
if (gestureModeString == "pointer") {
|
|
mParameters.gestureMode = Parameters::GESTURE_MODE_POINTER;
|
|
} else if (gestureModeString == "spots") {
|
|
mParameters.gestureMode = Parameters::GESTURE_MODE_SPOTS;
|
|
} else if (gestureModeString != "default") {
|
|
ALOGW("Invalid value for touch.gestureMode: '%s'", gestureModeString.string());
|
|
}
|
|
}
|
|
|
|
if (getEventHub()->hasInputProperty(getDeviceId(), INPUT_PROP_DIRECT)) {
|
|
// The device is a touch screen.
|
|
mParameters.deviceType = Parameters::DEVICE_TYPE_TOUCH_SCREEN;
|
|
} else if (getEventHub()->hasInputProperty(getDeviceId(), INPUT_PROP_POINTER)) {
|
|
// The device is a pointing device like a track pad.
|
|
mParameters.deviceType = Parameters::DEVICE_TYPE_POINTER;
|
|
} else if (getEventHub()->hasRelativeAxis(getDeviceId(), REL_X)
|
|
|| getEventHub()->hasRelativeAxis(getDeviceId(), REL_Y)) {
|
|
// The device is a cursor device with a touch pad attached.
|
|
// By default don't use the touch pad to move the pointer.
|
|
mParameters.deviceType = Parameters::DEVICE_TYPE_TOUCH_PAD;
|
|
} else {
|
|
// The device is a touch pad of unknown purpose.
|
|
mParameters.deviceType = Parameters::DEVICE_TYPE_POINTER;
|
|
}
|
|
|
|
mParameters.hasButtonUnderPad=
|
|
getEventHub()->hasInputProperty(getDeviceId(), INPUT_PROP_BUTTONPAD);
|
|
|
|
String8 deviceTypeString;
|
|
if (getDevice()->getConfiguration().tryGetProperty(String8("touch.deviceType"),
|
|
deviceTypeString)) {
|
|
if (deviceTypeString == "touchScreen") {
|
|
mParameters.deviceType = Parameters::DEVICE_TYPE_TOUCH_SCREEN;
|
|
} else if (deviceTypeString == "touchPad") {
|
|
mParameters.deviceType = Parameters::DEVICE_TYPE_TOUCH_PAD;
|
|
} else if (deviceTypeString == "touchNavigation") {
|
|
mParameters.deviceType = Parameters::DEVICE_TYPE_TOUCH_NAVIGATION;
|
|
} else if (deviceTypeString == "pointer") {
|
|
mParameters.deviceType = Parameters::DEVICE_TYPE_POINTER;
|
|
} else if (deviceTypeString != "default") {
|
|
ALOGW("Invalid value for touch.deviceType: '%s'", deviceTypeString.string());
|
|
}
|
|
}
|
|
|
|
mParameters.orientationAware = mParameters.deviceType == Parameters::DEVICE_TYPE_TOUCH_SCREEN;
|
|
getDevice()->getConfiguration().tryGetProperty(String8("touch.orientationAware"),
|
|
mParameters.orientationAware);
|
|
|
|
mParameters.hasAssociatedDisplay = false;
|
|
mParameters.associatedDisplayIsExternal = false;
|
|
if (mParameters.orientationAware
|
|
|| mParameters.deviceType == Parameters::DEVICE_TYPE_TOUCH_SCREEN
|
|
|| mParameters.deviceType == Parameters::DEVICE_TYPE_POINTER) {
|
|
mParameters.hasAssociatedDisplay = true;
|
|
mParameters.associatedDisplayIsExternal =
|
|
mParameters.deviceType == Parameters::DEVICE_TYPE_TOUCH_SCREEN
|
|
&& getDevice()->isExternal();
|
|
}
|
|
}
|
|
|
|
void TouchInputMapper::dumpParameters(String8& dump) {
|
|
dump.append(INDENT3 "Parameters:\n");
|
|
|
|
switch (mParameters.gestureMode) {
|
|
case Parameters::GESTURE_MODE_POINTER:
|
|
dump.append(INDENT4 "GestureMode: pointer\n");
|
|
break;
|
|
case Parameters::GESTURE_MODE_SPOTS:
|
|
dump.append(INDENT4 "GestureMode: spots\n");
|
|
break;
|
|
default:
|
|
assert(false);
|
|
}
|
|
|
|
switch (mParameters.deviceType) {
|
|
case Parameters::DEVICE_TYPE_TOUCH_SCREEN:
|
|
dump.append(INDENT4 "DeviceType: touchScreen\n");
|
|
break;
|
|
case Parameters::DEVICE_TYPE_TOUCH_PAD:
|
|
dump.append(INDENT4 "DeviceType: touchPad\n");
|
|
break;
|
|
case Parameters::DEVICE_TYPE_TOUCH_NAVIGATION:
|
|
dump.append(INDENT4 "DeviceType: touchNavigation\n");
|
|
break;
|
|
case Parameters::DEVICE_TYPE_POINTER:
|
|
dump.append(INDENT4 "DeviceType: pointer\n");
|
|
break;
|
|
default:
|
|
ALOG_ASSERT(false);
|
|
}
|
|
|
|
dump.appendFormat(INDENT4 "AssociatedDisplay: hasAssociatedDisplay=%s, isExternal=%s\n",
|
|
toString(mParameters.hasAssociatedDisplay),
|
|
toString(mParameters.associatedDisplayIsExternal));
|
|
dump.appendFormat(INDENT4 "OrientationAware: %s\n",
|
|
toString(mParameters.orientationAware));
|
|
}
|
|
|
|
void TouchInputMapper::configureRawPointerAxes() {
|
|
mRawPointerAxes.clear();
|
|
}
|
|
|
|
void TouchInputMapper::dumpRawPointerAxes(String8& dump) {
|
|
dump.append(INDENT3 "Raw Touch Axes:\n");
|
|
dumpRawAbsoluteAxisInfo(dump, mRawPointerAxes.x, "X");
|
|
dumpRawAbsoluteAxisInfo(dump, mRawPointerAxes.y, "Y");
|
|
dumpRawAbsoluteAxisInfo(dump, mRawPointerAxes.pressure, "Pressure");
|
|
dumpRawAbsoluteAxisInfo(dump, mRawPointerAxes.touchMajor, "TouchMajor");
|
|
dumpRawAbsoluteAxisInfo(dump, mRawPointerAxes.touchMinor, "TouchMinor");
|
|
dumpRawAbsoluteAxisInfo(dump, mRawPointerAxes.toolMajor, "ToolMajor");
|
|
dumpRawAbsoluteAxisInfo(dump, mRawPointerAxes.toolMinor, "ToolMinor");
|
|
dumpRawAbsoluteAxisInfo(dump, mRawPointerAxes.orientation, "Orientation");
|
|
dumpRawAbsoluteAxisInfo(dump, mRawPointerAxes.distance, "Distance");
|
|
dumpRawAbsoluteAxisInfo(dump, mRawPointerAxes.tiltX, "TiltX");
|
|
dumpRawAbsoluteAxisInfo(dump, mRawPointerAxes.tiltY, "TiltY");
|
|
dumpRawAbsoluteAxisInfo(dump, mRawPointerAxes.trackingId, "TrackingId");
|
|
dumpRawAbsoluteAxisInfo(dump, mRawPointerAxes.slot, "Slot");
|
|
}
|
|
|
|
void TouchInputMapper::configureSurface(nsecs_t when, bool* outResetNeeded) {
|
|
int32_t oldDeviceMode = mDeviceMode;
|
|
|
|
// Determine device mode.
|
|
if (mParameters.deviceType == Parameters::DEVICE_TYPE_POINTER
|
|
&& mConfig.pointerGesturesEnabled) {
|
|
mSource = AINPUT_SOURCE_MOUSE;
|
|
mDeviceMode = DEVICE_MODE_POINTER;
|
|
if (hasStylus()) {
|
|
mSource |= AINPUT_SOURCE_STYLUS;
|
|
}
|
|
} else if (mParameters.deviceType == Parameters::DEVICE_TYPE_TOUCH_SCREEN
|
|
&& mParameters.hasAssociatedDisplay) {
|
|
mSource = AINPUT_SOURCE_TOUCHSCREEN;
|
|
mDeviceMode = DEVICE_MODE_DIRECT;
|
|
if (hasStylus()) {
|
|
mSource |= AINPUT_SOURCE_STYLUS;
|
|
}
|
|
} else if (mParameters.deviceType == Parameters::DEVICE_TYPE_TOUCH_NAVIGATION) {
|
|
mSource = AINPUT_SOURCE_TOUCH_NAVIGATION;
|
|
mDeviceMode = DEVICE_MODE_NAVIGATION;
|
|
} else {
|
|
mSource = AINPUT_SOURCE_TOUCHPAD;
|
|
mDeviceMode = DEVICE_MODE_UNSCALED;
|
|
}
|
|
|
|
// Ensure we have valid X and Y axes.
|
|
if (!mRawPointerAxes.x.valid || !mRawPointerAxes.y.valid) {
|
|
ALOGW(INDENT "Touch device '%s' did not report support for X or Y axis! "
|
|
"The device will be inoperable.", getDeviceName().string());
|
|
mDeviceMode = DEVICE_MODE_DISABLED;
|
|
return;
|
|
}
|
|
|
|
// Raw width and height in the natural orientation.
|
|
int32_t rawWidth = mRawPointerAxes.x.maxValue - mRawPointerAxes.x.minValue + 1;
|
|
int32_t rawHeight = mRawPointerAxes.y.maxValue - mRawPointerAxes.y.minValue + 1;
|
|
|
|
// Get associated display dimensions.
|
|
DisplayViewport newViewport;
|
|
if (mParameters.hasAssociatedDisplay) {
|
|
if (!mConfig.getDisplayInfo(mParameters.associatedDisplayIsExternal, &newViewport)) {
|
|
ALOGI(INDENT "Touch device '%s' could not query the properties of its associated "
|
|
"display. The device will be inoperable until the display size "
|
|
"becomes available.",
|
|
getDeviceName().string());
|
|
mDeviceMode = DEVICE_MODE_DISABLED;
|
|
return;
|
|
}
|
|
} else {
|
|
newViewport.setNonDisplayViewport(rawWidth, rawHeight);
|
|
}
|
|
bool viewportChanged = mViewport != newViewport;
|
|
if (viewportChanged) {
|
|
mViewport = newViewport;
|
|
|
|
if (mDeviceMode == DEVICE_MODE_DIRECT || mDeviceMode == DEVICE_MODE_POINTER) {
|
|
// Convert rotated viewport to natural surface coordinates.
|
|
int32_t naturalLogicalWidth, naturalLogicalHeight;
|
|
int32_t naturalPhysicalWidth, naturalPhysicalHeight;
|
|
int32_t naturalPhysicalLeft, naturalPhysicalTop;
|
|
int32_t naturalDeviceWidth, naturalDeviceHeight;
|
|
switch (mViewport.orientation) {
|
|
case DISPLAY_ORIENTATION_90:
|
|
naturalLogicalWidth = mViewport.logicalBottom - mViewport.logicalTop;
|
|
naturalLogicalHeight = mViewport.logicalRight - mViewport.logicalLeft;
|
|
naturalPhysicalWidth = mViewport.physicalBottom - mViewport.physicalTop;
|
|
naturalPhysicalHeight = mViewport.physicalRight - mViewport.physicalLeft;
|
|
naturalPhysicalLeft = mViewport.deviceHeight - mViewport.physicalBottom;
|
|
naturalPhysicalTop = mViewport.physicalLeft;
|
|
naturalDeviceWidth = mViewport.deviceHeight;
|
|
naturalDeviceHeight = mViewport.deviceWidth;
|
|
break;
|
|
case DISPLAY_ORIENTATION_180:
|
|
naturalLogicalWidth = mViewport.logicalRight - mViewport.logicalLeft;
|
|
naturalLogicalHeight = mViewport.logicalBottom - mViewport.logicalTop;
|
|
naturalPhysicalWidth = mViewport.physicalRight - mViewport.physicalLeft;
|
|
naturalPhysicalHeight = mViewport.physicalBottom - mViewport.physicalTop;
|
|
naturalPhysicalLeft = mViewport.deviceWidth - mViewport.physicalRight;
|
|
naturalPhysicalTop = mViewport.deviceHeight - mViewport.physicalBottom;
|
|
naturalDeviceWidth = mViewport.deviceWidth;
|
|
naturalDeviceHeight = mViewport.deviceHeight;
|
|
break;
|
|
case DISPLAY_ORIENTATION_270:
|
|
naturalLogicalWidth = mViewport.logicalBottom - mViewport.logicalTop;
|
|
naturalLogicalHeight = mViewport.logicalRight - mViewport.logicalLeft;
|
|
naturalPhysicalWidth = mViewport.physicalBottom - mViewport.physicalTop;
|
|
naturalPhysicalHeight = mViewport.physicalRight - mViewport.physicalLeft;
|
|
naturalPhysicalLeft = mViewport.physicalTop;
|
|
naturalPhysicalTop = mViewport.deviceWidth - mViewport.physicalRight;
|
|
naturalDeviceWidth = mViewport.deviceHeight;
|
|
naturalDeviceHeight = mViewport.deviceWidth;
|
|
break;
|
|
case DISPLAY_ORIENTATION_0:
|
|
default:
|
|
naturalLogicalWidth = mViewport.logicalRight - mViewport.logicalLeft;
|
|
naturalLogicalHeight = mViewport.logicalBottom - mViewport.logicalTop;
|
|
naturalPhysicalWidth = mViewport.physicalRight - mViewport.physicalLeft;
|
|
naturalPhysicalHeight = mViewport.physicalBottom - mViewport.physicalTop;
|
|
naturalPhysicalLeft = mViewport.physicalLeft;
|
|
naturalPhysicalTop = mViewport.physicalTop;
|
|
naturalDeviceWidth = mViewport.deviceWidth;
|
|
naturalDeviceHeight = mViewport.deviceHeight;
|
|
break;
|
|
}
|
|
|
|
mSurfaceWidth = naturalLogicalWidth * naturalDeviceWidth / naturalPhysicalWidth;
|
|
mSurfaceHeight = naturalLogicalHeight * naturalDeviceHeight / naturalPhysicalHeight;
|
|
mSurfaceLeft = naturalPhysicalLeft * naturalLogicalWidth / naturalPhysicalWidth;
|
|
mSurfaceTop = naturalPhysicalTop * naturalLogicalHeight / naturalPhysicalHeight;
|
|
|
|
mSurfaceOrientation = mParameters.orientationAware ?
|
|
mViewport.orientation : DISPLAY_ORIENTATION_0;
|
|
} else {
|
|
mSurfaceWidth = rawWidth;
|
|
mSurfaceHeight = rawHeight;
|
|
mSurfaceLeft = 0;
|
|
mSurfaceTop = 0;
|
|
mSurfaceOrientation = DISPLAY_ORIENTATION_0;
|
|
}
|
|
}
|
|
|
|
// If moving between pointer modes, need to reset some state.
|
|
bool deviceModeChanged = mDeviceMode != oldDeviceMode;
|
|
if (deviceModeChanged) {
|
|
mOrientedRanges.clear();
|
|
}
|
|
|
|
// Create pointer controller if needed.
|
|
if (mDeviceMode == DEVICE_MODE_POINTER ||
|
|
(mDeviceMode == DEVICE_MODE_DIRECT && mConfig.showTouches)) {
|
|
if (mPointerController == NULL) {
|
|
mPointerController = getPolicy()->obtainPointerController(getDeviceId());
|
|
}
|
|
} else {
|
|
mPointerController.clear();
|
|
}
|
|
|
|
if (viewportChanged || deviceModeChanged) {
|
|
ALOGI("Device reconfigured: id=%d, name='%s', size %dx%d, orientation %d, mode %d, "
|
|
"display id %d",
|
|
getDeviceId(), getDeviceName().string(), mSurfaceWidth, mSurfaceHeight,
|
|
mSurfaceOrientation, mDeviceMode, mViewport.displayId);
|
|
|
|
// Configure X and Y factors.
|
|
mXScale = float(mSurfaceWidth) / rawWidth;
|
|
mYScale = float(mSurfaceHeight) / rawHeight;
|
|
mXTranslate = -mSurfaceLeft;
|
|
mYTranslate = -mSurfaceTop;
|
|
mXPrecision = 1.0f / mXScale;
|
|
mYPrecision = 1.0f / mYScale;
|
|
|
|
mOrientedRanges.x.axis = AMOTION_EVENT_AXIS_X;
|
|
mOrientedRanges.x.source = mSource;
|
|
mOrientedRanges.y.axis = AMOTION_EVENT_AXIS_Y;
|
|
mOrientedRanges.y.source = mSource;
|
|
|
|
configureVirtualKeys();
|
|
|
|
// Scale factor for terms that are not oriented in a particular axis.
|
|
// If the pixels are square then xScale == yScale otherwise we fake it
|
|
// by choosing an average.
|
|
mGeometricScale = avg(mXScale, mYScale);
|
|
|
|
// Size of diagonal axis.
|
|
float diagonalSize = hypotf(mSurfaceWidth, mSurfaceHeight);
|
|
|
|
// Size factors.
|
|
if (mCalibration.sizeCalibration != Calibration::SIZE_CALIBRATION_NONE) {
|
|
if (mRawPointerAxes.touchMajor.valid
|
|
&& mRawPointerAxes.touchMajor.maxValue != 0) {
|
|
mSizeScale = 1.0f / mRawPointerAxes.touchMajor.maxValue;
|
|
} else if (mRawPointerAxes.toolMajor.valid
|
|
&& mRawPointerAxes.toolMajor.maxValue != 0) {
|
|
mSizeScale = 1.0f / mRawPointerAxes.toolMajor.maxValue;
|
|
} else {
|
|
mSizeScale = 0.0f;
|
|
}
|
|
|
|
mOrientedRanges.haveTouchSize = true;
|
|
mOrientedRanges.haveToolSize = true;
|
|
mOrientedRanges.haveSize = true;
|
|
|
|
mOrientedRanges.touchMajor.axis = AMOTION_EVENT_AXIS_TOUCH_MAJOR;
|
|
mOrientedRanges.touchMajor.source = mSource;
|
|
mOrientedRanges.touchMajor.min = 0;
|
|
mOrientedRanges.touchMajor.max = diagonalSize;
|
|
mOrientedRanges.touchMajor.flat = 0;
|
|
mOrientedRanges.touchMajor.fuzz = 0;
|
|
mOrientedRanges.touchMajor.resolution = 0;
|
|
|
|
mOrientedRanges.touchMinor = mOrientedRanges.touchMajor;
|
|
mOrientedRanges.touchMinor.axis = AMOTION_EVENT_AXIS_TOUCH_MINOR;
|
|
|
|
mOrientedRanges.toolMajor.axis = AMOTION_EVENT_AXIS_TOOL_MAJOR;
|
|
mOrientedRanges.toolMajor.source = mSource;
|
|
mOrientedRanges.toolMajor.min = 0;
|
|
mOrientedRanges.toolMajor.max = diagonalSize;
|
|
mOrientedRanges.toolMajor.flat = 0;
|
|
mOrientedRanges.toolMajor.fuzz = 0;
|
|
mOrientedRanges.toolMajor.resolution = 0;
|
|
|
|
mOrientedRanges.toolMinor = mOrientedRanges.toolMajor;
|
|
mOrientedRanges.toolMinor.axis = AMOTION_EVENT_AXIS_TOOL_MINOR;
|
|
|
|
mOrientedRanges.size.axis = AMOTION_EVENT_AXIS_SIZE;
|
|
mOrientedRanges.size.source = mSource;
|
|
mOrientedRanges.size.min = 0;
|
|
mOrientedRanges.size.max = 1.0;
|
|
mOrientedRanges.size.flat = 0;
|
|
mOrientedRanges.size.fuzz = 0;
|
|
mOrientedRanges.size.resolution = 0;
|
|
} else {
|
|
mSizeScale = 0.0f;
|
|
}
|
|
|
|
// Pressure factors.
|
|
mPressureScale = 0;
|
|
if (mCalibration.pressureCalibration == Calibration::PRESSURE_CALIBRATION_PHYSICAL
|
|
|| mCalibration.pressureCalibration
|
|
== Calibration::PRESSURE_CALIBRATION_AMPLITUDE) {
|
|
if (mCalibration.havePressureScale) {
|
|
mPressureScale = mCalibration.pressureScale;
|
|
} else if (mRawPointerAxes.pressure.valid
|
|
&& mRawPointerAxes.pressure.maxValue != 0) {
|
|
mPressureScale = 1.0f / mRawPointerAxes.pressure.maxValue;
|
|
}
|
|
}
|
|
|
|
mOrientedRanges.pressure.axis = AMOTION_EVENT_AXIS_PRESSURE;
|
|
mOrientedRanges.pressure.source = mSource;
|
|
mOrientedRanges.pressure.min = 0;
|
|
mOrientedRanges.pressure.max = 1.0;
|
|
mOrientedRanges.pressure.flat = 0;
|
|
mOrientedRanges.pressure.fuzz = 0;
|
|
mOrientedRanges.pressure.resolution = 0;
|
|
|
|
// Tilt
|
|
mTiltXCenter = 0;
|
|
mTiltXScale = 0;
|
|
mTiltYCenter = 0;
|
|
mTiltYScale = 0;
|
|
mHaveTilt = mRawPointerAxes.tiltX.valid && mRawPointerAxes.tiltY.valid;
|
|
if (mHaveTilt) {
|
|
mTiltXCenter = avg(mRawPointerAxes.tiltX.minValue,
|
|
mRawPointerAxes.tiltX.maxValue);
|
|
mTiltYCenter = avg(mRawPointerAxes.tiltY.minValue,
|
|
mRawPointerAxes.tiltY.maxValue);
|
|
mTiltXScale = M_PI / 180;
|
|
mTiltYScale = M_PI / 180;
|
|
|
|
mOrientedRanges.haveTilt = true;
|
|
|
|
mOrientedRanges.tilt.axis = AMOTION_EVENT_AXIS_TILT;
|
|
mOrientedRanges.tilt.source = mSource;
|
|
mOrientedRanges.tilt.min = 0;
|
|
mOrientedRanges.tilt.max = M_PI_2;
|
|
mOrientedRanges.tilt.flat = 0;
|
|
mOrientedRanges.tilt.fuzz = 0;
|
|
mOrientedRanges.tilt.resolution = 0;
|
|
}
|
|
|
|
// Orientation
|
|
mOrientationScale = 0;
|
|
if (mHaveTilt) {
|
|
mOrientedRanges.haveOrientation = true;
|
|
|
|
mOrientedRanges.orientation.axis = AMOTION_EVENT_AXIS_ORIENTATION;
|
|
mOrientedRanges.orientation.source = mSource;
|
|
mOrientedRanges.orientation.min = -M_PI;
|
|
mOrientedRanges.orientation.max = M_PI;
|
|
mOrientedRanges.orientation.flat = 0;
|
|
mOrientedRanges.orientation.fuzz = 0;
|
|
mOrientedRanges.orientation.resolution = 0;
|
|
} else if (mCalibration.orientationCalibration !=
|
|
Calibration::ORIENTATION_CALIBRATION_NONE) {
|
|
if (mCalibration.orientationCalibration
|
|
== Calibration::ORIENTATION_CALIBRATION_INTERPOLATED) {
|
|
if (mRawPointerAxes.orientation.valid) {
|
|
if (mRawPointerAxes.orientation.maxValue > 0) {
|
|
mOrientationScale = M_PI_2 / mRawPointerAxes.orientation.maxValue;
|
|
} else if (mRawPointerAxes.orientation.minValue < 0) {
|
|
mOrientationScale = -M_PI_2 / mRawPointerAxes.orientation.minValue;
|
|
} else {
|
|
mOrientationScale = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
mOrientedRanges.haveOrientation = true;
|
|
|
|
mOrientedRanges.orientation.axis = AMOTION_EVENT_AXIS_ORIENTATION;
|
|
mOrientedRanges.orientation.source = mSource;
|
|
mOrientedRanges.orientation.min = -M_PI_2;
|
|
mOrientedRanges.orientation.max = M_PI_2;
|
|
mOrientedRanges.orientation.flat = 0;
|
|
mOrientedRanges.orientation.fuzz = 0;
|
|
mOrientedRanges.orientation.resolution = 0;
|
|
}
|
|
|
|
// Distance
|
|
mDistanceScale = 0;
|
|
if (mCalibration.distanceCalibration != Calibration::DISTANCE_CALIBRATION_NONE) {
|
|
if (mCalibration.distanceCalibration
|
|
== Calibration::DISTANCE_CALIBRATION_SCALED) {
|
|
if (mCalibration.haveDistanceScale) {
|
|
mDistanceScale = mCalibration.distanceScale;
|
|
} else {
|
|
mDistanceScale = 1.0f;
|
|
}
|
|
}
|
|
|
|
mOrientedRanges.haveDistance = true;
|
|
|
|
mOrientedRanges.distance.axis = AMOTION_EVENT_AXIS_DISTANCE;
|
|
mOrientedRanges.distance.source = mSource;
|
|
mOrientedRanges.distance.min =
|
|
mRawPointerAxes.distance.minValue * mDistanceScale;
|
|
mOrientedRanges.distance.max =
|
|
mRawPointerAxes.distance.maxValue * mDistanceScale;
|
|
mOrientedRanges.distance.flat = 0;
|
|
mOrientedRanges.distance.fuzz =
|
|
mRawPointerAxes.distance.fuzz * mDistanceScale;
|
|
mOrientedRanges.distance.resolution = 0;
|
|
}
|
|
|
|
// Compute oriented precision, scales and ranges.
|
|
// Note that the maximum value reported is an inclusive maximum value so it is one
|
|
// unit less than the total width or height of surface.
|
|
switch (mSurfaceOrientation) {
|
|
case DISPLAY_ORIENTATION_90:
|
|
case DISPLAY_ORIENTATION_270:
|
|
mOrientedXPrecision = mYPrecision;
|
|
mOrientedYPrecision = mXPrecision;
|
|
|
|
mOrientedRanges.x.min = mYTranslate;
|
|
mOrientedRanges.x.max = mSurfaceHeight + mYTranslate - 1;
|
|
mOrientedRanges.x.flat = 0;
|
|
mOrientedRanges.x.fuzz = 0;
|
|
mOrientedRanges.x.resolution = mRawPointerAxes.y.resolution * mYScale;
|
|
|
|
mOrientedRanges.y.min = mXTranslate;
|
|
mOrientedRanges.y.max = mSurfaceWidth + mXTranslate - 1;
|
|
mOrientedRanges.y.flat = 0;
|
|
mOrientedRanges.y.fuzz = 0;
|
|
mOrientedRanges.y.resolution = mRawPointerAxes.x.resolution * mXScale;
|
|
break;
|
|
|
|
default:
|
|
mOrientedXPrecision = mXPrecision;
|
|
mOrientedYPrecision = mYPrecision;
|
|
|
|
mOrientedRanges.x.min = mXTranslate;
|
|
mOrientedRanges.x.max = mSurfaceWidth + mXTranslate - 1;
|
|
mOrientedRanges.x.flat = 0;
|
|
mOrientedRanges.x.fuzz = 0;
|
|
mOrientedRanges.x.resolution = mRawPointerAxes.x.resolution * mXScale;
|
|
|
|
mOrientedRanges.y.min = mYTranslate;
|
|
mOrientedRanges.y.max = mSurfaceHeight + mYTranslate - 1;
|
|
mOrientedRanges.y.flat = 0;
|
|
mOrientedRanges.y.fuzz = 0;
|
|
mOrientedRanges.y.resolution = mRawPointerAxes.y.resolution * mYScale;
|
|
break;
|
|
}
|
|
|
|
if (mDeviceMode == DEVICE_MODE_POINTER) {
|
|
// Compute pointer gesture detection parameters.
|
|
float rawDiagonal = hypotf(rawWidth, rawHeight);
|
|
float displayDiagonal = hypotf(mSurfaceWidth, mSurfaceHeight);
|
|
|
|
// Scale movements such that one whole swipe of the touch pad covers a
|
|
// given area relative to the diagonal size of the display when no acceleration
|
|
// is applied.
|
|
// Assume that the touch pad has a square aspect ratio such that movements in
|
|
// X and Y of the same number of raw units cover the same physical distance.
|
|
mPointerXMovementScale = mConfig.pointerGestureMovementSpeedRatio
|
|
* displayDiagonal / rawDiagonal;
|
|
mPointerYMovementScale = mPointerXMovementScale;
|
|
|
|
// Scale zooms to cover a smaller range of the display than movements do.
|
|
// This value determines the area around the pointer that is affected by freeform
|
|
// pointer gestures.
|
|
mPointerXZoomScale = mConfig.pointerGestureZoomSpeedRatio
|
|
* displayDiagonal / rawDiagonal;
|
|
mPointerYZoomScale = mPointerXZoomScale;
|
|
|
|
// Max width between pointers to detect a swipe gesture is more than some fraction
|
|
// of the diagonal axis of the touch pad. Touches that are wider than this are
|
|
// translated into freeform gestures.
|
|
mPointerGestureMaxSwipeWidth =
|
|
mConfig.pointerGestureSwipeMaxWidthRatio * rawDiagonal;
|
|
|
|
// Abort current pointer usages because the state has changed.
|
|
abortPointerUsage(when, 0 /*policyFlags*/);
|
|
}
|
|
|
|
// Inform the dispatcher about the changes.
|
|
*outResetNeeded = true;
|
|
bumpGeneration();
|
|
}
|
|
}
|
|
|
|
void TouchInputMapper::dumpSurface(String8& dump) {
|
|
dump.appendFormat(INDENT3 "Viewport: displayId=%d, orientation=%d, "
|
|
"logicalFrame=[%d, %d, %d, %d], "
|
|
"physicalFrame=[%d, %d, %d, %d], "
|
|
"deviceSize=[%d, %d]\n",
|
|
mViewport.displayId, mViewport.orientation,
|
|
mViewport.logicalLeft, mViewport.logicalTop,
|
|
mViewport.logicalRight, mViewport.logicalBottom,
|
|
mViewport.physicalLeft, mViewport.physicalTop,
|
|
mViewport.physicalRight, mViewport.physicalBottom,
|
|
mViewport.deviceWidth, mViewport.deviceHeight);
|
|
|
|
dump.appendFormat(INDENT3 "SurfaceWidth: %dpx\n", mSurfaceWidth);
|
|
dump.appendFormat(INDENT3 "SurfaceHeight: %dpx\n", mSurfaceHeight);
|
|
dump.appendFormat(INDENT3 "SurfaceLeft: %d\n", mSurfaceLeft);
|
|
dump.appendFormat(INDENT3 "SurfaceTop: %d\n", mSurfaceTop);
|
|
dump.appendFormat(INDENT3 "SurfaceOrientation: %d\n", mSurfaceOrientation);
|
|
}
|
|
|
|
void TouchInputMapper::configureVirtualKeys() {
|
|
Vector<VirtualKeyDefinition> virtualKeyDefinitions;
|
|
getEventHub()->getVirtualKeyDefinitions(getDeviceId(), virtualKeyDefinitions);
|
|
|
|
mVirtualKeys.clear();
|
|
|
|
if (virtualKeyDefinitions.size() == 0) {
|
|
return;
|
|
}
|
|
|
|
mVirtualKeys.setCapacity(virtualKeyDefinitions.size());
|
|
|
|
int32_t touchScreenLeft = mRawPointerAxes.x.minValue;
|
|
int32_t touchScreenTop = mRawPointerAxes.y.minValue;
|
|
int32_t touchScreenWidth = mRawPointerAxes.x.maxValue - mRawPointerAxes.x.minValue + 1;
|
|
int32_t touchScreenHeight = mRawPointerAxes.y.maxValue - mRawPointerAxes.y.minValue + 1;
|
|
|
|
for (size_t i = 0; i < virtualKeyDefinitions.size(); i++) {
|
|
const VirtualKeyDefinition& virtualKeyDefinition =
|
|
virtualKeyDefinitions[i];
|
|
|
|
mVirtualKeys.add();
|
|
VirtualKey& virtualKey = mVirtualKeys.editTop();
|
|
|
|
virtualKey.scanCode = virtualKeyDefinition.scanCode;
|
|
int32_t keyCode;
|
|
uint32_t flags;
|
|
if (getEventHub()->mapKey(getDeviceId(), virtualKey.scanCode, 0, &keyCode, &flags)) {
|
|
ALOGW(INDENT "VirtualKey %d: could not obtain key code, ignoring",
|
|
virtualKey.scanCode);
|
|
mVirtualKeys.pop(); // drop the key
|
|
continue;
|
|
}
|
|
|
|
virtualKey.keyCode = keyCode;
|
|
virtualKey.flags = flags;
|
|
|
|
// convert the key definition's display coordinates into touch coordinates for a hit box
|
|
int32_t halfWidth = virtualKeyDefinition.width / 2;
|
|
int32_t halfHeight = virtualKeyDefinition.height / 2;
|
|
|
|
virtualKey.hitLeft = (virtualKeyDefinition.centerX - halfWidth)
|
|
* touchScreenWidth / mSurfaceWidth + touchScreenLeft;
|
|
virtualKey.hitRight= (virtualKeyDefinition.centerX + halfWidth)
|
|
* touchScreenWidth / mSurfaceWidth + touchScreenLeft;
|
|
virtualKey.hitTop = (virtualKeyDefinition.centerY - halfHeight)
|
|
* touchScreenHeight / mSurfaceHeight + touchScreenTop;
|
|
virtualKey.hitBottom = (virtualKeyDefinition.centerY + halfHeight)
|
|
* touchScreenHeight / mSurfaceHeight + touchScreenTop;
|
|
}
|
|
}
|
|
|
|
void TouchInputMapper::dumpVirtualKeys(String8& dump) {
|
|
if (!mVirtualKeys.isEmpty()) {
|
|
dump.append(INDENT3 "Virtual Keys:\n");
|
|
|
|
for (size_t i = 0; i < mVirtualKeys.size(); i++) {
|
|
const VirtualKey& virtualKey = mVirtualKeys.itemAt(i);
|
|
dump.appendFormat(INDENT4 "%d: scanCode=%d, keyCode=%d, "
|
|
"hitLeft=%d, hitRight=%d, hitTop=%d, hitBottom=%d\n",
|
|
i, virtualKey.scanCode, virtualKey.keyCode,
|
|
virtualKey.hitLeft, virtualKey.hitRight,
|
|
virtualKey.hitTop, virtualKey.hitBottom);
|
|
}
|
|
}
|
|
}
|
|
|
|
void TouchInputMapper::parseCalibration() {
|
|
const PropertyMap& in = getDevice()->getConfiguration();
|
|
Calibration& out = mCalibration;
|
|
|
|
// Size
|
|
out.sizeCalibration = Calibration::SIZE_CALIBRATION_DEFAULT;
|
|
String8 sizeCalibrationString;
|
|
if (in.tryGetProperty(String8("touch.size.calibration"), sizeCalibrationString)) {
|
|
if (sizeCalibrationString == "none") {
|
|
out.sizeCalibration = Calibration::SIZE_CALIBRATION_NONE;
|
|
} else if (sizeCalibrationString == "geometric") {
|
|
out.sizeCalibration = Calibration::SIZE_CALIBRATION_GEOMETRIC;
|
|
} else if (sizeCalibrationString == "diameter") {
|
|
out.sizeCalibration = Calibration::SIZE_CALIBRATION_DIAMETER;
|
|
} else if (sizeCalibrationString == "box") {
|
|
out.sizeCalibration = Calibration::SIZE_CALIBRATION_BOX;
|
|
} else if (sizeCalibrationString == "area") {
|
|
out.sizeCalibration = Calibration::SIZE_CALIBRATION_AREA;
|
|
} else if (sizeCalibrationString != "default") {
|
|
ALOGW("Invalid value for touch.size.calibration: '%s'",
|
|
sizeCalibrationString.string());
|
|
}
|
|
}
|
|
|
|
out.haveSizeScale = in.tryGetProperty(String8("touch.size.scale"),
|
|
out.sizeScale);
|
|
out.haveSizeBias = in.tryGetProperty(String8("touch.size.bias"),
|
|
out.sizeBias);
|
|
out.haveSizeIsSummed = in.tryGetProperty(String8("touch.size.isSummed"),
|
|
out.sizeIsSummed);
|
|
|
|
// Pressure
|
|
out.pressureCalibration = Calibration::PRESSURE_CALIBRATION_DEFAULT;
|
|
String8 pressureCalibrationString;
|
|
if (in.tryGetProperty(String8("touch.pressure.calibration"), pressureCalibrationString)) {
|
|
if (pressureCalibrationString == "none") {
|
|
out.pressureCalibration = Calibration::PRESSURE_CALIBRATION_NONE;
|
|
} else if (pressureCalibrationString == "physical") {
|
|
out.pressureCalibration = Calibration::PRESSURE_CALIBRATION_PHYSICAL;
|
|
} else if (pressureCalibrationString == "amplitude") {
|
|
out.pressureCalibration = Calibration::PRESSURE_CALIBRATION_AMPLITUDE;
|
|
} else if (pressureCalibrationString != "default") {
|
|
ALOGW("Invalid value for touch.pressure.calibration: '%s'",
|
|
pressureCalibrationString.string());
|
|
}
|
|
}
|
|
|
|
out.havePressureScale = in.tryGetProperty(String8("touch.pressure.scale"),
|
|
out.pressureScale);
|
|
|
|
// Orientation
|
|
out.orientationCalibration = Calibration::ORIENTATION_CALIBRATION_DEFAULT;
|
|
String8 orientationCalibrationString;
|
|
if (in.tryGetProperty(String8("touch.orientation.calibration"), orientationCalibrationString)) {
|
|
if (orientationCalibrationString == "none") {
|
|
out.orientationCalibration = Calibration::ORIENTATION_CALIBRATION_NONE;
|
|
} else if (orientationCalibrationString == "interpolated") {
|
|
out.orientationCalibration = Calibration::ORIENTATION_CALIBRATION_INTERPOLATED;
|
|
} else if (orientationCalibrationString == "vector") {
|
|
out.orientationCalibration = Calibration::ORIENTATION_CALIBRATION_VECTOR;
|
|
} else if (orientationCalibrationString != "default") {
|
|
ALOGW("Invalid value for touch.orientation.calibration: '%s'",
|
|
orientationCalibrationString.string());
|
|
}
|
|
}
|
|
|
|
// Distance
|
|
out.distanceCalibration = Calibration::DISTANCE_CALIBRATION_DEFAULT;
|
|
String8 distanceCalibrationString;
|
|
if (in.tryGetProperty(String8("touch.distance.calibration"), distanceCalibrationString)) {
|
|
if (distanceCalibrationString == "none") {
|
|
out.distanceCalibration = Calibration::DISTANCE_CALIBRATION_NONE;
|
|
} else if (distanceCalibrationString == "scaled") {
|
|
out.distanceCalibration = Calibration::DISTANCE_CALIBRATION_SCALED;
|
|
} else if (distanceCalibrationString != "default") {
|
|
ALOGW("Invalid value for touch.distance.calibration: '%s'",
|
|
distanceCalibrationString.string());
|
|
}
|
|
}
|
|
|
|
out.haveDistanceScale = in.tryGetProperty(String8("touch.distance.scale"),
|
|
out.distanceScale);
|
|
|
|
out.coverageCalibration = Calibration::COVERAGE_CALIBRATION_DEFAULT;
|
|
String8 coverageCalibrationString;
|
|
if (in.tryGetProperty(String8("touch.coverage.calibration"), coverageCalibrationString)) {
|
|
if (coverageCalibrationString == "none") {
|
|
out.coverageCalibration = Calibration::COVERAGE_CALIBRATION_NONE;
|
|
} else if (coverageCalibrationString == "box") {
|
|
out.coverageCalibration = Calibration::COVERAGE_CALIBRATION_BOX;
|
|
} else if (coverageCalibrationString != "default") {
|
|
ALOGW("Invalid value for touch.coverage.calibration: '%s'",
|
|
coverageCalibrationString.string());
|
|
}
|
|
}
|
|
}
|
|
|
|
void TouchInputMapper::resolveCalibration() {
|
|
// Size
|
|
if (mRawPointerAxes.touchMajor.valid || mRawPointerAxes.toolMajor.valid) {
|
|
if (mCalibration.sizeCalibration == Calibration::SIZE_CALIBRATION_DEFAULT) {
|
|
mCalibration.sizeCalibration = Calibration::SIZE_CALIBRATION_GEOMETRIC;
|
|
}
|
|
} else {
|
|
mCalibration.sizeCalibration = Calibration::SIZE_CALIBRATION_NONE;
|
|
}
|
|
|
|
// Pressure
|
|
if (mRawPointerAxes.pressure.valid) {
|
|
if (mCalibration.pressureCalibration == Calibration::PRESSURE_CALIBRATION_DEFAULT) {
|
|
mCalibration.pressureCalibration = Calibration::PRESSURE_CALIBRATION_PHYSICAL;
|
|
}
|
|
} else {
|
|
mCalibration.pressureCalibration = Calibration::PRESSURE_CALIBRATION_NONE;
|
|
}
|
|
|
|
// Orientation
|
|
if (mRawPointerAxes.orientation.valid) {
|
|
if (mCalibration.orientationCalibration == Calibration::ORIENTATION_CALIBRATION_DEFAULT) {
|
|
mCalibration.orientationCalibration = Calibration::ORIENTATION_CALIBRATION_INTERPOLATED;
|
|
}
|
|
} else {
|
|
mCalibration.orientationCalibration = Calibration::ORIENTATION_CALIBRATION_NONE;
|
|
}
|
|
|
|
// Distance
|
|
if (mRawPointerAxes.distance.valid) {
|
|
if (mCalibration.distanceCalibration == Calibration::DISTANCE_CALIBRATION_DEFAULT) {
|
|
mCalibration.distanceCalibration = Calibration::DISTANCE_CALIBRATION_SCALED;
|
|
}
|
|
} else {
|
|
mCalibration.distanceCalibration = Calibration::DISTANCE_CALIBRATION_NONE;
|
|
}
|
|
|
|
// Coverage
|
|
if (mCalibration.coverageCalibration == Calibration::COVERAGE_CALIBRATION_DEFAULT) {
|
|
mCalibration.coverageCalibration = Calibration::COVERAGE_CALIBRATION_NONE;
|
|
}
|
|
}
|
|
|
|
void TouchInputMapper::dumpCalibration(String8& dump) {
|
|
dump.append(INDENT3 "Calibration:\n");
|
|
|
|
// Size
|
|
switch (mCalibration.sizeCalibration) {
|
|
case Calibration::SIZE_CALIBRATION_NONE:
|
|
dump.append(INDENT4 "touch.size.calibration: none\n");
|
|
break;
|
|
case Calibration::SIZE_CALIBRATION_GEOMETRIC:
|
|
dump.append(INDENT4 "touch.size.calibration: geometric\n");
|
|
break;
|
|
case Calibration::SIZE_CALIBRATION_DIAMETER:
|
|
dump.append(INDENT4 "touch.size.calibration: diameter\n");
|
|
break;
|
|
case Calibration::SIZE_CALIBRATION_BOX:
|
|
dump.append(INDENT4 "touch.size.calibration: box\n");
|
|
break;
|
|
case Calibration::SIZE_CALIBRATION_AREA:
|
|
dump.append(INDENT4 "touch.size.calibration: area\n");
|
|
break;
|
|
default:
|
|
ALOG_ASSERT(false);
|
|
}
|
|
|
|
if (mCalibration.haveSizeScale) {
|
|
dump.appendFormat(INDENT4 "touch.size.scale: %0.3f\n",
|
|
mCalibration.sizeScale);
|
|
}
|
|
|
|
if (mCalibration.haveSizeBias) {
|
|
dump.appendFormat(INDENT4 "touch.size.bias: %0.3f\n",
|
|
mCalibration.sizeBias);
|
|
}
|
|
|
|
if (mCalibration.haveSizeIsSummed) {
|
|
dump.appendFormat(INDENT4 "touch.size.isSummed: %s\n",
|
|
toString(mCalibration.sizeIsSummed));
|
|
}
|
|
|
|
// Pressure
|
|
switch (mCalibration.pressureCalibration) {
|
|
case Calibration::PRESSURE_CALIBRATION_NONE:
|
|
dump.append(INDENT4 "touch.pressure.calibration: none\n");
|
|
break;
|
|
case Calibration::PRESSURE_CALIBRATION_PHYSICAL:
|
|
dump.append(INDENT4 "touch.pressure.calibration: physical\n");
|
|
break;
|
|
case Calibration::PRESSURE_CALIBRATION_AMPLITUDE:
|
|
dump.append(INDENT4 "touch.pressure.calibration: amplitude\n");
|
|
break;
|
|
default:
|
|
ALOG_ASSERT(false);
|
|
}
|
|
|
|
if (mCalibration.havePressureScale) {
|
|
dump.appendFormat(INDENT4 "touch.pressure.scale: %0.3f\n",
|
|
mCalibration.pressureScale);
|
|
}
|
|
|
|
// Orientation
|
|
switch (mCalibration.orientationCalibration) {
|
|
case Calibration::ORIENTATION_CALIBRATION_NONE:
|
|
dump.append(INDENT4 "touch.orientation.calibration: none\n");
|
|
break;
|
|
case Calibration::ORIENTATION_CALIBRATION_INTERPOLATED:
|
|
dump.append(INDENT4 "touch.orientation.calibration: interpolated\n");
|
|
break;
|
|
case Calibration::ORIENTATION_CALIBRATION_VECTOR:
|
|
dump.append(INDENT4 "touch.orientation.calibration: vector\n");
|
|
break;
|
|
default:
|
|
ALOG_ASSERT(false);
|
|
}
|
|
|
|
// Distance
|
|
switch (mCalibration.distanceCalibration) {
|
|
case Calibration::DISTANCE_CALIBRATION_NONE:
|
|
dump.append(INDENT4 "touch.distance.calibration: none\n");
|
|
break;
|
|
case Calibration::DISTANCE_CALIBRATION_SCALED:
|
|
dump.append(INDENT4 "touch.distance.calibration: scaled\n");
|
|
break;
|
|
default:
|
|
ALOG_ASSERT(false);
|
|
}
|
|
|
|
if (mCalibration.haveDistanceScale) {
|
|
dump.appendFormat(INDENT4 "touch.distance.scale: %0.3f\n",
|
|
mCalibration.distanceScale);
|
|
}
|
|
|
|
switch (mCalibration.coverageCalibration) {
|
|
case Calibration::COVERAGE_CALIBRATION_NONE:
|
|
dump.append(INDENT4 "touch.coverage.calibration: none\n");
|
|
break;
|
|
case Calibration::COVERAGE_CALIBRATION_BOX:
|
|
dump.append(INDENT4 "touch.coverage.calibration: box\n");
|
|
break;
|
|
default:
|
|
ALOG_ASSERT(false);
|
|
}
|
|
}
|
|
|
|
void TouchInputMapper::reset(nsecs_t when) {
|
|
mCursorButtonAccumulator.reset(getDevice());
|
|
mCursorScrollAccumulator.reset(getDevice());
|
|
mTouchButtonAccumulator.reset(getDevice());
|
|
|
|
mPointerVelocityControl.reset();
|
|
mWheelXVelocityControl.reset();
|
|
mWheelYVelocityControl.reset();
|
|
|
|
mCurrentRawPointerData.clear();
|
|
mLastRawPointerData.clear();
|
|
mCurrentCookedPointerData.clear();
|
|
mLastCookedPointerData.clear();
|
|
mCurrentButtonState = 0;
|
|
mLastButtonState = 0;
|
|
mCurrentRawVScroll = 0;
|
|
mCurrentRawHScroll = 0;
|
|
mCurrentFingerIdBits.clear();
|
|
mLastFingerIdBits.clear();
|
|
mCurrentStylusIdBits.clear();
|
|
mLastStylusIdBits.clear();
|
|
mCurrentMouseIdBits.clear();
|
|
mLastMouseIdBits.clear();
|
|
mPointerUsage = POINTER_USAGE_NONE;
|
|
mSentHoverEnter = false;
|
|
mDownTime = 0;
|
|
|
|
mCurrentVirtualKey.down = false;
|
|
|
|
mPointerGesture.reset();
|
|
mPointerSimple.reset();
|
|
|
|
if (mPointerController != NULL) {
|
|
mPointerController->fade(PointerControllerInterface::TRANSITION_GRADUAL);
|
|
mPointerController->clearSpots();
|
|
}
|
|
|
|
InputMapper::reset(when);
|
|
}
|
|
|
|
void TouchInputMapper::process(const RawEvent* rawEvent) {
|
|
mCursorButtonAccumulator.process(rawEvent);
|
|
mCursorScrollAccumulator.process(rawEvent);
|
|
mTouchButtonAccumulator.process(rawEvent);
|
|
|
|
if (rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT) {
|
|
sync(rawEvent->when);
|
|
}
|
|
}
|
|
|
|
void TouchInputMapper::sync(nsecs_t when) {
|
|
// Sync button state.
|
|
mCurrentButtonState = mTouchButtonAccumulator.getButtonState()
|
|
| mCursorButtonAccumulator.getButtonState();
|
|
|
|
// Sync scroll state.
|
|
mCurrentRawVScroll = mCursorScrollAccumulator.getRelativeVWheel();
|
|
mCurrentRawHScroll = mCursorScrollAccumulator.getRelativeHWheel();
|
|
mCursorScrollAccumulator.finishSync();
|
|
|
|
// Sync touch state.
|
|
bool havePointerIds = true;
|
|
mCurrentRawPointerData.clear();
|
|
syncTouch(when, &havePointerIds);
|
|
|
|
#if DEBUG_RAW_EVENTS
|
|
if (!havePointerIds) {
|
|
ALOGD("syncTouch: pointerCount %d -> %d, no pointer ids",
|
|
mLastRawPointerData.pointerCount,
|
|
mCurrentRawPointerData.pointerCount);
|
|
} else {
|
|
ALOGD("syncTouch: pointerCount %d -> %d, touching ids 0x%08x -> 0x%08x, "
|
|
"hovering ids 0x%08x -> 0x%08x",
|
|
mLastRawPointerData.pointerCount,
|
|
mCurrentRawPointerData.pointerCount,
|
|
mLastRawPointerData.touchingIdBits.value,
|
|
mCurrentRawPointerData.touchingIdBits.value,
|
|
mLastRawPointerData.hoveringIdBits.value,
|
|
mCurrentRawPointerData.hoveringIdBits.value);
|
|
}
|
|
#endif
|
|
|
|
// Reset state that we will compute below.
|
|
mCurrentFingerIdBits.clear();
|
|
mCurrentStylusIdBits.clear();
|
|
mCurrentMouseIdBits.clear();
|
|
mCurrentCookedPointerData.clear();
|
|
|
|
if (mDeviceMode == DEVICE_MODE_DISABLED) {
|
|
// Drop all input if the device is disabled.
|
|
mCurrentRawPointerData.clear();
|
|
mCurrentButtonState = 0;
|
|
} else {
|
|
// Preprocess pointer data.
|
|
if (!havePointerIds) {
|
|
assignPointerIds();
|
|
}
|
|
|
|
// Handle policy on initial down or hover events.
|
|
uint32_t policyFlags = 0;
|
|
bool initialDown = mLastRawPointerData.pointerCount == 0
|
|
&& mCurrentRawPointerData.pointerCount != 0;
|
|
bool buttonsPressed = mCurrentButtonState & ~mLastButtonState;
|
|
if (initialDown || buttonsPressed) {
|
|
// If this is a touch screen, hide the pointer on an initial down.
|
|
if (mDeviceMode == DEVICE_MODE_DIRECT) {
|
|
getContext()->fadePointer();
|
|
}
|
|
|
|
// Initial downs on external touch devices should wake the device.
|
|
// We don't do this for internal touch screens to prevent them from waking
|
|
// up in your pocket.
|
|
// TODO: Use the input device configuration to control this behavior more finely.
|
|
if (getDevice()->isExternal()) {
|
|
policyFlags |= POLICY_FLAG_WAKE_DROPPED;
|
|
}
|
|
}
|
|
|
|
// Synthesize key down from raw buttons if needed.
|
|
synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_DOWN, when, getDeviceId(), mSource,
|
|
policyFlags, mLastButtonState, mCurrentButtonState);
|
|
|
|
// Consume raw off-screen touches before cooking pointer data.
|
|
// If touches are consumed, subsequent code will not receive any pointer data.
|
|
if (consumeRawTouches(when, policyFlags)) {
|
|
mCurrentRawPointerData.clear();
|
|
}
|
|
|
|
// Cook pointer data. This call populates the mCurrentCookedPointerData structure
|
|
// with cooked pointer data that has the same ids and indices as the raw data.
|
|
// The following code can use either the raw or cooked data, as needed.
|
|
cookPointerData();
|
|
|
|
// Dispatch the touches either directly or by translation through a pointer on screen.
|
|
if (mDeviceMode == DEVICE_MODE_POINTER) {
|
|
for (BitSet32 idBits(mCurrentRawPointerData.touchingIdBits); !idBits.isEmpty(); ) {
|
|
uint32_t id = idBits.clearFirstMarkedBit();
|
|
const RawPointerData::Pointer& pointer = mCurrentRawPointerData.pointerForId(id);
|
|
if (pointer.toolType == AMOTION_EVENT_TOOL_TYPE_STYLUS
|
|
|| pointer.toolType == AMOTION_EVENT_TOOL_TYPE_ERASER) {
|
|
mCurrentStylusIdBits.markBit(id);
|
|
} else if (pointer.toolType == AMOTION_EVENT_TOOL_TYPE_FINGER
|
|
|| pointer.toolType == AMOTION_EVENT_TOOL_TYPE_UNKNOWN) {
|
|
mCurrentFingerIdBits.markBit(id);
|
|
} else if (pointer.toolType == AMOTION_EVENT_TOOL_TYPE_MOUSE) {
|
|
mCurrentMouseIdBits.markBit(id);
|
|
}
|
|
}
|
|
for (BitSet32 idBits(mCurrentRawPointerData.hoveringIdBits); !idBits.isEmpty(); ) {
|
|
uint32_t id = idBits.clearFirstMarkedBit();
|
|
const RawPointerData::Pointer& pointer = mCurrentRawPointerData.pointerForId(id);
|
|
if (pointer.toolType == AMOTION_EVENT_TOOL_TYPE_STYLUS
|
|
|| pointer.toolType == AMOTION_EVENT_TOOL_TYPE_ERASER) {
|
|
mCurrentStylusIdBits.markBit(id);
|
|
}
|
|
}
|
|
|
|
// Stylus takes precedence over all tools, then mouse, then finger.
|
|
PointerUsage pointerUsage = mPointerUsage;
|
|
if (!mCurrentStylusIdBits.isEmpty()) {
|
|
mCurrentMouseIdBits.clear();
|
|
mCurrentFingerIdBits.clear();
|
|
pointerUsage = POINTER_USAGE_STYLUS;
|
|
} else if (!mCurrentMouseIdBits.isEmpty()) {
|
|
mCurrentFingerIdBits.clear();
|
|
pointerUsage = POINTER_USAGE_MOUSE;
|
|
} else if (!mCurrentFingerIdBits.isEmpty() || isPointerDown(mCurrentButtonState)) {
|
|
pointerUsage = POINTER_USAGE_GESTURES;
|
|
}
|
|
|
|
dispatchPointerUsage(when, policyFlags, pointerUsage);
|
|
} else {
|
|
if (mDeviceMode == DEVICE_MODE_DIRECT
|
|
&& mConfig.showTouches && mPointerController != NULL) {
|
|
mPointerController->setPresentation(PointerControllerInterface::PRESENTATION_SPOT);
|
|
mPointerController->fade(PointerControllerInterface::TRANSITION_GRADUAL);
|
|
|
|
mPointerController->setButtonState(mCurrentButtonState);
|
|
mPointerController->setSpots(mCurrentCookedPointerData.pointerCoords,
|
|
mCurrentCookedPointerData.idToIndex,
|
|
mCurrentCookedPointerData.touchingIdBits);
|
|
}
|
|
|
|
dispatchHoverExit(when, policyFlags);
|
|
dispatchTouches(when, policyFlags);
|
|
dispatchHoverEnterAndMove(when, policyFlags);
|
|
}
|
|
|
|
// Synthesize key up from raw buttons if needed.
|
|
synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_UP, when, getDeviceId(), mSource,
|
|
policyFlags, mLastButtonState, mCurrentButtonState);
|
|
}
|
|
|
|
// Copy current touch to last touch in preparation for the next cycle.
|
|
mLastRawPointerData.copyFrom(mCurrentRawPointerData);
|
|
mLastCookedPointerData.copyFrom(mCurrentCookedPointerData);
|
|
mLastButtonState = mCurrentButtonState;
|
|
mLastFingerIdBits = mCurrentFingerIdBits;
|
|
mLastStylusIdBits = mCurrentStylusIdBits;
|
|
mLastMouseIdBits = mCurrentMouseIdBits;
|
|
|
|
// Clear some transient state.
|
|
mCurrentRawVScroll = 0;
|
|
mCurrentRawHScroll = 0;
|
|
}
|
|
|
|
void TouchInputMapper::timeoutExpired(nsecs_t when) {
|
|
if (mDeviceMode == DEVICE_MODE_POINTER) {
|
|
if (mPointerUsage == POINTER_USAGE_GESTURES) {
|
|
dispatchPointerGestures(when, 0 /*policyFlags*/, true /*isTimeout*/);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool TouchInputMapper::consumeRawTouches(nsecs_t when, uint32_t policyFlags) {
|
|
// Check for release of a virtual key.
|
|
if (mCurrentVirtualKey.down) {
|
|
if (mCurrentRawPointerData.touchingIdBits.isEmpty()) {
|
|
// Pointer went up while virtual key was down.
|
|
mCurrentVirtualKey.down = false;
|
|
if (!mCurrentVirtualKey.ignored) {
|
|
#if DEBUG_VIRTUAL_KEYS
|
|
ALOGD("VirtualKeys: Generating key up: keyCode=%d, scanCode=%d",
|
|
mCurrentVirtualKey.keyCode, mCurrentVirtualKey.scanCode);
|
|
#endif
|
|
dispatchVirtualKey(when, policyFlags,
|
|
AKEY_EVENT_ACTION_UP,
|
|
AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (mCurrentRawPointerData.touchingIdBits.count() == 1) {
|
|
uint32_t id = mCurrentRawPointerData.touchingIdBits.firstMarkedBit();
|
|
const RawPointerData::Pointer& pointer = mCurrentRawPointerData.pointerForId(id);
|
|
const VirtualKey* virtualKey = findVirtualKeyHit(pointer.x, pointer.y);
|
|
if (virtualKey && virtualKey->keyCode == mCurrentVirtualKey.keyCode) {
|
|
// Pointer is still within the space of the virtual key.
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Pointer left virtual key area or another pointer also went down.
|
|
// Send key cancellation but do not consume the touch yet.
|
|
// This is useful when the user swipes through from the virtual key area
|
|
// into the main display surface.
|
|
mCurrentVirtualKey.down = false;
|
|
if (!mCurrentVirtualKey.ignored) {
|
|
#if DEBUG_VIRTUAL_KEYS
|
|
ALOGD("VirtualKeys: Canceling key: keyCode=%d, scanCode=%d",
|
|
mCurrentVirtualKey.keyCode, mCurrentVirtualKey.scanCode);
|
|
#endif
|
|
dispatchVirtualKey(when, policyFlags,
|
|
AKEY_EVENT_ACTION_UP,
|
|
AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY
|
|
| AKEY_EVENT_FLAG_CANCELED);
|
|
}
|
|
}
|
|
|
|
if (mLastRawPointerData.touchingIdBits.isEmpty()
|
|
&& !mCurrentRawPointerData.touchingIdBits.isEmpty()) {
|
|
// Pointer just went down. Check for virtual key press or off-screen touches.
|
|
uint32_t id = mCurrentRawPointerData.touchingIdBits.firstMarkedBit();
|
|
const RawPointerData::Pointer& pointer = mCurrentRawPointerData.pointerForId(id);
|
|
if (!isPointInsideSurface(pointer.x, pointer.y)) {
|
|
// If exactly one pointer went down, check for virtual key hit.
|
|
// Otherwise we will drop the entire stroke.
|
|
if (mCurrentRawPointerData.touchingIdBits.count() == 1) {
|
|
const VirtualKey* virtualKey = findVirtualKeyHit(pointer.x, pointer.y);
|
|
if (virtualKey) {
|
|
mCurrentVirtualKey.down = true;
|
|
mCurrentVirtualKey.downTime = when;
|
|
mCurrentVirtualKey.keyCode = virtualKey->keyCode;
|
|
mCurrentVirtualKey.scanCode = virtualKey->scanCode;
|
|
mCurrentVirtualKey.ignored = mContext->shouldDropVirtualKey(
|
|
when, getDevice(), virtualKey->keyCode, virtualKey->scanCode);
|
|
|
|
if (!mCurrentVirtualKey.ignored) {
|
|
#if DEBUG_VIRTUAL_KEYS
|
|
ALOGD("VirtualKeys: Generating key down: keyCode=%d, scanCode=%d",
|
|
mCurrentVirtualKey.keyCode,
|
|
mCurrentVirtualKey.scanCode);
|
|
#endif
|
|
dispatchVirtualKey(when, policyFlags,
|
|
AKEY_EVENT_ACTION_DOWN,
|
|
AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY);
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Disable all virtual key touches that happen within a short time interval of the
|
|
// most recent touch within the screen area. The idea is to filter out stray
|
|
// virtual key presses when interacting with the touch screen.
|
|
//
|
|
// Problems we're trying to solve:
|
|
//
|
|
// 1. While scrolling a list or dragging the window shade, the user swipes down into a
|
|
// virtual key area that is implemented by a separate touch panel and accidentally
|
|
// triggers a virtual key.
|
|
//
|
|
// 2. While typing in the on screen keyboard, the user taps slightly outside the screen
|
|
// area and accidentally triggers a virtual key. This often happens when virtual keys
|
|
// are layed out below the screen near to where the on screen keyboard's space bar
|
|
// is displayed.
|
|
if (mConfig.virtualKeyQuietTime > 0 && !mCurrentRawPointerData.touchingIdBits.isEmpty()) {
|
|
mContext->disableVirtualKeysUntil(when + mConfig.virtualKeyQuietTime);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void TouchInputMapper::dispatchVirtualKey(nsecs_t when, uint32_t policyFlags,
|
|
int32_t keyEventAction, int32_t keyEventFlags) {
|
|
int32_t keyCode = mCurrentVirtualKey.keyCode;
|
|
int32_t scanCode = mCurrentVirtualKey.scanCode;
|
|
nsecs_t downTime = mCurrentVirtualKey.downTime;
|
|
int32_t metaState = mContext->getGlobalMetaState();
|
|
policyFlags |= POLICY_FLAG_VIRTUAL;
|
|
|
|
NotifyKeyArgs args(when, getDeviceId(), AINPUT_SOURCE_KEYBOARD, policyFlags,
|
|
keyEventAction, keyEventFlags, keyCode, scanCode, metaState, downTime);
|
|
getListener()->notifyKey(&args);
|
|
}
|
|
|
|
void TouchInputMapper::dispatchTouches(nsecs_t when, uint32_t policyFlags) {
|
|
BitSet32 currentIdBits = mCurrentCookedPointerData.touchingIdBits;
|
|
BitSet32 lastIdBits = mLastCookedPointerData.touchingIdBits;
|
|
int32_t metaState = getContext()->getGlobalMetaState();
|
|
int32_t buttonState = mCurrentButtonState;
|
|
|
|
if (currentIdBits == lastIdBits) {
|
|
if (!currentIdBits.isEmpty()) {
|
|
// No pointer id changes so this is a move event.
|
|
// The listener takes care of batching moves so we don't have to deal with that here.
|
|
dispatchMotion(when, policyFlags, mSource,
|
|
AMOTION_EVENT_ACTION_MOVE, 0, metaState, buttonState,
|
|
AMOTION_EVENT_EDGE_FLAG_NONE,
|
|
mCurrentCookedPointerData.pointerProperties,
|
|
mCurrentCookedPointerData.pointerCoords,
|
|
mCurrentCookedPointerData.idToIndex,
|
|
currentIdBits, -1,
|
|
mOrientedXPrecision, mOrientedYPrecision, mDownTime);
|
|
}
|
|
} else {
|
|
// There may be pointers going up and pointers going down and pointers moving
|
|
// all at the same time.
|
|
BitSet32 upIdBits(lastIdBits.value & ~currentIdBits.value);
|
|
BitSet32 downIdBits(currentIdBits.value & ~lastIdBits.value);
|
|
BitSet32 moveIdBits(lastIdBits.value & currentIdBits.value);
|
|
BitSet32 dispatchedIdBits(lastIdBits.value);
|
|
|
|
// Update last coordinates of pointers that have moved so that we observe the new
|
|
// pointer positions at the same time as other pointers that have just gone up.
|
|
bool moveNeeded = updateMovedPointers(
|
|
mCurrentCookedPointerData.pointerProperties,
|
|
mCurrentCookedPointerData.pointerCoords,
|
|
mCurrentCookedPointerData.idToIndex,
|
|
mLastCookedPointerData.pointerProperties,
|
|
mLastCookedPointerData.pointerCoords,
|
|
mLastCookedPointerData.idToIndex,
|
|
moveIdBits);
|
|
if (buttonState != mLastButtonState) {
|
|
moveNeeded = true;
|
|
}
|
|
|
|
// Dispatch pointer up events.
|
|
while (!upIdBits.isEmpty()) {
|
|
uint32_t upId = upIdBits.clearFirstMarkedBit();
|
|
|
|
dispatchMotion(when, policyFlags, mSource,
|
|
AMOTION_EVENT_ACTION_POINTER_UP, 0, metaState, buttonState, 0,
|
|
mLastCookedPointerData.pointerProperties,
|
|
mLastCookedPointerData.pointerCoords,
|
|
mLastCookedPointerData.idToIndex,
|
|
dispatchedIdBits, upId,
|
|
mOrientedXPrecision, mOrientedYPrecision, mDownTime);
|
|
dispatchedIdBits.clearBit(upId);
|
|
}
|
|
|
|
// Dispatch move events if any of the remaining pointers moved from their old locations.
|
|
// Although applications receive new locations as part of individual pointer up
|
|
// events, they do not generally handle them except when presented in a move event.
|
|
if (moveNeeded) {
|
|
ALOG_ASSERT(moveIdBits.value == dispatchedIdBits.value);
|
|
dispatchMotion(when, policyFlags, mSource,
|
|
AMOTION_EVENT_ACTION_MOVE, 0, metaState, buttonState, 0,
|
|
mCurrentCookedPointerData.pointerProperties,
|
|
mCurrentCookedPointerData.pointerCoords,
|
|
mCurrentCookedPointerData.idToIndex,
|
|
dispatchedIdBits, -1,
|
|
mOrientedXPrecision, mOrientedYPrecision, mDownTime);
|
|
}
|
|
|
|
// Dispatch pointer down events using the new pointer locations.
|
|
while (!downIdBits.isEmpty()) {
|
|
uint32_t downId = downIdBits.clearFirstMarkedBit();
|
|
dispatchedIdBits.markBit(downId);
|
|
|
|
if (dispatchedIdBits.count() == 1) {
|
|
// First pointer is going down. Set down time.
|
|
mDownTime = when;
|
|
}
|
|
|
|
dispatchMotion(when, policyFlags, mSource,
|
|
AMOTION_EVENT_ACTION_POINTER_DOWN, 0, metaState, buttonState, 0,
|
|
mCurrentCookedPointerData.pointerProperties,
|
|
mCurrentCookedPointerData.pointerCoords,
|
|
mCurrentCookedPointerData.idToIndex,
|
|
dispatchedIdBits, downId,
|
|
mOrientedXPrecision, mOrientedYPrecision, mDownTime);
|
|
}
|
|
}
|
|
}
|
|
|
|
void TouchInputMapper::dispatchHoverExit(nsecs_t when, uint32_t policyFlags) {
|
|
if (mSentHoverEnter &&
|
|
(mCurrentCookedPointerData.hoveringIdBits.isEmpty()
|
|
|| !mCurrentCookedPointerData.touchingIdBits.isEmpty())) {
|
|
int32_t metaState = getContext()->getGlobalMetaState();
|
|
dispatchMotion(when, policyFlags, mSource,
|
|
AMOTION_EVENT_ACTION_HOVER_EXIT, 0, metaState, mLastButtonState, 0,
|
|
mLastCookedPointerData.pointerProperties,
|
|
mLastCookedPointerData.pointerCoords,
|
|
mLastCookedPointerData.idToIndex,
|
|
mLastCookedPointerData.hoveringIdBits, -1,
|
|
mOrientedXPrecision, mOrientedYPrecision, mDownTime);
|
|
mSentHoverEnter = false;
|
|
}
|
|
}
|
|
|
|
void TouchInputMapper::dispatchHoverEnterAndMove(nsecs_t when, uint32_t policyFlags) {
|
|
if (mCurrentCookedPointerData.touchingIdBits.isEmpty()
|
|
&& !mCurrentCookedPointerData.hoveringIdBits.isEmpty()) {
|
|
int32_t metaState = getContext()->getGlobalMetaState();
|
|
if (!mSentHoverEnter) {
|
|
dispatchMotion(when, policyFlags, mSource,
|
|
AMOTION_EVENT_ACTION_HOVER_ENTER, 0, metaState, mCurrentButtonState, 0,
|
|
mCurrentCookedPointerData.pointerProperties,
|
|
mCurrentCookedPointerData.pointerCoords,
|
|
mCurrentCookedPointerData.idToIndex,
|
|
mCurrentCookedPointerData.hoveringIdBits, -1,
|
|
mOrientedXPrecision, mOrientedYPrecision, mDownTime);
|
|
mSentHoverEnter = true;
|
|
}
|
|
|
|
dispatchMotion(when, policyFlags, mSource,
|
|
AMOTION_EVENT_ACTION_HOVER_MOVE, 0, metaState, mCurrentButtonState, 0,
|
|
mCurrentCookedPointerData.pointerProperties,
|
|
mCurrentCookedPointerData.pointerCoords,
|
|
mCurrentCookedPointerData.idToIndex,
|
|
mCurrentCookedPointerData.hoveringIdBits, -1,
|
|
mOrientedXPrecision, mOrientedYPrecision, mDownTime);
|
|
}
|
|
}
|
|
|
|
void TouchInputMapper::cookPointerData() {
|
|
uint32_t currentPointerCount = mCurrentRawPointerData.pointerCount;
|
|
|
|
mCurrentCookedPointerData.clear();
|
|
mCurrentCookedPointerData.pointerCount = currentPointerCount;
|
|
mCurrentCookedPointerData.hoveringIdBits = mCurrentRawPointerData.hoveringIdBits;
|
|
mCurrentCookedPointerData.touchingIdBits = mCurrentRawPointerData.touchingIdBits;
|
|
|
|
// Walk through the the active pointers and map device coordinates onto
|
|
// surface coordinates and adjust for display orientation.
|
|
for (uint32_t i = 0; i < currentPointerCount; i++) {
|
|
const RawPointerData::Pointer& in = mCurrentRawPointerData.pointers[i];
|
|
|
|
// Size
|
|
float touchMajor, touchMinor, toolMajor, toolMinor, size;
|
|
switch (mCalibration.sizeCalibration) {
|
|
case Calibration::SIZE_CALIBRATION_GEOMETRIC:
|
|
case Calibration::SIZE_CALIBRATION_DIAMETER:
|
|
case Calibration::SIZE_CALIBRATION_BOX:
|
|
case Calibration::SIZE_CALIBRATION_AREA:
|
|
if (mRawPointerAxes.touchMajor.valid && mRawPointerAxes.toolMajor.valid) {
|
|
touchMajor = in.touchMajor;
|
|
touchMinor = mRawPointerAxes.touchMinor.valid ? in.touchMinor : in.touchMajor;
|
|
toolMajor = in.toolMajor;
|
|
toolMinor = mRawPointerAxes.toolMinor.valid ? in.toolMinor : in.toolMajor;
|
|
size = mRawPointerAxes.touchMinor.valid
|
|
? avg(in.touchMajor, in.touchMinor) : in.touchMajor;
|
|
} else if (mRawPointerAxes.touchMajor.valid) {
|
|
toolMajor = touchMajor = in.touchMajor;
|
|
toolMinor = touchMinor = mRawPointerAxes.touchMinor.valid
|
|
? in.touchMinor : in.touchMajor;
|
|
size = mRawPointerAxes.touchMinor.valid
|
|
? avg(in.touchMajor, in.touchMinor) : in.touchMajor;
|
|
} else if (mRawPointerAxes.toolMajor.valid) {
|
|
touchMajor = toolMajor = in.toolMajor;
|
|
touchMinor = toolMinor = mRawPointerAxes.toolMinor.valid
|
|
? in.toolMinor : in.toolMajor;
|
|
size = mRawPointerAxes.toolMinor.valid
|
|
? avg(in.toolMajor, in.toolMinor) : in.toolMajor;
|
|
} else {
|
|
ALOG_ASSERT(false, "No touch or tool axes. "
|
|
"Size calibration should have been resolved to NONE.");
|
|
touchMajor = 0;
|
|
touchMinor = 0;
|
|
toolMajor = 0;
|
|
toolMinor = 0;
|
|
size = 0;
|
|
}
|
|
|
|
if (mCalibration.haveSizeIsSummed && mCalibration.sizeIsSummed) {
|
|
uint32_t touchingCount = mCurrentRawPointerData.touchingIdBits.count();
|
|
if (touchingCount > 1) {
|
|
touchMajor /= touchingCount;
|
|
touchMinor /= touchingCount;
|
|
toolMajor /= touchingCount;
|
|
toolMinor /= touchingCount;
|
|
size /= touchingCount;
|
|
}
|
|
}
|
|
|
|
if (mCalibration.sizeCalibration == Calibration::SIZE_CALIBRATION_GEOMETRIC) {
|
|
touchMajor *= mGeometricScale;
|
|
touchMinor *= mGeometricScale;
|
|
toolMajor *= mGeometricScale;
|
|
toolMinor *= mGeometricScale;
|
|
} else if (mCalibration.sizeCalibration == Calibration::SIZE_CALIBRATION_AREA) {
|
|
touchMajor = touchMajor > 0 ? sqrtf(touchMajor) : 0;
|
|
touchMinor = touchMajor;
|
|
toolMajor = toolMajor > 0 ? sqrtf(toolMajor) : 0;
|
|
toolMinor = toolMajor;
|
|
} else if (mCalibration.sizeCalibration == Calibration::SIZE_CALIBRATION_DIAMETER) {
|
|
touchMinor = touchMajor;
|
|
toolMinor = toolMajor;
|
|
}
|
|
|
|
mCalibration.applySizeScaleAndBias(&touchMajor);
|
|
mCalibration.applySizeScaleAndBias(&touchMinor);
|
|
mCalibration.applySizeScaleAndBias(&toolMajor);
|
|
mCalibration.applySizeScaleAndBias(&toolMinor);
|
|
size *= mSizeScale;
|
|
break;
|
|
default:
|
|
touchMajor = 0;
|
|
touchMinor = 0;
|
|
toolMajor = 0;
|
|
toolMinor = 0;
|
|
size = 0;
|
|
break;
|
|
}
|
|
|
|
// Pressure
|
|
float pressure;
|
|
switch (mCalibration.pressureCalibration) {
|
|
case Calibration::PRESSURE_CALIBRATION_PHYSICAL:
|
|
case Calibration::PRESSURE_CALIBRATION_AMPLITUDE:
|
|
pressure = in.pressure * mPressureScale;
|
|
break;
|
|
default:
|
|
pressure = in.isHovering ? 0 : 1;
|
|
break;
|
|
}
|
|
|
|
// Tilt and Orientation
|
|
float tilt;
|
|
float orientation;
|
|
if (mHaveTilt) {
|
|
float tiltXAngle = (in.tiltX - mTiltXCenter) * mTiltXScale;
|
|
float tiltYAngle = (in.tiltY - mTiltYCenter) * mTiltYScale;
|
|
orientation = atan2f(-sinf(tiltXAngle), sinf(tiltYAngle));
|
|
tilt = acosf(cosf(tiltXAngle) * cosf(tiltYAngle));
|
|
} else {
|
|
tilt = 0;
|
|
|
|
switch (mCalibration.orientationCalibration) {
|
|
case Calibration::ORIENTATION_CALIBRATION_INTERPOLATED:
|
|
orientation = in.orientation * mOrientationScale;
|
|
break;
|
|
case Calibration::ORIENTATION_CALIBRATION_VECTOR: {
|
|
int32_t c1 = signExtendNybble((in.orientation & 0xf0) >> 4);
|
|
int32_t c2 = signExtendNybble(in.orientation & 0x0f);
|
|
if (c1 != 0 || c2 != 0) {
|
|
orientation = atan2f(c1, c2) * 0.5f;
|
|
float confidence = hypotf(c1, c2);
|
|
float scale = 1.0f + confidence / 16.0f;
|
|
touchMajor *= scale;
|
|
touchMinor /= scale;
|
|
toolMajor *= scale;
|
|
toolMinor /= scale;
|
|
} else {
|
|
orientation = 0;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
orientation = 0;
|
|
}
|
|
}
|
|
|
|
// Distance
|
|
float distance;
|
|
switch (mCalibration.distanceCalibration) {
|
|
case Calibration::DISTANCE_CALIBRATION_SCALED:
|
|
distance = in.distance * mDistanceScale;
|
|
break;
|
|
default:
|
|
distance = 0;
|
|
}
|
|
|
|
// Coverage
|
|
int32_t rawLeft, rawTop, rawRight, rawBottom;
|
|
switch (mCalibration.coverageCalibration) {
|
|
case Calibration::COVERAGE_CALIBRATION_BOX:
|
|
rawLeft = (in.toolMinor & 0xffff0000) >> 16;
|
|
rawRight = in.toolMinor & 0x0000ffff;
|
|
rawBottom = in.toolMajor & 0x0000ffff;
|
|
rawTop = (in.toolMajor & 0xffff0000) >> 16;
|
|
break;
|
|
default:
|
|
rawLeft = rawTop = rawRight = rawBottom = 0;
|
|
break;
|
|
}
|
|
|
|
// X, Y, and the bounding box for coverage information
|
|
// Adjust coords for surface orientation.
|
|
float x, y, left, top, right, bottom;
|
|
switch (mSurfaceOrientation) {
|
|
case DISPLAY_ORIENTATION_90:
|
|
x = float(in.y - mRawPointerAxes.y.minValue) * mYScale + mYTranslate;
|
|
y = float(mRawPointerAxes.x.maxValue - in.x) * mXScale + mXTranslate;
|
|
left = float(rawTop - mRawPointerAxes.y.minValue) * mYScale + mYTranslate;
|
|
right = float(rawBottom- mRawPointerAxes.y.minValue) * mYScale + mYTranslate;
|
|
bottom = float(mRawPointerAxes.x.maxValue - rawLeft) * mXScale + mXTranslate;
|
|
top = float(mRawPointerAxes.x.maxValue - rawRight) * mXScale + mXTranslate;
|
|
orientation -= M_PI_2;
|
|
if (orientation < mOrientedRanges.orientation.min) {
|
|
orientation += (mOrientedRanges.orientation.max - mOrientedRanges.orientation.min);
|
|
}
|
|
break;
|
|
case DISPLAY_ORIENTATION_180:
|
|
x = float(mRawPointerAxes.x.maxValue - in.x) * mXScale + mXTranslate;
|
|
y = float(mRawPointerAxes.y.maxValue - in.y) * mYScale + mYTranslate;
|
|
left = float(mRawPointerAxes.x.maxValue - rawRight) * mXScale + mXTranslate;
|
|
right = float(mRawPointerAxes.x.maxValue - rawLeft) * mXScale + mXTranslate;
|
|
bottom = float(mRawPointerAxes.y.maxValue - rawTop) * mYScale + mYTranslate;
|
|
top = float(mRawPointerAxes.y.maxValue - rawBottom) * mYScale + mYTranslate;
|
|
orientation -= M_PI;
|
|
if (orientation < mOrientedRanges.orientation.min) {
|
|
orientation += (mOrientedRanges.orientation.max - mOrientedRanges.orientation.min);
|
|
}
|
|
break;
|
|
case DISPLAY_ORIENTATION_270:
|
|
x = float(mRawPointerAxes.y.maxValue - in.y) * mYScale + mYTranslate;
|
|
y = float(in.x - mRawPointerAxes.x.minValue) * mXScale + mXTranslate;
|
|
left = float(mRawPointerAxes.y.maxValue - rawBottom) * mYScale + mYTranslate;
|
|
right = float(mRawPointerAxes.y.maxValue - rawTop) * mYScale + mYTranslate;
|
|
bottom = float(rawRight - mRawPointerAxes.x.minValue) * mXScale + mXTranslate;
|
|
top = float(rawLeft - mRawPointerAxes.x.minValue) * mXScale + mXTranslate;
|
|
orientation += M_PI_2;
|
|
if (orientation > mOrientedRanges.orientation.max) {
|
|
orientation -= (mOrientedRanges.orientation.max - mOrientedRanges.orientation.min);
|
|
}
|
|
break;
|
|
default:
|
|
x = float(in.x - mRawPointerAxes.x.minValue) * mXScale + mXTranslate;
|
|
y = float(in.y - mRawPointerAxes.y.minValue) * mYScale + mYTranslate;
|
|
left = float(rawLeft - mRawPointerAxes.x.minValue) * mXScale + mXTranslate;
|
|
right = float(rawRight - mRawPointerAxes.x.minValue) * mXScale + mXTranslate;
|
|
bottom = float(rawBottom - mRawPointerAxes.y.minValue) * mYScale + mYTranslate;
|
|
top = float(rawTop - mRawPointerAxes.y.minValue) * mYScale + mYTranslate;
|
|
break;
|
|
}
|
|
|
|
// Write output coords.
|
|
PointerCoords& out = mCurrentCookedPointerData.pointerCoords[i];
|
|
out.clear();
|
|
out.setAxisValue(AMOTION_EVENT_AXIS_X, x);
|
|
out.setAxisValue(AMOTION_EVENT_AXIS_Y, y);
|
|
out.setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, pressure);
|
|
out.setAxisValue(AMOTION_EVENT_AXIS_SIZE, size);
|
|
out.setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, touchMajor);
|
|
out.setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, touchMinor);
|
|
out.setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, orientation);
|
|
out.setAxisValue(AMOTION_EVENT_AXIS_TILT, tilt);
|
|
out.setAxisValue(AMOTION_EVENT_AXIS_DISTANCE, distance);
|
|
if (mCalibration.coverageCalibration == Calibration::COVERAGE_CALIBRATION_BOX) {
|
|
out.setAxisValue(AMOTION_EVENT_AXIS_GENERIC_1, left);
|
|
out.setAxisValue(AMOTION_EVENT_AXIS_GENERIC_2, top);
|
|
out.setAxisValue(AMOTION_EVENT_AXIS_GENERIC_3, right);
|
|
out.setAxisValue(AMOTION_EVENT_AXIS_GENERIC_4, bottom);
|
|
} else {
|
|
out.setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, toolMajor);
|
|
out.setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, toolMinor);
|
|
}
|
|
|
|
// Write output properties.
|
|
PointerProperties& properties = mCurrentCookedPointerData.pointerProperties[i];
|
|
uint32_t id = in.id;
|
|
properties.clear();
|
|
properties.id = id;
|
|
properties.toolType = in.toolType;
|
|
|
|
// Write id index.
|
|
mCurrentCookedPointerData.idToIndex[id] = i;
|
|
}
|
|
}
|
|
|
|
void TouchInputMapper::dispatchPointerUsage(nsecs_t when, uint32_t policyFlags,
|
|
PointerUsage pointerUsage) {
|
|
if (pointerUsage != mPointerUsage) {
|
|
abortPointerUsage(when, policyFlags);
|
|
mPointerUsage = pointerUsage;
|
|
}
|
|
|
|
switch (mPointerUsage) {
|
|
case POINTER_USAGE_GESTURES:
|
|
dispatchPointerGestures(when, policyFlags, false /*isTimeout*/);
|
|
break;
|
|
case POINTER_USAGE_STYLUS:
|
|
dispatchPointerStylus(when, policyFlags);
|
|
break;
|
|
case POINTER_USAGE_MOUSE:
|
|
dispatchPointerMouse(when, policyFlags);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void TouchInputMapper::abortPointerUsage(nsecs_t when, uint32_t policyFlags) {
|
|
switch (mPointerUsage) {
|
|
case POINTER_USAGE_GESTURES:
|
|
abortPointerGestures(when, policyFlags);
|
|
break;
|
|
case POINTER_USAGE_STYLUS:
|
|
abortPointerStylus(when, policyFlags);
|
|
break;
|
|
case POINTER_USAGE_MOUSE:
|
|
abortPointerMouse(when, policyFlags);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
mPointerUsage = POINTER_USAGE_NONE;
|
|
}
|
|
|
|
void TouchInputMapper::dispatchPointerGestures(nsecs_t when, uint32_t policyFlags,
|
|
bool isTimeout) {
|
|
// Update current gesture coordinates.
|
|
bool cancelPreviousGesture, finishPreviousGesture;
|
|
bool sendEvents = preparePointerGestures(when,
|
|
&cancelPreviousGesture, &finishPreviousGesture, isTimeout);
|
|
if (!sendEvents) {
|
|
return;
|
|
}
|
|
if (finishPreviousGesture) {
|
|
cancelPreviousGesture = false;
|
|
}
|
|
|
|
// Update the pointer presentation and spots.
|
|
if (mParameters.gestureMode == Parameters::GESTURE_MODE_SPOTS) {
|
|
mPointerController->setPresentation(PointerControllerInterface::PRESENTATION_SPOT);
|
|
if (finishPreviousGesture || cancelPreviousGesture) {
|
|
mPointerController->clearSpots();
|
|
}
|
|
mPointerController->setSpots(mPointerGesture.currentGestureCoords,
|
|
mPointerGesture.currentGestureIdToIndex,
|
|
mPointerGesture.currentGestureIdBits);
|
|
} else {
|
|
mPointerController->setPresentation(PointerControllerInterface::PRESENTATION_POINTER);
|
|
}
|
|
|
|
// Show or hide the pointer if needed.
|
|
switch (mPointerGesture.currentGestureMode) {
|
|
case PointerGesture::NEUTRAL:
|
|
case PointerGesture::QUIET:
|
|
if (mParameters.gestureMode == Parameters::GESTURE_MODE_SPOTS
|
|
&& (mPointerGesture.lastGestureMode == PointerGesture::SWIPE
|
|
|| mPointerGesture.lastGestureMode == PointerGesture::FREEFORM)) {
|
|
// Remind the user of where the pointer is after finishing a gesture with spots.
|
|
mPointerController->unfade(PointerControllerInterface::TRANSITION_GRADUAL);
|
|
}
|
|
break;
|
|
case PointerGesture::TAP:
|
|
case PointerGesture::TAP_DRAG:
|
|
case PointerGesture::BUTTON_CLICK_OR_DRAG:
|
|
case PointerGesture::HOVER:
|
|
case PointerGesture::PRESS:
|
|
// Unfade the pointer when the current gesture manipulates the
|
|
// area directly under the pointer.
|
|
mPointerController->unfade(PointerControllerInterface::TRANSITION_IMMEDIATE);
|
|
break;
|
|
case PointerGesture::SWIPE:
|
|
case PointerGesture::FREEFORM:
|
|
// Fade the pointer when the current gesture manipulates a different
|
|
// area and there are spots to guide the user experience.
|
|
if (mParameters.gestureMode == Parameters::GESTURE_MODE_SPOTS) {
|
|
mPointerController->fade(PointerControllerInterface::TRANSITION_GRADUAL);
|
|
} else {
|
|
mPointerController->unfade(PointerControllerInterface::TRANSITION_IMMEDIATE);
|
|
}
|
|
break;
|
|
}
|
|
|
|
// Send events!
|
|
int32_t metaState = getContext()->getGlobalMetaState();
|
|
int32_t buttonState = mCurrentButtonState;
|
|
|
|
// Update last coordinates of pointers that have moved so that we observe the new
|
|
// pointer positions at the same time as other pointers that have just gone up.
|
|
bool down = mPointerGesture.currentGestureMode == PointerGesture::TAP
|
|
|| mPointerGesture.currentGestureMode == PointerGesture::TAP_DRAG
|
|
|| mPointerGesture.currentGestureMode == PointerGesture::BUTTON_CLICK_OR_DRAG
|
|
|| mPointerGesture.currentGestureMode == PointerGesture::PRESS
|
|
|| mPointerGesture.currentGestureMode == PointerGesture::SWIPE
|
|
|| mPointerGesture.currentGestureMode == PointerGesture::FREEFORM;
|
|
bool moveNeeded = false;
|
|
if (down && !cancelPreviousGesture && !finishPreviousGesture
|
|
&& !mPointerGesture.lastGestureIdBits.isEmpty()
|
|
&& !mPointerGesture.currentGestureIdBits.isEmpty()) {
|
|
BitSet32 movedGestureIdBits(mPointerGesture.currentGestureIdBits.value
|
|
& mPointerGesture.lastGestureIdBits.value);
|
|
moveNeeded = updateMovedPointers(mPointerGesture.currentGestureProperties,
|
|
mPointerGesture.currentGestureCoords, mPointerGesture.currentGestureIdToIndex,
|
|
mPointerGesture.lastGestureProperties,
|
|
mPointerGesture.lastGestureCoords, mPointerGesture.lastGestureIdToIndex,
|
|
movedGestureIdBits);
|
|
if (buttonState != mLastButtonState) {
|
|
moveNeeded = true;
|
|
}
|
|
}
|
|
|
|
// Send motion events for all pointers that went up or were canceled.
|
|
BitSet32 dispatchedGestureIdBits(mPointerGesture.lastGestureIdBits);
|
|
if (!dispatchedGestureIdBits.isEmpty()) {
|
|
if (cancelPreviousGesture) {
|
|
dispatchMotion(when, policyFlags, mSource,
|
|
AMOTION_EVENT_ACTION_CANCEL, 0, metaState, buttonState,
|
|
AMOTION_EVENT_EDGE_FLAG_NONE,
|
|
mPointerGesture.lastGestureProperties,
|
|
mPointerGesture.lastGestureCoords, mPointerGesture.lastGestureIdToIndex,
|
|
dispatchedGestureIdBits, -1,
|
|
0, 0, mPointerGesture.downTime);
|
|
|
|
dispatchedGestureIdBits.clear();
|
|
} else {
|
|
BitSet32 upGestureIdBits;
|
|
if (finishPreviousGesture) {
|
|
upGestureIdBits = dispatchedGestureIdBits;
|
|
} else {
|
|
upGestureIdBits.value = dispatchedGestureIdBits.value
|
|
& ~mPointerGesture.currentGestureIdBits.value;
|
|
}
|
|
while (!upGestureIdBits.isEmpty()) {
|
|
uint32_t id = upGestureIdBits.clearFirstMarkedBit();
|
|
|
|
dispatchMotion(when, policyFlags, mSource,
|
|
AMOTION_EVENT_ACTION_POINTER_UP, 0,
|
|
metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE,
|
|
mPointerGesture.lastGestureProperties,
|
|
mPointerGesture.lastGestureCoords, mPointerGesture.lastGestureIdToIndex,
|
|
dispatchedGestureIdBits, id,
|
|
0, 0, mPointerGesture.downTime);
|
|
|
|
dispatchedGestureIdBits.clearBit(id);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Send motion events for all pointers that moved.
|
|
if (moveNeeded) {
|
|
dispatchMotion(when, policyFlags, mSource,
|
|
AMOTION_EVENT_ACTION_MOVE, 0, metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE,
|
|
mPointerGesture.currentGestureProperties,
|
|
mPointerGesture.currentGestureCoords, mPointerGesture.currentGestureIdToIndex,
|
|
dispatchedGestureIdBits, -1,
|
|
0, 0, mPointerGesture.downTime);
|
|
}
|
|
|
|
// Send motion events for all pointers that went down.
|
|
if (down) {
|
|
BitSet32 downGestureIdBits(mPointerGesture.currentGestureIdBits.value
|
|
& ~dispatchedGestureIdBits.value);
|
|
while (!downGestureIdBits.isEmpty()) {
|
|
uint32_t id = downGestureIdBits.clearFirstMarkedBit();
|
|
dispatchedGestureIdBits.markBit(id);
|
|
|
|
if (dispatchedGestureIdBits.count() == 1) {
|
|
mPointerGesture.downTime = when;
|
|
}
|
|
|
|
dispatchMotion(when, policyFlags, mSource,
|
|
AMOTION_EVENT_ACTION_POINTER_DOWN, 0, metaState, buttonState, 0,
|
|
mPointerGesture.currentGestureProperties,
|
|
mPointerGesture.currentGestureCoords, mPointerGesture.currentGestureIdToIndex,
|
|
dispatchedGestureIdBits, id,
|
|
0, 0, mPointerGesture.downTime);
|
|
}
|
|
}
|
|
|
|
// Send motion events for hover.
|
|
if (mPointerGesture.currentGestureMode == PointerGesture::HOVER) {
|
|
dispatchMotion(when, policyFlags, mSource,
|
|
AMOTION_EVENT_ACTION_HOVER_MOVE, 0,
|
|
metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE,
|
|
mPointerGesture.currentGestureProperties,
|
|
mPointerGesture.currentGestureCoords, mPointerGesture.currentGestureIdToIndex,
|
|
mPointerGesture.currentGestureIdBits, -1,
|
|
0, 0, mPointerGesture.downTime);
|
|
} else if (dispatchedGestureIdBits.isEmpty()
|
|
&& !mPointerGesture.lastGestureIdBits.isEmpty()) {
|
|
// Synthesize a hover move event after all pointers go up to indicate that
|
|
// the pointer is hovering again even if the user is not currently touching
|
|
// the touch pad. This ensures that a view will receive a fresh hover enter
|
|
// event after a tap.
|
|
float x, y;
|
|
mPointerController->getPosition(&x, &y);
|
|
|
|
PointerProperties pointerProperties;
|
|
pointerProperties.clear();
|
|
pointerProperties.id = 0;
|
|
pointerProperties.toolType = AMOTION_EVENT_TOOL_TYPE_FINGER;
|
|
|
|
PointerCoords pointerCoords;
|
|
pointerCoords.clear();
|
|
pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_X, x);
|
|
pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_Y, y);
|
|
|
|
NotifyMotionArgs args(when, getDeviceId(), mSource, policyFlags,
|
|
AMOTION_EVENT_ACTION_HOVER_MOVE, 0,
|
|
metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE,
|
|
mViewport.displayId, 1, &pointerProperties, &pointerCoords,
|
|
0, 0, mPointerGesture.downTime);
|
|
getListener()->notifyMotion(&args);
|
|
}
|
|
|
|
// Update state.
|
|
mPointerGesture.lastGestureMode = mPointerGesture.currentGestureMode;
|
|
if (!down) {
|
|
mPointerGesture.lastGestureIdBits.clear();
|
|
} else {
|
|
mPointerGesture.lastGestureIdBits = mPointerGesture.currentGestureIdBits;
|
|
for (BitSet32 idBits(mPointerGesture.currentGestureIdBits); !idBits.isEmpty(); ) {
|
|
uint32_t id = idBits.clearFirstMarkedBit();
|
|
uint32_t index = mPointerGesture.currentGestureIdToIndex[id];
|
|
mPointerGesture.lastGestureProperties[index].copyFrom(
|
|
mPointerGesture.currentGestureProperties[index]);
|
|
mPointerGesture.lastGestureCoords[index].copyFrom(
|
|
mPointerGesture.currentGestureCoords[index]);
|
|
mPointerGesture.lastGestureIdToIndex[id] = index;
|
|
}
|
|
}
|
|
}
|
|
|
|
void TouchInputMapper::abortPointerGestures(nsecs_t when, uint32_t policyFlags) {
|
|
// Cancel previously dispatches pointers.
|
|
if (!mPointerGesture.lastGestureIdBits.isEmpty()) {
|
|
int32_t metaState = getContext()->getGlobalMetaState();
|
|
int32_t buttonState = mCurrentButtonState;
|
|
dispatchMotion(when, policyFlags, mSource,
|
|
AMOTION_EVENT_ACTION_CANCEL, 0, metaState, buttonState,
|
|
AMOTION_EVENT_EDGE_FLAG_NONE,
|
|
mPointerGesture.lastGestureProperties,
|
|
mPointerGesture.lastGestureCoords, mPointerGesture.lastGestureIdToIndex,
|
|
mPointerGesture.lastGestureIdBits, -1,
|
|
0, 0, mPointerGesture.downTime);
|
|
}
|
|
|
|
// Reset the current pointer gesture.
|
|
mPointerGesture.reset();
|
|
mPointerVelocityControl.reset();
|
|
|
|
// Remove any current spots.
|
|
if (mPointerController != NULL) {
|
|
mPointerController->fade(PointerControllerInterface::TRANSITION_GRADUAL);
|
|
mPointerController->clearSpots();
|
|
}
|
|
}
|
|
|
|
bool TouchInputMapper::preparePointerGestures(nsecs_t when,
|
|
bool* outCancelPreviousGesture, bool* outFinishPreviousGesture, bool isTimeout) {
|
|
*outCancelPreviousGesture = false;
|
|
*outFinishPreviousGesture = false;
|
|
|
|
// Handle TAP timeout.
|
|
if (isTimeout) {
|
|
#if DEBUG_GESTURES
|
|
ALOGD("Gestures: Processing timeout");
|
|
#endif
|
|
|
|
if (mPointerGesture.lastGestureMode == PointerGesture::TAP) {
|
|
if (when <= mPointerGesture.tapUpTime + mConfig.pointerGestureTapDragInterval) {
|
|
// The tap/drag timeout has not yet expired.
|
|
getContext()->requestTimeoutAtTime(mPointerGesture.tapUpTime
|
|
+ mConfig.pointerGestureTapDragInterval);
|
|
} else {
|
|
// The tap is finished.
|
|
#if DEBUG_GESTURES
|
|
ALOGD("Gestures: TAP finished");
|
|
#endif
|
|
*outFinishPreviousGesture = true;
|
|
|
|
mPointerGesture.activeGestureId = -1;
|
|
mPointerGesture.currentGestureMode = PointerGesture::NEUTRAL;
|
|
mPointerGesture.currentGestureIdBits.clear();
|
|
|
|
mPointerVelocityControl.reset();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// We did not handle this timeout.
|
|
return false;
|
|
}
|
|
|
|
const uint32_t currentFingerCount = mCurrentFingerIdBits.count();
|
|
const uint32_t lastFingerCount = mLastFingerIdBits.count();
|
|
|
|
// Update the velocity tracker.
|
|
{
|
|
VelocityTracker::Position positions[MAX_POINTERS];
|
|
uint32_t count = 0;
|
|
for (BitSet32 idBits(mCurrentFingerIdBits); !idBits.isEmpty(); count++) {
|
|
uint32_t id = idBits.clearFirstMarkedBit();
|
|
const RawPointerData::Pointer& pointer = mCurrentRawPointerData.pointerForId(id);
|
|
positions[count].x = pointer.x * mPointerXMovementScale;
|
|
positions[count].y = pointer.y * mPointerYMovementScale;
|
|
}
|
|
mPointerGesture.velocityTracker.addMovement(when,
|
|
mCurrentFingerIdBits, positions);
|
|
}
|
|
|
|
// If the gesture ever enters a mode other than TAP, HOVER or TAP_DRAG, without first returning
|
|
// to NEUTRAL, then we should not generate tap event.
|
|
if (mPointerGesture.lastGestureMode != PointerGesture::HOVER
|
|
&& mPointerGesture.lastGestureMode != PointerGesture::TAP
|
|
&& mPointerGesture.lastGestureMode != PointerGesture::TAP_DRAG) {
|
|
mPointerGesture.resetTap();
|
|
}
|
|
|
|
// Pick a new active touch id if needed.
|
|
// Choose an arbitrary pointer that just went down, if there is one.
|
|
// Otherwise choose an arbitrary remaining pointer.
|
|
// This guarantees we always have an active touch id when there is at least one pointer.
|
|
// We keep the same active touch id for as long as possible.
|
|
bool activeTouchChanged = false;
|
|
int32_t lastActiveTouchId = mPointerGesture.activeTouchId;
|
|
int32_t activeTouchId = lastActiveTouchId;
|
|
if (activeTouchId < 0) {
|
|
if (!mCurrentFingerIdBits.isEmpty()) {
|
|
activeTouchChanged = true;
|
|
activeTouchId = mPointerGesture.activeTouchId =
|
|
mCurrentFingerIdBits.firstMarkedBit();
|
|
mPointerGesture.firstTouchTime = when;
|
|
}
|
|
} else if (!mCurrentFingerIdBits.hasBit(activeTouchId)) {
|
|
activeTouchChanged = true;
|
|
if (!mCurrentFingerIdBits.isEmpty()) {
|
|
activeTouchId = mPointerGesture.activeTouchId =
|
|
mCurrentFingerIdBits.firstMarkedBit();
|
|
} else {
|
|
activeTouchId = mPointerGesture.activeTouchId = -1;
|
|
}
|
|
}
|
|
|
|
// Determine whether we are in quiet time.
|
|
bool isQuietTime = false;
|
|
if (activeTouchId < 0) {
|
|
mPointerGesture.resetQuietTime();
|
|
} else {
|
|
isQuietTime = when < mPointerGesture.quietTime + mConfig.pointerGestureQuietInterval;
|
|
if (!isQuietTime) {
|
|
if ((mPointerGesture.lastGestureMode == PointerGesture::PRESS
|
|
|| mPointerGesture.lastGestureMode == PointerGesture::SWIPE
|
|
|| mPointerGesture.lastGestureMode == PointerGesture::FREEFORM)
|
|
&& currentFingerCount < 2) {
|
|
// Enter quiet time when exiting swipe or freeform state.
|
|
// This is to prevent accidentally entering the hover state and flinging the
|
|
// pointer when finishing a swipe and there is still one pointer left onscreen.
|
|
isQuietTime = true;
|
|
} else if (mPointerGesture.lastGestureMode == PointerGesture::BUTTON_CLICK_OR_DRAG
|
|
&& currentFingerCount >= 2
|
|
&& !isPointerDown(mCurrentButtonState)) {
|
|
// Enter quiet time when releasing the button and there are still two or more
|
|
// fingers down. This may indicate that one finger was used to press the button
|
|
// but it has not gone up yet.
|
|
isQuietTime = true;
|
|
}
|
|
if (isQuietTime) {
|
|
mPointerGesture.quietTime = when;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Switch states based on button and pointer state.
|
|
if (isQuietTime) {
|
|
// Case 1: Quiet time. (QUIET)
|
|
#if DEBUG_GESTURES
|
|
ALOGD("Gestures: QUIET for next %0.3fms", (mPointerGesture.quietTime
|
|
+ mConfig.pointerGestureQuietInterval - when) * 0.000001f);
|
|
#endif
|
|
if (mPointerGesture.lastGestureMode != PointerGesture::QUIET) {
|
|
*outFinishPreviousGesture = true;
|
|
}
|
|
|
|
mPointerGesture.activeGestureId = -1;
|
|
mPointerGesture.currentGestureMode = PointerGesture::QUIET;
|
|
mPointerGesture.currentGestureIdBits.clear();
|
|
|
|
mPointerVelocityControl.reset();
|
|
} else if (isPointerDown(mCurrentButtonState)) {
|
|
// Case 2: Button is pressed. (BUTTON_CLICK_OR_DRAG)
|
|
// The pointer follows the active touch point.
|
|
// Emit DOWN, MOVE, UP events at the pointer location.
|
|
//
|
|
// Only the active touch matters; other fingers are ignored. This policy helps
|
|
// to handle the case where the user places a second finger on the touch pad
|
|
// to apply the necessary force to depress an integrated button below the surface.
|
|
// We don't want the second finger to be delivered to applications.
|
|
//
|
|
// For this to work well, we need to make sure to track the pointer that is really
|
|
// active. If the user first puts one finger down to click then adds another
|
|
// finger to drag then the active pointer should switch to the finger that is
|
|
// being dragged.
|
|
#if DEBUG_GESTURES
|
|
ALOGD("Gestures: BUTTON_CLICK_OR_DRAG activeTouchId=%d, "
|
|
"currentFingerCount=%d", activeTouchId, currentFingerCount);
|
|
#endif
|
|
// Reset state when just starting.
|
|
if (mPointerGesture.lastGestureMode != PointerGesture::BUTTON_CLICK_OR_DRAG) {
|
|
*outFinishPreviousGesture = true;
|
|
mPointerGesture.activeGestureId = 0;
|
|
}
|
|
|
|
// Switch pointers if needed.
|
|
// Find the fastest pointer and follow it.
|
|
if (activeTouchId >= 0 && currentFingerCount > 1) {
|
|
int32_t bestId = -1;
|
|
float bestSpeed = mConfig.pointerGestureDragMinSwitchSpeed;
|
|
for (BitSet32 idBits(mCurrentFingerIdBits); !idBits.isEmpty(); ) {
|
|
uint32_t id = idBits.clearFirstMarkedBit();
|
|
float vx, vy;
|
|
if (mPointerGesture.velocityTracker.getVelocity(id, &vx, &vy)) {
|
|
float speed = hypotf(vx, vy);
|
|
if (speed > bestSpeed) {
|
|
bestId = id;
|
|
bestSpeed = speed;
|
|
}
|
|
}
|
|
}
|
|
if (bestId >= 0 && bestId != activeTouchId) {
|
|
mPointerGesture.activeTouchId = activeTouchId = bestId;
|
|
activeTouchChanged = true;
|
|
#if DEBUG_GESTURES
|
|
ALOGD("Gestures: BUTTON_CLICK_OR_DRAG switched pointers, "
|
|
"bestId=%d, bestSpeed=%0.3f", bestId, bestSpeed);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
if (activeTouchId >= 0 && mLastFingerIdBits.hasBit(activeTouchId)) {
|
|
const RawPointerData::Pointer& currentPointer =
|
|
mCurrentRawPointerData.pointerForId(activeTouchId);
|
|
const RawPointerData::Pointer& lastPointer =
|
|
mLastRawPointerData.pointerForId(activeTouchId);
|
|
float deltaX = (currentPointer.x - lastPointer.x) * mPointerXMovementScale;
|
|
float deltaY = (currentPointer.y - lastPointer.y) * mPointerYMovementScale;
|
|
|
|
rotateDelta(mSurfaceOrientation, &deltaX, &deltaY);
|
|
mPointerVelocityControl.move(when, &deltaX, &deltaY);
|
|
|
|
// Move the pointer using a relative motion.
|
|
// When using spots, the click will occur at the position of the anchor
|
|
// spot and all other spots will move there.
|
|
mPointerController->move(deltaX, deltaY);
|
|
} else {
|
|
mPointerVelocityControl.reset();
|
|
}
|
|
|
|
float x, y;
|
|
mPointerController->getPosition(&x, &y);
|
|
|
|
mPointerGesture.currentGestureMode = PointerGesture::BUTTON_CLICK_OR_DRAG;
|
|
mPointerGesture.currentGestureIdBits.clear();
|
|
mPointerGesture.currentGestureIdBits.markBit(mPointerGesture.activeGestureId);
|
|
mPointerGesture.currentGestureIdToIndex[mPointerGesture.activeGestureId] = 0;
|
|
mPointerGesture.currentGestureProperties[0].clear();
|
|
mPointerGesture.currentGestureProperties[0].id = mPointerGesture.activeGestureId;
|
|
mPointerGesture.currentGestureProperties[0].toolType = AMOTION_EVENT_TOOL_TYPE_FINGER;
|
|
mPointerGesture.currentGestureCoords[0].clear();
|
|
mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X, x);
|
|
mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y, y);
|
|
mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 1.0f);
|
|
} else if (currentFingerCount == 0) {
|
|
// Case 3. No fingers down and button is not pressed. (NEUTRAL)
|
|
if (mPointerGesture.lastGestureMode != PointerGesture::NEUTRAL) {
|
|
*outFinishPreviousGesture = true;
|
|
}
|
|
|
|
// Watch for taps coming out of HOVER or TAP_DRAG mode.
|
|
// Checking for taps after TAP_DRAG allows us to detect double-taps.
|
|
bool tapped = false;
|
|
if ((mPointerGesture.lastGestureMode == PointerGesture::HOVER
|
|
|| mPointerGesture.lastGestureMode == PointerGesture::TAP_DRAG)
|
|
&& lastFingerCount == 1) {
|
|
if (when <= mPointerGesture.tapDownTime + mConfig.pointerGestureTapInterval) {
|
|
float x, y;
|
|
mPointerController->getPosition(&x, &y);
|
|
if (fabs(x - mPointerGesture.tapX) <= mConfig.pointerGestureTapSlop
|
|
&& fabs(y - mPointerGesture.tapY) <= mConfig.pointerGestureTapSlop) {
|
|
#if DEBUG_GESTURES
|
|
ALOGD("Gestures: TAP");
|
|
#endif
|
|
|
|
mPointerGesture.tapUpTime = when;
|
|
getContext()->requestTimeoutAtTime(when
|
|
+ mConfig.pointerGestureTapDragInterval);
|
|
|
|
mPointerGesture.activeGestureId = 0;
|
|
mPointerGesture.currentGestureMode = PointerGesture::TAP;
|
|
mPointerGesture.currentGestureIdBits.clear();
|
|
mPointerGesture.currentGestureIdBits.markBit(
|
|
mPointerGesture.activeGestureId);
|
|
mPointerGesture.currentGestureIdToIndex[
|
|
mPointerGesture.activeGestureId] = 0;
|
|
mPointerGesture.currentGestureProperties[0].clear();
|
|
mPointerGesture.currentGestureProperties[0].id =
|
|
mPointerGesture.activeGestureId;
|
|
mPointerGesture.currentGestureProperties[0].toolType =
|
|
AMOTION_EVENT_TOOL_TYPE_FINGER;
|
|
mPointerGesture.currentGestureCoords[0].clear();
|
|
mPointerGesture.currentGestureCoords[0].setAxisValue(
|
|
AMOTION_EVENT_AXIS_X, mPointerGesture.tapX);
|
|
mPointerGesture.currentGestureCoords[0].setAxisValue(
|
|
AMOTION_EVENT_AXIS_Y, mPointerGesture.tapY);
|
|
mPointerGesture.currentGestureCoords[0].setAxisValue(
|
|
AMOTION_EVENT_AXIS_PRESSURE, 1.0f);
|
|
|
|
tapped = true;
|
|
} else {
|
|
#if DEBUG_GESTURES
|
|
ALOGD("Gestures: Not a TAP, deltaX=%f, deltaY=%f",
|
|
x - mPointerGesture.tapX,
|
|
y - mPointerGesture.tapY);
|
|
#endif
|
|
}
|
|
} else {
|
|
#if DEBUG_GESTURES
|
|
if (mPointerGesture.tapDownTime != LLONG_MIN) {
|
|
ALOGD("Gestures: Not a TAP, %0.3fms since down",
|
|
(when - mPointerGesture.tapDownTime) * 0.000001f);
|
|
} else {
|
|
ALOGD("Gestures: Not a TAP, incompatible mode transitions");
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
mPointerVelocityControl.reset();
|
|
|
|
if (!tapped) {
|
|
#if DEBUG_GESTURES
|
|
ALOGD("Gestures: NEUTRAL");
|
|
#endif
|
|
mPointerGesture.activeGestureId = -1;
|
|
mPointerGesture.currentGestureMode = PointerGesture::NEUTRAL;
|
|
mPointerGesture.currentGestureIdBits.clear();
|
|
}
|
|
} else if (currentFingerCount == 1) {
|
|
// Case 4. Exactly one finger down, button is not pressed. (HOVER or TAP_DRAG)
|
|
// The pointer follows the active touch point.
|
|
// When in HOVER, emit HOVER_MOVE events at the pointer location.
|
|
// When in TAP_DRAG, emit MOVE events at the pointer location.
|
|
ALOG_ASSERT(activeTouchId >= 0);
|
|
|
|
mPointerGesture.currentGestureMode = PointerGesture::HOVER;
|
|
if (mPointerGesture.lastGestureMode == PointerGesture::TAP) {
|
|
if (when <= mPointerGesture.tapUpTime + mConfig.pointerGestureTapDragInterval) {
|
|
float x, y;
|
|
mPointerController->getPosition(&x, &y);
|
|
if (fabs(x - mPointerGesture.tapX) <= mConfig.pointerGestureTapSlop
|
|
&& fabs(y - mPointerGesture.tapY) <= mConfig.pointerGestureTapSlop) {
|
|
mPointerGesture.currentGestureMode = PointerGesture::TAP_DRAG;
|
|
} else {
|
|
#if DEBUG_GESTURES
|
|
ALOGD("Gestures: Not a TAP_DRAG, deltaX=%f, deltaY=%f",
|
|
x - mPointerGesture.tapX,
|
|
y - mPointerGesture.tapY);
|
|
#endif
|
|
}
|
|
} else {
|
|
#if DEBUG_GESTURES
|
|
ALOGD("Gestures: Not a TAP_DRAG, %0.3fms time since up",
|
|
(when - mPointerGesture.tapUpTime) * 0.000001f);
|
|
#endif
|
|
}
|
|
} else if (mPointerGesture.lastGestureMode == PointerGesture::TAP_DRAG) {
|
|
mPointerGesture.currentGestureMode = PointerGesture::TAP_DRAG;
|
|
}
|
|
|
|
if (mLastFingerIdBits.hasBit(activeTouchId)) {
|
|
const RawPointerData::Pointer& currentPointer =
|
|
mCurrentRawPointerData.pointerForId(activeTouchId);
|
|
const RawPointerData::Pointer& lastPointer =
|
|
mLastRawPointerData.pointerForId(activeTouchId);
|
|
float deltaX = (currentPointer.x - lastPointer.x)
|
|
* mPointerXMovementScale;
|
|
float deltaY = (currentPointer.y - lastPointer.y)
|
|
* mPointerYMovementScale;
|
|
|
|
rotateDelta(mSurfaceOrientation, &deltaX, &deltaY);
|
|
mPointerVelocityControl.move(when, &deltaX, &deltaY);
|
|
|
|
// Move the pointer using a relative motion.
|
|
// When using spots, the hover or drag will occur at the position of the anchor spot.
|
|
mPointerController->move(deltaX, deltaY);
|
|
} else {
|
|
mPointerVelocityControl.reset();
|
|
}
|
|
|
|
bool down;
|
|
if (mPointerGesture.currentGestureMode == PointerGesture::TAP_DRAG) {
|
|
#if DEBUG_GESTURES
|
|
ALOGD("Gestures: TAP_DRAG");
|
|
#endif
|
|
down = true;
|
|
} else {
|
|
#if DEBUG_GESTURES
|
|
ALOGD("Gestures: HOVER");
|
|
#endif
|
|
if (mPointerGesture.lastGestureMode != PointerGesture::HOVER) {
|
|
*outFinishPreviousGesture = true;
|
|
}
|
|
mPointerGesture.activeGestureId = 0;
|
|
down = false;
|
|
}
|
|
|
|
float x, y;
|
|
mPointerController->getPosition(&x, &y);
|
|
|
|
mPointerGesture.currentGestureIdBits.clear();
|
|
mPointerGesture.currentGestureIdBits.markBit(mPointerGesture.activeGestureId);
|
|
mPointerGesture.currentGestureIdToIndex[mPointerGesture.activeGestureId] = 0;
|
|
mPointerGesture.currentGestureProperties[0].clear();
|
|
mPointerGesture.currentGestureProperties[0].id = mPointerGesture.activeGestureId;
|
|
mPointerGesture.currentGestureProperties[0].toolType =
|
|
AMOTION_EVENT_TOOL_TYPE_FINGER;
|
|
mPointerGesture.currentGestureCoords[0].clear();
|
|
mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X, x);
|
|
mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y, y);
|
|
mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE,
|
|
down ? 1.0f : 0.0f);
|
|
|
|
if (lastFingerCount == 0 && currentFingerCount != 0) {
|
|
mPointerGesture.resetTap();
|
|
mPointerGesture.tapDownTime = when;
|
|
mPointerGesture.tapX = x;
|
|
mPointerGesture.tapY = y;
|
|
}
|
|
} else {
|
|
// Case 5. At least two fingers down, button is not pressed. (PRESS, SWIPE or FREEFORM)
|
|
// We need to provide feedback for each finger that goes down so we cannot wait
|
|
// for the fingers to move before deciding what to do.
|
|
//
|
|
// The ambiguous case is deciding what to do when there are two fingers down but they
|
|
// have not moved enough to determine whether they are part of a drag or part of a
|
|
// freeform gesture, or just a press or long-press at the pointer location.
|
|
//
|
|
// When there are two fingers we start with the PRESS hypothesis and we generate a
|
|
// down at the pointer location.
|
|
//
|
|
// When the two fingers move enough or when additional fingers are added, we make
|
|
// a decision to transition into SWIPE or FREEFORM mode accordingly.
|
|
ALOG_ASSERT(activeTouchId >= 0);
|
|
|
|
bool settled = when >= mPointerGesture.firstTouchTime
|
|
+ mConfig.pointerGestureMultitouchSettleInterval;
|
|
if (mPointerGesture.lastGestureMode != PointerGesture::PRESS
|
|
&& mPointerGesture.lastGestureMode != PointerGesture::SWIPE
|
|
&& mPointerGesture.lastGestureMode != PointerGesture::FREEFORM) {
|
|
*outFinishPreviousGesture = true;
|
|
} else if (!settled && currentFingerCount > lastFingerCount) {
|
|
// Additional pointers have gone down but not yet settled.
|
|
// Reset the gesture.
|
|
#if DEBUG_GESTURES
|
|
ALOGD("Gestures: Resetting gesture since additional pointers went down for MULTITOUCH, "
|
|
"settle time remaining %0.3fms", (mPointerGesture.firstTouchTime
|
|
+ mConfig.pointerGestureMultitouchSettleInterval - when)
|
|
* 0.000001f);
|
|
#endif
|
|
*outCancelPreviousGesture = true;
|
|
} else {
|
|
// Continue previous gesture.
|
|
mPointerGesture.currentGestureMode = mPointerGesture.lastGestureMode;
|
|
}
|
|
|
|
if (*outFinishPreviousGesture || *outCancelPreviousGesture) {
|
|
mPointerGesture.currentGestureMode = PointerGesture::PRESS;
|
|
mPointerGesture.activeGestureId = 0;
|
|
mPointerGesture.referenceIdBits.clear();
|
|
mPointerVelocityControl.reset();
|
|
|
|
// Use the centroid and pointer location as the reference points for the gesture.
|
|
#if DEBUG_GESTURES
|
|
ALOGD("Gestures: Using centroid as reference for MULTITOUCH, "
|
|
"settle time remaining %0.3fms", (mPointerGesture.firstTouchTime
|
|
+ mConfig.pointerGestureMultitouchSettleInterval - when)
|
|
* 0.000001f);
|
|
#endif
|
|
mCurrentRawPointerData.getCentroidOfTouchingPointers(
|
|
&mPointerGesture.referenceTouchX,
|
|
&mPointerGesture.referenceTouchY);
|
|
mPointerController->getPosition(&mPointerGesture.referenceGestureX,
|
|
&mPointerGesture.referenceGestureY);
|
|
}
|
|
|
|
// Clear the reference deltas for fingers not yet included in the reference calculation.
|
|
for (BitSet32 idBits(mCurrentFingerIdBits.value
|
|
& ~mPointerGesture.referenceIdBits.value); !idBits.isEmpty(); ) {
|
|
uint32_t id = idBits.clearFirstMarkedBit();
|
|
mPointerGesture.referenceDeltas[id].dx = 0;
|
|
mPointerGesture.referenceDeltas[id].dy = 0;
|
|
}
|
|
mPointerGesture.referenceIdBits = mCurrentFingerIdBits;
|
|
|
|
// Add delta for all fingers and calculate a common movement delta.
|
|
float commonDeltaX = 0, commonDeltaY = 0;
|
|
BitSet32 commonIdBits(mLastFingerIdBits.value
|
|
& mCurrentFingerIdBits.value);
|
|
for (BitSet32 idBits(commonIdBits); !idBits.isEmpty(); ) {
|
|
bool first = (idBits == commonIdBits);
|
|
uint32_t id = idBits.clearFirstMarkedBit();
|
|
const RawPointerData::Pointer& cpd = mCurrentRawPointerData.pointerForId(id);
|
|
const RawPointerData::Pointer& lpd = mLastRawPointerData.pointerForId(id);
|
|
PointerGesture::Delta& delta = mPointerGesture.referenceDeltas[id];
|
|
delta.dx += cpd.x - lpd.x;
|
|
delta.dy += cpd.y - lpd.y;
|
|
|
|
if (first) {
|
|
commonDeltaX = delta.dx;
|
|
commonDeltaY = delta.dy;
|
|
} else {
|
|
commonDeltaX = calculateCommonVector(commonDeltaX, delta.dx);
|
|
commonDeltaY = calculateCommonVector(commonDeltaY, delta.dy);
|
|
}
|
|
}
|
|
|
|
// Consider transitions from PRESS to SWIPE or MULTITOUCH.
|
|
if (mPointerGesture.currentGestureMode == PointerGesture::PRESS) {
|
|
float dist[MAX_POINTER_ID + 1];
|
|
int32_t distOverThreshold = 0;
|
|
for (BitSet32 idBits(mPointerGesture.referenceIdBits); !idBits.isEmpty(); ) {
|
|
uint32_t id = idBits.clearFirstMarkedBit();
|
|
PointerGesture::Delta& delta = mPointerGesture.referenceDeltas[id];
|
|
dist[id] = hypotf(delta.dx * mPointerXZoomScale,
|
|
delta.dy * mPointerYZoomScale);
|
|
if (dist[id] > mConfig.pointerGestureMultitouchMinDistance) {
|
|
distOverThreshold += 1;
|
|
}
|
|
}
|
|
|
|
// Only transition when at least two pointers have moved further than
|
|
// the minimum distance threshold.
|
|
if (distOverThreshold >= 2) {
|
|
if (currentFingerCount > 2) {
|
|
// There are more than two pointers, switch to FREEFORM.
|
|
#if DEBUG_GESTURES
|
|
ALOGD("Gestures: PRESS transitioned to FREEFORM, number of pointers %d > 2",
|
|
currentFingerCount);
|
|
#endif
|
|
*outCancelPreviousGesture = true;
|
|
mPointerGesture.currentGestureMode = PointerGesture::FREEFORM;
|
|
} else {
|
|
// There are exactly two pointers.
|
|
BitSet32 idBits(mCurrentFingerIdBits);
|
|
uint32_t id1 = idBits.clearFirstMarkedBit();
|
|
uint32_t id2 = idBits.firstMarkedBit();
|
|
const RawPointerData::Pointer& p1 = mCurrentRawPointerData.pointerForId(id1);
|
|
const RawPointerData::Pointer& p2 = mCurrentRawPointerData.pointerForId(id2);
|
|
float mutualDistance = distance(p1.x, p1.y, p2.x, p2.y);
|
|
if (mutualDistance > mPointerGestureMaxSwipeWidth) {
|
|
// There are two pointers but they are too far apart for a SWIPE,
|
|
// switch to FREEFORM.
|
|
#if DEBUG_GESTURES
|
|
ALOGD("Gestures: PRESS transitioned to FREEFORM, distance %0.3f > %0.3f",
|
|
mutualDistance, mPointerGestureMaxSwipeWidth);
|
|
#endif
|
|
*outCancelPreviousGesture = true;
|
|
mPointerGesture.currentGestureMode = PointerGesture::FREEFORM;
|
|
} else {
|
|
// There are two pointers. Wait for both pointers to start moving
|
|
// before deciding whether this is a SWIPE or FREEFORM gesture.
|
|
float dist1 = dist[id1];
|
|
float dist2 = dist[id2];
|
|
if (dist1 >= mConfig.pointerGestureMultitouchMinDistance
|
|
&& dist2 >= mConfig.pointerGestureMultitouchMinDistance) {
|
|
// Calculate the dot product of the displacement vectors.
|
|
// When the vectors are oriented in approximately the same direction,
|
|
// the angle betweeen them is near zero and the cosine of the angle
|
|
// approches 1.0. Recall that dot(v1, v2) = cos(angle) * mag(v1) * mag(v2).
|
|
PointerGesture::Delta& delta1 = mPointerGesture.referenceDeltas[id1];
|
|
PointerGesture::Delta& delta2 = mPointerGesture.referenceDeltas[id2];
|
|
float dx1 = delta1.dx * mPointerXZoomScale;
|
|
float dy1 = delta1.dy * mPointerYZoomScale;
|
|
float dx2 = delta2.dx * mPointerXZoomScale;
|
|
float dy2 = delta2.dy * mPointerYZoomScale;
|
|
float dot = dx1 * dx2 + dy1 * dy2;
|
|
float cosine = dot / (dist1 * dist2); // denominator always > 0
|
|
if (cosine >= mConfig.pointerGestureSwipeTransitionAngleCosine) {
|
|
// Pointers are moving in the same direction. Switch to SWIPE.
|
|
#if DEBUG_GESTURES
|
|
ALOGD("Gestures: PRESS transitioned to SWIPE, "
|
|
"dist1 %0.3f >= %0.3f, dist2 %0.3f >= %0.3f, "
|
|
"cosine %0.3f >= %0.3f",
|
|
dist1, mConfig.pointerGestureMultitouchMinDistance,
|
|
dist2, mConfig.pointerGestureMultitouchMinDistance,
|
|
cosine, mConfig.pointerGestureSwipeTransitionAngleCosine);
|
|
#endif
|
|
mPointerGesture.currentGestureMode = PointerGesture::SWIPE;
|
|
} else {
|
|
// Pointers are moving in different directions. Switch to FREEFORM.
|
|
#if DEBUG_GESTURES
|
|
ALOGD("Gestures: PRESS transitioned to FREEFORM, "
|
|
"dist1 %0.3f >= %0.3f, dist2 %0.3f >= %0.3f, "
|
|
"cosine %0.3f < %0.3f",
|
|
dist1, mConfig.pointerGestureMultitouchMinDistance,
|
|
dist2, mConfig.pointerGestureMultitouchMinDistance,
|
|
cosine, mConfig.pointerGestureSwipeTransitionAngleCosine);
|
|
#endif
|
|
*outCancelPreviousGesture = true;
|
|
mPointerGesture.currentGestureMode = PointerGesture::FREEFORM;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (mPointerGesture.currentGestureMode == PointerGesture::SWIPE) {
|
|
// Switch from SWIPE to FREEFORM if additional pointers go down.
|
|
// Cancel previous gesture.
|
|
if (currentFingerCount > 2) {
|
|
#if DEBUG_GESTURES
|
|
ALOGD("Gestures: SWIPE transitioned to FREEFORM, number of pointers %d > 2",
|
|
currentFingerCount);
|
|
#endif
|
|
*outCancelPreviousGesture = true;
|
|
mPointerGesture.currentGestureMode = PointerGesture::FREEFORM;
|
|
}
|
|
}
|
|
|
|
// Move the reference points based on the overall group motion of the fingers
|
|
// except in PRESS mode while waiting for a transition to occur.
|
|
if (mPointerGesture.currentGestureMode != PointerGesture::PRESS
|
|
&& (commonDeltaX || commonDeltaY)) {
|
|
for (BitSet32 idBits(mPointerGesture.referenceIdBits); !idBits.isEmpty(); ) {
|
|
uint32_t id = idBits.clearFirstMarkedBit();
|
|
PointerGesture::Delta& delta = mPointerGesture.referenceDeltas[id];
|
|
delta.dx = 0;
|
|
delta.dy = 0;
|
|
}
|
|
|
|
mPointerGesture.referenceTouchX += commonDeltaX;
|
|
mPointerGesture.referenceTouchY += commonDeltaY;
|
|
|
|
commonDeltaX *= mPointerXMovementScale;
|
|
commonDeltaY *= mPointerYMovementScale;
|
|
|
|
rotateDelta(mSurfaceOrientation, &commonDeltaX, &commonDeltaY);
|
|
mPointerVelocityControl.move(when, &commonDeltaX, &commonDeltaY);
|
|
|
|
mPointerGesture.referenceGestureX += commonDeltaX;
|
|
mPointerGesture.referenceGestureY += commonDeltaY;
|
|
}
|
|
|
|
// Report gestures.
|
|
if (mPointerGesture.currentGestureMode == PointerGesture::PRESS
|
|
|| mPointerGesture.currentGestureMode == PointerGesture::SWIPE) {
|
|
// PRESS or SWIPE mode.
|
|
#if DEBUG_GESTURES
|
|
ALOGD("Gestures: PRESS or SWIPE activeTouchId=%d,"
|
|
"activeGestureId=%d, currentTouchPointerCount=%d",
|
|
activeTouchId, mPointerGesture.activeGestureId, currentFingerCount);
|
|
#endif
|
|
ALOG_ASSERT(mPointerGesture.activeGestureId >= 0);
|
|
|
|
mPointerGesture.currentGestureIdBits.clear();
|
|
mPointerGesture.currentGestureIdBits.markBit(mPointerGesture.activeGestureId);
|
|
mPointerGesture.currentGestureIdToIndex[mPointerGesture.activeGestureId] = 0;
|
|
mPointerGesture.currentGestureProperties[0].clear();
|
|
mPointerGesture.currentGestureProperties[0].id = mPointerGesture.activeGestureId;
|
|
mPointerGesture.currentGestureProperties[0].toolType =
|
|
AMOTION_EVENT_TOOL_TYPE_FINGER;
|
|
mPointerGesture.currentGestureCoords[0].clear();
|
|
mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X,
|
|
mPointerGesture.referenceGestureX);
|
|
mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y,
|
|
mPointerGesture.referenceGestureY);
|
|
mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 1.0f);
|
|
} else if (mPointerGesture.currentGestureMode == PointerGesture::FREEFORM) {
|
|
// FREEFORM mode.
|
|
#if DEBUG_GESTURES
|
|
ALOGD("Gestures: FREEFORM activeTouchId=%d,"
|
|
"activeGestureId=%d, currentTouchPointerCount=%d",
|
|
activeTouchId, mPointerGesture.activeGestureId, currentFingerCount);
|
|
#endif
|
|
ALOG_ASSERT(mPointerGesture.activeGestureId >= 0);
|
|
|
|
mPointerGesture.currentGestureIdBits.clear();
|
|
|
|
BitSet32 mappedTouchIdBits;
|
|
BitSet32 usedGestureIdBits;
|
|
if (mPointerGesture.lastGestureMode != PointerGesture::FREEFORM) {
|
|
// Initially, assign the active gesture id to the active touch point
|
|
// if there is one. No other touch id bits are mapped yet.
|
|
if (!*outCancelPreviousGesture) {
|
|
mappedTouchIdBits.markBit(activeTouchId);
|
|
usedGestureIdBits.markBit(mPointerGesture.activeGestureId);
|
|
mPointerGesture.freeformTouchToGestureIdMap[activeTouchId] =
|
|
mPointerGesture.activeGestureId;
|
|
} else {
|
|
mPointerGesture.activeGestureId = -1;
|
|
}
|
|
} else {
|
|
// Otherwise, assume we mapped all touches from the previous frame.
|
|
// Reuse all mappings that are still applicable.
|
|
mappedTouchIdBits.value = mLastFingerIdBits.value
|
|
& mCurrentFingerIdBits.value;
|
|
usedGestureIdBits = mPointerGesture.lastGestureIdBits;
|
|
|
|
// Check whether we need to choose a new active gesture id because the
|
|
// current went went up.
|
|
for (BitSet32 upTouchIdBits(mLastFingerIdBits.value
|
|
& ~mCurrentFingerIdBits.value);
|
|
!upTouchIdBits.isEmpty(); ) {
|
|
uint32_t upTouchId = upTouchIdBits.clearFirstMarkedBit();
|
|
uint32_t upGestureId = mPointerGesture.freeformTouchToGestureIdMap[upTouchId];
|
|
if (upGestureId == uint32_t(mPointerGesture.activeGestureId)) {
|
|
mPointerGesture.activeGestureId = -1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
#if DEBUG_GESTURES
|
|
ALOGD("Gestures: FREEFORM follow up "
|
|
"mappedTouchIdBits=0x%08x, usedGestureIdBits=0x%08x, "
|
|
"activeGestureId=%d",
|
|
mappedTouchIdBits.value, usedGestureIdBits.value,
|
|
mPointerGesture.activeGestureId);
|
|
#endif
|
|
|
|
BitSet32 idBits(mCurrentFingerIdBits);
|
|
for (uint32_t i = 0; i < currentFingerCount; i++) {
|
|
uint32_t touchId = idBits.clearFirstMarkedBit();
|
|
uint32_t gestureId;
|
|
if (!mappedTouchIdBits.hasBit(touchId)) {
|
|
gestureId = usedGestureIdBits.markFirstUnmarkedBit();
|
|
mPointerGesture.freeformTouchToGestureIdMap[touchId] = gestureId;
|
|
#if DEBUG_GESTURES
|
|
ALOGD("Gestures: FREEFORM "
|
|
"new mapping for touch id %d -> gesture id %d",
|
|
touchId, gestureId);
|
|
#endif
|
|
} else {
|
|
gestureId = mPointerGesture.freeformTouchToGestureIdMap[touchId];
|
|
#if DEBUG_GESTURES
|
|
ALOGD("Gestures: FREEFORM "
|
|
"existing mapping for touch id %d -> gesture id %d",
|
|
touchId, gestureId);
|
|
#endif
|
|
}
|
|
mPointerGesture.currentGestureIdBits.markBit(gestureId);
|
|
mPointerGesture.currentGestureIdToIndex[gestureId] = i;
|
|
|
|
const RawPointerData::Pointer& pointer =
|
|
mCurrentRawPointerData.pointerForId(touchId);
|
|
float deltaX = (pointer.x - mPointerGesture.referenceTouchX)
|
|
* mPointerXZoomScale;
|
|
float deltaY = (pointer.y - mPointerGesture.referenceTouchY)
|
|
* mPointerYZoomScale;
|
|
rotateDelta(mSurfaceOrientation, &deltaX, &deltaY);
|
|
|
|
mPointerGesture.currentGestureProperties[i].clear();
|
|
mPointerGesture.currentGestureProperties[i].id = gestureId;
|
|
mPointerGesture.currentGestureProperties[i].toolType =
|
|
AMOTION_EVENT_TOOL_TYPE_FINGER;
|
|
mPointerGesture.currentGestureCoords[i].clear();
|
|
mPointerGesture.currentGestureCoords[i].setAxisValue(
|
|
AMOTION_EVENT_AXIS_X, mPointerGesture.referenceGestureX + deltaX);
|
|
mPointerGesture.currentGestureCoords[i].setAxisValue(
|
|
AMOTION_EVENT_AXIS_Y, mPointerGesture.referenceGestureY + deltaY);
|
|
mPointerGesture.currentGestureCoords[i].setAxisValue(
|
|
AMOTION_EVENT_AXIS_PRESSURE, 1.0f);
|
|
}
|
|
|
|
if (mPointerGesture.activeGestureId < 0) {
|
|
mPointerGesture.activeGestureId =
|
|
mPointerGesture.currentGestureIdBits.firstMarkedBit();
|
|
#if DEBUG_GESTURES
|
|
ALOGD("Gestures: FREEFORM new "
|
|
"activeGestureId=%d", mPointerGesture.activeGestureId);
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
mPointerController->setButtonState(mCurrentButtonState);
|
|
|
|
#if DEBUG_GESTURES
|
|
ALOGD("Gestures: finishPreviousGesture=%s, cancelPreviousGesture=%s, "
|
|
"currentGestureMode=%d, currentGestureIdBits=0x%08x, "
|
|
"lastGestureMode=%d, lastGestureIdBits=0x%08x",
|
|
toString(*outFinishPreviousGesture), toString(*outCancelPreviousGesture),
|
|
mPointerGesture.currentGestureMode, mPointerGesture.currentGestureIdBits.value,
|
|
mPointerGesture.lastGestureMode, mPointerGesture.lastGestureIdBits.value);
|
|
for (BitSet32 idBits = mPointerGesture.currentGestureIdBits; !idBits.isEmpty(); ) {
|
|
uint32_t id = idBits.clearFirstMarkedBit();
|
|
uint32_t index = mPointerGesture.currentGestureIdToIndex[id];
|
|
const PointerProperties& properties = mPointerGesture.currentGestureProperties[index];
|
|
const PointerCoords& coords = mPointerGesture.currentGestureCoords[index];
|
|
ALOGD(" currentGesture[%d]: index=%d, toolType=%d, "
|
|
"x=%0.3f, y=%0.3f, pressure=%0.3f",
|
|
id, index, properties.toolType,
|
|
coords.getAxisValue(AMOTION_EVENT_AXIS_X),
|
|
coords.getAxisValue(AMOTION_EVENT_AXIS_Y),
|
|
coords.getAxisValue(AMOTION_EVENT_AXIS_PRESSURE));
|
|
}
|
|
for (BitSet32 idBits = mPointerGesture.lastGestureIdBits; !idBits.isEmpty(); ) {
|
|
uint32_t id = idBits.clearFirstMarkedBit();
|
|
uint32_t index = mPointerGesture.lastGestureIdToIndex[id];
|
|
const PointerProperties& properties = mPointerGesture.lastGestureProperties[index];
|
|
const PointerCoords& coords = mPointerGesture.lastGestureCoords[index];
|
|
ALOGD(" lastGesture[%d]: index=%d, toolType=%d, "
|
|
"x=%0.3f, y=%0.3f, pressure=%0.3f",
|
|
id, index, properties.toolType,
|
|
coords.getAxisValue(AMOTION_EVENT_AXIS_X),
|
|
coords.getAxisValue(AMOTION_EVENT_AXIS_Y),
|
|
coords.getAxisValue(AMOTION_EVENT_AXIS_PRESSURE));
|
|
}
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
void TouchInputMapper::dispatchPointerStylus(nsecs_t when, uint32_t policyFlags) {
|
|
mPointerSimple.currentCoords.clear();
|
|
mPointerSimple.currentProperties.clear();
|
|
|
|
bool down, hovering;
|
|
if (!mCurrentStylusIdBits.isEmpty()) {
|
|
uint32_t id = mCurrentStylusIdBits.firstMarkedBit();
|
|
uint32_t index = mCurrentCookedPointerData.idToIndex[id];
|
|
float x = mCurrentCookedPointerData.pointerCoords[index].getX();
|
|
float y = mCurrentCookedPointerData.pointerCoords[index].getY();
|
|
mPointerController->setPosition(x, y);
|
|
|
|
hovering = mCurrentCookedPointerData.hoveringIdBits.hasBit(id);
|
|
down = !hovering;
|
|
|
|
mPointerController->getPosition(&x, &y);
|
|
mPointerSimple.currentCoords.copyFrom(mCurrentCookedPointerData.pointerCoords[index]);
|
|
mPointerSimple.currentCoords.setAxisValue(AMOTION_EVENT_AXIS_X, x);
|
|
mPointerSimple.currentCoords.setAxisValue(AMOTION_EVENT_AXIS_Y, y);
|
|
mPointerSimple.currentProperties.id = 0;
|
|
mPointerSimple.currentProperties.toolType =
|
|
mCurrentCookedPointerData.pointerProperties[index].toolType;
|
|
} else {
|
|
down = false;
|
|
hovering = false;
|
|
}
|
|
|
|
dispatchPointerSimple(when, policyFlags, down, hovering);
|
|
}
|
|
|
|
void TouchInputMapper::abortPointerStylus(nsecs_t when, uint32_t policyFlags) {
|
|
abortPointerSimple(when, policyFlags);
|
|
}
|
|
|
|
void TouchInputMapper::dispatchPointerMouse(nsecs_t when, uint32_t policyFlags) {
|
|
mPointerSimple.currentCoords.clear();
|
|
mPointerSimple.currentProperties.clear();
|
|
|
|
bool down, hovering;
|
|
if (!mCurrentMouseIdBits.isEmpty()) {
|
|
uint32_t id = mCurrentMouseIdBits.firstMarkedBit();
|
|
uint32_t currentIndex = mCurrentRawPointerData.idToIndex[id];
|
|
if (mLastMouseIdBits.hasBit(id)) {
|
|
uint32_t lastIndex = mCurrentRawPointerData.idToIndex[id];
|
|
float deltaX = (mCurrentRawPointerData.pointers[currentIndex].x
|
|
- mLastRawPointerData.pointers[lastIndex].x)
|
|
* mPointerXMovementScale;
|
|
float deltaY = (mCurrentRawPointerData.pointers[currentIndex].y
|
|
- mLastRawPointerData.pointers[lastIndex].y)
|
|
* mPointerYMovementScale;
|
|
|
|
rotateDelta(mSurfaceOrientation, &deltaX, &deltaY);
|
|
mPointerVelocityControl.move(when, &deltaX, &deltaY);
|
|
|
|
mPointerController->move(deltaX, deltaY);
|
|
} else {
|
|
mPointerVelocityControl.reset();
|
|
}
|
|
|
|
down = isPointerDown(mCurrentButtonState);
|
|
hovering = !down;
|
|
|
|
float x, y;
|
|
mPointerController->getPosition(&x, &y);
|
|
mPointerSimple.currentCoords.copyFrom(
|
|
mCurrentCookedPointerData.pointerCoords[currentIndex]);
|
|
mPointerSimple.currentCoords.setAxisValue(AMOTION_EVENT_AXIS_X, x);
|
|
mPointerSimple.currentCoords.setAxisValue(AMOTION_EVENT_AXIS_Y, y);
|
|
mPointerSimple.currentCoords.setAxisValue(AMOTION_EVENT_AXIS_PRESSURE,
|
|
hovering ? 0.0f : 1.0f);
|
|
mPointerSimple.currentProperties.id = 0;
|
|
mPointerSimple.currentProperties.toolType =
|
|
mCurrentCookedPointerData.pointerProperties[currentIndex].toolType;
|
|
} else {
|
|
mPointerVelocityControl.reset();
|
|
|
|
down = false;
|
|
hovering = false;
|
|
}
|
|
|
|
dispatchPointerSimple(when, policyFlags, down, hovering);
|
|
}
|
|
|
|
void TouchInputMapper::abortPointerMouse(nsecs_t when, uint32_t policyFlags) {
|
|
abortPointerSimple(when, policyFlags);
|
|
|
|
mPointerVelocityControl.reset();
|
|
}
|
|
|
|
void TouchInputMapper::dispatchPointerSimple(nsecs_t when, uint32_t policyFlags,
|
|
bool down, bool hovering) {
|
|
int32_t metaState = getContext()->getGlobalMetaState();
|
|
|
|
if (mPointerController != NULL) {
|
|
if (down || hovering) {
|
|
mPointerController->setPresentation(PointerControllerInterface::PRESENTATION_POINTER);
|
|
mPointerController->clearSpots();
|
|
mPointerController->setButtonState(mCurrentButtonState);
|
|
mPointerController->unfade(PointerControllerInterface::TRANSITION_IMMEDIATE);
|
|
} else if (!down && !hovering && (mPointerSimple.down || mPointerSimple.hovering)) {
|
|
mPointerController->fade(PointerControllerInterface::TRANSITION_GRADUAL);
|
|
}
|
|
}
|
|
|
|
if (mPointerSimple.down && !down) {
|
|
mPointerSimple.down = false;
|
|
|
|
// Send up.
|
|
NotifyMotionArgs args(when, getDeviceId(), mSource, policyFlags,
|
|
AMOTION_EVENT_ACTION_UP, 0, metaState, mLastButtonState, 0,
|
|
mViewport.displayId,
|
|
1, &mPointerSimple.lastProperties, &mPointerSimple.lastCoords,
|
|
mOrientedXPrecision, mOrientedYPrecision,
|
|
mPointerSimple.downTime);
|
|
getListener()->notifyMotion(&args);
|
|
}
|
|
|
|
if (mPointerSimple.hovering && !hovering) {
|
|
mPointerSimple.hovering = false;
|
|
|
|
// Send hover exit.
|
|
NotifyMotionArgs args(when, getDeviceId(), mSource, policyFlags,
|
|
AMOTION_EVENT_ACTION_HOVER_EXIT, 0, metaState, mLastButtonState, 0,
|
|
mViewport.displayId,
|
|
1, &mPointerSimple.lastProperties, &mPointerSimple.lastCoords,
|
|
mOrientedXPrecision, mOrientedYPrecision,
|
|
mPointerSimple.downTime);
|
|
getListener()->notifyMotion(&args);
|
|
}
|
|
|
|
if (down) {
|
|
if (!mPointerSimple.down) {
|
|
mPointerSimple.down = true;
|
|
mPointerSimple.downTime = when;
|
|
|
|
// Send down.
|
|
NotifyMotionArgs args(when, getDeviceId(), mSource, policyFlags,
|
|
AMOTION_EVENT_ACTION_DOWN, 0, metaState, mCurrentButtonState, 0,
|
|
mViewport.displayId,
|
|
1, &mPointerSimple.currentProperties, &mPointerSimple.currentCoords,
|
|
mOrientedXPrecision, mOrientedYPrecision,
|
|
mPointerSimple.downTime);
|
|
getListener()->notifyMotion(&args);
|
|
}
|
|
|
|
// Send move.
|
|
NotifyMotionArgs args(when, getDeviceId(), mSource, policyFlags,
|
|
AMOTION_EVENT_ACTION_MOVE, 0, metaState, mCurrentButtonState, 0,
|
|
mViewport.displayId,
|
|
1, &mPointerSimple.currentProperties, &mPointerSimple.currentCoords,
|
|
mOrientedXPrecision, mOrientedYPrecision,
|
|
mPointerSimple.downTime);
|
|
getListener()->notifyMotion(&args);
|
|
}
|
|
|
|
if (hovering) {
|
|
if (!mPointerSimple.hovering) {
|
|
mPointerSimple.hovering = true;
|
|
|
|
// Send hover enter.
|
|
NotifyMotionArgs args(when, getDeviceId(), mSource, policyFlags,
|
|
AMOTION_EVENT_ACTION_HOVER_ENTER, 0, metaState, mCurrentButtonState, 0,
|
|
mViewport.displayId,
|
|
1, &mPointerSimple.currentProperties, &mPointerSimple.currentCoords,
|
|
mOrientedXPrecision, mOrientedYPrecision,
|
|
mPointerSimple.downTime);
|
|
getListener()->notifyMotion(&args);
|
|
}
|
|
|
|
// Send hover move.
|
|
NotifyMotionArgs args(when, getDeviceId(), mSource, policyFlags,
|
|
AMOTION_EVENT_ACTION_HOVER_MOVE, 0, metaState, mCurrentButtonState, 0,
|
|
mViewport.displayId,
|
|
1, &mPointerSimple.currentProperties, &mPointerSimple.currentCoords,
|
|
mOrientedXPrecision, mOrientedYPrecision,
|
|
mPointerSimple.downTime);
|
|
getListener()->notifyMotion(&args);
|
|
}
|
|
|
|
if (mCurrentRawVScroll || mCurrentRawHScroll) {
|
|
float vscroll = mCurrentRawVScroll;
|
|
float hscroll = mCurrentRawHScroll;
|
|
mWheelYVelocityControl.move(when, NULL, &vscroll);
|
|
mWheelXVelocityControl.move(when, &hscroll, NULL);
|
|
|
|
// Send scroll.
|
|
PointerCoords pointerCoords;
|
|
pointerCoords.copyFrom(mPointerSimple.currentCoords);
|
|
pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_VSCROLL, vscroll);
|
|
pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_HSCROLL, hscroll);
|
|
|
|
NotifyMotionArgs args(when, getDeviceId(), mSource, policyFlags,
|
|
AMOTION_EVENT_ACTION_SCROLL, 0, metaState, mCurrentButtonState, 0,
|
|
mViewport.displayId,
|
|
1, &mPointerSimple.currentProperties, &pointerCoords,
|
|
mOrientedXPrecision, mOrientedYPrecision,
|
|
mPointerSimple.downTime);
|
|
getListener()->notifyMotion(&args);
|
|
}
|
|
|
|
// Save state.
|
|
if (down || hovering) {
|
|
mPointerSimple.lastCoords.copyFrom(mPointerSimple.currentCoords);
|
|
mPointerSimple.lastProperties.copyFrom(mPointerSimple.currentProperties);
|
|
} else {
|
|
mPointerSimple.reset();
|
|
}
|
|
}
|
|
|
|
void TouchInputMapper::abortPointerSimple(nsecs_t when, uint32_t policyFlags) {
|
|
mPointerSimple.currentCoords.clear();
|
|
mPointerSimple.currentProperties.clear();
|
|
|
|
dispatchPointerSimple(when, policyFlags, false, false);
|
|
}
|
|
|
|
void TouchInputMapper::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) {
|
|
PointerCoords pointerCoords[MAX_POINTERS];
|
|
PointerProperties pointerProperties[MAX_POINTERS];
|
|
uint32_t pointerCount = 0;
|
|
while (!idBits.isEmpty()) {
|
|
uint32_t id = idBits.clearFirstMarkedBit();
|
|
uint32_t index = idToIndex[id];
|
|
pointerProperties[pointerCount].copyFrom(properties[index]);
|
|
pointerCoords[pointerCount].copyFrom(coords[index]);
|
|
|
|
if (changedId >= 0 && id == uint32_t(changedId)) {
|
|
action |= pointerCount << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
|
|
}
|
|
|
|
pointerCount += 1;
|
|
}
|
|
|
|
ALOG_ASSERT(pointerCount != 0);
|
|
|
|
if (changedId >= 0 && pointerCount == 1) {
|
|
// Replace initial down and final up action.
|
|
// We can compare the action without masking off the changed pointer index
|
|
// because we know the index is 0.
|
|
if (action == AMOTION_EVENT_ACTION_POINTER_DOWN) {
|
|
action = AMOTION_EVENT_ACTION_DOWN;
|
|
} else if (action == AMOTION_EVENT_ACTION_POINTER_UP) {
|
|
action = AMOTION_EVENT_ACTION_UP;
|
|
} else {
|
|
// Can't happen.
|
|
ALOG_ASSERT(false);
|
|
}
|
|
}
|
|
|
|
NotifyMotionArgs args(when, getDeviceId(), source, policyFlags,
|
|
action, flags, metaState, buttonState, edgeFlags,
|
|
mViewport.displayId, pointerCount, pointerProperties, pointerCoords,
|
|
xPrecision, yPrecision, downTime);
|
|
getListener()->notifyMotion(&args);
|
|
}
|
|
|
|
bool TouchInputMapper::updateMovedPointers(const PointerProperties* inProperties,
|
|
const PointerCoords* inCoords, const uint32_t* inIdToIndex,
|
|
PointerProperties* outProperties, PointerCoords* outCoords, const uint32_t* outIdToIndex,
|
|
BitSet32 idBits) const {
|
|
bool changed = false;
|
|
while (!idBits.isEmpty()) {
|
|
uint32_t id = idBits.clearFirstMarkedBit();
|
|
uint32_t inIndex = inIdToIndex[id];
|
|
uint32_t outIndex = outIdToIndex[id];
|
|
|
|
const PointerProperties& curInProperties = inProperties[inIndex];
|
|
const PointerCoords& curInCoords = inCoords[inIndex];
|
|
PointerProperties& curOutProperties = outProperties[outIndex];
|
|
PointerCoords& curOutCoords = outCoords[outIndex];
|
|
|
|
if (curInProperties != curOutProperties) {
|
|
curOutProperties.copyFrom(curInProperties);
|
|
changed = true;
|
|
}
|
|
|
|
if (curInCoords != curOutCoords) {
|
|
curOutCoords.copyFrom(curInCoords);
|
|
changed = true;
|
|
}
|
|
}
|
|
return changed;
|
|
}
|
|
|
|
void TouchInputMapper::fadePointer() {
|
|
if (mPointerController != NULL) {
|
|
mPointerController->fade(PointerControllerInterface::TRANSITION_GRADUAL);
|
|
}
|
|
}
|
|
|
|
bool TouchInputMapper::isPointInsideSurface(int32_t x, int32_t y) {
|
|
return x >= mRawPointerAxes.x.minValue && x <= mRawPointerAxes.x.maxValue
|
|
&& y >= mRawPointerAxes.y.minValue && y <= mRawPointerAxes.y.maxValue;
|
|
}
|
|
|
|
const TouchInputMapper::VirtualKey* TouchInputMapper::findVirtualKeyHit(
|
|
int32_t x, int32_t y) {
|
|
size_t numVirtualKeys = mVirtualKeys.size();
|
|
for (size_t i = 0; i < numVirtualKeys; i++) {
|
|
const VirtualKey& virtualKey = mVirtualKeys[i];
|
|
|
|
#if DEBUG_VIRTUAL_KEYS
|
|
ALOGD("VirtualKeys: Hit test (%d, %d): keyCode=%d, scanCode=%d, "
|
|
"left=%d, top=%d, right=%d, bottom=%d",
|
|
x, y,
|
|
virtualKey.keyCode, virtualKey.scanCode,
|
|
virtualKey.hitLeft, virtualKey.hitTop,
|
|
virtualKey.hitRight, virtualKey.hitBottom);
|
|
#endif
|
|
|
|
if (virtualKey.isHit(x, y)) {
|
|
return & virtualKey;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void TouchInputMapper::assignPointerIds() {
|
|
uint32_t currentPointerCount = mCurrentRawPointerData.pointerCount;
|
|
uint32_t lastPointerCount = mLastRawPointerData.pointerCount;
|
|
|
|
mCurrentRawPointerData.clearIdBits();
|
|
|
|
if (currentPointerCount == 0) {
|
|
// No pointers to assign.
|
|
return;
|
|
}
|
|
|
|
if (lastPointerCount == 0) {
|
|
// All pointers are new.
|
|
for (uint32_t i = 0; i < currentPointerCount; i++) {
|
|
uint32_t id = i;
|
|
mCurrentRawPointerData.pointers[i].id = id;
|
|
mCurrentRawPointerData.idToIndex[id] = i;
|
|
mCurrentRawPointerData.markIdBit(id, mCurrentRawPointerData.isHovering(i));
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (currentPointerCount == 1 && lastPointerCount == 1
|
|
&& mCurrentRawPointerData.pointers[0].toolType
|
|
== mLastRawPointerData.pointers[0].toolType) {
|
|
// Only one pointer and no change in count so it must have the same id as before.
|
|
uint32_t id = mLastRawPointerData.pointers[0].id;
|
|
mCurrentRawPointerData.pointers[0].id = id;
|
|
mCurrentRawPointerData.idToIndex[id] = 0;
|
|
mCurrentRawPointerData.markIdBit(id, mCurrentRawPointerData.isHovering(0));
|
|
return;
|
|
}
|
|
|
|
// General case.
|
|
// We build a heap of squared euclidean distances between current and last pointers
|
|
// associated with the current and last pointer indices. Then, we find the best
|
|
// match (by distance) for each current pointer.
|
|
// The pointers must have the same tool type but it is possible for them to
|
|
// transition from hovering to touching or vice-versa while retaining the same id.
|
|
PointerDistanceHeapElement heap[MAX_POINTERS * MAX_POINTERS];
|
|
|
|
uint32_t heapSize = 0;
|
|
for (uint32_t currentPointerIndex = 0; currentPointerIndex < currentPointerCount;
|
|
currentPointerIndex++) {
|
|
for (uint32_t lastPointerIndex = 0; lastPointerIndex < lastPointerCount;
|
|
lastPointerIndex++) {
|
|
const RawPointerData::Pointer& currentPointer =
|
|
mCurrentRawPointerData.pointers[currentPointerIndex];
|
|
const RawPointerData::Pointer& lastPointer =
|
|
mLastRawPointerData.pointers[lastPointerIndex];
|
|
if (currentPointer.toolType == lastPointer.toolType) {
|
|
int64_t deltaX = currentPointer.x - lastPointer.x;
|
|
int64_t deltaY = currentPointer.y - lastPointer.y;
|
|
|
|
uint64_t distance = uint64_t(deltaX * deltaX + deltaY * deltaY);
|
|
|
|
// Insert new element into the heap (sift up).
|
|
heap[heapSize].currentPointerIndex = currentPointerIndex;
|
|
heap[heapSize].lastPointerIndex = lastPointerIndex;
|
|
heap[heapSize].distance = distance;
|
|
heapSize += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Heapify
|
|
for (uint32_t startIndex = heapSize / 2; startIndex != 0; ) {
|
|
startIndex -= 1;
|
|
for (uint32_t parentIndex = startIndex; ;) {
|
|
uint32_t childIndex = parentIndex * 2 + 1;
|
|
if (childIndex >= heapSize) {
|
|
break;
|
|
}
|
|
|
|
if (childIndex + 1 < heapSize
|
|
&& heap[childIndex + 1].distance < heap[childIndex].distance) {
|
|
childIndex += 1;
|
|
}
|
|
|
|
if (heap[parentIndex].distance <= heap[childIndex].distance) {
|
|
break;
|
|
}
|
|
|
|
swap(heap[parentIndex], heap[childIndex]);
|
|
parentIndex = childIndex;
|
|
}
|
|
}
|
|
|
|
#if DEBUG_POINTER_ASSIGNMENT
|
|
ALOGD("assignPointerIds - initial distance min-heap: size=%d", heapSize);
|
|
for (size_t i = 0; i < heapSize; i++) {
|
|
ALOGD(" heap[%d]: cur=%d, last=%d, distance=%lld",
|
|
i, heap[i].currentPointerIndex, heap[i].lastPointerIndex,
|
|
heap[i].distance);
|
|
}
|
|
#endif
|
|
|
|
// Pull matches out by increasing order of distance.
|
|
// To avoid reassigning pointers that have already been matched, the loop keeps track
|
|
// of which last and current pointers have been matched using the matchedXXXBits variables.
|
|
// It also tracks the used pointer id bits.
|
|
BitSet32 matchedLastBits(0);
|
|
BitSet32 matchedCurrentBits(0);
|
|
BitSet32 usedIdBits(0);
|
|
bool first = true;
|
|
for (uint32_t i = min(currentPointerCount, lastPointerCount); heapSize > 0 && i > 0; i--) {
|
|
while (heapSize > 0) {
|
|
if (first) {
|
|
// The first time through the loop, we just consume the root element of
|
|
// the heap (the one with smallest distance).
|
|
first = false;
|
|
} else {
|
|
// Previous iterations consumed the root element of the heap.
|
|
// Pop root element off of the heap (sift down).
|
|
heap[0] = heap[heapSize];
|
|
for (uint32_t parentIndex = 0; ;) {
|
|
uint32_t childIndex = parentIndex * 2 + 1;
|
|
if (childIndex >= heapSize) {
|
|
break;
|
|
}
|
|
|
|
if (childIndex + 1 < heapSize
|
|
&& heap[childIndex + 1].distance < heap[childIndex].distance) {
|
|
childIndex += 1;
|
|
}
|
|
|
|
if (heap[parentIndex].distance <= heap[childIndex].distance) {
|
|
break;
|
|
}
|
|
|
|
swap(heap[parentIndex], heap[childIndex]);
|
|
parentIndex = childIndex;
|
|
}
|
|
|
|
#if DEBUG_POINTER_ASSIGNMENT
|
|
ALOGD("assignPointerIds - reduced distance min-heap: size=%d", heapSize);
|
|
for (size_t i = 0; i < heapSize; i++) {
|
|
ALOGD(" heap[%d]: cur=%d, last=%d, distance=%lld",
|
|
i, heap[i].currentPointerIndex, heap[i].lastPointerIndex,
|
|
heap[i].distance);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
heapSize -= 1;
|
|
|
|
uint32_t currentPointerIndex = heap[0].currentPointerIndex;
|
|
if (matchedCurrentBits.hasBit(currentPointerIndex)) continue; // already matched
|
|
|
|
uint32_t lastPointerIndex = heap[0].lastPointerIndex;
|
|
if (matchedLastBits.hasBit(lastPointerIndex)) continue; // already matched
|
|
|
|
matchedCurrentBits.markBit(currentPointerIndex);
|
|
matchedLastBits.markBit(lastPointerIndex);
|
|
|
|
uint32_t id = mLastRawPointerData.pointers[lastPointerIndex].id;
|
|
mCurrentRawPointerData.pointers[currentPointerIndex].id = id;
|
|
mCurrentRawPointerData.idToIndex[id] = currentPointerIndex;
|
|
mCurrentRawPointerData.markIdBit(id,
|
|
mCurrentRawPointerData.isHovering(currentPointerIndex));
|
|
usedIdBits.markBit(id);
|
|
|
|
#if DEBUG_POINTER_ASSIGNMENT
|
|
ALOGD("assignPointerIds - matched: cur=%d, last=%d, id=%d, distance=%lld",
|
|
lastPointerIndex, currentPointerIndex, id, heap[0].distance);
|
|
#endif
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Assign fresh ids to pointers that were not matched in the process.
|
|
for (uint32_t i = currentPointerCount - matchedCurrentBits.count(); i != 0; i--) {
|
|
uint32_t currentPointerIndex = matchedCurrentBits.markFirstUnmarkedBit();
|
|
uint32_t id = usedIdBits.markFirstUnmarkedBit();
|
|
|
|
mCurrentRawPointerData.pointers[currentPointerIndex].id = id;
|
|
mCurrentRawPointerData.idToIndex[id] = currentPointerIndex;
|
|
mCurrentRawPointerData.markIdBit(id,
|
|
mCurrentRawPointerData.isHovering(currentPointerIndex));
|
|
|
|
#if DEBUG_POINTER_ASSIGNMENT
|
|
ALOGD("assignPointerIds - assigned: cur=%d, id=%d",
|
|
currentPointerIndex, id);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
int32_t TouchInputMapper::getKeyCodeState(uint32_t sourceMask, int32_t keyCode) {
|
|
if (mCurrentVirtualKey.down && mCurrentVirtualKey.keyCode == keyCode) {
|
|
return AKEY_STATE_VIRTUAL;
|
|
}
|
|
|
|
size_t numVirtualKeys = mVirtualKeys.size();
|
|
for (size_t i = 0; i < numVirtualKeys; i++) {
|
|
const VirtualKey& virtualKey = mVirtualKeys[i];
|
|
if (virtualKey.keyCode == keyCode) {
|
|
return AKEY_STATE_UP;
|
|
}
|
|
}
|
|
|
|
return AKEY_STATE_UNKNOWN;
|
|
}
|
|
|
|
int32_t TouchInputMapper::getScanCodeState(uint32_t sourceMask, int32_t scanCode) {
|
|
if (mCurrentVirtualKey.down && mCurrentVirtualKey.scanCode == scanCode) {
|
|
return AKEY_STATE_VIRTUAL;
|
|
}
|
|
|
|
size_t numVirtualKeys = mVirtualKeys.size();
|
|
for (size_t i = 0; i < numVirtualKeys; i++) {
|
|
const VirtualKey& virtualKey = mVirtualKeys[i];
|
|
if (virtualKey.scanCode == scanCode) {
|
|
return AKEY_STATE_UP;
|
|
}
|
|
}
|
|
|
|
return AKEY_STATE_UNKNOWN;
|
|
}
|
|
|
|
bool TouchInputMapper::markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes,
|
|
const int32_t* keyCodes, uint8_t* outFlags) {
|
|
size_t numVirtualKeys = mVirtualKeys.size();
|
|
for (size_t i = 0; i < numVirtualKeys; i++) {
|
|
const VirtualKey& virtualKey = mVirtualKeys[i];
|
|
|
|
for (size_t i = 0; i < numCodes; i++) {
|
|
if (virtualKey.keyCode == keyCodes[i]) {
|
|
outFlags[i] = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// --- SingleTouchInputMapper ---
|
|
|
|
SingleTouchInputMapper::SingleTouchInputMapper(InputDevice* device) :
|
|
TouchInputMapper(device) {
|
|
}
|
|
|
|
SingleTouchInputMapper::~SingleTouchInputMapper() {
|
|
}
|
|
|
|
void SingleTouchInputMapper::reset(nsecs_t when) {
|
|
mSingleTouchMotionAccumulator.reset(getDevice());
|
|
|
|
TouchInputMapper::reset(when);
|
|
}
|
|
|
|
void SingleTouchInputMapper::process(const RawEvent* rawEvent) {
|
|
TouchInputMapper::process(rawEvent);
|
|
|
|
mSingleTouchMotionAccumulator.process(rawEvent);
|
|
}
|
|
|
|
void SingleTouchInputMapper::syncTouch(nsecs_t when, bool* outHavePointerIds) {
|
|
if (mTouchButtonAccumulator.isToolActive()) {
|
|
mCurrentRawPointerData.pointerCount = 1;
|
|
mCurrentRawPointerData.idToIndex[0] = 0;
|
|
|
|
bool isHovering = mTouchButtonAccumulator.getToolType() != AMOTION_EVENT_TOOL_TYPE_MOUSE
|
|
&& (mTouchButtonAccumulator.isHovering()
|
|
|| (mRawPointerAxes.pressure.valid
|
|
&& mSingleTouchMotionAccumulator.getAbsolutePressure() <= 0));
|
|
mCurrentRawPointerData.markIdBit(0, isHovering);
|
|
|
|
RawPointerData::Pointer& outPointer = mCurrentRawPointerData.pointers[0];
|
|
outPointer.id = 0;
|
|
outPointer.x = mSingleTouchMotionAccumulator.getAbsoluteX();
|
|
outPointer.y = mSingleTouchMotionAccumulator.getAbsoluteY();
|
|
outPointer.pressure = mSingleTouchMotionAccumulator.getAbsolutePressure();
|
|
outPointer.touchMajor = 0;
|
|
outPointer.touchMinor = 0;
|
|
outPointer.toolMajor = mSingleTouchMotionAccumulator.getAbsoluteToolWidth();
|
|
outPointer.toolMinor = mSingleTouchMotionAccumulator.getAbsoluteToolWidth();
|
|
outPointer.orientation = 0;
|
|
outPointer.distance = mSingleTouchMotionAccumulator.getAbsoluteDistance();
|
|
outPointer.tiltX = mSingleTouchMotionAccumulator.getAbsoluteTiltX();
|
|
outPointer.tiltY = mSingleTouchMotionAccumulator.getAbsoluteTiltY();
|
|
outPointer.toolType = mTouchButtonAccumulator.getToolType();
|
|
if (outPointer.toolType == AMOTION_EVENT_TOOL_TYPE_UNKNOWN) {
|
|
outPointer.toolType = AMOTION_EVENT_TOOL_TYPE_FINGER;
|
|
}
|
|
outPointer.isHovering = isHovering;
|
|
}
|
|
}
|
|
|
|
void SingleTouchInputMapper::configureRawPointerAxes() {
|
|
TouchInputMapper::configureRawPointerAxes();
|
|
|
|
getAbsoluteAxisInfo(ABS_X, &mRawPointerAxes.x);
|
|
getAbsoluteAxisInfo(ABS_Y, &mRawPointerAxes.y);
|
|
getAbsoluteAxisInfo(ABS_PRESSURE, &mRawPointerAxes.pressure);
|
|
getAbsoluteAxisInfo(ABS_TOOL_WIDTH, &mRawPointerAxes.toolMajor);
|
|
getAbsoluteAxisInfo(ABS_DISTANCE, &mRawPointerAxes.distance);
|
|
getAbsoluteAxisInfo(ABS_TILT_X, &mRawPointerAxes.tiltX);
|
|
getAbsoluteAxisInfo(ABS_TILT_Y, &mRawPointerAxes.tiltY);
|
|
}
|
|
|
|
bool SingleTouchInputMapper::hasStylus() const {
|
|
return mTouchButtonAccumulator.hasStylus();
|
|
}
|
|
|
|
|
|
// --- MultiTouchInputMapper ---
|
|
|
|
MultiTouchInputMapper::MultiTouchInputMapper(InputDevice* device) :
|
|
TouchInputMapper(device) {
|
|
}
|
|
|
|
MultiTouchInputMapper::~MultiTouchInputMapper() {
|
|
}
|
|
|
|
void MultiTouchInputMapper::reset(nsecs_t when) {
|
|
mMultiTouchMotionAccumulator.reset(getDevice());
|
|
|
|
mPointerIdBits.clear();
|
|
|
|
TouchInputMapper::reset(when);
|
|
}
|
|
|
|
void MultiTouchInputMapper::process(const RawEvent* rawEvent) {
|
|
TouchInputMapper::process(rawEvent);
|
|
|
|
mMultiTouchMotionAccumulator.process(rawEvent);
|
|
}
|
|
|
|
void MultiTouchInputMapper::syncTouch(nsecs_t when, bool* outHavePointerIds) {
|
|
size_t inCount = mMultiTouchMotionAccumulator.getSlotCount();
|
|
size_t outCount = 0;
|
|
BitSet32 newPointerIdBits;
|
|
|
|
for (size_t inIndex = 0; inIndex < inCount; inIndex++) {
|
|
const MultiTouchMotionAccumulator::Slot* inSlot =
|
|
mMultiTouchMotionAccumulator.getSlot(inIndex);
|
|
if (!inSlot->isInUse()) {
|
|
continue;
|
|
}
|
|
|
|
if (outCount >= MAX_POINTERS) {
|
|
#if DEBUG_POINTERS
|
|
ALOGD("MultiTouch device %s emitted more than maximum of %d pointers; "
|
|
"ignoring the rest.",
|
|
getDeviceName().string(), MAX_POINTERS);
|
|
#endif
|
|
break; // too many fingers!
|
|
}
|
|
|
|
RawPointerData::Pointer& outPointer = mCurrentRawPointerData.pointers[outCount];
|
|
outPointer.x = inSlot->getX();
|
|
outPointer.y = inSlot->getY();
|
|
outPointer.pressure = inSlot->getPressure();
|
|
outPointer.touchMajor = inSlot->getTouchMajor();
|
|
outPointer.touchMinor = inSlot->getTouchMinor();
|
|
outPointer.toolMajor = inSlot->getToolMajor();
|
|
outPointer.toolMinor = inSlot->getToolMinor();
|
|
outPointer.orientation = inSlot->getOrientation();
|
|
outPointer.distance = inSlot->getDistance();
|
|
outPointer.tiltX = 0;
|
|
outPointer.tiltY = 0;
|
|
|
|
outPointer.toolType = inSlot->getToolType();
|
|
if (outPointer.toolType == AMOTION_EVENT_TOOL_TYPE_UNKNOWN) {
|
|
outPointer.toolType = mTouchButtonAccumulator.getToolType();
|
|
if (outPointer.toolType == AMOTION_EVENT_TOOL_TYPE_UNKNOWN) {
|
|
outPointer.toolType = AMOTION_EVENT_TOOL_TYPE_FINGER;
|
|
}
|
|
}
|
|
|
|
bool isHovering = mTouchButtonAccumulator.getToolType() != AMOTION_EVENT_TOOL_TYPE_MOUSE
|
|
&& (mTouchButtonAccumulator.isHovering()
|
|
|| (mRawPointerAxes.pressure.valid && inSlot->getPressure() <= 0));
|
|
outPointer.isHovering = isHovering;
|
|
|
|
// Assign pointer id using tracking id if available.
|
|
if (*outHavePointerIds) {
|
|
int32_t trackingId = inSlot->getTrackingId();
|
|
int32_t id = -1;
|
|
if (trackingId >= 0) {
|
|
for (BitSet32 idBits(mPointerIdBits); !idBits.isEmpty(); ) {
|
|
uint32_t n = idBits.clearFirstMarkedBit();
|
|
if (mPointerTrackingIdMap[n] == trackingId) {
|
|
id = n;
|
|
}
|
|
}
|
|
|
|
if (id < 0 && !mPointerIdBits.isFull()) {
|
|
id = mPointerIdBits.markFirstUnmarkedBit();
|
|
mPointerTrackingIdMap[id] = trackingId;
|
|
}
|
|
}
|
|
if (id < 0) {
|
|
*outHavePointerIds = false;
|
|
mCurrentRawPointerData.clearIdBits();
|
|
newPointerIdBits.clear();
|
|
} else {
|
|
outPointer.id = id;
|
|
mCurrentRawPointerData.idToIndex[id] = outCount;
|
|
mCurrentRawPointerData.markIdBit(id, isHovering);
|
|
newPointerIdBits.markBit(id);
|
|
}
|
|
}
|
|
|
|
outCount += 1;
|
|
}
|
|
|
|
mCurrentRawPointerData.pointerCount = outCount;
|
|
mPointerIdBits = newPointerIdBits;
|
|
|
|
mMultiTouchMotionAccumulator.finishSync();
|
|
}
|
|
|
|
void MultiTouchInputMapper::configureRawPointerAxes() {
|
|
TouchInputMapper::configureRawPointerAxes();
|
|
|
|
getAbsoluteAxisInfo(ABS_MT_POSITION_X, &mRawPointerAxes.x);
|
|
getAbsoluteAxisInfo(ABS_MT_POSITION_Y, &mRawPointerAxes.y);
|
|
getAbsoluteAxisInfo(ABS_MT_TOUCH_MAJOR, &mRawPointerAxes.touchMajor);
|
|
getAbsoluteAxisInfo(ABS_MT_TOUCH_MINOR, &mRawPointerAxes.touchMinor);
|
|
getAbsoluteAxisInfo(ABS_MT_WIDTH_MAJOR, &mRawPointerAxes.toolMajor);
|
|
getAbsoluteAxisInfo(ABS_MT_WIDTH_MINOR, &mRawPointerAxes.toolMinor);
|
|
getAbsoluteAxisInfo(ABS_MT_ORIENTATION, &mRawPointerAxes.orientation);
|
|
getAbsoluteAxisInfo(ABS_MT_PRESSURE, &mRawPointerAxes.pressure);
|
|
getAbsoluteAxisInfo(ABS_MT_DISTANCE, &mRawPointerAxes.distance);
|
|
getAbsoluteAxisInfo(ABS_MT_TRACKING_ID, &mRawPointerAxes.trackingId);
|
|
getAbsoluteAxisInfo(ABS_MT_SLOT, &mRawPointerAxes.slot);
|
|
|
|
if (mRawPointerAxes.trackingId.valid
|
|
&& mRawPointerAxes.slot.valid
|
|
&& mRawPointerAxes.slot.minValue == 0 && mRawPointerAxes.slot.maxValue > 0) {
|
|
size_t slotCount = mRawPointerAxes.slot.maxValue + 1;
|
|
if (slotCount > MAX_SLOTS) {
|
|
ALOGW("MultiTouch Device %s reported %d slots but the framework "
|
|
"only supports a maximum of %d slots at this time.",
|
|
getDeviceName().string(), slotCount, MAX_SLOTS);
|
|
slotCount = MAX_SLOTS;
|
|
}
|
|
mMultiTouchMotionAccumulator.configure(getDevice(),
|
|
slotCount, true /*usingSlotsProtocol*/);
|
|
} else {
|
|
mMultiTouchMotionAccumulator.configure(getDevice(),
|
|
MAX_POINTERS, false /*usingSlotsProtocol*/);
|
|
}
|
|
}
|
|
|
|
bool MultiTouchInputMapper::hasStylus() const {
|
|
return mMultiTouchMotionAccumulator.hasStylus()
|
|
|| mTouchButtonAccumulator.hasStylus();
|
|
}
|
|
|
|
|
|
// --- JoystickInputMapper ---
|
|
|
|
JoystickInputMapper::JoystickInputMapper(InputDevice* device) :
|
|
InputMapper(device) {
|
|
}
|
|
|
|
JoystickInputMapper::~JoystickInputMapper() {
|
|
}
|
|
|
|
uint32_t JoystickInputMapper::getSources() {
|
|
return AINPUT_SOURCE_JOYSTICK;
|
|
}
|
|
|
|
void JoystickInputMapper::populateDeviceInfo(InputDeviceInfo* info) {
|
|
InputMapper::populateDeviceInfo(info);
|
|
|
|
for (size_t i = 0; i < mAxes.size(); i++) {
|
|
const Axis& axis = mAxes.valueAt(i);
|
|
addMotionRange(axis.axisInfo.axis, axis, info);
|
|
|
|
if (axis.axisInfo.mode == AxisInfo::MODE_SPLIT) {
|
|
addMotionRange(axis.axisInfo.highAxis, axis, info);
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
void JoystickInputMapper::addMotionRange(int32_t axisId, const Axis& axis,
|
|
InputDeviceInfo* info) {
|
|
info->addMotionRange(axisId, AINPUT_SOURCE_JOYSTICK,
|
|
axis.min, axis.max, axis.flat, axis.fuzz, axis.resolution);
|
|
/* In order to ease the transition for developers from using the old axes
|
|
* to the newer, more semantically correct axes, we'll continue to register
|
|
* the old axes as duplicates of their corresponding new ones. */
|
|
int32_t compatAxis = getCompatAxis(axisId);
|
|
if (compatAxis >= 0) {
|
|
info->addMotionRange(compatAxis, AINPUT_SOURCE_JOYSTICK,
|
|
axis.min, axis.max, axis.flat, axis.fuzz, axis.resolution);
|
|
}
|
|
}
|
|
|
|
/* A mapping from axes the joystick actually has to the axes that should be
|
|
* artificially created for compatibility purposes.
|
|
* Returns -1 if no compatibility axis is needed. */
|
|
int32_t JoystickInputMapper::getCompatAxis(int32_t axis) {
|
|
switch(axis) {
|
|
case AMOTION_EVENT_AXIS_LTRIGGER:
|
|
return AMOTION_EVENT_AXIS_BRAKE;
|
|
case AMOTION_EVENT_AXIS_RTRIGGER:
|
|
return AMOTION_EVENT_AXIS_GAS;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void JoystickInputMapper::dump(String8& dump) {
|
|
dump.append(INDENT2 "Joystick Input Mapper:\n");
|
|
|
|
dump.append(INDENT3 "Axes:\n");
|
|
size_t numAxes = mAxes.size();
|
|
for (size_t i = 0; i < numAxes; i++) {
|
|
const Axis& axis = mAxes.valueAt(i);
|
|
const char* label = getAxisLabel(axis.axisInfo.axis);
|
|
if (label) {
|
|
dump.appendFormat(INDENT4 "%s", label);
|
|
} else {
|
|
dump.appendFormat(INDENT4 "%d", axis.axisInfo.axis);
|
|
}
|
|
if (axis.axisInfo.mode == AxisInfo::MODE_SPLIT) {
|
|
label = getAxisLabel(axis.axisInfo.highAxis);
|
|
if (label) {
|
|
dump.appendFormat(" / %s (split at %d)", label, axis.axisInfo.splitValue);
|
|
} else {
|
|
dump.appendFormat(" / %d (split at %d)", axis.axisInfo.highAxis,
|
|
axis.axisInfo.splitValue);
|
|
}
|
|
} else if (axis.axisInfo.mode == AxisInfo::MODE_INVERT) {
|
|
dump.append(" (invert)");
|
|
}
|
|
|
|
dump.appendFormat(": min=%0.5f, max=%0.5f, flat=%0.5f, fuzz=%0.5f, resolution=%0.5f\n",
|
|
axis.min, axis.max, axis.flat, axis.fuzz, axis.resolution);
|
|
dump.appendFormat(INDENT4 " scale=%0.5f, offset=%0.5f, "
|
|
"highScale=%0.5f, highOffset=%0.5f\n",
|
|
axis.scale, axis.offset, axis.highScale, axis.highOffset);
|
|
dump.appendFormat(INDENT4 " rawAxis=%d, rawMin=%d, rawMax=%d, "
|
|
"rawFlat=%d, rawFuzz=%d, rawResolution=%d\n",
|
|
mAxes.keyAt(i), axis.rawAxisInfo.minValue, axis.rawAxisInfo.maxValue,
|
|
axis.rawAxisInfo.flat, axis.rawAxisInfo.fuzz, axis.rawAxisInfo.resolution);
|
|
}
|
|
}
|
|
|
|
void JoystickInputMapper::configure(nsecs_t when,
|
|
const InputReaderConfiguration* config, uint32_t changes) {
|
|
InputMapper::configure(when, config, changes);
|
|
|
|
if (!changes) { // first time only
|
|
// Collect all axes.
|
|
for (int32_t abs = 0; abs <= ABS_MAX; abs++) {
|
|
if (!(getAbsAxisUsage(abs, getDevice()->getClasses())
|
|
& INPUT_DEVICE_CLASS_JOYSTICK)) {
|
|
continue; // axis must be claimed by a different device
|
|
}
|
|
|
|
RawAbsoluteAxisInfo rawAxisInfo;
|
|
getAbsoluteAxisInfo(abs, &rawAxisInfo);
|
|
if (rawAxisInfo.valid) {
|
|
// Map axis.
|
|
AxisInfo axisInfo;
|
|
bool explicitlyMapped = !getEventHub()->mapAxis(getDeviceId(), abs, &axisInfo);
|
|
if (!explicitlyMapped) {
|
|
// Axis is not explicitly mapped, will choose a generic axis later.
|
|
axisInfo.mode = AxisInfo::MODE_NORMAL;
|
|
axisInfo.axis = -1;
|
|
}
|
|
|
|
// Apply flat override.
|
|
int32_t rawFlat = axisInfo.flatOverride < 0
|
|
? rawAxisInfo.flat : axisInfo.flatOverride;
|
|
|
|
// Calculate scaling factors and limits.
|
|
Axis axis;
|
|
if (axisInfo.mode == AxisInfo::MODE_SPLIT) {
|
|
float scale = 1.0f / (axisInfo.splitValue - rawAxisInfo.minValue);
|
|
float highScale = 1.0f / (rawAxisInfo.maxValue - axisInfo.splitValue);
|
|
axis.initialize(rawAxisInfo, axisInfo, explicitlyMapped,
|
|
scale, 0.0f, highScale, 0.0f,
|
|
0.0f, 1.0f, rawFlat * scale, rawAxisInfo.fuzz * scale,
|
|
rawAxisInfo.resolution * scale);
|
|
} else if (isCenteredAxis(axisInfo.axis)) {
|
|
float scale = 2.0f / (rawAxisInfo.maxValue - rawAxisInfo.minValue);
|
|
float offset = avg(rawAxisInfo.minValue, rawAxisInfo.maxValue) * -scale;
|
|
axis.initialize(rawAxisInfo, axisInfo, explicitlyMapped,
|
|
scale, offset, scale, offset,
|
|
-1.0f, 1.0f, rawFlat * scale, rawAxisInfo.fuzz * scale,
|
|
rawAxisInfo.resolution * scale);
|
|
} else {
|
|
float scale = 1.0f / (rawAxisInfo.maxValue - rawAxisInfo.minValue);
|
|
axis.initialize(rawAxisInfo, axisInfo, explicitlyMapped,
|
|
scale, 0.0f, scale, 0.0f,
|
|
0.0f, 1.0f, rawFlat * scale, rawAxisInfo.fuzz * scale,
|
|
rawAxisInfo.resolution * scale);
|
|
}
|
|
|
|
// To eliminate noise while the joystick is at rest, filter out small variations
|
|
// in axis values up front.
|
|
axis.filter = axis.fuzz ? axis.fuzz : axis.flat * 0.25f;
|
|
|
|
mAxes.add(abs, axis);
|
|
}
|
|
}
|
|
|
|
// If there are too many axes, start dropping them.
|
|
// Prefer to keep explicitly mapped axes.
|
|
if (mAxes.size() > PointerCoords::MAX_AXES) {
|
|
ALOGI("Joystick '%s' has %d axes but the framework only supports a maximum of %d.",
|
|
getDeviceName().string(), mAxes.size(), PointerCoords::MAX_AXES);
|
|
pruneAxes(true);
|
|
pruneAxes(false);
|
|
}
|
|
|
|
// Assign generic axis ids to remaining axes.
|
|
int32_t nextGenericAxisId = AMOTION_EVENT_AXIS_GENERIC_1;
|
|
size_t numAxes = mAxes.size();
|
|
for (size_t i = 0; i < numAxes; i++) {
|
|
Axis& axis = mAxes.editValueAt(i);
|
|
if (axis.axisInfo.axis < 0) {
|
|
while (nextGenericAxisId <= AMOTION_EVENT_AXIS_GENERIC_16
|
|
&& haveAxis(nextGenericAxisId)) {
|
|
nextGenericAxisId += 1;
|
|
}
|
|
|
|
if (nextGenericAxisId <= AMOTION_EVENT_AXIS_GENERIC_16) {
|
|
axis.axisInfo.axis = nextGenericAxisId;
|
|
nextGenericAxisId += 1;
|
|
} else {
|
|
ALOGI("Ignoring joystick '%s' axis %d because all of the generic axis ids "
|
|
"have already been assigned to other axes.",
|
|
getDeviceName().string(), mAxes.keyAt(i));
|
|
mAxes.removeItemsAt(i--);
|
|
numAxes -= 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool JoystickInputMapper::haveAxis(int32_t axisId) {
|
|
size_t numAxes = mAxes.size();
|
|
for (size_t i = 0; i < numAxes; i++) {
|
|
const Axis& axis = mAxes.valueAt(i);
|
|
if (axis.axisInfo.axis == axisId
|
|
|| (axis.axisInfo.mode == AxisInfo::MODE_SPLIT
|
|
&& axis.axisInfo.highAxis == axisId)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void JoystickInputMapper::pruneAxes(bool ignoreExplicitlyMappedAxes) {
|
|
size_t i = mAxes.size();
|
|
while (mAxes.size() > PointerCoords::MAX_AXES && i-- > 0) {
|
|
if (ignoreExplicitlyMappedAxes && mAxes.valueAt(i).explicitlyMapped) {
|
|
continue;
|
|
}
|
|
ALOGI("Discarding joystick '%s' axis %d because there are too many axes.",
|
|
getDeviceName().string(), mAxes.keyAt(i));
|
|
mAxes.removeItemsAt(i);
|
|
}
|
|
}
|
|
|
|
bool JoystickInputMapper::isCenteredAxis(int32_t axis) {
|
|
switch (axis) {
|
|
case AMOTION_EVENT_AXIS_X:
|
|
case AMOTION_EVENT_AXIS_Y:
|
|
case AMOTION_EVENT_AXIS_Z:
|
|
case AMOTION_EVENT_AXIS_RX:
|
|
case AMOTION_EVENT_AXIS_RY:
|
|
case AMOTION_EVENT_AXIS_RZ:
|
|
case AMOTION_EVENT_AXIS_HAT_X:
|
|
case AMOTION_EVENT_AXIS_HAT_Y:
|
|
case AMOTION_EVENT_AXIS_ORIENTATION:
|
|
case AMOTION_EVENT_AXIS_RUDDER:
|
|
case AMOTION_EVENT_AXIS_WHEEL:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void JoystickInputMapper::reset(nsecs_t when) {
|
|
// Recenter all axes.
|
|
size_t numAxes = mAxes.size();
|
|
for (size_t i = 0; i < numAxes; i++) {
|
|
Axis& axis = mAxes.editValueAt(i);
|
|
axis.resetValue();
|
|
}
|
|
|
|
InputMapper::reset(when);
|
|
}
|
|
|
|
void JoystickInputMapper::process(const RawEvent* rawEvent) {
|
|
switch (rawEvent->type) {
|
|
case EV_ABS: {
|
|
ssize_t index = mAxes.indexOfKey(rawEvent->code);
|
|
if (index >= 0) {
|
|
Axis& axis = mAxes.editValueAt(index);
|
|
float newValue, highNewValue;
|
|
switch (axis.axisInfo.mode) {
|
|
case AxisInfo::MODE_INVERT:
|
|
newValue = (axis.rawAxisInfo.maxValue - rawEvent->value)
|
|
* axis.scale + axis.offset;
|
|
highNewValue = 0.0f;
|
|
break;
|
|
case AxisInfo::MODE_SPLIT:
|
|
if (rawEvent->value < axis.axisInfo.splitValue) {
|
|
newValue = (axis.axisInfo.splitValue - rawEvent->value)
|
|
* axis.scale + axis.offset;
|
|
highNewValue = 0.0f;
|
|
} else if (rawEvent->value > axis.axisInfo.splitValue) {
|
|
newValue = 0.0f;
|
|
highNewValue = (rawEvent->value - axis.axisInfo.splitValue)
|
|
* axis.highScale + axis.highOffset;
|
|
} else {
|
|
newValue = 0.0f;
|
|
highNewValue = 0.0f;
|
|
}
|
|
break;
|
|
default:
|
|
newValue = rawEvent->value * axis.scale + axis.offset;
|
|
highNewValue = 0.0f;
|
|
break;
|
|
}
|
|
axis.newValue = newValue;
|
|
axis.highNewValue = highNewValue;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case EV_SYN:
|
|
switch (rawEvent->code) {
|
|
case SYN_REPORT:
|
|
sync(rawEvent->when, false /*force*/);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
void JoystickInputMapper::sync(nsecs_t when, bool force) {
|
|
if (!filterAxes(force)) {
|
|
return;
|
|
}
|
|
|
|
int32_t metaState = mContext->getGlobalMetaState();
|
|
int32_t buttonState = 0;
|
|
|
|
PointerProperties pointerProperties;
|
|
pointerProperties.clear();
|
|
pointerProperties.id = 0;
|
|
pointerProperties.toolType = AMOTION_EVENT_TOOL_TYPE_UNKNOWN;
|
|
|
|
PointerCoords pointerCoords;
|
|
pointerCoords.clear();
|
|
|
|
size_t numAxes = mAxes.size();
|
|
for (size_t i = 0; i < numAxes; i++) {
|
|
const Axis& axis = mAxes.valueAt(i);
|
|
setPointerCoordsAxisValue(&pointerCoords, axis.axisInfo.axis, axis.currentValue);
|
|
if (axis.axisInfo.mode == AxisInfo::MODE_SPLIT) {
|
|
setPointerCoordsAxisValue(&pointerCoords, axis.axisInfo.highAxis,
|
|
axis.highCurrentValue);
|
|
}
|
|
}
|
|
|
|
// Moving a joystick axis should not wake the device because joysticks can
|
|
// be fairly noisy even when not in use. On the other hand, pushing a gamepad
|
|
// button will likely wake the device.
|
|
// TODO: Use the input device configuration to control this behavior more finely.
|
|
uint32_t policyFlags = 0;
|
|
|
|
NotifyMotionArgs args(when, getDeviceId(), AINPUT_SOURCE_JOYSTICK, policyFlags,
|
|
AMOTION_EVENT_ACTION_MOVE, 0, metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE,
|
|
ADISPLAY_ID_NONE, 1, &pointerProperties, &pointerCoords, 0, 0, 0);
|
|
getListener()->notifyMotion(&args);
|
|
}
|
|
|
|
void JoystickInputMapper::setPointerCoordsAxisValue(PointerCoords* pointerCoords,
|
|
int32_t axis, float value) {
|
|
pointerCoords->setAxisValue(axis, value);
|
|
/* In order to ease the transition for developers from using the old axes
|
|
* to the newer, more semantically correct axes, we'll continue to produce
|
|
* values for the old axes as mirrors of the value of their corresponding
|
|
* new axes. */
|
|
int32_t compatAxis = getCompatAxis(axis);
|
|
if (compatAxis >= 0) {
|
|
pointerCoords->setAxisValue(compatAxis, value);
|
|
}
|
|
}
|
|
|
|
bool JoystickInputMapper::filterAxes(bool force) {
|
|
bool atLeastOneSignificantChange = force;
|
|
size_t numAxes = mAxes.size();
|
|
for (size_t i = 0; i < numAxes; i++) {
|
|
Axis& axis = mAxes.editValueAt(i);
|
|
if (force || hasValueChangedSignificantly(axis.filter,
|
|
axis.newValue, axis.currentValue, axis.min, axis.max)) {
|
|
axis.currentValue = axis.newValue;
|
|
atLeastOneSignificantChange = true;
|
|
}
|
|
if (axis.axisInfo.mode == AxisInfo::MODE_SPLIT) {
|
|
if (force || hasValueChangedSignificantly(axis.filter,
|
|
axis.highNewValue, axis.highCurrentValue, axis.min, axis.max)) {
|
|
axis.highCurrentValue = axis.highNewValue;
|
|
atLeastOneSignificantChange = true;
|
|
}
|
|
}
|
|
}
|
|
return atLeastOneSignificantChange;
|
|
}
|
|
|
|
bool JoystickInputMapper::hasValueChangedSignificantly(
|
|
float filter, float newValue, float currentValue, float min, float max) {
|
|
if (newValue != currentValue) {
|
|
// Filter out small changes in value unless the value is converging on the axis
|
|
// bounds or center point. This is intended to reduce the amount of information
|
|
// sent to applications by particularly noisy joysticks (such as PS3).
|
|
if (fabs(newValue - currentValue) > filter
|
|
|| hasMovedNearerToValueWithinFilteredRange(filter, newValue, currentValue, min)
|
|
|| hasMovedNearerToValueWithinFilteredRange(filter, newValue, currentValue, max)
|
|
|| hasMovedNearerToValueWithinFilteredRange(filter, newValue, currentValue, 0)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool JoystickInputMapper::hasMovedNearerToValueWithinFilteredRange(
|
|
float filter, float newValue, float currentValue, float thresholdValue) {
|
|
float newDistance = fabs(newValue - thresholdValue);
|
|
if (newDistance < filter) {
|
|
float oldDistance = fabs(currentValue - thresholdValue);
|
|
if (newDistance < oldDistance) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
} // namespace android
|