The Tor Browser: comparison widget/gonk/libui/InputReader.cpp

--1:000000000000
+:8899cc4a41d2
+/*
+* 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
+#include "cutils_log.h"
+// 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 "Keyboard.h"
+#include "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);
+InputDevice* device = createDeviceLocked(deviceId, 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,
+const InputDeviceIdentifier& identifier, uint32_t classes) {
+InputDevice* device = new InputDevice(&mContext, deviceId, bumpGenerationLocked(),
+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,
+const InputDeviceIdentifier& identifier, uint32_t classes) :
+mContext(context), mId(id), mGeneration(generation),
+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.descriptor);
+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, 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;
+}
+}
+bool metaStateChanged = false;
+int32_t oldMetaState = mMetaState;
+int32_t newMetaState = updateMetaState(keyCode, down, oldMetaState);
+if (oldMetaState != newMetaState) {
+mMetaState = newMetaState;
+metaStateChanged = true;
+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, LED_CAPSL);
+initializeLedState(mNumLockLedState, LED_NUML);
+initializeLedState(mScrollLockLedState, LED_SCROLLL);
+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, LED_CAPSL,
+AMETA_CAPS_LOCK_ON, reset);
+updateLedStateForModifier(mNumLockLedState, LED_NUML,
+AMETA_NUM_LOCK_ON, reset);
+updateLedStateForModifier(mScrollLockLedState, LED_SCROLLL,
+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);
+}
+}
+}
+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;
+}
+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.
+bool viewportChanged = false;
+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);
+}
+if (mViewport != newViewport) {
+mViewport = newViewport;
+viewportChanged = true;
+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;
+if (mDeviceMode != oldDeviceMode) {
+deviceModeChanged = true;
+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 < - M_PI_2) {
+orientation += M_PI;
+}
+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;
+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 > M_PI_2) {
+orientation -= M_PI;
+}
+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);
+}
+// 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
+ALOGD("Gestures: Not a TAP, %0.3fms since down",
+(when - mPointerGesture.tapDownTime) * 0.000001f);
+#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.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

The Tor Browser / file comparison

comparison: widget/gonk/libui/InputReader.cpp

widget/gonk/libui/InputReader.cpp