| /* |
| * Copyright (C) 2010 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #define LOG_TAG "InputReader" |
| |
| //#define LOG_NDEBUG 0 |
| |
| // Log debug messages for each raw event received from the EventHub. |
| #define DEBUG_RAW_EVENTS 0 |
| |
| // Log debug messages about touch screen filtering hacks. |
| #define DEBUG_HACKS 0 |
| |
| // Log debug messages about virtual key processing. |
| #define DEBUG_VIRTUAL_KEYS 0 |
| |
| // Log debug messages about pointers. |
| #define DEBUG_POINTERS 0 |
| |
| // Log debug messages about pointer assignment calculations. |
| #define DEBUG_POINTER_ASSIGNMENT 0 |
| |
| // Log debug messages about gesture detection. |
| #define DEBUG_GESTURES 0 |
| |
| #include "InputReader.h" |
| |
| #include <cutils/log.h> |
| #include <ui/Keyboard.h> |
| #include <ui/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]); |
| |
| int32_t rotateKeyCode(int32_t keyCode, int32_t orientation) { |
| return rotateValueUsingRotationMap(keyCode, orientation, |
| keyCodeRotationMap, keyCodeRotationMapSize); |
| } |
| |
| static const int32_t edgeFlagRotationMap[][4] = { |
| // edge flags enumerated counter-clockwise with the original (unrotated) edge flag first |
| // no rotation, 90 degree rotation, 180 degree rotation, 270 degree rotation |
| { AMOTION_EVENT_EDGE_FLAG_BOTTOM, AMOTION_EVENT_EDGE_FLAG_RIGHT, |
| AMOTION_EVENT_EDGE_FLAG_TOP, AMOTION_EVENT_EDGE_FLAG_LEFT }, |
| { AMOTION_EVENT_EDGE_FLAG_RIGHT, AMOTION_EVENT_EDGE_FLAG_TOP, |
| AMOTION_EVENT_EDGE_FLAG_LEFT, AMOTION_EVENT_EDGE_FLAG_BOTTOM }, |
| { AMOTION_EVENT_EDGE_FLAG_TOP, AMOTION_EVENT_EDGE_FLAG_LEFT, |
| AMOTION_EVENT_EDGE_FLAG_BOTTOM, AMOTION_EVENT_EDGE_FLAG_RIGHT }, |
| { AMOTION_EVENT_EDGE_FLAG_LEFT, AMOTION_EVENT_EDGE_FLAG_BOTTOM, |
| AMOTION_EVENT_EDGE_FLAG_RIGHT, AMOTION_EVENT_EDGE_FLAG_TOP }, |
| }; |
| static const size_t edgeFlagRotationMapSize = |
| sizeof(edgeFlagRotationMap) / sizeof(edgeFlagRotationMap[0]); |
| |
| static int32_t rotateEdgeFlag(int32_t edgeFlag, int32_t orientation) { |
| return rotateValueUsingRotationMap(edgeFlag, orientation, |
| edgeFlagRotationMap, edgeFlagRotationMapSize); |
| } |
| |
| static inline bool sourcesMatchMask(uint32_t sources, uint32_t sourceMask) { |
| return (sources & sourceMask & ~ AINPUT_SOURCE_CLASS_MASK) != 0; |
| } |
| |
| static uint32_t getButtonStateForScanCode(int32_t scanCode) { |
| // Currently all buttons are mapped to the primary button. |
| switch (scanCode) { |
| case BTN_LEFT: |
| return AMOTION_EVENT_BUTTON_PRIMARY; |
| case BTN_RIGHT: |
| case BTN_STYLUS: |
| return AMOTION_EVENT_BUTTON_SECONDARY; |
| case BTN_MIDDLE: |
| case BTN_STYLUS2: |
| return AMOTION_EVENT_BUTTON_TERTIARY; |
| case BTN_SIDE: |
| return AMOTION_EVENT_BUTTON_BACK; |
| case BTN_FORWARD: |
| case BTN_EXTRA: |
| return AMOTION_EVENT_BUTTON_FORWARD; |
| case BTN_BACK: |
| return AMOTION_EVENT_BUTTON_BACK; |
| case BTN_TASK: |
| default: |
| return 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 int32_t calculateEdgeFlagsUsingPointerBounds( |
| const sp<PointerControllerInterface>& pointerController, float x, float y) { |
| int32_t edgeFlags = 0; |
| float minX, minY, maxX, maxY; |
| if (pointerController->getBounds(&minX, &minY, &maxX, &maxY)) { |
| if (x <= minX) { |
| edgeFlags |= AMOTION_EVENT_EDGE_FLAG_LEFT; |
| } else if (x >= maxX) { |
| edgeFlags |= AMOTION_EVENT_EDGE_FLAG_RIGHT; |
| } |
| if (y <= minY) { |
| edgeFlags |= AMOTION_EVENT_EDGE_FLAG_TOP; |
| } else if (y >= maxY) { |
| edgeFlags |= AMOTION_EVENT_EDGE_FLAG_BOTTOM; |
| } |
| } |
| return edgeFlags; |
| } |
| |
| 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))) { |
| context->getDispatcher()->notifyKey(when, deviceId, source, policyFlags, |
| action, 0, keyCode, 0, context->getGlobalMetaState(), when); |
| } |
| } |
| |
| 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); |
| } |
| |
| |
| // --- InputReader --- |
| |
| InputReader::InputReader(const sp<EventHubInterface>& eventHub, |
| const sp<InputReaderPolicyInterface>& policy, |
| const sp<InputDispatcherInterface>& dispatcher) : |
| mEventHub(eventHub), mPolicy(policy), mDispatcher(dispatcher), |
| mGlobalMetaState(0), mDisableVirtualKeysTimeout(LLONG_MIN), mNextTimeout(LLONG_MAX), |
| mConfigurationChangesToRefresh(0) { |
| refreshConfiguration(0); |
| updateGlobalMetaState(); |
| updateInputConfiguration(); |
| } |
| |
| InputReader::~InputReader() { |
| for (size_t i = 0; i < mDevices.size(); i++) { |
| delete mDevices.valueAt(i); |
| } |
| } |
| |
| void InputReader::loopOnce() { |
| uint32_t changes; |
| { // acquire lock |
| AutoMutex _l(mStateLock); |
| |
| changes = mConfigurationChangesToRefresh; |
| mConfigurationChangesToRefresh = 0; |
| } // release lock |
| |
| if (changes) { |
| refreshConfiguration(changes); |
| } |
| |
| int32_t timeoutMillis = -1; |
| if (mNextTimeout != LLONG_MAX) { |
| nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC); |
| timeoutMillis = toMillisecondTimeoutDelay(now, mNextTimeout); |
| } |
| |
| size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE); |
| if (count) { |
| processEvents(mEventBuffer, count); |
| } |
| if (!count || timeoutMillis == 0) { |
| nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC); |
| #if DEBUG_RAW_EVENTS |
| LOGD("Timeout expired, latency=%0.3fms", (now - mNextTimeout) * 0.000001f); |
| #endif |
| mNextTimeout = LLONG_MAX; |
| timeoutExpired(now); |
| } |
| } |
| |
| void InputReader::processEvents(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 |
| LOGD("BatchSize: %d Count: %d", batchSize, count); |
| #endif |
| processEventsForDevice(deviceId, rawEvent, batchSize); |
| } else { |
| switch (rawEvent->type) { |
| case EventHubInterface::DEVICE_ADDED: |
| addDevice(rawEvent->deviceId); |
| break; |
| case EventHubInterface::DEVICE_REMOVED: |
| removeDevice(rawEvent->deviceId); |
| break; |
| case EventHubInterface::FINISHED_DEVICE_SCAN: |
| handleConfigurationChanged(rawEvent->when); |
| break; |
| default: |
| LOG_ASSERT(false); // can't happen |
| break; |
| } |
| } |
| count -= batchSize; |
| rawEvent += batchSize; |
| } |
| } |
| |
| void InputReader::addDevice(int32_t deviceId) { |
| String8 name = mEventHub->getDeviceName(deviceId); |
| uint32_t classes = mEventHub->getDeviceClasses(deviceId); |
| |
| InputDevice* device = createDevice(deviceId, name, classes); |
| device->configure(&mConfig, 0); |
| |
| if (device->isIgnored()) { |
| LOGI("Device added: id=%d, name='%s' (ignored non-input device)", deviceId, name.string()); |
| } else { |
| LOGI("Device added: id=%d, name='%s', sources=0x%08x", deviceId, name.string(), |
| device->getSources()); |
| } |
| |
| bool added = false; |
| { // acquire device registry writer lock |
| RWLock::AutoWLock _wl(mDeviceRegistryLock); |
| |
| ssize_t deviceIndex = mDevices.indexOfKey(deviceId); |
| if (deviceIndex < 0) { |
| mDevices.add(deviceId, device); |
| added = true; |
| } |
| } // release device registry writer lock |
| |
| if (! added) { |
| LOGW("Ignoring spurious device added event for deviceId %d.", deviceId); |
| delete device; |
| return; |
| } |
| } |
| |
| void InputReader::removeDevice(int32_t deviceId) { |
| bool removed = false; |
| InputDevice* device = NULL; |
| { // acquire device registry writer lock |
| RWLock::AutoWLock _wl(mDeviceRegistryLock); |
| |
| ssize_t deviceIndex = mDevices.indexOfKey(deviceId); |
| if (deviceIndex >= 0) { |
| device = mDevices.valueAt(deviceIndex); |
| mDevices.removeItemsAt(deviceIndex, 1); |
| removed = true; |
| } |
| } // release device registry writer lock |
| |
| if (! removed) { |
| LOGW("Ignoring spurious device removed event for deviceId %d.", deviceId); |
| return; |
| } |
| |
| if (device->isIgnored()) { |
| LOGI("Device removed: id=%d, name='%s' (ignored non-input device)", |
| device->getId(), device->getName().string()); |
| } else { |
| LOGI("Device removed: id=%d, name='%s', sources=0x%08x", |
| device->getId(), device->getName().string(), device->getSources()); |
| } |
| |
| device->reset(); |
| |
| delete device; |
| } |
| |
| InputDevice* InputReader::createDevice(int32_t deviceId, const String8& name, uint32_t classes) { |
| InputDevice* device = new InputDevice(this, deviceId, name); |
| |
| // 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)); |
| } |
| |
| // 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::processEventsForDevice(int32_t deviceId, |
| const RawEvent* rawEvents, size_t count) { |
| { // acquire device registry reader lock |
| RWLock::AutoRLock _rl(mDeviceRegistryLock); |
| |
| ssize_t deviceIndex = mDevices.indexOfKey(deviceId); |
| if (deviceIndex < 0) { |
| LOGW("Discarding event for unknown deviceId %d.", deviceId); |
| return; |
| } |
| |
| InputDevice* device = mDevices.valueAt(deviceIndex); |
| if (device->isIgnored()) { |
| //LOGD("Discarding event for ignored deviceId %d.", deviceId); |
| return; |
| } |
| |
| device->process(rawEvents, count); |
| } // release device registry reader lock |
| } |
| |
| void InputReader::timeoutExpired(nsecs_t when) { |
| { // acquire device registry reader lock |
| RWLock::AutoRLock _rl(mDeviceRegistryLock); |
| |
| for (size_t i = 0; i < mDevices.size(); i++) { |
| InputDevice* device = mDevices.valueAt(i); |
| if (!device->isIgnored()) { |
| device->timeoutExpired(when); |
| } |
| } |
| } // release device registry reader lock |
| } |
| |
| void InputReader::handleConfigurationChanged(nsecs_t when) { |
| // Reset global meta state because it depends on the list of all configured devices. |
| updateGlobalMetaState(); |
| |
| // Update input configuration. |
| updateInputConfiguration(); |
| |
| // Enqueue configuration changed. |
| mDispatcher->notifyConfigurationChanged(when); |
| } |
| |
| void InputReader::refreshConfiguration(uint32_t changes) { |
| mPolicy->getReaderConfiguration(&mConfig); |
| mEventHub->setExcludedDevices(mConfig.excludedDeviceNames); |
| |
| if (changes) { |
| LOGI("Reconfiguring input devices. changes=0x%08x", changes); |
| |
| if (changes & InputReaderConfiguration::CHANGE_MUST_REOPEN) { |
| mEventHub->requestReopenDevices(); |
| } else { |
| { // acquire device registry reader lock |
| RWLock::AutoRLock _rl(mDeviceRegistryLock); |
| |
| for (size_t i = 0; i < mDevices.size(); i++) { |
| InputDevice* device = mDevices.valueAt(i); |
| device->configure(&mConfig, changes); |
| } |
| } // release device registry reader lock |
| } |
| } |
| } |
| |
| void InputReader::updateGlobalMetaState() { |
| { // acquire state lock |
| AutoMutex _l(mStateLock); |
| |
| mGlobalMetaState = 0; |
| |
| { // acquire device registry reader lock |
| RWLock::AutoRLock _rl(mDeviceRegistryLock); |
| |
| for (size_t i = 0; i < mDevices.size(); i++) { |
| InputDevice* device = mDevices.valueAt(i); |
| mGlobalMetaState |= device->getMetaState(); |
| } |
| } // release device registry reader lock |
| } // release state lock |
| } |
| |
| int32_t InputReader::getGlobalMetaState() { |
| { // acquire state lock |
| AutoMutex _l(mStateLock); |
| |
| return mGlobalMetaState; |
| } // release state lock |
| } |
| |
| void InputReader::updateInputConfiguration() { |
| { // acquire state lock |
| AutoMutex _l(mStateLock); |
| |
| int32_t touchScreenConfig = InputConfiguration::TOUCHSCREEN_NOTOUCH; |
| int32_t keyboardConfig = InputConfiguration::KEYBOARD_NOKEYS; |
| int32_t navigationConfig = InputConfiguration::NAVIGATION_NONAV; |
| { // acquire device registry reader lock |
| RWLock::AutoRLock _rl(mDeviceRegistryLock); |
| |
| InputDeviceInfo deviceInfo; |
| for (size_t i = 0; i < mDevices.size(); i++) { |
| InputDevice* device = mDevices.valueAt(i); |
| device->getDeviceInfo(& deviceInfo); |
| uint32_t sources = deviceInfo.getSources(); |
| |
| if ((sources & AINPUT_SOURCE_TOUCHSCREEN) == AINPUT_SOURCE_TOUCHSCREEN) { |
| touchScreenConfig = InputConfiguration::TOUCHSCREEN_FINGER; |
| } |
| if ((sources & AINPUT_SOURCE_TRACKBALL) == AINPUT_SOURCE_TRACKBALL) { |
| navigationConfig = InputConfiguration::NAVIGATION_TRACKBALL; |
| } else if ((sources & AINPUT_SOURCE_DPAD) == AINPUT_SOURCE_DPAD) { |
| navigationConfig = InputConfiguration::NAVIGATION_DPAD; |
| } |
| if (deviceInfo.getKeyboardType() == AINPUT_KEYBOARD_TYPE_ALPHABETIC) { |
| keyboardConfig = InputConfiguration::KEYBOARD_QWERTY; |
| } |
| } |
| } // release device registry reader lock |
| |
| mInputConfiguration.touchScreen = touchScreenConfig; |
| mInputConfiguration.keyboard = keyboardConfig; |
| mInputConfiguration.navigation = navigationConfig; |
| } // release state lock |
| } |
| |
| void InputReader::disableVirtualKeysUntil(nsecs_t time) { |
| mDisableVirtualKeysTimeout = time; |
| } |
| |
| bool InputReader::shouldDropVirtualKey(nsecs_t now, |
| InputDevice* device, int32_t keyCode, int32_t scanCode) { |
| if (now < mDisableVirtualKeysTimeout) { |
| LOGI("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::fadePointer() { |
| { // acquire device registry reader lock |
| RWLock::AutoRLock _rl(mDeviceRegistryLock); |
| |
| for (size_t i = 0; i < mDevices.size(); i++) { |
| InputDevice* device = mDevices.valueAt(i); |
| device->fadePointer(); |
| } |
| } // release device registry reader lock |
| } |
| |
| void InputReader::requestTimeoutAtTime(nsecs_t when) { |
| if (when < mNextTimeout) { |
| mNextTimeout = when; |
| } |
| } |
| |
| void InputReader::getInputConfiguration(InputConfiguration* outConfiguration) { |
| { // acquire state lock |
| AutoMutex _l(mStateLock); |
| |
| *outConfiguration = mInputConfiguration; |
| } // release state lock |
| } |
| |
| status_t InputReader::getInputDeviceInfo(int32_t deviceId, InputDeviceInfo* outDeviceInfo) { |
| { // acquire device registry reader lock |
| RWLock::AutoRLock _rl(mDeviceRegistryLock); |
| |
| ssize_t deviceIndex = mDevices.indexOfKey(deviceId); |
| if (deviceIndex < 0) { |
| return NAME_NOT_FOUND; |
| } |
| |
| InputDevice* device = mDevices.valueAt(deviceIndex); |
| if (device->isIgnored()) { |
| return NAME_NOT_FOUND; |
| } |
| |
| device->getDeviceInfo(outDeviceInfo); |
| return OK; |
| } // release device registy reader lock |
| } |
| |
| void InputReader::getInputDeviceIds(Vector<int32_t>& outDeviceIds) { |
| outDeviceIds.clear(); |
| |
| { // acquire device registry reader lock |
| RWLock::AutoRLock _rl(mDeviceRegistryLock); |
| |
| size_t numDevices = mDevices.size(); |
| for (size_t i = 0; i < numDevices; i++) { |
| InputDevice* device = mDevices.valueAt(i); |
| if (! device->isIgnored()) { |
| outDeviceIds.add(device->getId()); |
| } |
| } |
| } // release device registy reader lock |
| } |
| |
| int32_t InputReader::getKeyCodeState(int32_t deviceId, uint32_t sourceMask, |
| int32_t keyCode) { |
| return getState(deviceId, sourceMask, keyCode, & InputDevice::getKeyCodeState); |
| } |
| |
| int32_t InputReader::getScanCodeState(int32_t deviceId, uint32_t sourceMask, |
| int32_t scanCode) { |
| return getState(deviceId, sourceMask, scanCode, & InputDevice::getScanCodeState); |
| } |
| |
| int32_t InputReader::getSwitchState(int32_t deviceId, uint32_t sourceMask, int32_t switchCode) { |
| return getState(deviceId, sourceMask, switchCode, & InputDevice::getSwitchState); |
| } |
| |
| int32_t InputReader::getState(int32_t deviceId, uint32_t sourceMask, int32_t code, |
| GetStateFunc getStateFunc) { |
| { // acquire device registry reader lock |
| RWLock::AutoRLock _rl(mDeviceRegistryLock); |
| |
| 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)) { |
| result = (device->*getStateFunc)(sourceMask, code); |
| if (result >= AKEY_STATE_DOWN) { |
| return result; |
| } |
| } |
| } |
| } |
| return result; |
| } // release device registy reader lock |
| } |
| |
| bool InputReader::hasKeys(int32_t deviceId, uint32_t sourceMask, |
| size_t numCodes, const int32_t* keyCodes, uint8_t* outFlags) { |
| memset(outFlags, 0, numCodes); |
| return markSupportedKeyCodes(deviceId, sourceMask, numCodes, keyCodes, outFlags); |
| } |
| |
| bool InputReader::markSupportedKeyCodes(int32_t deviceId, uint32_t sourceMask, size_t numCodes, |
| const int32_t* keyCodes, uint8_t* outFlags) { |
| { // acquire device registry reader lock |
| RWLock::AutoRLock _rl(mDeviceRegistryLock); |
| 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; |
| } // release device registy reader lock |
| } |
| |
| void InputReader::requestRefreshConfiguration(uint32_t changes) { |
| if (changes) { |
| bool needWake; |
| { // acquire lock |
| AutoMutex _l(mStateLock); |
| |
| needWake = !mConfigurationChangesToRefresh; |
| mConfigurationChangesToRefresh |= changes; |
| } // release lock |
| |
| if (needWake) { |
| mEventHub->wake(); |
| } |
| } |
| } |
| |
| void InputReader::dump(String8& dump) { |
| mEventHub->dump(dump); |
| dump.append("\n"); |
| |
| dump.append("Input Reader State:\n"); |
| |
| { // acquire device registry reader lock |
| RWLock::AutoRLock _rl(mDeviceRegistryLock); |
| |
| for (size_t i = 0; i < mDevices.size(); i++) { |
| mDevices.valueAt(i)->dump(dump); |
| } |
| } // release device registy reader lock |
| |
| 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 "FilterTouchEvents: %s\n", |
| toString(mConfig.filterTouchEvents)); |
| dump.appendFormat(INDENT2 "FilterJumpyTouchEvents: %s\n", |
| toString(mConfig.filterJumpyTouchEvents)); |
| 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); |
| } |
| |
| |
| // --- 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, const String8& name) : |
| mContext(context), mId(id), mName(name), 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.getName().string()); |
| 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\n", |
| name, range.source, range.min, range.max, range.flat, range.fuzz); |
| } |
| } |
| |
| 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(const InputReaderConfiguration* config, uint32_t changes) { |
| mSources = 0; |
| |
| if (!isIgnored()) { |
| if (!changes) { // first time only |
| mContext->getEventHub()->getConfiguration(mId, &mConfiguration); |
| } |
| |
| size_t numMappers = mMappers.size(); |
| for (size_t i = 0; i < numMappers; i++) { |
| InputMapper* mapper = mMappers[i]; |
| mapper->configure(config, changes); |
| mSources |= mapper->getSources(); |
| } |
| } |
| } |
| |
| void InputDevice::reset() { |
| size_t numMappers = mMappers.size(); |
| for (size_t i = 0; i < numMappers; i++) { |
| InputMapper* mapper = mMappers[i]; |
| mapper->reset(); |
| } |
| } |
| |
| 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 |
| LOGD("Input event: device=%d type=0x%04x scancode=0x%04x " |
| "keycode=0x%04x value=0x%08x flags=0x%08x", |
| rawEvent->deviceId, rawEvent->type, rawEvent->scanCode, rawEvent->keyCode, |
| rawEvent->value, rawEvent->flags); |
| #endif |
| |
| if (mDropUntilNextSync) { |
| if (rawEvent->type == EV_SYN && rawEvent->scanCode == SYN_REPORT) { |
| mDropUntilNextSync = false; |
| #if DEBUG_RAW_EVENTS |
| LOGD("Recovered from input event buffer overrun."); |
| #endif |
| } else { |
| #if DEBUG_RAW_EVENTS |
| LOGD("Dropped input event while waiting for next input sync."); |
| #endif |
| } |
| } else if (rawEvent->type == EV_SYN && rawEvent->scanCode == SYN_DROPPED) { |
| LOGI("Detected input event buffer overrun for device %s.", mName.string()); |
| mDropUntilNextSync = true; |
| reset(); |
| } 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, mName); |
| |
| 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)) { |
| result = (mapper->*getStateFunc)(sourceMask, code); |
| if (result >= AKEY_STATE_DOWN) { |
| return result; |
| } |
| } |
| } |
| 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; |
| } |
| |
| 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(); |
| } |
| } |
| |
| |
| // --- 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(const InputReaderConfiguration* config, uint32_t changes) { |
| } |
| |
| void InputMapper::reset() { |
| } |
| |
| 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; |
| } |
| |
| int32_t InputMapper::getMetaState() { |
| return 0; |
| } |
| |
| void InputMapper::fadePointer() { |
| } |
| |
| 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) { |
| } |
| |
| SwitchInputMapper::~SwitchInputMapper() { |
| } |
| |
| uint32_t SwitchInputMapper::getSources() { |
| return AINPUT_SOURCE_SWITCH; |
| } |
| |
| void SwitchInputMapper::process(const RawEvent* rawEvent) { |
| switch (rawEvent->type) { |
| case EV_SW: |
| processSwitch(rawEvent->when, rawEvent->scanCode, rawEvent->value); |
| break; |
| } |
| } |
| |
| void SwitchInputMapper::processSwitch(nsecs_t when, int32_t switchCode, int32_t switchValue) { |
| getDispatcher()->notifySwitch(when, switchCode, switchValue, 0); |
| } |
| |
| int32_t SwitchInputMapper::getSwitchState(uint32_t sourceMask, int32_t switchCode) { |
| return getEventHub()->getSwitchState(getDeviceId(), switchCode); |
| } |
| |
| |
| // --- KeyboardInputMapper --- |
| |
| KeyboardInputMapper::KeyboardInputMapper(InputDevice* device, |
| uint32_t source, int32_t keyboardType) : |
| InputMapper(device), mSource(source), |
| mKeyboardType(keyboardType) { |
| initializeLocked(); |
| } |
| |
| KeyboardInputMapper::~KeyboardInputMapper() { |
| } |
| |
| void KeyboardInputMapper::initializeLocked() { |
| mLocked.metaState = AMETA_NONE; |
| mLocked.downTime = 0; |
| } |
| |
| uint32_t KeyboardInputMapper::getSources() { |
| return mSource; |
| } |
| |
| void KeyboardInputMapper::populateDeviceInfo(InputDeviceInfo* info) { |
| InputMapper::populateDeviceInfo(info); |
| |
| info->setKeyboardType(mKeyboardType); |
| } |
| |
| void KeyboardInputMapper::dump(String8& dump) { |
| { // acquire lock |
| AutoMutex _l(mLock); |
| dump.append(INDENT2 "Keyboard Input Mapper:\n"); |
| dumpParameters(dump); |
| dump.appendFormat(INDENT3 "KeyboardType: %d\n", mKeyboardType); |
| dump.appendFormat(INDENT3 "KeyDowns: %d keys currently down\n", mLocked.keyDowns.size()); |
| dump.appendFormat(INDENT3 "MetaState: 0x%0x\n", mLocked.metaState); |
| dump.appendFormat(INDENT3 "DownTime: %lld\n", mLocked.downTime); |
| } // release lock |
| } |
| |
| |
| void KeyboardInputMapper::configure(const InputReaderConfiguration* config, uint32_t changes) { |
| InputMapper::configure(config, changes); |
| |
| if (!changes) { // first time only |
| // Configure basic parameters. |
| configureParameters(); |
| |
| // Reset LEDs. |
| { |
| AutoMutex _l(mLock); |
| resetLedStateLocked(); |
| } |
| } |
| } |
| |
| void KeyboardInputMapper::configureParameters() { |
| mParameters.orientationAware = false; |
| getDevice()->getConfiguration().tryGetProperty(String8("keyboard.orientationAware"), |
| mParameters.orientationAware); |
| |
| mParameters.associatedDisplayId = mParameters.orientationAware ? 0 : -1; |
| } |
| |
| void KeyboardInputMapper::dumpParameters(String8& dump) { |
| dump.append(INDENT3 "Parameters:\n"); |
| dump.appendFormat(INDENT4 "AssociatedDisplayId: %d\n", |
| mParameters.associatedDisplayId); |
| dump.appendFormat(INDENT4 "OrientationAware: %s\n", |
| toString(mParameters.orientationAware)); |
| } |
| |
| void KeyboardInputMapper::reset() { |
| for (;;) { |
| int32_t keyCode, scanCode; |
| { // acquire lock |
| AutoMutex _l(mLock); |
| |
| // Synthesize key up event on reset if keys are currently down. |
| if (mLocked.keyDowns.isEmpty()) { |
| initializeLocked(); |
| resetLedStateLocked(); |
| break; // done |
| } |
| |
| const KeyDown& keyDown = mLocked.keyDowns.top(); |
| keyCode = keyDown.keyCode; |
| scanCode = keyDown.scanCode; |
| } // release lock |
| |
| nsecs_t when = systemTime(SYSTEM_TIME_MONOTONIC); |
| processKey(when, false, keyCode, scanCode, 0); |
| } |
| |
| InputMapper::reset(); |
| getContext()->updateGlobalMetaState(); |
| } |
| |
| void KeyboardInputMapper::process(const RawEvent* rawEvent) { |
| switch (rawEvent->type) { |
| case EV_KEY: { |
| int32_t scanCode = rawEvent->scanCode; |
| if (isKeyboardOrGamepadKey(scanCode)) { |
| processKey(rawEvent->when, rawEvent->value != 0, rawEvent->keyCode, scanCode, |
| rawEvent->flags); |
| } |
| break; |
| } |
| } |
| } |
| |
| 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) { |
| int32_t newMetaState; |
| nsecs_t downTime; |
| bool metaStateChanged = false; |
| |
| { // acquire lock |
| AutoMutex _l(mLock); |
| |
| if (down) { |
| // Rotate key codes according to orientation if needed. |
| // Note: getDisplayInfo is non-reentrant so we can continue holding the lock. |
| if (mParameters.orientationAware && mParameters.associatedDisplayId >= 0) { |
| int32_t orientation; |
| if (!getPolicy()->getDisplayInfo(mParameters.associatedDisplayId, |
| NULL, NULL, & orientation)) { |
| orientation = DISPLAY_ORIENTATION_0; |
| } |
| |
| keyCode = rotateKeyCode(keyCode, orientation); |
| } |
| |
| // Add key down. |
| ssize_t keyDownIndex = findKeyDownLocked(scanCode); |
| if (keyDownIndex >= 0) { |
| // key repeat, be sure to use same keycode as before in case of rotation |
| keyCode = mLocked.keyDowns.itemAt(keyDownIndex).keyCode; |
| } else { |
| // key down |
| if ((policyFlags & POLICY_FLAG_VIRTUAL) |
| && mContext->shouldDropVirtualKey(when, |
| getDevice(), keyCode, scanCode)) { |
| return; |
| } |
| |
| mLocked.keyDowns.push(); |
| KeyDown& keyDown = mLocked.keyDowns.editTop(); |
| keyDown.keyCode = keyCode; |
| keyDown.scanCode = scanCode; |
| } |
| |
| mLocked.downTime = when; |
| } else { |
| // Remove key down. |
| ssize_t keyDownIndex = findKeyDownLocked(scanCode); |
| if (keyDownIndex >= 0) { |
| // key up, be sure to use same keycode as before in case of rotation |
| keyCode = mLocked.keyDowns.itemAt(keyDownIndex).keyCode; |
| mLocked.keyDowns.removeAt(size_t(keyDownIndex)); |
| } else { |
| // key was not actually down |
| LOGI("Dropping key up from device %s because the key was not down. " |
| "keyCode=%d, scanCode=%d", |
| getDeviceName().string(), keyCode, scanCode); |
| return; |
| } |
| } |
| |
| int32_t oldMetaState = mLocked.metaState; |
| newMetaState = updateMetaState(keyCode, down, oldMetaState); |
| if (oldMetaState != newMetaState) { |
| mLocked.metaState = newMetaState; |
| metaStateChanged = true; |
| updateLedStateLocked(false); |
| } |
| |
| downTime = mLocked.downTime; |
| } // release lock |
| |
| // 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(); |
| } |
| |
| getDispatcher()->notifyKey(when, getDeviceId(), mSource, policyFlags, |
| down ? AKEY_EVENT_ACTION_DOWN : AKEY_EVENT_ACTION_UP, |
| AKEY_EVENT_FLAG_FROM_SYSTEM, keyCode, scanCode, newMetaState, downTime); |
| } |
| |
| ssize_t KeyboardInputMapper::findKeyDownLocked(int32_t scanCode) { |
| size_t n = mLocked.keyDowns.size(); |
| for (size_t i = 0; i < n; i++) { |
| if (mLocked.keyDowns[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() { |
| { // acquire lock |
| AutoMutex _l(mLock); |
| return mLocked.metaState; |
| } // release lock |
| } |
| |
| void KeyboardInputMapper::resetLedStateLocked() { |
| initializeLedStateLocked(mLocked.capsLockLedState, LED_CAPSL); |
| initializeLedStateLocked(mLocked.numLockLedState, LED_NUML); |
| initializeLedStateLocked(mLocked.scrollLockLedState, LED_SCROLLL); |
| |
| updateLedStateLocked(true); |
| } |
| |
| void KeyboardInputMapper::initializeLedStateLocked(LockedState::LedState& ledState, int32_t led) { |
| ledState.avail = getEventHub()->hasLed(getDeviceId(), led); |
| ledState.on = false; |
| } |
| |
| void KeyboardInputMapper::updateLedStateLocked(bool reset) { |
| updateLedStateForModifierLocked(mLocked.capsLockLedState, LED_CAPSL, |
| AMETA_CAPS_LOCK_ON, reset); |
| updateLedStateForModifierLocked(mLocked.numLockLedState, LED_NUML, |
| AMETA_NUM_LOCK_ON, reset); |
| updateLedStateForModifierLocked(mLocked.scrollLockLedState, LED_SCROLLL, |
| AMETA_SCROLL_LOCK_ON, reset); |
| } |
| |
| void KeyboardInputMapper::updateLedStateForModifierLocked(LockedState::LedState& ledState, |
| int32_t led, int32_t modifier, bool reset) { |
| if (ledState.avail) { |
| bool desiredState = (mLocked.metaState & modifier) != 0; |
| if (reset || ledState.on != desiredState) { |
| getEventHub()->setLedState(getDeviceId(), led, desiredState); |
| ledState.on = desiredState; |
| } |
| } |
| } |
| |
| |
| // --- CursorInputMapper --- |
| |
| CursorInputMapper::CursorInputMapper(InputDevice* device) : |
| InputMapper(device) { |
| initializeLocked(); |
| } |
| |
| 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); |
| info->addMotionRange(AMOTION_EVENT_AXIS_Y, mSource, minY, maxY, 0.0f, 0.0f); |
| } |
| } else { |
| info->addMotionRange(AMOTION_EVENT_AXIS_X, mSource, -1.0f, 1.0f, 0.0f, mXScale); |
| info->addMotionRange(AMOTION_EVENT_AXIS_Y, mSource, -1.0f, 1.0f, 0.0f, mYScale); |
| } |
| info->addMotionRange(AMOTION_EVENT_AXIS_PRESSURE, mSource, 0.0f, 1.0f, 0.0f, 0.0f); |
| |
| if (mHaveVWheel) { |
| info->addMotionRange(AMOTION_EVENT_AXIS_VSCROLL, mSource, -1.0f, 1.0f, 0.0f, 0.0f); |
| } |
| if (mHaveHWheel) { |
| info->addMotionRange(AMOTION_EVENT_AXIS_HSCROLL, mSource, -1.0f, 1.0f, 0.0f, 0.0f); |
| } |
| } |
| |
| void CursorInputMapper::dump(String8& dump) { |
| { // acquire lock |
| AutoMutex _l(mLock); |
| 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(mHaveVWheel)); |
| dump.appendFormat(INDENT3 "HaveHWheel: %s\n", toString(mHaveHWheel)); |
| dump.appendFormat(INDENT3 "VWheelScale: %0.3f\n", mVWheelScale); |
| dump.appendFormat(INDENT3 "HWheelScale: %0.3f\n", mHWheelScale); |
| dump.appendFormat(INDENT3 "ButtonState: 0x%08x\n", mLocked.buttonState); |
| dump.appendFormat(INDENT3 "Down: %s\n", toString(isPointerDown(mLocked.buttonState))); |
| dump.appendFormat(INDENT3 "DownTime: %lld\n", mLocked.downTime); |
| } // release lock |
| } |
| |
| void CursorInputMapper::configure(const InputReaderConfiguration* config, uint32_t changes) { |
| InputMapper::configure(config, changes); |
| |
| if (!changes) { // first time only |
| // 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; |
| |
| mHaveVWheel = getEventHub()->hasRelativeAxis(getDeviceId(), REL_WHEEL); |
| mHaveHWheel = getEventHub()->hasRelativeAxis(getDeviceId(), REL_HWHEEL); |
| } |
| |
| if (!changes || (changes & InputReaderConfiguration::CHANGE_POINTER_SPEED)) { |
| mPointerVelocityControl.setParameters(config->pointerVelocityControlParameters); |
| mWheelXVelocityControl.setParameters(config->wheelVelocityControlParameters); |
| mWheelYVelocityControl.setParameters(config->wheelVelocityControlParameters); |
| } |
| } |
| |
| 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") { |
| LOGW("Invalid value for cursor.mode: '%s'", cursorModeString.string()); |
| } |
| } |
| |
| mParameters.orientationAware = false; |
| getDevice()->getConfiguration().tryGetProperty(String8("cursor.orientationAware"), |
| mParameters.orientationAware); |
| |
| mParameters.associatedDisplayId = mParameters.mode == Parameters::MODE_POINTER |
| || mParameters.orientationAware ? 0 : -1; |
| } |
| |
| void CursorInputMapper::dumpParameters(String8& dump) { |
| dump.append(INDENT3 "Parameters:\n"); |
| dump.appendFormat(INDENT4 "AssociatedDisplayId: %d\n", |
| mParameters.associatedDisplayId); |
| |
| 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: |
| LOG_ASSERT(false); |
| } |
| |
| dump.appendFormat(INDENT4 "OrientationAware: %s\n", |
| toString(mParameters.orientationAware)); |
| } |
| |
| void CursorInputMapper::initializeLocked() { |
| mAccumulator.clear(); |
| |
| mLocked.buttonState = 0; |
| mLocked.downTime = 0; |
| } |
| |
| void CursorInputMapper::reset() { |
| for (;;) { |
| int32_t buttonState; |
| { // acquire lock |
| AutoMutex _l(mLock); |
| |
| buttonState = mLocked.buttonState; |
| if (!buttonState) { |
| initializeLocked(); |
| break; // done |
| } |
| } // release lock |
| |
| // Reset velocity. |
| mPointerVelocityControl.reset(); |
| mWheelXVelocityControl.reset(); |
| mWheelYVelocityControl.reset(); |
| |
| // Synthesize button up event on reset. |
| nsecs_t when = systemTime(SYSTEM_TIME_MONOTONIC); |
| mAccumulator.clear(); |
| mAccumulator.buttonDown = 0; |
| mAccumulator.buttonUp = buttonState; |
| mAccumulator.fields = Accumulator::FIELD_BUTTONS; |
| sync(when); |
| } |
| |
| InputMapper::reset(); |
| } |
| |
| void CursorInputMapper::process(const RawEvent* rawEvent) { |
| switch (rawEvent->type) { |
| case EV_KEY: { |
| int32_t buttonState = getButtonStateForScanCode(rawEvent->scanCode); |
| if (buttonState) { |
| if (rawEvent->value) { |
| mAccumulator.buttonDown = buttonState; |
| mAccumulator.buttonUp = 0; |
| } else { |
| mAccumulator.buttonDown = 0; |
| mAccumulator.buttonUp = buttonState; |
| } |
| mAccumulator.fields |= Accumulator::FIELD_BUTTONS; |
| |
| // Sync now since BTN_MOUSE is not necessarily followed by SYN_REPORT and |
| // we need to ensure that we report the up/down promptly. |
| sync(rawEvent->when); |
| break; |
| } |
| break; |
| } |
| |
| case EV_REL: |
| switch (rawEvent->scanCode) { |
| case REL_X: |
| mAccumulator.fields |= Accumulator::FIELD_REL_X; |
| mAccumulator.relX = rawEvent->value; |
| break; |
| case REL_Y: |
| mAccumulator.fields |= Accumulator::FIELD_REL_Y; |
| mAccumulator.relY = rawEvent->value; |
| break; |
| case REL_WHEEL: |
| mAccumulator.fields |= Accumulator::FIELD_REL_WHEEL; |
| mAccumulator.relWheel = rawEvent->value; |
| break; |
| case REL_HWHEEL: |
| mAccumulator.fields |= Accumulator::FIELD_REL_HWHEEL; |
| mAccumulator.relHWheel = rawEvent->value; |
| break; |
| } |
| break; |
| |
| case EV_SYN: |
| switch (rawEvent->scanCode) { |
| case SYN_REPORT: |
| sync(rawEvent->when); |
| break; |
| } |
| break; |
| } |
| } |
| |
| void CursorInputMapper::sync(nsecs_t when) { |
| uint32_t fields = mAccumulator.fields; |
| if (fields == 0) { |
| return; // no new state changes, so nothing to do |
| } |
| |
| int32_t motionEventAction; |
| int32_t motionEventEdgeFlags; |
| int32_t lastButtonState, currentButtonState; |
| PointerProperties pointerProperties; |
| PointerCoords pointerCoords; |
| nsecs_t downTime; |
| float vscroll, hscroll; |
| { // acquire lock |
| AutoMutex _l(mLock); |
| |
| lastButtonState = mLocked.buttonState; |
| |
| bool down, downChanged; |
| bool wasDown = isPointerDown(mLocked.buttonState); |
| bool buttonsChanged = fields & Accumulator::FIELD_BUTTONS; |
| if (buttonsChanged) { |
| mLocked.buttonState = (mLocked.buttonState | mAccumulator.buttonDown) |
| & ~mAccumulator.buttonUp; |
| |
| down = isPointerDown(mLocked.buttonState); |
| |
| if (!wasDown && down) { |
| mLocked.downTime = when; |
| downChanged = true; |
| } else if (wasDown && !down) { |
| downChanged = true; |
| } else { |
| downChanged = false; |
| } |
| } else { |
| down = wasDown; |
| downChanged = false; |
| } |
| |
| currentButtonState = mLocked.buttonState; |
| |
| downTime = mLocked.downTime; |
| float deltaX = fields & Accumulator::FIELD_REL_X ? mAccumulator.relX * mXScale : 0.0f; |
| float deltaY = fields & Accumulator::FIELD_REL_Y ? mAccumulator.relY * mYScale : 0.0f; |
| |
| 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; |
| } |
| |
| if (mParameters.orientationAware && mParameters.associatedDisplayId >= 0 |
| && (deltaX != 0.0f || deltaY != 0.0f)) { |
| // Rotate motion based on display orientation if needed. |
| // Note: getDisplayInfo is non-reentrant so we can continue holding the lock. |
| int32_t orientation; |
| if (! getPolicy()->getDisplayInfo(mParameters.associatedDisplayId, |
| NULL, NULL, & orientation)) { |
| orientation = DISPLAY_ORIENTATION_0; |
| } |
| |
| 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; |
| } |
| } |
| |
| motionEventEdgeFlags = AMOTION_EVENT_EDGE_FLAG_NONE; |
| |
| pointerProperties.clear(); |
| pointerProperties.id = 0; |
| pointerProperties.toolType = AMOTION_EVENT_TOOL_TYPE_MOUSE; |
| |
| pointerCoords.clear(); |
| |
| if (mHaveVWheel && (fields & Accumulator::FIELD_REL_WHEEL)) { |
| vscroll = mAccumulator.relWheel; |
| } else { |
| vscroll = 0; |
| } |
| mWheelYVelocityControl.move(when, NULL, &vscroll); |
| |
| if (mHaveHWheel && (fields & Accumulator::FIELD_REL_HWHEEL)) { |
| hscroll = mAccumulator.relHWheel; |
| } else { |
| hscroll = 0; |
| } |
| mWheelXVelocityControl.move(when, &hscroll, NULL); |
| |
| mPointerVelocityControl.move(when, &deltaX, &deltaY); |
| |
| if (mPointerController != NULL) { |
| if (deltaX != 0 || deltaY != 0 || vscroll != 0 || hscroll != 0 |
| || buttonsChanged) { |
| mPointerController->setPresentation( |
| PointerControllerInterface::PRESENTATION_POINTER); |
| |
| if (deltaX != 0 || deltaY != 0) { |
| mPointerController->move(deltaX, deltaY); |
| } |
| |
| if (buttonsChanged) { |
| mPointerController->setButtonState(mLocked.buttonState); |
| } |
| |
| 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); |
| |
| if (motionEventAction == AMOTION_EVENT_ACTION_DOWN) { |
| motionEventEdgeFlags = calculateEdgeFlagsUsingPointerBounds( |
| mPointerController, x, y); |
| } |
| } else { |
| pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_X, deltaX); |
| pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_Y, deltaY); |
| } |
| |
| pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, down ? 1.0f : 0.0f); |
| } // release lock |
| |
| // 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 (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. |
| int32_t metaState = mContext->getGlobalMetaState(); |
| getDispatcher()->notifyMotion(when, getDeviceId(), mSource, policyFlags, |
| motionEventAction, 0, metaState, currentButtonState, motionEventEdgeFlags, |
| 1, &pointerProperties, &pointerCoords, mXPrecision, mYPrecision, downTime); |
| |
| // Send hover move after UP to tell the application that the mouse is hovering now. |
| if (motionEventAction == AMOTION_EVENT_ACTION_UP |
| && mPointerController != NULL) { |
| getDispatcher()->notifyMotion(when, getDeviceId(), mSource, policyFlags, |
| AMOTION_EVENT_ACTION_HOVER_MOVE, 0, |
| metaState, currentButtonState, AMOTION_EVENT_EDGE_FLAG_NONE, |
| 1, &pointerProperties, &pointerCoords, mXPrecision, mYPrecision, downTime); |
| } |
| |
| // Send scroll events. |
| if (vscroll != 0 || hscroll != 0) { |
| pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_VSCROLL, vscroll); |
| pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_HSCROLL, hscroll); |
| |
| getDispatcher()->notifyMotion(when, getDeviceId(), mSource, policyFlags, |
| AMOTION_EVENT_ACTION_SCROLL, 0, metaState, currentButtonState, |
| AMOTION_EVENT_EDGE_FLAG_NONE, |
| 1, &pointerProperties, &pointerCoords, mXPrecision, mYPrecision, downTime); |
| } |
| |
| // Synthesize key up from buttons if needed. |
| synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_UP, when, getDeviceId(), mSource, |
| policyFlags, lastButtonState, currentButtonState); |
| |
| mAccumulator.clear(); |
| } |
| |
| 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() { |
| { // acquire lock |
| AutoMutex _l(mLock); |
| if (mPointerController != NULL) { |
| mPointerController->fade(PointerControllerInterface::TRANSITION_GRADUAL); |
| } |
| } // release lock |
| } |
| |
| |
| // --- TouchInputMapper --- |
| |
| TouchInputMapper::TouchInputMapper(InputDevice* device) : |
| InputMapper(device) { |
| mLocked.surfaceOrientation = -1; |
| mLocked.surfaceWidth = -1; |
| mLocked.surfaceHeight = -1; |
| |
| initializeLocked(); |
| } |
| |
| TouchInputMapper::~TouchInputMapper() { |
| } |
| |
| uint32_t TouchInputMapper::getSources() { |
| return mTouchSource | mPointerSource; |
| } |
| |
| void TouchInputMapper::populateDeviceInfo(InputDeviceInfo* info) { |
| InputMapper::populateDeviceInfo(info); |
| |
| { // acquire lock |
| AutoMutex _l(mLock); |
| |
| // Ensure surface information is up to date so that orientation changes are |
| // noticed immediately. |
| if (!configureSurfaceLocked()) { |
| return; |
| } |
| |
| info->addMotionRange(mLocked.orientedRanges.x); |
| info->addMotionRange(mLocked.orientedRanges.y); |
| |
| if (mLocked.orientedRanges.havePressure) { |
| info->addMotionRange(mLocked.orientedRanges.pressure); |
| } |
| |
| if (mLocked.orientedRanges.haveSize) { |
| info->addMotionRange(mLocked.orientedRanges.size); |
| } |
| |
| if (mLocked.orientedRanges.haveTouchSize) { |
| info->addMotionRange(mLocked.orientedRanges.touchMajor); |
| info->addMotionRange(mLocked.orientedRanges.touchMinor); |
| } |
| |
| if (mLocked.orientedRanges.haveToolSize) { |
| info->addMotionRange(mLocked.orientedRanges.toolMajor); |
| info->addMotionRange(mLocked.orientedRanges.toolMinor); |
| } |
| |
| if (mLocked.orientedRanges.haveOrientation) { |
| info->addMotionRange(mLocked.orientedRanges.orientation); |
| } |
| |
| if (mLocked.orientedRanges.haveDistance) { |
| info->addMotionRange(mLocked.orientedRanges.distance); |
| } |
| |
| if (mPointerController != NULL) { |
| float minX, minY, maxX, maxY; |
| if (mPointerController->getBounds(&minX, &minY, &maxX, &maxY)) { |
| info->addMotionRange(AMOTION_EVENT_AXIS_X, mPointerSource, |
| minX, maxX, 0.0f, 0.0f); |
| info->addMotionRange(AMOTION_EVENT_AXIS_Y, mPointerSource, |
| minY, maxY, 0.0f, 0.0f); |
| } |
| info->addMotionRange(AMOTION_EVENT_AXIS_PRESSURE, mPointerSource, |
| 0.0f, 1.0f, 0.0f, 0.0f); |
| } |
| } // release lock |
| } |
| |
| void TouchInputMapper::dump(String8& dump) { |
| { // acquire lock |
| AutoMutex _l(mLock); |
| dump.append(INDENT2 "Touch Input Mapper:\n"); |
| dumpParameters(dump); |
| dumpVirtualKeysLocked(dump); |
| dumpRawAxes(dump); |
| dumpCalibration(dump); |
| dumpSurfaceLocked(dump); |
| |
| dump.appendFormat(INDENT3 "Translation and Scaling Factors:\n"); |
| dump.appendFormat(INDENT4 "XScale: %0.3f\n", mLocked.xScale); |
| dump.appendFormat(INDENT4 "YScale: %0.3f\n", mLocked.yScale); |
| dump.appendFormat(INDENT4 "XPrecision: %0.3f\n", mLocked.xPrecision); |
| dump.appendFormat(INDENT4 "YPrecision: %0.3f\n", mLocked.yPrecision); |
| dump.appendFormat(INDENT4 "GeometricScale: %0.3f\n", mLocked.geometricScale); |
| dump.appendFormat(INDENT4 "ToolSizeLinearScale: %0.3f\n", mLocked.toolSizeLinearScale); |
| dump.appendFormat(INDENT4 "ToolSizeLinearBias: %0.3f\n", mLocked.toolSizeLinearBias); |
| dump.appendFormat(INDENT4 "ToolSizeAreaScale: %0.3f\n", mLocked.toolSizeAreaScale); |
| dump.appendFormat(INDENT4 "ToolSizeAreaBias: %0.3f\n", mLocked.toolSizeAreaBias); |
| dump.appendFormat(INDENT4 "PressureScale: %0.3f\n", mLocked.pressureScale); |
| dump.appendFormat(INDENT4 "SizeScale: %0.3f\n", mLocked.sizeScale); |
| dump.appendFormat(INDENT4 "OrientationScale: %0.3f\n", mLocked.orientationScale); |
| dump.appendFormat(INDENT4 "DistanceScale: %0.3f\n", mLocked.distanceScale); |
| |
| dump.appendFormat(INDENT3 "Last Touch:\n"); |
| dump.appendFormat(INDENT4 "Button State: 0x%08x\n", mLastTouch.buttonState); |
| dump.appendFormat(INDENT4 "Pointer Count: %d\n", mLastTouch.pointerCount); |
| for (uint32_t i = 0; i < mLastTouch.pointerCount; i++) { |
| const PointerData& pointer = mLastTouch.pointers[i]; |
| dump.appendFormat(INDENT5 "[%d]: id=%d, x=%d, y=%d, pressure=%d, " |
| "touchMajor=%d, touchMinor=%d, toolMajor=%d, toolMinor=%d, " |
| "orientation=%d, distance=%d, isStylus=%s\n", i, |
| pointer.id, pointer.x, pointer.y, pointer.pressure, |
| pointer.touchMajor, pointer.touchMinor, pointer.toolMajor, pointer.toolMinor, |
| pointer.orientation, pointer.distance, toString(pointer.isStylus)); |
| } |
| |
| if (mParameters.deviceType == Parameters::DEVICE_TYPE_POINTER) { |
| dump.appendFormat(INDENT3 "Pointer Gesture Detector:\n"); |
| dump.appendFormat(INDENT4 "XMovementScale: %0.3f\n", |
| mLocked.pointerGestureXMovementScale); |
| dump.appendFormat(INDENT4 "YMovementScale: %0.3f\n", |
| mLocked.pointerGestureYMovementScale); |
| dump.appendFormat(INDENT4 "XZoomScale: %0.3f\n", |
| mLocked.pointerGestureXZoomScale); |
| dump.appendFormat(INDENT4 "YZoomScale: %0.3f\n", |
| mLocked.pointerGestureYZoomScale); |
| dump.appendFormat(INDENT4 "MaxSwipeWidth: %f\n", |
| mLocked.pointerGestureMaxSwipeWidth); |
| } |
| } // release lock |
| } |
| |
| void TouchInputMapper::initializeLocked() { |
| mCurrentTouch.clear(); |
| mLastTouch.clear(); |
| mDownTime = 0; |
| |
| for (uint32_t i = 0; i < MAX_POINTERS; i++) { |
| mAveragingTouchFilter.historyStart[i] = 0; |
| mAveragingTouchFilter.historyEnd[i] = 0; |
| } |
| |
| mJumpyTouchFilter.jumpyPointsDropped = 0; |
| |
| mLocked.currentVirtualKey.down = false; |
| |
| mLocked.orientedRanges.havePressure = false; |
| mLocked.orientedRanges.haveSize = false; |
| mLocked.orientedRanges.haveTouchSize = false; |
| mLocked.orientedRanges.haveToolSize = false; |
| mLocked.orientedRanges.haveOrientation = false; |
| mLocked.orientedRanges.haveDistance = false; |
| |
| mPointerGesture.reset(); |
| } |
| |
| void TouchInputMapper::configure(const InputReaderConfiguration* config, uint32_t changes) { |
| InputMapper::configure(config, changes); |
| |
| mConfig = *config; |
| |
| if (!changes) { // first time only |
| // Configure basic parameters. |
| configureParameters(); |
| |
| // Configure sources. |
| switch (mParameters.deviceType) { |
| case Parameters::DEVICE_TYPE_TOUCH_SCREEN: |
| mTouchSource = AINPUT_SOURCE_TOUCHSCREEN; |
| mPointerSource = 0; |
| break; |
| case Parameters::DEVICE_TYPE_TOUCH_PAD: |
| mTouchSource = AINPUT_SOURCE_TOUCHPAD; |
| mPointerSource = 0; |
| break; |
| case Parameters::DEVICE_TYPE_POINTER: |
| mTouchSource = AINPUT_SOURCE_TOUCHPAD; |
| mPointerSource = AINPUT_SOURCE_MOUSE; |
| break; |
| default: |
| LOG_ASSERT(false); |
| } |
| |
| // Configure absolute axis information. |
| configureRawAxes(); |
| |
| // Prepare input device calibration. |
| parseCalibration(); |
| resolveCalibration(); |
| |
| { // acquire lock |
| AutoMutex _l(mLock); |
| |
| // Configure surface dimensions and orientation. |
| configureSurfaceLocked(); |
| } // release lock |
| } |
| |
| if (!changes || (changes & InputReaderConfiguration::CHANGE_POINTER_SPEED)) { |
| mPointerGesture.pointerVelocityControl.setParameters( |
| mConfig.pointerVelocityControlParameters); |
| } |
| |
| if (!changes || (changes & InputReaderConfiguration::CHANGE_POINTER_GESTURE_ENABLEMENT)) { |
| // Reset the touch screen when pointer gesture enablement changes. |
| reset(); |
| } |
| } |
| |
| void TouchInputMapper::configureParameters() { |
| mParameters.useBadTouchFilter = mConfig.filterTouchEvents; |
| mParameters.useAveragingTouchFilter = mConfig.filterTouchEvents; |
| mParameters.useJumpyTouchFilter = mConfig.filterJumpyTouchEvents; |
| |
| // 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") { |
| LOGW("Invalid value for touch.gestureMode: '%s'", gestureModeString.string()); |
| } |
| } |
| |
| 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 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()->hasInputProperty(getDeviceId(), INPUT_PROP_DIRECT)) { |
| // The device is a touch screen. |
| mParameters.deviceType = Parameters::DEVICE_TYPE_TOUCH_SCREEN; |
| } 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 == "pointer") { |
| mParameters.deviceType = Parameters::DEVICE_TYPE_POINTER; |
| } else if (deviceTypeString != "default") { |
| LOGW("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.associatedDisplayId = mParameters.orientationAware |
| || mParameters.deviceType == Parameters::DEVICE_TYPE_TOUCH_SCREEN |
| || mParameters.deviceType == Parameters::DEVICE_TYPE_POINTER |
| ? 0 : -1; |
| } |
| |
| 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_POINTER: |
| dump.append(INDENT4 "DeviceType: pointer\n"); |
| break; |
| default: |
| LOG_ASSERT(false); |
| } |
| |
| dump.appendFormat(INDENT4 "AssociatedDisplayId: %d\n", |
| mParameters.associatedDisplayId); |
| dump.appendFormat(INDENT4 "OrientationAware: %s\n", |
| toString(mParameters.orientationAware)); |
| |
| dump.appendFormat(INDENT4 "UseBadTouchFilter: %s\n", |
| toString(mParameters.useBadTouchFilter)); |
| dump.appendFormat(INDENT4 "UseAveragingTouchFilter: %s\n", |
| toString(mParameters.useAveragingTouchFilter)); |
| dump.appendFormat(INDENT4 "UseJumpyTouchFilter: %s\n", |
| toString(mParameters.useJumpyTouchFilter)); |
| } |
| |
| void TouchInputMapper::configureRawAxes() { |
| mRawAxes.x.clear(); |
| mRawAxes.y.clear(); |
| mRawAxes.pressure.clear(); |
| mRawAxes.touchMajor.clear(); |
| mRawAxes.touchMinor.clear(); |
| mRawAxes.toolMajor.clear(); |
| mRawAxes.toolMinor.clear(); |
| mRawAxes.orientation.clear(); |
| mRawAxes.distance.clear(); |
| mRawAxes.trackingId.clear(); |
| mRawAxes.slot.clear(); |
| } |
| |
| void TouchInputMapper::dumpRawAxes(String8& dump) { |
| dump.append(INDENT3 "Raw Axes:\n"); |
| dumpRawAbsoluteAxisInfo(dump, mRawAxes.x, "X"); |
| dumpRawAbsoluteAxisInfo(dump, mRawAxes.y, "Y"); |
| dumpRawAbsoluteAxisInfo(dump, mRawAxes.pressure, "Pressure"); |
| dumpRawAbsoluteAxisInfo(dump, mRawAxes.touchMajor, "TouchMajor"); |
| dumpRawAbsoluteAxisInfo(dump, mRawAxes.touchMinor, "TouchMinor"); |
| dumpRawAbsoluteAxisInfo(dump, mRawAxes.toolMajor, "ToolMajor"); |
| dumpRawAbsoluteAxisInfo(dump, mRawAxes.toolMinor, "ToolMinor"); |
| dumpRawAbsoluteAxisInfo(dump, mRawAxes.orientation, "Orientation"); |
| dumpRawAbsoluteAxisInfo(dump, mRawAxes.distance, "Distance"); |
| dumpRawAbsoluteAxisInfo(dump, mRawAxes.trackingId, "TrackingId"); |
| dumpRawAbsoluteAxisInfo(dump, mRawAxes.slot, "Slot"); |
| } |
| |
| bool TouchInputMapper::configureSurfaceLocked() { |
| // Ensure we have valid X and Y axes. |
| if (!mRawAxes.x.valid || !mRawAxes.y.valid) { |
| LOGW(INDENT "Touch device '%s' did not report support for X or Y axis! " |
| "The device will be inoperable.", getDeviceName().string()); |
| return false; |
| } |
| |
| // Update orientation and dimensions if needed. |
| int32_t orientation = DISPLAY_ORIENTATION_0; |
| int32_t width = mRawAxes.x.maxValue - mRawAxes.x.minValue + 1; |
| int32_t height = mRawAxes.y.maxValue - mRawAxes.y.minValue + 1; |
| |
| if (mParameters.associatedDisplayId >= 0) { |
| // Note: getDisplayInfo is non-reentrant so we can continue holding the lock. |
| if (! getPolicy()->getDisplayInfo(mParameters.associatedDisplayId, |
| &mLocked.associatedDisplayWidth, &mLocked.associatedDisplayHeight, |
| &mLocked.associatedDisplayOrientation)) { |
| return false; |
| } |
| |
| // A touch screen inherits the dimensions of the display. |
| if (mParameters.deviceType == Parameters::DEVICE_TYPE_TOUCH_SCREEN) { |
| width = mLocked.associatedDisplayWidth; |
| height = mLocked.associatedDisplayHeight; |
| } |
| |
| // The device inherits the orientation of the display if it is orientation aware. |
| if (mParameters.orientationAware) { |
| orientation = mLocked.associatedDisplayOrientation; |
| } |
| } |
| |
| if (mParameters.deviceType == Parameters::DEVICE_TYPE_POINTER |
| && mPointerController == NULL) { |
| mPointerController = getPolicy()->obtainPointerController(getDeviceId()); |
| } |
| |
| bool orientationChanged = mLocked.surfaceOrientation != orientation; |
| if (orientationChanged) { |
| mLocked.surfaceOrientation = orientation; |
| } |
| |
| bool sizeChanged = mLocked.surfaceWidth != width || mLocked.surfaceHeight != height; |
| if (sizeChanged) { |
| LOGI("Device reconfigured: id=%d, name='%s', surface size is now %dx%d", |
| getDeviceId(), getDeviceName().string(), width, height); |
| |
| mLocked.surfaceWidth = width; |
| mLocked.surfaceHeight = height; |
| |
| // Configure X and Y factors. |
| mLocked.xScale = float(width) / (mRawAxes.x.maxValue - mRawAxes.x.minValue + 1); |
| mLocked.yScale = float(height) / (mRawAxes.y.maxValue - mRawAxes.y.minValue + 1); |
| mLocked.xPrecision = 1.0f / mLocked.xScale; |
| mLocked.yPrecision = 1.0f / mLocked.yScale; |
| |
| mLocked.orientedRanges.x.axis = AMOTION_EVENT_AXIS_X; |
| mLocked.orientedRanges.x.source = mTouchSource; |
| mLocked.orientedRanges.y.axis = AMOTION_EVENT_AXIS_Y; |
| mLocked.orientedRanges.y.source = mTouchSource; |
| |
| configureVirtualKeysLocked(); |
| |
| // 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. |
| mLocked.geometricScale = avg(mLocked.xScale, mLocked.yScale); |
| |
| // Size of diagonal axis. |
| float diagonalSize = hypotf(width, height); |
| |
| // TouchMajor and TouchMinor factors. |
| if (mCalibration.touchSizeCalibration != Calibration::TOUCH_SIZE_CALIBRATION_NONE) { |
| mLocked.orientedRanges.haveTouchSize = true; |
| |
| mLocked.orientedRanges.touchMajor.axis = AMOTION_EVENT_AXIS_TOUCH_MAJOR; |
| mLocked.orientedRanges.touchMajor.source = mTouchSource; |
| mLocked.orientedRanges.touchMajor.min = 0; |
| mLocked.orientedRanges.touchMajor.max = diagonalSize; |
| mLocked.orientedRanges.touchMajor.flat = 0; |
| mLocked.orientedRanges.touchMajor.fuzz = 0; |
| |
| mLocked.orientedRanges.touchMinor = mLocked.orientedRanges.touchMajor; |
| mLocked.orientedRanges.touchMinor.axis = AMOTION_EVENT_AXIS_TOUCH_MINOR; |
| } |
| |
| // ToolMajor and ToolMinor factors. |
| mLocked.toolSizeLinearScale = 0; |
| mLocked.toolSizeLinearBias = 0; |
| mLocked.toolSizeAreaScale = 0; |
| mLocked.toolSizeAreaBias = 0; |
| if (mCalibration.toolSizeCalibration != Calibration::TOOL_SIZE_CALIBRATION_NONE) { |
| if (mCalibration.toolSizeCalibration == Calibration::TOOL_SIZE_CALIBRATION_LINEAR) { |
| if (mCalibration.haveToolSizeLinearScale) { |
| mLocked.toolSizeLinearScale = mCalibration.toolSizeLinearScale; |
| } else if (mRawAxes.toolMajor.valid && mRawAxes.toolMajor.maxValue != 0) { |
| mLocked.toolSizeLinearScale = float(min(width, height)) |
| / mRawAxes.toolMajor.maxValue; |
| } |
| |
| if (mCalibration.haveToolSizeLinearBias) { |
| mLocked.toolSizeLinearBias = mCalibration.toolSizeLinearBias; |
| } |
| } else if (mCalibration.toolSizeCalibration == |
| Calibration::TOOL_SIZE_CALIBRATION_AREA) { |
| if (mCalibration.haveToolSizeLinearScale) { |
| mLocked.toolSizeLinearScale = mCalibration.toolSizeLinearScale; |
| } else { |
| mLocked.toolSizeLinearScale = min(width, height); |
| } |
| |
| if (mCalibration.haveToolSizeLinearBias) { |
| mLocked.toolSizeLinearBias = mCalibration.toolSizeLinearBias; |
| } |
| |
| if (mCalibration.haveToolSizeAreaScale) { |
| mLocked.toolSizeAreaScale = mCalibration.toolSizeAreaScale; |
| } else if (mRawAxes.toolMajor.valid && mRawAxes.toolMajor.maxValue != 0) { |
| mLocked.toolSizeAreaScale = 1.0f / mRawAxes.toolMajor.maxValue; |
| } |
| |
| if (mCalibration.haveToolSizeAreaBias) { |
| mLocked.toolSizeAreaBias = mCalibration.toolSizeAreaBias; |
| } |
| } |
| |
| mLocked.orientedRanges.haveToolSize = true; |
| |
| mLocked.orientedRanges.toolMajor.axis = AMOTION_EVENT_AXIS_TOOL_MAJOR; |
| mLocked.orientedRanges.toolMajor.source = mTouchSource; |
| mLocked.orientedRanges.toolMajor.min = 0; |
| mLocked.orientedRanges.toolMajor.max = diagonalSize; |
| mLocked.orientedRanges.toolMajor.flat = 0; |
| mLocked.orientedRanges.toolMajor.fuzz = 0; |
| |
| mLocked.orientedRanges.toolMinor = mLocked.orientedRanges.toolMajor; |
| mLocked.orientedRanges.toolMinor.axis = AMOTION_EVENT_AXIS_TOOL_MINOR; |
| } |
| |
| // Pressure factors. |
| mLocked.pressureScale = 0; |
| if (mCalibration.pressureCalibration != Calibration::PRESSURE_CALIBRATION_NONE) { |
| RawAbsoluteAxisInfo rawPressureAxis; |
| switch (mCalibration.pressureSource) { |
| case Calibration::PRESSURE_SOURCE_PRESSURE: |
| rawPressureAxis = mRawAxes.pressure; |
| break; |
| case Calibration::PRESSURE_SOURCE_TOUCH: |
| rawPressureAxis = mRawAxes.touchMajor; |
| break; |
| default: |
| rawPressureAxis.clear(); |
| } |
| |
| if (mCalibration.pressureCalibration == Calibration::PRESSURE_CALIBRATION_PHYSICAL |
| || mCalibration.pressureCalibration |
| == Calibration::PRESSURE_CALIBRATION_AMPLITUDE) { |
| if (mCalibration.havePressureScale) { |
| mLocked.pressureScale = mCalibration.pressureScale; |
| } else if (rawPressureAxis.valid && rawPressureAxis.maxValue != 0) { |
| mLocked.pressureScale = 1.0f / rawPressureAxis.maxValue; |
| } |
| } |
| |
| mLocked.orientedRanges.havePressure = true; |
| |
| mLocked.orientedRanges.pressure.axis = AMOTION_EVENT_AXIS_PRESSURE; |
| mLocked.orientedRanges.pressure.source = mTouchSource; |
| mLocked.orientedRanges.pressure.min = 0; |
| mLocked.orientedRanges.pressure.max = 1.0; |
| mLocked.orientedRanges.pressure.flat = 0; |
| mLocked.orientedRanges.pressure.fuzz = 0; |
| } |
| |
| // Size factors. |
| mLocked.sizeScale = 0; |
| if (mCalibration.sizeCalibration != Calibration::SIZE_CALIBRATION_NONE) { |
| if (mCalibration.sizeCalibration == Calibration::SIZE_CALIBRATION_NORMALIZED) { |
| if (mRawAxes.toolMajor.valid && mRawAxes.toolMajor.maxValue != 0) { |
| mLocked.sizeScale = 1.0f / mRawAxes.toolMajor.maxValue; |
| } |
| } |
| |
| mLocked.orientedRanges.haveSize = true; |
| |
| mLocked.orientedRanges.size.axis = AMOTION_EVENT_AXIS_SIZE; |
| mLocked.orientedRanges.size.source = mTouchSource; |
| mLocked.orientedRanges.size.min = 0; |
| mLocked.orientedRanges.size.max = 1.0; |
| mLocked.orientedRanges.size.flat = 0; |
| mLocked.orientedRanges.size.fuzz = 0; |
| } |
| |
| // Orientation |
| mLocked.orientationScale = 0; |
| if (mCalibration.orientationCalibration != Calibration::ORIENTATION_CALIBRATION_NONE) { |
| if (mCalibration.orientationCalibration |
| == Calibration::ORIENTATION_CALIBRATION_INTERPOLATED) { |
| if (mRawAxes.orientation.valid && mRawAxes.orientation.maxValue != 0) { |
| mLocked.orientationScale = float(M_PI_2) / mRawAxes.orientation.maxValue; |
| } |
| } |
| |
| mLocked.orientedRanges.haveOrientation = true; |
| |
| mLocked.orientedRanges.orientation.axis = AMOTION_EVENT_AXIS_ORIENTATION; |
| mLocked.orientedRanges.orientation.source = mTouchSource; |
| mLocked.orientedRanges.orientation.min = - M_PI_2; |
| mLocked.orientedRanges.orientation.max = M_PI_2; |
| mLocked.orientedRanges.orientation.flat = 0; |
| mLocked.orientedRanges.orientation.fuzz = 0; |
| } |
| |
| // Distance |
| mLocked.distanceScale = 0; |
| if (mCalibration.distanceCalibration != Calibration::DISTANCE_CALIBRATION_NONE) { |
| if (mCalibration.distanceCalibration |
| == Calibration::DISTANCE_CALIBRATION_SCALED) { |
| if (mCalibration.haveDistanceScale) { |
| mLocked.distanceScale = mCalibration.distanceScale; |
| } else { |
| mLocked.distanceScale = 1.0f; |
| } |
| } |
| |
| mLocked.orientedRanges.haveDistance = true; |
| |
| mLocked.orientedRanges.distance.axis = AMOTION_EVENT_AXIS_DISTANCE; |
| mLocked.orientedRanges.distance.source = mTouchSource; |
| mLocked.orientedRanges.distance.min = |
| mRawAxes.distance.minValue * mLocked.distanceScale; |
| mLocked.orientedRanges.distance.max = |
| mRawAxes.distance.minValue * mLocked.distanceScale; |
| mLocked.orientedRanges.distance.flat = 0; |
| mLocked.orientedRanges.distance.fuzz = |
| mRawAxes.distance.fuzz * mLocked.distanceScale; |
| } |
| } |
| |
| if (orientationChanged || sizeChanged) { |
| // Compute oriented surface dimensions, 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 (mLocked.surfaceOrientation) { |
| case DISPLAY_ORIENTATION_90: |
| case DISPLAY_ORIENTATION_270: |
| mLocked.orientedSurfaceWidth = mLocked.surfaceHeight; |
| mLocked.orientedSurfaceHeight = mLocked.surfaceWidth; |
| |
| mLocked.orientedXPrecision = mLocked.yPrecision; |
| mLocked.orientedYPrecision = mLocked.xPrecision; |
| |
| mLocked.orientedRanges.x.min = 0; |
| mLocked.orientedRanges.x.max = (mRawAxes.y.maxValue - mRawAxes.y.minValue) |
| * mLocked.yScale; |
| mLocked.orientedRanges.x.flat = 0; |
| mLocked.orientedRanges.x.fuzz = mLocked.yScale; |
| |
| mLocked.orientedRanges.y.min = 0; |
| mLocked.orientedRanges.y.max = (mRawAxes.x.maxValue - mRawAxes.x.minValue) |
| * mLocked.xScale; |
| mLocked.orientedRanges.y.flat = 0; |
| mLocked.orientedRanges.y.fuzz = mLocked.xScale; |
| break; |
| |
| default: |
| mLocked.orientedSurfaceWidth = mLocked.surfaceWidth; |
| mLocked.orientedSurfaceHeight = mLocked.surfaceHeight; |
| |
| mLocked.orientedXPrecision = mLocked.xPrecision; |
| mLocked.orientedYPrecision = mLocked.yPrecision; |
| |
| mLocked.orientedRanges.x.min = 0; |
| mLocked.orientedRanges.x.max = (mRawAxes.x.maxValue - mRawAxes.x.minValue) |
| * mLocked.xScale; |
| mLocked.orientedRanges.x.flat = 0; |
| mLocked.orientedRanges.x.fuzz = mLocked.xScale; |
| |
| mLocked.orientedRanges.y.min = 0; |
| mLocked.orientedRanges.y.max = (mRawAxes.y.maxValue - mRawAxes.y.minValue) |
| * mLocked.yScale; |
| mLocked.orientedRanges.y.flat = 0; |
| mLocked.orientedRanges.y.fuzz = mLocked.yScale; |
| break; |
| } |
| |
| // Compute pointer gesture detection parameters. |
| // TODO: These factors should not be hardcoded. |
| if (mParameters.deviceType == Parameters::DEVICE_TYPE_POINTER) { |
| int32_t rawWidth = mRawAxes.x.maxValue - mRawAxes.x.minValue + 1; |
| int32_t rawHeight = mRawAxes.y.maxValue - mRawAxes.y.minValue + 1; |
| float rawDiagonal = hypotf(rawWidth, rawHeight); |
| float displayDiagonal = hypotf(mLocked.associatedDisplayWidth, |
| mLocked.associatedDisplayHeight); |
| |
| // 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. |
| mLocked.pointerGestureXMovementScale = mConfig.pointerGestureMovementSpeedRatio |
| * displayDiagonal / rawDiagonal; |
| mLocked.pointerGestureYMovementScale = mLocked.pointerGestureXMovementScale; |
| |
| // 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. |
| mLocked.pointerGestureXZoomScale = mConfig.pointerGestureZoomSpeedRatio |
| * displayDiagonal / rawDiagonal; |
| mLocked.pointerGestureYZoomScale = mLocked.pointerGestureXZoomScale; |
| |
| // 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. |
| mLocked.pointerGestureMaxSwipeWidth = |
| mConfig.pointerGestureSwipeMaxWidthRatio * rawDiagonal; |
| |
| // Reset the current pointer gesture. |
| mPointerGesture.reset(); |
| |
| // Remove any current spots. |
| if (mParameters.gestureMode == Parameters::GESTURE_MODE_SPOTS) { |
| mPointerController->clearSpots(); |
| } |
| } |
| } |
| |
| return true; |
| } |
| |
| void TouchInputMapper::dumpSurfaceLocked(String8& dump) { |
| dump.appendFormat(INDENT3 "SurfaceWidth: %dpx\n", mLocked.surfaceWidth); |
| dump.appendFormat(INDENT3 "SurfaceHeight: %dpx\n", mLocked.surfaceHeight); |
| dump.appendFormat(INDENT3 "SurfaceOrientation: %d\n", mLocked.surfaceOrientation); |
| } |
| |
| void TouchInputMapper::configureVirtualKeysLocked() { |
| Vector<VirtualKeyDefinition> virtualKeyDefinitions; |
| getEventHub()->getVirtualKeyDefinitions(getDeviceId(), virtualKeyDefinitions); |
| |
| mLocked.virtualKeys.clear(); |
| |
| if (virtualKeyDefinitions.size() == 0) { |
| return; |
| } |
| |
| mLocked.virtualKeys.setCapacity(virtualKeyDefinitions.size()); |
| |
| int32_t touchScreenLeft = mRawAxes.x.minValue; |
| int32_t touchScreenTop = mRawAxes.y.minValue; |
| int32_t touchScreenWidth = mRawAxes.x.maxValue - mRawAxes.x.minValue + 1; |
| int32_t touchScreenHeight = mRawAxes.y.maxValue - mRawAxes.y.minValue + 1; |
| |
| for (size_t i = 0; i < virtualKeyDefinitions.size(); i++) { |
| const VirtualKeyDefinition& virtualKeyDefinition = |
| virtualKeyDefinitions[i]; |
| |
| mLocked.virtualKeys.add(); |
| VirtualKey& virtualKey = mLocked.virtualKeys.editTop(); |
| |
| virtualKey.scanCode = virtualKeyDefinition.scanCode; |
| int32_t keyCode; |
| uint32_t flags; |
| if (getEventHub()->mapKey(getDeviceId(), virtualKey.scanCode, |
| & keyCode, & flags)) { |
| LOGW(INDENT "VirtualKey %d: could not obtain key code, ignoring", |
| virtualKey.scanCode); |
| mLocked.virtualKeys.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 / mLocked.surfaceWidth + touchScreenLeft; |
| virtualKey.hitRight= (virtualKeyDefinition.centerX + halfWidth) |
| * touchScreenWidth / mLocked.surfaceWidth + touchScreenLeft; |
| virtualKey.hitTop = (virtualKeyDefinition.centerY - halfHeight) |
| * touchScreenHeight / mLocked.surfaceHeight + touchScreenTop; |
| virtualKey.hitBottom = (virtualKeyDefinition.centerY + halfHeight) |
| * touchScreenHeight / mLocked.surfaceHeight + touchScreenTop; |
| } |
| } |
| |
| void TouchInputMapper::dumpVirtualKeysLocked(String8& dump) { |
| if (!mLocked.virtualKeys.isEmpty()) { |
| dump.append(INDENT3 "Virtual Keys:\n"); |
| |
| for (size_t i = 0; i < mLocked.virtualKeys.size(); i++) { |
| const VirtualKey& virtualKey = mLocked.virtualKeys.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; |
| |
| // Touch Size |
| out.touchSizeCalibration = Calibration::TOUCH_SIZE_CALIBRATION_DEFAULT; |
| String8 touchSizeCalibrationString; |
| if (in.tryGetProperty(String8("touch.touchSize.calibration"), touchSizeCalibrationString)) { |
| if (touchSizeCalibrationString == "none") { |
| out.touchSizeCalibration = Calibration::TOUCH_SIZE_CALIBRATION_NONE; |
| } else if (touchSizeCalibrationString == "geometric") { |
| out.touchSizeCalibration = Calibration::TOUCH_SIZE_CALIBRATION_GEOMETRIC; |
| } else if (touchSizeCalibrationString == "pressure") { |
| out.touchSizeCalibration = Calibration::TOUCH_SIZE_CALIBRATION_PRESSURE; |
| } else if (touchSizeCalibrationString != "default") { |
| LOGW("Invalid value for touch.touchSize.calibration: '%s'", |
| touchSizeCalibrationString.string()); |
| } |
| } |
| |
| // Tool Size |
| out.toolSizeCalibration = Calibration::TOOL_SIZE_CALIBRATION_DEFAULT; |
| String8 toolSizeCalibrationString; |
| if (in.tryGetProperty(String8("touch.toolSize.calibration"), toolSizeCalibrationString)) { |
| if (toolSizeCalibrationString == "none") { |
| out.toolSizeCalibration = Calibration::TOOL_SIZE_CALIBRATION_NONE; |
| } else if (toolSizeCalibrationString == "geometric") { |
| out.toolSizeCalibration = Calibration::TOOL_SIZE_CALIBRATION_GEOMETRIC; |
| } else if (toolSizeCalibrationString == "linear") { |
| out.toolSizeCalibration = Calibration::TOOL_SIZE_CALIBRATION_LINEAR; |
| } else if (toolSizeCalibrationString == "area") { |
| out.toolSizeCalibration = Calibration::TOOL_SIZE_CALIBRATION_AREA; |
| } else if (toolSizeCalibrationString != "default") { |
| LOGW("Invalid value for touch.toolSize.calibration: '%s'", |
| toolSizeCalibrationString.string()); |
| } |
| } |
| |
| out.haveToolSizeLinearScale = in.tryGetProperty(String8("touch.toolSize.linearScale"), |
| out.toolSizeLinearScale); |
| out.haveToolSizeLinearBias = in.tryGetProperty(String8("touch.toolSize.linearBias"), |
| out.toolSizeLinearBias); |
| out.haveToolSizeAreaScale = in.tryGetProperty(String8("touch.toolSize.areaScale"), |
| out.toolSizeAreaScale); |
| out.haveToolSizeAreaBias = in.tryGetProperty(String8("touch.toolSize.areaBias"), |
| out.toolSizeAreaBias); |
| out.haveToolSizeIsSummed = in.tryGetProperty(String8("touch.toolSize.isSummed"), |
| out.toolSizeIsSummed); |
| |
| // 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") { |
| LOGW("Invalid value for touch.pressure.calibration: '%s'", |
| pressureCalibrationString.string()); |
| } |
| } |
| |
| out.pressureSource = Calibration::PRESSURE_SOURCE_DEFAULT; |
| String8 pressureSourceString; |
| if (in.tryGetProperty(String8("touch.pressure.source"), pressureSourceString)) { |
| if (pressureSourceString == "pressure") { |
| out.pressureSource = Calibration::PRESSURE_SOURCE_PRESSURE; |
| } else if (pressureSourceString == "touch") { |
| out.pressureSource = Calibration::PRESSURE_SOURCE_TOUCH; |
| } else if (pressureSourceString != "default") { |
| LOGW("Invalid value for touch.pressure.source: '%s'", |
| pressureSourceString.string()); |
| } |
| } |
| |
| out.havePressureScale = in.tryGetProperty(String8("touch.pressure.scale"), |
| out.pressureScale); |
| |
| // 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 == "normalized") { |
| out.sizeCalibration = Calibration::SIZE_CALIBRATION_NORMALIZED; |
| } else if (sizeCalibrationString != "default") { |
| LOGW("Invalid value for touch.size.calibration: '%s'", |
| sizeCalibrationString.string()); |
| } |
| } |
| |
| // 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") { |
| LOGW("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") { |
| LOGW("Invalid value for touch.distance.calibration: '%s'", |
| distanceCalibrationString.string()); |
| } |
| } |
| |
| out.haveDistanceScale = in.tryGetProperty(String8("touch.distance.scale"), |
| out.distanceScale); |
| } |
| |
| void TouchInputMapper::resolveCalibration() { |
| // Pressure |
| switch (mCalibration.pressureSource) { |
| case Calibration::PRESSURE_SOURCE_DEFAULT: |
| if (mRawAxes.pressure.valid) { |
| mCalibration.pressureSource = Calibration::PRESSURE_SOURCE_PRESSURE; |
| } else if (mRawAxes.touchMajor.valid) { |
| mCalibration.pressureSource = Calibration::PRESSURE_SOURCE_TOUCH; |
| } |
| break; |
| |
| case Calibration::PRESSURE_SOURCE_PRESSURE: |
| if (! mRawAxes.pressure.valid) { |
| LOGW("Calibration property touch.pressure.source is 'pressure' but " |
| "the pressure axis is not available."); |
| } |
| break; |
| |
| case Calibration::PRESSURE_SOURCE_TOUCH: |
| if (! mRawAxes.touchMajor.valid) { |
| LOGW("Calibration property touch.pressure.source is 'touch' but " |
| "the touchMajor axis is not available."); |
| } |
| break; |
| |
| default: |
| break; |
| } |
| |
| switch (mCalibration.pressureCalibration) { |
| case Calibration::PRESSURE_CALIBRATION_DEFAULT: |
| if (mCalibration.pressureSource != Calibration::PRESSURE_SOURCE_DEFAULT) { |
| mCalibration.pressureCalibration = Calibration::PRESSURE_CALIBRATION_AMPLITUDE; |
| } else { |
| mCalibration.pressureCalibration = Calibration::PRESSURE_CALIBRATION_NONE; |
| } |
| break; |
| |
| default: |
| break; |
| } |
| |
| // Tool Size |
| switch (mCalibration.toolSizeCalibration) { |
| case Calibration::TOOL_SIZE_CALIBRATION_DEFAULT: |
| if (mRawAxes.toolMajor.valid) { |
| mCalibration.toolSizeCalibration = Calibration::TOOL_SIZE_CALIBRATION_LINEAR; |
| } else { |
| mCalibration.toolSizeCalibration = Calibration::TOOL_SIZE_CALIBRATION_NONE; |
| } |
| break; |
| |
| default: |
| break; |
| } |
| |
| // Touch Size |
| switch (mCalibration.touchSizeCalibration) { |
| case Calibration::TOUCH_SIZE_CALIBRATION_DEFAULT: |
| if (mCalibration.pressureCalibration != Calibration::PRESSURE_CALIBRATION_NONE |
| && mCalibration.toolSizeCalibration != Calibration::TOOL_SIZE_CALIBRATION_NONE) { |
| mCalibration.touchSizeCalibration = Calibration::TOUCH_SIZE_CALIBRATION_PRESSURE; |
| } else { |
| mCalibration.touchSizeCalibration = Calibration::TOUCH_SIZE_CALIBRATION_NONE; |
| } |
| break; |
| |
| default: |
| break; |
| } |
| |
| // Size |
| switch (mCalibration.sizeCalibration) { |
| case Calibration::SIZE_CALIBRATION_DEFAULT: |
| if (mRawAxes.toolMajor.valid) { |
| mCalibration.sizeCalibration = Calibration::SIZE_CALIBRATION_NORMALIZED; |
| } else { |
| mCalibration.sizeCalibration = Calibration::SIZE_CALIBRATION_NONE; |
| } |
| break; |
| |
| default: |
| break; |
| } |
| |
| // Orientation |
| switch (mCalibration.orientationCalibration) { |
| case Calibration::ORIENTATION_CALIBRATION_DEFAULT: |
| if (mRawAxes.orientation.valid) { |
| mCalibration.orientationCalibration = Calibration::ORIENTATION_CALIBRATION_INTERPOLATED; |
| } else { |
| mCalibration.orientationCalibration = Calibration::ORIENTATION_CALIBRATION_NONE; |
| } |
| break; |
| |
| default: |
| break; |
| } |
| |
| // Distance |
| switch (mCalibration.distanceCalibration) { |
| case Calibration::DISTANCE_CALIBRATION_DEFAULT: |
| if (mRawAxes.distance.valid) { |
| mCalibration.distanceCalibration = Calibration::DISTANCE_CALIBRATION_SCALED; |
| } else { |
| mCalibration.distanceCalibration = Calibration::DISTANCE_CALIBRATION_NONE; |
| } |
| break; |
| |
| default: |
| break; |
| } |
| } |
| |
| void TouchInputMapper::dumpCalibration(String8& dump) { |
| dump.append(INDENT3 "Calibration:\n"); |
| |
| // Touch Size |
| switch (mCalibration.touchSizeCalibration) { |
| case Calibration::TOUCH_SIZE_CALIBRATION_NONE: |
| dump.append(INDENT4 "touch.touchSize.calibration: none\n"); |
| break; |
| case Calibration::TOUCH_SIZE_CALIBRATION_GEOMETRIC: |
| dump.append(INDENT4 "touch.touchSize.calibration: geometric\n"); |
| break; |
| case Calibration::TOUCH_SIZE_CALIBRATION_PRESSURE: |
| dump.append(INDENT4 "touch.touchSize.calibration: pressure\n"); |
| break; |
| default: |
| LOG_ASSERT(false); |
| } |
| |
| // Tool Size |
| switch (mCalibration.toolSizeCalibration) { |
| case Calibration::TOOL_SIZE_CALIBRATION_NONE: |
| dump.append(INDENT4 "touch.toolSize.calibration: none\n"); |
| break; |
| case Calibration::TOOL_SIZE_CALIBRATION_GEOMETRIC: |
| dump.append(INDENT4 "touch.toolSize.calibration: geometric\n"); |
| break; |
| case Calibration::TOOL_SIZE_CALIBRATION_LINEAR: |
| dump.append(INDENT4 "touch.toolSize.calibration: linear\n"); |
| break; |
| case Calibration::TOOL_SIZE_CALIBRATION_AREA: |
| dump.append(INDENT4 "touch.toolSize.calibration: area\n"); |
| break; |
| default: |
| LOG_ASSERT(false); |
| } |
| |
| if (mCalibration.haveToolSizeLinearScale) { |
| dump.appendFormat(INDENT4 "touch.toolSize.linearScale: %0.3f\n", |
| mCalibration.toolSizeLinearScale); |
| } |
| |
| if (mCalibration.haveToolSizeLinearBias) { |
| dump.appendFormat(INDENT4 "touch.toolSize.linearBias: %0.3f\n", |
| mCalibration.toolSizeLinearBias); |
| } |
| |
| if (mCalibration.haveToolSizeAreaScale) { |
| dump.appendFormat(INDENT4 "touch.toolSize.areaScale: %0.3f\n", |
| mCalibration.toolSizeAreaScale); |
| } |
| |
| if (mCalibration.haveToolSizeAreaBias) { |
| dump.appendFormat(INDENT4 "touch.toolSize.areaBias: %0.3f\n", |
| mCalibration.toolSizeAreaBias); |
| } |
| |
| if (mCalibration.haveToolSizeIsSummed) { |
| dump.appendFormat(INDENT4 "touch.toolSize.isSummed: %s\n", |
| toString(mCalibration.toolSizeIsSummed)); |
| } |
| |
| // 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: |
| LOG_ASSERT(false); |
| } |
| |
| switch (mCalibration.pressureSource) { |
| case Calibration::PRESSURE_SOURCE_PRESSURE: |
| dump.append(INDENT4 "touch.pressure.source: pressure\n"); |
| break; |
| case Calibration::PRESSURE_SOURCE_TOUCH: |
| dump.append(INDENT4 "touch.pressure.source: touch\n"); |
| break; |
| case Calibration::PRESSURE_SOURCE_DEFAULT: |
| break; |
| default: |
| LOG_ASSERT(false); |
| } |
| |
| if (mCalibration.havePressureScale) { |
| dump.appendFormat(INDENT4 "touch.pressure.scale: %0.3f\n", |
| mCalibration.pressureScale); |
| } |
| |
| // Size |
| switch (mCalibration.sizeCalibration) { |
| case Calibration::SIZE_CALIBRATION_NONE: |
| dump.append(INDENT4 "touch.size.calibration: none\n"); |
| break; |
| case Calibration::SIZE_CALIBRATION_NORMALIZED: |
| dump.append(INDENT4 "touch.size.calibration: normalized\n"); |
| break; |
| default: |
| LOG_ASSERT(false); |
| } |
| |
| // 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: |
| LOG_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: |
| LOG_ASSERT(false); |
| } |
| |
| if (mCalibration.haveDistanceScale) { |
| dump.appendFormat(INDENT4 "touch.distance.scale: %0.3f\n", |
| mCalibration.distanceScale); |
| } |
| } |
| |
| void TouchInputMapper::reset() { |
| // Synthesize touch up event if touch is currently down. |
| // This will also take care of finishing virtual key processing if needed. |
| if (mLastTouch.pointerCount != 0) { |
| nsecs_t when = systemTime(SYSTEM_TIME_MONOTONIC); |
| mCurrentTouch.clear(); |
| syncTouch(when, true); |
| } |
| |
| { // acquire lock |
| AutoMutex _l(mLock); |
| initializeLocked(); |
| |
| if (mPointerController != NULL |
| && mParameters.gestureMode == Parameters::GESTURE_MODE_SPOTS) { |
| mPointerController->fade(PointerControllerInterface::TRANSITION_GRADUAL); |
| mPointerController->clearSpots(); |
| } |
| } // release lock |
| |
| InputMapper::reset(); |
| } |
| |
| void TouchInputMapper::syncTouch(nsecs_t when, bool havePointerIds) { |
| #if DEBUG_RAW_EVENTS |
| if (!havePointerIds) { |
| LOGD("syncTouch: pointerCount=%d, no pointer ids", mCurrentTouch.pointerCount); |
| } else { |
| LOGD("syncTouch: pointerCount=%d, up=0x%08x, down=0x%08x, move=0x%08x, " |
| "last=0x%08x, current=0x%08x", mCurrentTouch.pointerCount, |
| mLastTouch.idBits.value & ~mCurrentTouch.idBits.value, |
| mCurrentTouch.idBits.value & ~mLastTouch.idBits.value, |
| mLastTouch.idBits.value & mCurrentTouch.idBits.value, |
| mLastTouch.idBits.value, mCurrentTouch.idBits.value); |
| } |
| #endif |
| |
| // Preprocess pointer data. |
| if (mParameters.useBadTouchFilter) { |
| if (applyBadTouchFilter()) { |
| havePointerIds = false; |
| } |
| } |
| |
| if (mParameters.useJumpyTouchFilter) { |
| if (applyJumpyTouchFilter()) { |
| havePointerIds = false; |
| } |
| } |
| |
| if (!havePointerIds) { |
| calculatePointerIds(); |
| } |
| |
| TouchData temp; |
| TouchData* savedTouch; |
| if (mParameters.useAveragingTouchFilter) { |
| temp.copyFrom(mCurrentTouch); |
| savedTouch = & temp; |
| |
| applyAveragingTouchFilter(); |
| } else { |
| savedTouch = & mCurrentTouch; |
| } |
| |
| uint32_t policyFlags = 0; |
| if (mLastTouch.pointerCount == 0 && mCurrentTouch.pointerCount != 0) { |
| if (mParameters.deviceType == Parameters::DEVICE_TYPE_TOUCH_SCREEN) { |
| // If this is a touch screen, hide the pointer on an initial down. |
| 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 buttons if needed. |
| synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_DOWN, when, getDeviceId(), mTouchSource, |
| policyFlags, mLastTouch.buttonState, mCurrentTouch.buttonState); |
| |
| // Send motion events. |
| TouchResult touchResult; |
| if (mLastTouch.pointerCount == 0 && mCurrentTouch.pointerCount == 0 |
| && mLastTouch.buttonState == mCurrentTouch.buttonState) { |
| // Drop spurious syncs. |
| touchResult = DROP_STROKE; |
| } else { |
| // Process touches and virtual keys. |
| touchResult = consumeOffScreenTouches(when, policyFlags); |
| if (touchResult == DISPATCH_TOUCH) { |
| suppressSwipeOntoVirtualKeys(when); |
| if (mPointerController != NULL && mConfig.pointerGesturesEnabled) { |
| dispatchPointerGestures(when, policyFlags, false /*isTimeout*/); |
| } |
| dispatchTouches(when, policyFlags); |
| } |
| } |
| |
| // Synthesize key up from buttons if needed. |
| synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_UP, when, getDeviceId(), mTouchSource, |
| policyFlags, mLastTouch.buttonState, mCurrentTouch.buttonState); |
| |
| // Copy current touch to last touch in preparation for the next cycle. |
| // Keep the button state so we can track edge-triggered button state changes. |
| if (touchResult == DROP_STROKE) { |
| mLastTouch.clear(); |
| mLastTouch.buttonState = savedTouch->buttonState; |
| } else { |
| mLastTouch.copyFrom(*savedTouch); |
| } |
| } |
| |
| void TouchInputMapper::timeoutExpired(nsecs_t when) { |
| if (mPointerController != NULL) { |
| dispatchPointerGestures(when, 0 /*policyFlags*/, true /*isTimeout*/); |
| } |
| } |
| |
| TouchInputMapper::TouchResult TouchInputMapper::consumeOffScreenTouches( |
| nsecs_t when, uint32_t policyFlags) { |
| int32_t keyEventAction, keyEventFlags; |
| int32_t keyCode, scanCode, downTime; |
| TouchResult touchResult; |
| |
| { // acquire lock |
| AutoMutex _l(mLock); |
| |
| // Update surface size and orientation, including virtual key positions. |
| if (! configureSurfaceLocked()) { |
| return DROP_STROKE; |
| } |
| |
| // Check for virtual key press. |
| if (mLocked.currentVirtualKey.down) { |
| if (mCurrentTouch.pointerCount == 0) { |
| // Pointer went up while virtual key was down. |
| mLocked.currentVirtualKey.down = false; |
| #if DEBUG_VIRTUAL_KEYS |
| LOGD("VirtualKeys: Generating key up: keyCode=%d, scanCode=%d", |
| mLocked.currentVirtualKey.keyCode, mLocked.currentVirtualKey.scanCode); |
| #endif |
| keyEventAction = AKEY_EVENT_ACTION_UP; |
| keyEventFlags = AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY; |
| touchResult = SKIP_TOUCH; |
| goto DispatchVirtualKey; |
| } |
| |
| if (mCurrentTouch.pointerCount == 1) { |
| int32_t x = mCurrentTouch.pointers[0].x; |
| int32_t y = mCurrentTouch.pointers[0].y; |
| const VirtualKey* virtualKey = findVirtualKeyHitLocked(x, y); |
| if (virtualKey && virtualKey->keyCode == mLocked.currentVirtualKey.keyCode) { |
| // Pointer is still within the space of the virtual key. |
| return SKIP_TOUCH; |
| } |
| } |
| |
| // Pointer left virtual key area or another pointer also went down. |
| // Send key cancellation and drop the stroke so subsequent motions will be |
| // considered fresh downs. This is useful when the user swipes away from the |
| // virtual key area into the main display surface. |
| mLocked.currentVirtualKey.down = false; |
| #if DEBUG_VIRTUAL_KEYS |
| LOGD("VirtualKeys: Canceling key: keyCode=%d, scanCode=%d", |
| mLocked.currentVirtualKey.keyCode, mLocked.currentVirtualKey.scanCode); |
| #endif |
| keyEventAction = AKEY_EVENT_ACTION_UP; |
| keyEventFlags = AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY |
| | AKEY_EVENT_FLAG_CANCELED; |
| |
| // Check whether the pointer moved inside the display area where we should |
| // start a new stroke. |
| int32_t x = mCurrentTouch.pointers[0].x; |
| int32_t y = mCurrentTouch.pointers[0].y; |
| if (isPointInsideSurfaceLocked(x, y)) { |
| mLastTouch.clear(); |
| touchResult = DISPATCH_TOUCH; |
| } else { |
| touchResult = DROP_STROKE; |
| } |
| } else { |
| if (mCurrentTouch.pointerCount >= 1 && mLastTouch.pointerCount == 0) { |
| // Pointer just went down. Handle off-screen touches, if needed. |
| int32_t x = mCurrentTouch.pointers[0].x; |
| int32_t y = mCurrentTouch.pointers[0].y; |
| if (! isPointInsideSurfaceLocked(x, y)) { |
| // If exactly one pointer went down, check for virtual key hit. |
| // Otherwise we will drop the entire stroke. |
| if (mCurrentTouch.pointerCount == 1) { |
| const VirtualKey* virtualKey = findVirtualKeyHitLocked(x, y); |
| if (virtualKey) { |
| if (mContext->shouldDropVirtualKey(when, getDevice(), |
| virtualKey->keyCode, virtualKey->scanCode)) { |
| return DROP_STROKE; |
| } |
| |
| mLocked.currentVirtualKey.down = true; |
| mLocked.currentVirtualKey.downTime = when; |
| mLocked.currentVirtualKey.keyCode = virtualKey->keyCode; |
| mLocked.currentVirtualKey.scanCode = virtualKey->scanCode; |
| #if DEBUG_VIRTUAL_KEYS |
| LOGD("VirtualKeys: Generating key down: keyCode=%d, scanCode=%d", |
| mLocked.currentVirtualKey.keyCode, |
| mLocked.currentVirtualKey.scanCode); |
| #endif |
| keyEventAction = AKEY_EVENT_ACTION_DOWN; |
| keyEventFlags = AKEY_EVENT_FLAG_FROM_SYSTEM |
| | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY; |
| touchResult = SKIP_TOUCH; |
| goto DispatchVirtualKey; |
| } |
| } |
| return DROP_STROKE; |
| } |
| } |
| return DISPATCH_TOUCH; |
| } |
| |
| DispatchVirtualKey: |
| // Collect remaining state needed to dispatch virtual key. |
| keyCode = mLocked.currentVirtualKey.keyCode; |
| scanCode = mLocked.currentVirtualKey.scanCode; |
| downTime = mLocked.currentVirtualKey.downTime; |
| } // release lock |
| |
| // Dispatch virtual key. |
| int32_t metaState = mContext->getGlobalMetaState(); |
| policyFlags |= POLICY_FLAG_VIRTUAL; |
| getDispatcher()->notifyKey(when, getDeviceId(), AINPUT_SOURCE_KEYBOARD, policyFlags, |
| keyEventAction, keyEventFlags, keyCode, scanCode, metaState, downTime); |
| return touchResult; |
| } |
| |
| void TouchInputMapper::suppressSwipeOntoVirtualKeys(nsecs_t when) { |
| // Disable all virtual key touches that happen within a short time interval of the |
| // most recent touch. 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 && mCurrentTouch.pointerCount != 0) { |
| mContext->disableVirtualKeysUntil(when + mConfig.virtualKeyQuietTime); |
| } |
| } |
| |
| void TouchInputMapper::dispatchTouches(nsecs_t when, uint32_t policyFlags) { |
| uint32_t currentPointerCount = mCurrentTouch.pointerCount; |
| uint32_t lastPointerCount = mLastTouch.pointerCount; |
| if (currentPointerCount == 0 && lastPointerCount == 0) { |
| return; // nothing to do! |
| } |
| |
| // Update current touch coordinates. |
| int32_t edgeFlags; |
| float xPrecision, yPrecision; |
| prepareTouches(&edgeFlags, &xPrecision, &yPrecision); |
| |
| // Dispatch motions. |
| BitSet32 currentIdBits = mCurrentTouch.idBits; |
| BitSet32 lastIdBits = mLastTouch.idBits; |
| int32_t metaState = getContext()->getGlobalMetaState(); |
| int32_t buttonState = mCurrentTouch.buttonState; |
| |
| if (currentIdBits == lastIdBits) { |
| // No pointer id changes so this is a move event. |
| // The dispatcher takes care of batching moves so we don't have to deal with that here. |
| dispatchMotion(when, policyFlags, mTouchSource, |
| AMOTION_EVENT_ACTION_MOVE, 0, metaState, buttonState, |
| AMOTION_EVENT_EDGE_FLAG_NONE, |
| mCurrentTouchProperties, mCurrentTouchCoords, |
| mCurrentTouch.idToIndex, currentIdBits, -1, |
| xPrecision, yPrecision, 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( |
| mCurrentTouchProperties, mCurrentTouchCoords, mCurrentTouch.idToIndex, |
| mLastTouchProperties, mLastTouchCoords, mLastTouch.idToIndex, |
| moveIdBits); |
| if (buttonState != mLastTouch.buttonState) { |
| moveNeeded = true; |
| } |
| |
| // Dispatch pointer up events. |
| while (!upIdBits.isEmpty()) { |
| uint32_t upId = upIdBits.firstMarkedBit(); |
| upIdBits.clearBit(upId); |
| |
| dispatchMotion(when, policyFlags, mTouchSource, |
| AMOTION_EVENT_ACTION_POINTER_UP, 0, metaState, buttonState, 0, |
| mLastTouchProperties, mLastTouchCoords, |
| mLastTouch.idToIndex, dispatchedIdBits, upId, |
| xPrecision, yPrecision, 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) { |
| LOG_ASSERT(moveIdBits.value == dispatchedIdBits.value); |
| dispatchMotion(when, policyFlags, mTouchSource, |
| AMOTION_EVENT_ACTION_MOVE, 0, metaState, buttonState, 0, |
| mCurrentTouchProperties, mCurrentTouchCoords, |
| mCurrentTouch.idToIndex, dispatchedIdBits, -1, |
| xPrecision, yPrecision, mDownTime); |
| } |
| |
| // Dispatch pointer down events using the new pointer locations. |
| while (!downIdBits.isEmpty()) { |
| uint32_t downId = downIdBits.firstMarkedBit(); |
| downIdBits.clearBit(downId); |
| dispatchedIdBits.markBit(downId); |
| |
| if (dispatchedIdBits.count() == 1) { |
| // First pointer is going down. Set down time. |
| mDownTime = when; |
| } else { |
| // Only send edge flags with first pointer down. |
| edgeFlags = AMOTION_EVENT_EDGE_FLAG_NONE; |
| } |
| |
| dispatchMotion(when, policyFlags, mTouchSource, |
| AMOTION_EVENT_ACTION_POINTER_DOWN, 0, metaState, buttonState, edgeFlags, |
| mCurrentTouchProperties, mCurrentTouchCoords, |
| mCurrentTouch.idToIndex, dispatchedIdBits, downId, |
| xPrecision, yPrecision, mDownTime); |
| } |
| } |
| |
| // Update state for next time. |
| for (uint32_t i = 0; i < currentPointerCount; i++) { |
| mLastTouchProperties[i].copyFrom(mCurrentTouchProperties[i]); |
| mLastTouchCoords[i].copyFrom(mCurrentTouchCoords[i]); |
| } |
| } |
| |
| void TouchInputMapper::prepareTouches(int32_t* outEdgeFlags, |
| float* outXPrecision, float* outYPrecision) { |
| uint32_t currentPointerCount = mCurrentTouch.pointerCount; |
| uint32_t lastPointerCount = mLastTouch.pointerCount; |
| |
| AutoMutex _l(mLock); |
| |
| // Walk through the the active pointers and map touch screen coordinates (TouchData) into |
| // display or surface coordinates (PointerCoords) and adjust for display orientation. |
| for (uint32_t i = 0; i < currentPointerCount; i++) { |
| const PointerData& in = mCurrentTouch.pointers[i]; |
| |
| // ToolMajor and ToolMinor |
| float toolMajor, toolMinor; |
| switch (mCalibration.toolSizeCalibration) { |
| case Calibration::TOOL_SIZE_CALIBRATION_GEOMETRIC: |
| toolMajor = in.toolMajor * mLocked.geometricScale; |
| if (mRawAxes.toolMinor.valid) { |
| toolMinor = in.toolMinor * mLocked.geometricScale; |
| } else { |
| toolMinor = toolMajor; |
| } |
| break; |
| case Calibration::TOOL_SIZE_CALIBRATION_LINEAR: |
| toolMajor = in.toolMajor != 0 |
| ? in.toolMajor * mLocked.toolSizeLinearScale + mLocked.toolSizeLinearBias |
| : 0; |
| if (mRawAxes.toolMinor.valid) { |
| toolMinor = in.toolMinor != 0 |
| ? in.toolMinor * mLocked.toolSizeLinearScale |
| + mLocked.toolSizeLinearBias |
| : 0; |
| } else { |
| toolMinor = toolMajor; |
| } |
| break; |
| case Calibration::TOOL_SIZE_CALIBRATION_AREA: |
| if (in.toolMajor != 0) { |
| float diameter = sqrtf(in.toolMajor |
| * mLocked.toolSizeAreaScale + mLocked.toolSizeAreaBias); |
| toolMajor = diameter * mLocked.toolSizeLinearScale + mLocked.toolSizeLinearBias; |
| } else { |
| toolMajor = 0; |
| } |
| toolMinor = toolMajor; |
| break; |
| default: |
| toolMajor = 0; |
| toolMinor = 0; |
| break; |
| } |
| |
| if (mCalibration.haveToolSizeIsSummed && mCalibration.toolSizeIsSummed) { |
| toolMajor /= currentPointerCount; |
| toolMinor /= currentPointerCount; |
| } |
| |
| // Pressure |
| float rawPressure; |
| switch (mCalibration.pressureSource) { |
| case Calibration::PRESSURE_SOURCE_PRESSURE: |
| rawPressure = in.pressure; |
| break; |
| case Calibration::PRESSURE_SOURCE_TOUCH: |
| rawPressure = in.touchMajor; |
| break; |
| default: |
| rawPressure = 0; |
| } |
| |
| float pressure; |
| switch (mCalibration.pressureCalibration) { |
| case Calibration::PRESSURE_CALIBRATION_PHYSICAL: |
| case Calibration::PRESSURE_CALIBRATION_AMPLITUDE: |
| pressure = rawPressure * mLocked.pressureScale; |
| break; |
| default: |
| pressure = 1; |
| break; |
| } |
| |
| // TouchMajor and TouchMinor |
| float touchMajor, touchMinor; |
| switch (mCalibration.touchSizeCalibration) { |
| case Calibration::TOUCH_SIZE_CALIBRATION_GEOMETRIC: |
| touchMajor = in.touchMajor * mLocked.geometricScale; |
| if (mRawAxes.touchMinor.valid) { |
| touchMinor = in.touchMinor * mLocked.geometricScale; |
| } else { |
| touchMinor = touchMajor; |
| } |
| break; |
| case Calibration::TOUCH_SIZE_CALIBRATION_PRESSURE: |
| touchMajor = toolMajor * pressure; |
| touchMinor = toolMinor * pressure; |
| break; |
| default: |
| touchMajor = 0; |
| touchMinor = 0; |
| break; |
| } |
| |
| if (touchMajor > toolMajor) { |
| touchMajor = toolMajor; |
| } |
| if (touchMinor > toolMinor) { |
| touchMinor = toolMinor; |
| } |
| |
| // Size |
| float size; |
| switch (mCalibration.sizeCalibration) { |
| case Calibration::SIZE_CALIBRATION_NORMALIZED: { |
| float rawSize = mRawAxes.toolMinor.valid |
| ? avg(in.toolMajor, in.toolMinor) |
| : in.toolMajor; |
| size = rawSize * mLocked.sizeScale; |
| break; |
| } |
| default: |
| size = 0; |
| break; |
| } |
| |
| // Orientation |
| float orientation; |
| switch (mCalibration.orientationCalibration) { |
| case Calibration::ORIENTATION_CALIBRATION_INTERPOLATED: |
| orientation = in.orientation * mLocked.orientationScale; |
| 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 scale = 1.0f + hypotf(c1, c2) / 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 * mLocked.distanceScale; |
| break; |
| default: |
| distance = 0; |
| } |
| |
| // X and Y |
| // Adjust coords for surface orientation. |
| float x, y; |
| switch (mLocked.surfaceOrientation) { |
| case DISPLAY_ORIENTATION_90: |
| x = float(in.y - mRawAxes.y.minValue) * mLocked.yScale; |
| y = float(mRawAxes.x.maxValue - in.x) * mLocked.xScale; |
| orientation -= M_PI_2; |
| if (orientation < - M_PI_2) { |
| orientation += M_PI; |
| } |
| break; |
| case DISPLAY_ORIENTATION_180: |
| x = float(mRawAxes.x.maxValue - in.x) * mLocked.xScale; |
| y = float(mRawAxes.y.maxValue - in.y) * mLocked.yScale; |
| break; |
| case DISPLAY_ORIENTATION_270: |
| x = float(mRawAxes.y.maxValue - in.y) * mLocked.yScale; |
| y = float(in.x - mRawAxes.x.minValue) * mLocked.xScale; |
| orientation += M_PI_2; |
| if (orientation > M_PI_2) { |
| orientation -= M_PI; |
| } |
| break; |
| default: |
| x = float(in.x - mRawAxes.x.minValue) * mLocked.xScale; |
| y = float(in.y - mRawAxes.y.minValue) * mLocked.yScale; |
| break; |
| } |
| |
| // Write output coords. |
| PointerCoords& out = mCurrentTouchCoords[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_TOOL_MAJOR, toolMajor); |
| out.setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, toolMinor); |
| out.setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, orientation); |
| if (distance != 0) { |
| out.setAxisValue(AMOTION_EVENT_AXIS_DISTANCE, distance); |
| } |
| |
| // Write output properties. |
| PointerProperties& properties = mCurrentTouchProperties[i]; |
| properties.clear(); |
| properties.id = mCurrentTouch.pointers[i].id; |
| properties.toolType = getTouchToolType(mCurrentTouch.pointers[i].isStylus); |
| } |
| |
| // Check edge flags by looking only at the first pointer since the flags are |
| // global to the event. |
| *outEdgeFlags = AMOTION_EVENT_EDGE_FLAG_NONE; |
| if (lastPointerCount == 0 && currentPointerCount > 0) { |
| const PointerData& in = mCurrentTouch.pointers[0]; |
| |
| if (in.x <= mRawAxes.x.minValue) { |
| *outEdgeFlags |= rotateEdgeFlag(AMOTION_EVENT_EDGE_FLAG_LEFT, |
| mLocked.surfaceOrientation); |
| } else if (in.x >= mRawAxes.x.maxValue) { |
| *outEdgeFlags |= rotateEdgeFlag(AMOTION_EVENT_EDGE_FLAG_RIGHT, |
| mLocked.surfaceOrientation); |
| } |
| if (in.y <= mRawAxes.y.minValue) { |
| *outEdgeFlags |= rotateEdgeFlag(AMOTION_EVENT_EDGE_FLAG_TOP, |
| mLocked.surfaceOrientation); |
| } else if (in.y >= mRawAxes.y.maxValue) { |
| *outEdgeFlags |= rotateEdgeFlag(AMOTION_EVENT_EDGE_FLAG_BOTTOM, |
| mLocked.surfaceOrientation); |
| } |
| } |
| |
| *outXPrecision = mLocked.orientedXPrecision; |
| *outYPrecision = mLocked.orientedYPrecision; |
| } |
| |
| 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 = mCurrentTouch.buttonState; |
| |
| // 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 != mLastTouch.buttonState) { |
| 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, mPointerSource, |
| 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.firstMarkedBit(); |
| upGestureIdBits.clearBit(id); |
| |
| dispatchMotion(when, policyFlags, mPointerSource, |
| 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, mPointerSource, |
| 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.firstMarkedBit(); |
| downGestureIdBits.clearBit(id); |
| dispatchedGestureIdBits.markBit(id); |
| |
| int32_t edgeFlags = AMOTION_EVENT_EDGE_FLAG_NONE; |
| if (dispatchedGestureIdBits.count() == 1) { |
| // First pointer is going down. Calculate edge flags and set down time. |
| uint32_t index = mPointerGesture.currentGestureIdToIndex[id]; |
| const PointerCoords& downCoords = mPointerGesture.currentGestureCoords[index]; |
| edgeFlags = calculateEdgeFlagsUsingPointerBounds(mPointerController, |
| downCoords.getAxisValue(AMOTION_EVENT_AXIS_X), |
| downCoords.getAxisValue(AMOTION_EVENT_AXIS_Y)); |
| mPointerGesture.downTime = when; |
| } |
| |
| dispatchMotion(when, policyFlags, mPointerSource, |
| AMOTION_EVENT_ACTION_POINTER_DOWN, 0, metaState, buttonState, edgeFlags, |
| 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, mPointerSource, |
| 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_INDIRECT_FINGER; |
| |
| PointerCoords pointerCoords; |
| pointerCoords.clear(); |
| pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_X, x); |
| pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_Y, y); |
| |
| getDispatcher()->notifyMotion(when, getDeviceId(), mPointerSource, policyFlags, |
| AMOTION_EVENT_ACTION_HOVER_MOVE, 0, |
| metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, |
| 1, &pointerProperties, &pointerCoords, 0, 0, mPointerGesture.downTime); |
| } |
| |
| // 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.firstMarkedBit(); |
| idBits.clearBit(id); |
| uint32_t index = mPointerGesture.currentGestureIdToIndex[id]; |
| mPointerGesture.lastGestureProperties[index].copyFrom( |
| mPointerGesture.currentGestureProperties[index]); |
| mPointerGesture.lastGestureCoords[index].copyFrom( |
| mPointerGesture.currentGestureCoords[index]); |
| mPointerGesture.lastGestureIdToIndex[id] = index; |
| } |
| } |
| } |
| |
| bool TouchInputMapper::preparePointerGestures(nsecs_t when, |
| bool* outCancelPreviousGesture, bool* outFinishPreviousGesture, bool isTimeout) { |
| *outCancelPreviousGesture = false; |
| *outFinishPreviousGesture = false; |
| |
| AutoMutex _l(mLock); |
| |
| // Handle TAP timeout. |
| if (isTimeout) { |
| #if DEBUG_GESTURES |
| LOGD("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 |
| LOGD("Gestures: TAP finished"); |
| #endif |
| *outFinishPreviousGesture = true; |
| |
| mPointerGesture.activeGestureId = -1; |
| mPointerGesture.currentGestureMode = PointerGesture::NEUTRAL; |
| mPointerGesture.currentGestureIdBits.clear(); |
| |
| mPointerGesture.pointerVelocityControl.reset(); |
| return true; |
| } |
| } |
| |
| // We did not handle this timeout. |
| return false; |
| } |
| |
| // Update the velocity tracker. |
| { |
| VelocityTracker::Position positions[MAX_POINTERS]; |
| uint32_t count = 0; |
| for (BitSet32 idBits(mCurrentTouch.idBits); !idBits.isEmpty(); count++) { |
| uint32_t id = idBits.firstMarkedBit(); |
| idBits.clearBit(id); |
| uint32_t index = mCurrentTouch.idToIndex[id]; |
| positions[count].x = mCurrentTouch.pointers[index].x |
| * mLocked.pointerGestureXMovementScale; |
| positions[count].y = mCurrentTouch.pointers[index].y |
| * mLocked.pointerGestureYMovementScale; |
| } |
| mPointerGesture.velocityTracker.addMovement(when, mCurrentTouch.idBits, 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 (!mCurrentTouch.idBits.isEmpty()) { |
| activeTouchChanged = true; |
| activeTouchId = mPointerGesture.activeTouchId = mCurrentTouch.idBits.firstMarkedBit(); |
| mPointerGesture.firstTouchTime = when; |
| } |
| } else if (!mCurrentTouch.idBits.hasBit(activeTouchId)) { |
| activeTouchChanged = true; |
| if (!mCurrentTouch.idBits.isEmpty()) { |
| activeTouchId = mPointerGesture.activeTouchId = mCurrentTouch.idBits.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) |
| && mCurrentTouch.pointerCount < 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 |
| && mCurrentTouch.pointerCount >= 2 |
| && !isPointerDown(mCurrentTouch.buttonState)) { |
| // 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 |
| LOGD("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(); |
| |
| mPointerGesture.pointerVelocityControl.reset(); |
| } else if (isPointerDown(mCurrentTouch.buttonState)) { |
| // 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 |
| LOGD("Gestures: BUTTON_CLICK_OR_DRAG activeTouchId=%d, " |
| "currentTouchPointerCount=%d", activeTouchId, mCurrentTouch.pointerCount); |
| #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 && mCurrentTouch.pointerCount > 1) { |
| int32_t bestId = -1; |
| float bestSpeed = mConfig.pointerGestureDragMinSwitchSpeed; |
| for (uint32_t i = 0; i < mCurrentTouch.pointerCount; i++) { |
| uint32_t id = mCurrentTouch.pointers[i].id; |
| 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 |
| LOGD("Gestures: BUTTON_CLICK_OR_DRAG switched pointers, " |
| "bestId=%d, bestSpeed=%0.3f", bestId, bestSpeed); |
| #endif |
| } |
| } |
| |
| if (activeTouchId >= 0 && mLastTouch.idBits.hasBit(activeTouchId)) { |
| const PointerData& currentPointer = |
| mCurrentTouch.pointers[mCurrentTouch.idToIndex[activeTouchId]]; |
| const PointerData& lastPointer = |
| mLastTouch.pointers[mLastTouch.idToIndex[activeTouchId]]; |
| float deltaX = (currentPointer.x - lastPointer.x) |
| * mLocked.pointerGestureXMovementScale; |
| float deltaY = (currentPointer.y - lastPointer.y) |
| * mLocked.pointerGestureYMovementScale; |
| |
| mPointerGesture.pointerVelocityControl.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 { |
| mPointerGesture.pointerVelocityControl.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_INDIRECT_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 (mCurrentTouch.pointerCount == 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) |
| && mLastTouch.pointerCount == 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 |
| LOGD("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_INDIRECT_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 |
| LOGD("Gestures: Not a TAP, deltaX=%f, deltaY=%f", |
| x - mPointerGesture.tapX, |
| y - mPointerGesture.tapY); |
| #endif |
| } |
| } else { |
| #if DEBUG_GESTURES |
| LOGD("Gestures: Not a TAP, %0.3fms since down", |
| (when - mPointerGesture.tapDownTime) * 0.000001f); |
| #endif |
| } |
| } |
| |
| mPointerGesture.pointerVelocityControl.reset(); |
| |
| if (!tapped) { |
| #if DEBUG_GESTURES |
| LOGD("Gestures: NEUTRAL"); |
| #endif |
| mPointerGesture.activeGestureId = -1; |
| mPointerGesture.currentGestureMode = PointerGesture::NEUTRAL; |
| mPointerGesture.currentGestureIdBits.clear(); |
| } |
| } else if (mCurrentTouch.pointerCount == 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. |
| LOG_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 |
| LOGD("Gestures: Not a TAP_DRAG, deltaX=%f, deltaY=%f", |
| x - mPointerGesture.tapX, |
| y - mPointerGesture.tapY); |
| #endif |
| } |
| } else { |
| #if DEBUG_GESTURES |
| LOGD("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 (mLastTouch.idBits.hasBit(activeTouchId)) { |
| const PointerData& currentPointer = |
| mCurrentTouch.pointers[mCurrentTouch.idToIndex[activeTouchId]]; |
| const PointerData& lastPointer = |
| mLastTouch.pointers[mLastTouch.idToIndex[activeTouchId]]; |
| float deltaX = (currentPointer.x - lastPointer.x) |
| * mLocked.pointerGestureXMovementScale; |
| float deltaY = (currentPointer.y - lastPointer.y) |
| * mLocked.pointerGestureYMovementScale; |
| |
| mPointerGesture.pointerVelocityControl.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 { |
| mPointerGesture.pointerVelocityControl.reset(); |
| } |
| |
| bool down; |
| if (mPointerGesture.currentGestureMode == PointerGesture::TAP_DRAG) { |
| #if DEBUG_GESTURES |
| LOGD("Gestures: TAP_DRAG"); |
| #endif |
| down = true; |
| } else { |
| #if DEBUG_GESTURES |
| LOGD("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_INDIRECT_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 (mLastTouch.pointerCount == 0 && mCurrentTouch.pointerCount != 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. |
| LOG_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 && mCurrentTouch.pointerCount > mLastTouch.pointerCount) { |
| // Additional pointers have gone down but not yet settled. |
| // Reset the gesture. |
| #if DEBUG_GESTURES |
| LOGD("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(); |
| mPointerGesture.pointerVelocityControl.reset(); |
| |
| // Use the centroid and pointer location as the reference points for the gesture. |
| #if DEBUG_GESTURES |
| LOGD("Gestures: Using centroid as reference for MULTITOUCH, " |
| "settle time remaining %0.3fms", (mPointerGesture.firstTouchTime |
| + mConfig.pointerGestureMultitouchSettleInterval - when) |
| * 0.000001f); |
| #endif |
| mCurrentTouch.getCentroid(&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(mCurrentTouch.idBits.value & ~mPointerGesture.referenceIdBits.value); |
| !idBits.isEmpty(); ) { |
| uint32_t id = idBits.firstMarkedBit(); |
| idBits.clearBit(id); |
| |
| mPointerGesture.referenceDeltas[id].dx = 0; |
| mPointerGesture.referenceDeltas[id].dy = 0; |
| } |
| mPointerGesture.referenceIdBits = mCurrentTouch.idBits; |
| |
| // Add delta for all fingers and calculate a common movement delta. |
| float commonDeltaX = 0, commonDeltaY = 0; |
| BitSet32 commonIdBits(mLastTouch.idBits.value & mCurrentTouch.idBits.value); |
| for (BitSet32 idBits(commonIdBits); !idBits.isEmpty(); ) { |
| bool first = (idBits == commonIdBits); |
| uint32_t id = idBits.firstMarkedBit(); |
| idBits.clearBit(id); |
| |
| const PointerData& cpd = mCurrentTouch.pointers[mCurrentTouch.idToIndex[id]]; |
| const PointerData& lpd = mLastTouch.pointers[mLastTouch.idToIndex[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.firstMarkedBit(); |
| idBits.clearBit(id); |
| |
| PointerGesture::Delta& delta = mPointerGesture.referenceDeltas[id]; |
| dist[id] = hypotf(delta.dx * mLocked.pointerGestureXZoomScale, |
| delta.dy * mLocked.pointerGestureYZoomScale); |
| 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) { |
| float d; |
| if (mCurrentTouch.pointerCount > 2) { |
| // There are more than two pointers, switch to FREEFORM. |
| #if DEBUG_GESTURES |
| LOGD("Gestures: PRESS transitioned to FREEFORM, number of pointers %d > 2", |
| mCurrentTouch.pointerCount); |
| #endif |
| *outCancelPreviousGesture = true; |
| mPointerGesture.currentGestureMode = PointerGesture::FREEFORM; |
| } else if (((d = distance( |
| mCurrentTouch.pointers[0].x, mCurrentTouch.pointers[0].y, |
| mCurrentTouch.pointers[1].x, mCurrentTouch.pointers[1].y)) |
| > mLocked.pointerGestureMaxSwipeWidth)) { |
| // There are two pointers but they are too far apart for a SWIPE, |
| // switch to FREEFORM. |
| #if DEBUG_GESTURES |
| LOGD("Gestures: PRESS transitioned to FREEFORM, distance %0.3f > %0.3f", |
| d, mLocked.pointerGestureMaxSwipeWidth); |
| #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. |
| uint32_t id1 = mCurrentTouch.pointers[0].id; |
| uint32_t id2 = mCurrentTouch.pointers[1].id; |
| 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 * mLocked.pointerGestureXZoomScale; |
| float dy1 = delta1.dy * mLocked.pointerGestureYZoomScale; |
| float dx2 = delta2.dx * mLocked.pointerGestureXZoomScale; |
| float dy2 = delta2.dy * mLocked.pointerGestureYZoomScale; |
| 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 |
| LOGD("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 |
| LOGD("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 (mCurrentTouch.pointerCount > 2) { |
| #if DEBUG_GESTURES |
| LOGD("Gestures: SWIPE transitioned to FREEFORM, number of pointers %d > 2", |
| mCurrentTouch.pointerCount); |
| #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.firstMarkedBit(); |
| idBits.clearBit(id); |
| |
| PointerGesture::Delta& delta = mPointerGesture.referenceDeltas[id]; |
| delta.dx = 0; |
| delta.dy = 0; |
| } |
| |
| mPointerGesture.referenceTouchX += commonDeltaX; |
| mPointerGesture.referenceTouchY += commonDeltaY; |
| |
| commonDeltaX *= mLocked.pointerGestureXMovementScale; |
| commonDeltaY *= mLocked.pointerGestureYMovementScale; |
| mPointerGesture.pointerVelocityControl.move(when, &commonDeltaX, &commonDeltaY); |
| |
| mPointerGesture.referenceGestureX += commonDeltaX; |
| mPointerGesture.referenceGestureY += commonDeltaY; |
| } |
| |
| // Report gestures. |
| if (mPointerGesture.currentGestureMode == PointerGesture::PRESS) { |
| // PRESS mode. |
| #if DEBUG_GESTURES |
| LOGD("Gestures: PRESS activeTouchId=%d," |
| "activeGestureId=%d, currentTouchPointerCount=%d", |
| activeTouchId, mPointerGesture.activeGestureId, mCurrentTouch.pointerCount); |
| #endif |
| LOG_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_INDIRECT_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::SWIPE) { |
| // SWIPE mode. |
| #if DEBUG_GESTURES |
| LOGD("Gestures: SWIPE activeTouchId=%d," |
| "activeGestureId=%d, currentTouchPointerCount=%d", |
| activeTouchId, mPointerGesture.activeGestureId, mCurrentTouch.pointerCount); |
| #endif |
| LOG_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_INDIRECT_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 |
| LOGD("Gestures: FREEFORM activeTouchId=%d," |
| "activeGestureId=%d, currentTouchPointerCount=%d", |
| activeTouchId, mPointerGesture.activeGestureId, mCurrentTouch.pointerCount); |
| #endif |
| LOG_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 = mLastTouch.idBits.value & mCurrentTouch.idBits.value; |
| usedGestureIdBits = mPointerGesture.lastGestureIdBits; |
| |
| // Check whether we need to choose a new active gesture id because the |
| // current went went up. |
| for (BitSet32 upTouchIdBits(mLastTouch.idBits.value & ~mCurrentTouch.idBits.value); |
| !upTouchIdBits.isEmpty(); ) { |
| uint32_t upTouchId = upTouchIdBits.firstMarkedBit(); |
| upTouchIdBits.clearBit(upTouchId); |
| uint32_t upGestureId = mPointerGesture.freeformTouchToGestureIdMap[upTouchId]; |
| if (upGestureId == uint32_t(mPointerGesture.activeGestureId)) { |
| mPointerGesture.activeGestureId = -1; |
| break; |
| } |
| } |
| } |
| |
| #if DEBUG_GESTURES |
| LOGD("Gestures: FREEFORM follow up " |
| "mappedTouchIdBits=0x%08x, usedGestureIdBits=0x%08x, " |
| "activeGestureId=%d", |
| mappedTouchIdBits.value, usedGestureIdBits.value, |
| mPointerGesture.activeGestureId); |
| #endif |
| |
| for (uint32_t i = 0; i < mCurrentTouch.pointerCount; i++) { |
| uint32_t touchId = mCurrentTouch.pointers[i].id; |
| uint32_t gestureId; |
| if (!mappedTouchIdBits.hasBit(touchId)) { |
| gestureId = usedGestureIdBits.firstUnmarkedBit(); |
| usedGestureIdBits.markBit(gestureId); |
| mPointerGesture.freeformTouchToGestureIdMap[touchId] = gestureId; |
| #if DEBUG_GESTURES |
| LOGD("Gestures: FREEFORM " |
| "new mapping for touch id %d -> gesture id %d", |
| touchId, gestureId); |
| #endif |
| } else { |
| gestureId = mPointerGesture.freeformTouchToGestureIdMap[touchId]; |
| #if DEBUG_GESTURES |
| LOGD("Gestures: FREEFORM " |
| "existing mapping for touch id %d -> gesture id %d", |
| touchId, gestureId); |
| #endif |
| } |
| mPointerGesture.currentGestureIdBits.markBit(gestureId); |
| mPointerGesture.currentGestureIdToIndex[gestureId] = i; |
| |
| float x = (mCurrentTouch.pointers[i].x - mPointerGesture.referenceTouchX) |
| * mLocked.pointerGestureXZoomScale + mPointerGesture.referenceGestureX; |
| float y = (mCurrentTouch.pointers[i].y - mPointerGesture.referenceTouchY) |
| * mLocked.pointerGestureYZoomScale + mPointerGesture.referenceGestureY; |
| |
| mPointerGesture.currentGestureProperties[i].clear(); |
| mPointerGesture.currentGestureProperties[i].id = gestureId; |
| mPointerGesture.currentGestureProperties[i].toolType = |
| AMOTION_EVENT_TOOL_TYPE_INDIRECT_FINGER; |
| mPointerGesture.currentGestureCoords[i].clear(); |
| mPointerGesture.currentGestureCoords[i].setAxisValue( |
| AMOTION_EVENT_AXIS_X, x); |
| mPointerGesture.currentGestureCoords[i].setAxisValue( |
| AMOTION_EVENT_AXIS_Y, y); |
| mPointerGesture.currentGestureCoords[i].setAxisValue( |
| AMOTION_EVENT_AXIS_PRESSURE, 1.0f); |
| } |
| |
| if (mPointerGesture.activeGestureId < 0) { |
| mPointerGesture.activeGestureId = |
| mPointerGesture.currentGestureIdBits.firstMarkedBit(); |
| #if DEBUG_GESTURES |
| LOGD("Gestures: FREEFORM new " |
| "activeGestureId=%d", mPointerGesture.activeGestureId); |
| #endif |
| } |
| } |
| } |
| |
| mPointerController->setButtonState(mCurrentTouch.buttonState); |
| |
| #if DEBUG_GESTURES |
| LOGD("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.firstMarkedBit(); |
| idBits.clearBit(id); |
| uint32_t index = mPointerGesture.currentGestureIdToIndex[id]; |
| const PointerProperties& properties = mPointerGesture.currentGestureProperties[index]; |
| const PointerCoords& coords = mPointerGesture.currentGestureCoords[index]; |
| LOGD(" 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.firstMarkedBit(); |
| idBits.clearBit(id); |
| uint32_t index = mPointerGesture.lastGestureIdToIndex[id]; |
| const PointerProperties& properties = mPointerGesture.lastGestureProperties[index]; |
| const PointerCoords& coords = mPointerGesture.lastGestureCoords[index]; |
| LOGD(" 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::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.firstMarkedBit(); |
| idBits.clearBit(id); |
| 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; |
| } |
| |
| LOG_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. |
| LOG_ASSERT(false); |
| } |
| } |
| |
| getDispatcher()->notifyMotion(when, getDeviceId(), source, policyFlags, |
| action, flags, metaState, buttonState, edgeFlags, |
| pointerCount, pointerProperties, pointerCoords, xPrecision, yPrecision, downTime); |
| } |
| |
| 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.firstMarkedBit(); |
| idBits.clearBit(id); |
| |
| 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() { |
| { // acquire lock |
| AutoMutex _l(mLock); |
| if (mPointerController != NULL) { |
| mPointerController->fade(PointerControllerInterface::TRANSITION_GRADUAL); |
| } |
| } // release lock |
| } |
| |
| int32_t TouchInputMapper::getTouchToolType(bool isStylus) const { |
| if (mParameters.deviceType == Parameters::DEVICE_TYPE_TOUCH_SCREEN) { |
| return isStylus ? AMOTION_EVENT_TOOL_TYPE_STYLUS : AMOTION_EVENT_TOOL_TYPE_FINGER; |
| } else { |
| return isStylus ? AMOTION_EVENT_TOOL_TYPE_INDIRECT_STYLUS |
| : AMOTION_EVENT_TOOL_TYPE_INDIRECT_FINGER; |
| } |
| } |
| |
| bool TouchInputMapper::isPointInsideSurfaceLocked(int32_t x, int32_t y) { |
| return x >= mRawAxes.x.minValue && x <= mRawAxes.x.maxValue |
| && y >= mRawAxes.y.minValue && y <= mRawAxes.y.maxValue; |
| } |
| |
| const TouchInputMapper::VirtualKey* TouchInputMapper::findVirtualKeyHitLocked( |
| int32_t x, int32_t y) { |
| size_t numVirtualKeys = mLocked.virtualKeys.size(); |
| for (size_t i = 0; i < numVirtualKeys; i++) { |
| const VirtualKey& virtualKey = mLocked.virtualKeys[i]; |
| |
| #if DEBUG_VIRTUAL_KEYS |
| LOGD("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::calculatePointerIds() { |
| uint32_t currentPointerCount = mCurrentTouch.pointerCount; |
| uint32_t lastPointerCount = mLastTouch.pointerCount; |
| |
| if (currentPointerCount == 0) { |
| // No pointers to assign. |
| mCurrentTouch.idBits.clear(); |
| } else if (lastPointerCount == 0) { |
| // All pointers are new. |
| mCurrentTouch.idBits.clear(); |
| for (uint32_t i = 0; i < currentPointerCount; i++) { |
| mCurrentTouch.pointers[i].id = i; |
| mCurrentTouch.idToIndex[i] = i; |
| mCurrentTouch.idBits.markBit(i); |
| } |
| } else if (currentPointerCount == 1 && lastPointerCount == 1) { |
| // Only one pointer and no change in count so it must have the same id as before. |
| uint32_t id = mLastTouch.pointers[0].id; |
| mCurrentTouch.pointers[0].id = id; |
| mCurrentTouch.idToIndex[id] = 0; |
| mCurrentTouch.idBits.value = BitSet32::valueForBit(id); |
| } else { |
| // 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. |
| 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++) { |
| int64_t deltaX = mCurrentTouch.pointers[currentPointerIndex].x |
| - mLastTouch.pointers[lastPointerIndex].x; |
| int64_t deltaY = mCurrentTouch.pointers[currentPointerIndex].y |
| - mLastTouch.pointers[lastPointerIndex].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 |
| LOGD("calculatePointerIds - initial distance min-heap: size=%d", heapSize); |
| for (size_t i = 0; i < heapSize; i++) { |
| LOGD(" 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); i > 0; i--) { |
| for (;;) { |
| 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). |
| heapSize -= 1; |
| LOG_ASSERT(heapSize > 0); |
| |
| // 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 |
| LOGD("calculatePointerIds - reduced distance min-heap: size=%d", heapSize); |
| for (size_t i = 0; i < heapSize; i++) { |
| LOGD(" heap[%d]: cur=%d, last=%d, distance=%lld", |
| i, heap[i].currentPointerIndex, heap[i].lastPointerIndex, |
| heap[i].distance); |
| } |
| #endif |
| } |
| |
| 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 = mLastTouch.pointers[lastPointerIndex].id; |
| mCurrentTouch.pointers[currentPointerIndex].id = id; |
| mCurrentTouch.idToIndex[id] = currentPointerIndex; |
| usedIdBits.markBit(id); |
| |
| #if DEBUG_POINTER_ASSIGNMENT |
| LOGD("calculatePointerIds - matched: cur=%d, last=%d, id=%d, distance=%lld", |
| lastPointerIndex, currentPointerIndex, id, heap[0].distance); |
| #endif |
| break; |
| } |
| } |
| |
| // Assign fresh ids to new pointers. |
| if (currentPointerCount > lastPointerCount) { |
| for (uint32_t i = currentPointerCount - lastPointerCount; ;) { |
| uint32_t currentPointerIndex = matchedCurrentBits.firstUnmarkedBit(); |
| uint32_t id = usedIdBits.firstUnmarkedBit(); |
| |
| mCurrentTouch.pointers[currentPointerIndex].id = id; |
| mCurrentTouch.idToIndex[id] = currentPointerIndex; |
| usedIdBits.markBit(id); |
| |
| #if DEBUG_POINTER_ASSIGNMENT |
| LOGD("calculatePointerIds - assigned: cur=%d, id=%d", |
| currentPointerIndex, id); |
| #endif |
| |
| if (--i == 0) break; // done |
| matchedCurrentBits.markBit(currentPointerIndex); |
| } |
| } |
| |
| // Fix id bits. |
| mCurrentTouch.idBits = usedIdBits; |
| } |
| } |
| |
| /* Special hack for devices that have bad screen data: if one of the |
| * points has moved more than a screen height from the last position, |
| * then drop it. */ |
| bool TouchInputMapper::applyBadTouchFilter() { |
| uint32_t pointerCount = mCurrentTouch.pointerCount; |
| |
| // Nothing to do if there are no points. |
| if (pointerCount == 0) { |
| return false; |
| } |
| |
| // Don't do anything if a finger is going down or up. We run |
| // here before assigning pointer IDs, so there isn't a good |
| // way to do per-finger matching. |
| if (pointerCount != mLastTouch.pointerCount) { |
| return false; |
| } |
| |
| // We consider a single movement across more than a 7/16 of |
| // the long size of the screen to be bad. This was a magic value |
| // determined by looking at the maximum distance it is feasible |
| // to actually move in one sample. |
| int32_t maxDeltaY = (mRawAxes.y.maxValue - mRawAxes.y.minValue + 1) * 7 / 16; |
| |
| // XXX The original code in InputDevice.java included commented out |
| // code for testing the X axis. Note that when we drop a point |
| // we don't actually restore the old X either. Strange. |
| // The old code also tries to track when bad points were previously |
| // detected but it turns out that due to the placement of a "break" |
| // at the end of the loop, we never set mDroppedBadPoint to true |
| // so it is effectively dead code. |
| // Need to figure out if the old code is busted or just overcomplicated |
| // but working as intended. |
| |
| // Look through all new points and see if any are farther than |
| // acceptable from all previous points. |
| for (uint32_t i = pointerCount; i-- > 0; ) { |
| int32_t y = mCurrentTouch.pointers[i].y; |
| int32_t closestY = INT_MAX; |
| int32_t closestDeltaY = 0; |
| |
| #if DEBUG_HACKS |
| LOGD("BadTouchFilter: Looking at next point #%d: y=%d", i, y); |
| #endif |
| |
| for (uint32_t j = pointerCount; j-- > 0; ) { |
| int32_t lastY = mLastTouch.pointers[j].y; |
| int32_t deltaY = abs(y - lastY); |
| |
| #if DEBUG_HACKS |
| LOGD("BadTouchFilter: Comparing with last point #%d: y=%d deltaY=%d", |
| j, lastY, deltaY); |
| #endif |
| |
| if (deltaY < maxDeltaY) { |
| goto SkipSufficientlyClosePoint; |
| } |
| if (deltaY < closestDeltaY) { |
| closestDeltaY = deltaY; |
| closestY = lastY; |
| } |
| } |
| |
| // Must not have found a close enough match. |
| #if DEBUG_HACKS |
| LOGD("BadTouchFilter: Dropping bad point #%d: newY=%d oldY=%d deltaY=%d maxDeltaY=%d", |
| i, y, closestY, closestDeltaY, maxDeltaY); |
| #endif |
| |
| mCurrentTouch.pointers[i].y = closestY; |
| return true; // XXX original code only corrects one point |
| |
| SkipSufficientlyClosePoint: ; |
| } |
| |
| // No change. |
| return false; |
| } |
| |
| /* Special hack for devices that have bad screen data: drop points where |
| * the coordinate value for one axis has jumped to the other pointer's location. |
| */ |
| bool TouchInputMapper::applyJumpyTouchFilter() { |
| uint32_t pointerCount = mCurrentTouch.pointerCount; |
| if (mLastTouch.pointerCount != pointerCount) { |
| #if DEBUG_HACKS |
| LOGD("JumpyTouchFilter: Different pointer count %d -> %d", |
| mLastTouch.pointerCount, pointerCount); |
| for (uint32_t i = 0; i < pointerCount; i++) { |
| LOGD(" Pointer %d (%d, %d)", i, |
| mCurrentTouch.pointers[i].x, mCurrentTouch.pointers[i].y); |
| } |
| #endif |
| |
| if (mJumpyTouchFilter.jumpyPointsDropped < JUMPY_TRANSITION_DROPS) { |
| if (mLastTouch.pointerCount == 1 && pointerCount == 2) { |
| // Just drop the first few events going from 1 to 2 pointers. |
| // They're bad often enough that they're not worth considering. |
| mCurrentTouch.pointerCount = 1; |
| mJumpyTouchFilter.jumpyPointsDropped += 1; |
| |
| #if DEBUG_HACKS |
| LOGD("JumpyTouchFilter: Pointer 2 dropped"); |
| #endif |
| return true; |
| } else if (mLastTouch.pointerCount == 2 && pointerCount == 1) { |
| // The event when we go from 2 -> 1 tends to be messed up too |
| mCurrentTouch.pointerCount = 2; |
| mCurrentTouch.pointers[0] = mLastTouch.pointers[0]; |
| mCurrentTouch.pointers[1] = mLastTouch.pointers[1]; |
| mJumpyTouchFilter.jumpyPointsDropped += 1; |
| |
| #if DEBUG_HACKS |
| for (int32_t i = 0; i < 2; i++) { |
| LOGD("JumpyTouchFilter: Pointer %d replaced (%d, %d)", i, |
| mCurrentTouch.pointers[i].x, mCurrentTouch.pointers[i].y); |
| } |
| #endif |
| return true; |
| } |
| } |
| // Reset jumpy points dropped on other transitions or if limit exceeded. |
| mJumpyTouchFilter.jumpyPointsDropped = 0; |
| |
| #if DEBUG_HACKS |
| LOGD("JumpyTouchFilter: Transition - drop limit reset"); |
| #endif |
| return false; |
| } |
| |
| // We have the same number of pointers as last time. |
| // A 'jumpy' point is one where the coordinate value for one axis |
| // has jumped to the other pointer's location. No need to do anything |
| // else if we only have one pointer. |
| if (pointerCount < 2) { |
| return false; |
| } |
| |
| if (mJumpyTouchFilter.jumpyPointsDropped < JUMPY_DROP_LIMIT) { |
| int jumpyEpsilon = (mRawAxes.y.maxValue - mRawAxes.y.minValue + 1) / JUMPY_EPSILON_DIVISOR; |
| |
| // We only replace the single worst jumpy point as characterized by pointer distance |
| // in a single axis. |
| int32_t badPointerIndex = -1; |
| int32_t badPointerReplacementIndex = -1; |
| int32_t badPointerDistance = INT_MIN; // distance to be corrected |
| |
| for (uint32_t i = pointerCount; i-- > 0; ) { |
| int32_t x = mCurrentTouch.pointers[i].x; |
| int32_t y = mCurrentTouch.pointers[i].y; |
| |
| #if DEBUG_HACKS |
| LOGD("JumpyTouchFilter: Point %d (%d, %d)", i, x, y); |
| #endif |
| |
| // Check if a touch point is too close to another's coordinates |
| bool dropX = false, dropY = false; |
| for (uint32_t j = 0; j < pointerCount; j++) { |
| if (i == j) { |
| continue; |
| } |
| |
| if (abs(x - mCurrentTouch.pointers[j].x) <= jumpyEpsilon) { |
| dropX = true; |
| break; |
| } |
| |
| if (abs(y - mCurrentTouch.pointers[j].y) <= jumpyEpsilon) { |
| dropY = true; |
| break; |
| } |
| } |
| if (! dropX && ! dropY) { |
| continue; // not jumpy |
| } |
| |
| // Find a replacement candidate by comparing with older points on the |
| // complementary (non-jumpy) axis. |
| int32_t distance = INT_MIN; // distance to be corrected |
| int32_t replacementIndex = -1; |
| |
| if (dropX) { |
| // X looks too close. Find an older replacement point with a close Y. |
| int32_t smallestDeltaY = INT_MAX; |
| for (uint32_t j = 0; j < pointerCount; j++) { |
| int32_t deltaY = abs(y - mLastTouch.pointers[j].y); |
| if (deltaY < smallestDeltaY) { |
| smallestDeltaY = deltaY; |
| replacementIndex = j; |
| } |
| } |
| distance = abs(x - mLastTouch.pointers[replacementIndex].x); |
| } else { |
| // Y looks too close. Find an older replacement point with a close X. |
| int32_t smallestDeltaX = INT_MAX; |
| for (uint32_t j = 0; j < pointerCount; j++) { |
| int32_t deltaX = abs(x - mLastTouch.pointers[j].x); |
| if (deltaX < smallestDeltaX) { |
| smallestDeltaX = deltaX; |
| replacementIndex = j; |
| } |
| } |
| distance = abs(y - mLastTouch.pointers[replacementIndex].y); |
| } |
| |
| // If replacing this pointer would correct a worse error than the previous ones |
| // considered, then use this replacement instead. |
| if (distance > badPointerDistance) { |
| badPointerIndex = i; |
| badPointerReplacementIndex = replacementIndex; |
| badPointerDistance = distance; |
| } |
| } |
| |
| // Correct the jumpy pointer if one was found. |
| if (badPointerIndex >= 0) { |
| #if DEBUG_HACKS |
| LOGD("JumpyTouchFilter: Replacing bad pointer %d with (%d, %d)", |
| badPointerIndex, |
| mLastTouch.pointers[badPointerReplacementIndex].x, |
| mLastTouch.pointers[badPointerReplacementIndex].y); |
| #endif |
| |
| mCurrentTouch.pointers[badPointerIndex].x = |
| mLastTouch.pointers[badPointerReplacementIndex].x; |
| mCurrentTouch.pointers[badPointerIndex].y = |
| mLastTouch.pointers[badPointerReplacementIndex].y; |
| mJumpyTouchFilter.jumpyPointsDropped += 1; |
| return true; |
| } |
| } |
| |
| mJumpyTouchFilter.jumpyPointsDropped = 0; |
| return false; |
| } |
| |
| /* Special hack for devices that have bad screen data: aggregate and |
| * compute averages of the coordinate data, to reduce the amount of |
| * jitter seen by applications. */ |
| void TouchInputMapper::applyAveragingTouchFilter() { |
| for (uint32_t currentIndex = 0; currentIndex < mCurrentTouch.pointerCount; currentIndex++) { |
| uint32_t id = mCurrentTouch.pointers[currentIndex].id; |
| int32_t x = mCurrentTouch.pointers[currentIndex].x; |
| int32_t y = mCurrentTouch.pointers[currentIndex].y; |
| int32_t pressure; |
| switch (mCalibration.pressureSource) { |
| case Calibration::PRESSURE_SOURCE_PRESSURE: |
| pressure = mCurrentTouch.pointers[currentIndex].pressure; |
| break; |
| case Calibration::PRESSURE_SOURCE_TOUCH: |
| pressure = mCurrentTouch.pointers[currentIndex].touchMajor; |
| break; |
| default: |
| pressure = 1; |
| break; |
| } |
| |
| if (mLastTouch.idBits.hasBit(id)) { |
| // Pointer was down before and is still down now. |
| // Compute average over history trace. |
| uint32_t start = mAveragingTouchFilter.historyStart[id]; |
| uint32_t end = mAveragingTouchFilter.historyEnd[id]; |
| |
| int64_t deltaX = x - mAveragingTouchFilter.historyData[end].pointers[id].x; |
| int64_t deltaY = y - mAveragingTouchFilter.historyData[end].pointers[id].y; |
| uint64_t distance = uint64_t(deltaX * deltaX + deltaY * deltaY); |
| |
| #if DEBUG_HACKS |
| LOGD("AveragingTouchFilter: Pointer id %d - Distance from last sample: %lld", |
| id, distance); |
| #endif |
| |
| if (distance < AVERAGING_DISTANCE_LIMIT) { |
| // Increment end index in preparation for recording new historical data. |
| end += 1; |
| if (end > AVERAGING_HISTORY_SIZE) { |
| end = 0; |
| } |
| |
| // If the end index has looped back to the start index then we have filled |
| // the historical trace up to the desired size so we drop the historical |
| // data at the start of the trace. |
| if (end == start) { |
| start += 1; |
| if (start > AVERAGING_HISTORY_SIZE) { |
| start = 0; |
| } |
| } |
| |
| // Add the raw data to the historical trace. |
| mAveragingTouchFilter.historyStart[id] = start; |
| mAveragingTouchFilter.historyEnd[id] = end; |
| mAveragingTouchFilter.historyData[end].pointers[id].x = x; |
| mAveragingTouchFilter.historyData[end].pointers[id].y = y; |
| mAveragingTouchFilter.historyData[end].pointers[id].pressure = pressure; |
| |
| // Average over all historical positions in the trace by total pressure. |
| int32_t averagedX = 0; |
| int32_t averagedY = 0; |
| int32_t totalPressure = 0; |
| for (;;) { |
| int32_t historicalX = mAveragingTouchFilter.historyData[start].pointers[id].x; |
| int32_t historicalY = mAveragingTouchFilter.historyData[start].pointers[id].y; |
| int32_t historicalPressure = mAveragingTouchFilter.historyData[start] |
| .pointers[id].pressure; |
| |
| averagedX += historicalX * historicalPressure; |
| averagedY += historicalY * historicalPressure; |
| totalPressure += historicalPressure; |
| |
| if (start == end) { |
| break; |
| } |
| |
| start += 1; |
| if (start > AVERAGING_HISTORY_SIZE) { |
| start = 0; |
| } |
| } |
| |
| if (totalPressure != 0) { |
| averagedX /= totalPressure; |
| averagedY /= totalPressure; |
| |
| #if DEBUG_HACKS |
| LOGD("AveragingTouchFilter: Pointer id %d - " |
| "totalPressure=%d, averagedX=%d, averagedY=%d", id, totalPressure, |
| averagedX, averagedY); |
| #endif |
| |
| mCurrentTouch.pointers[currentIndex].x = averagedX; |
| mCurrentTouch.pointers[currentIndex].y = averagedY; |
| } |
| } else { |
| #if DEBUG_HACKS |
| LOGD("AveragingTouchFilter: Pointer id %d - Exceeded max distance", id); |
| #endif |
| } |
| } else { |
| #if DEBUG_HACKS |
| LOGD("AveragingTouchFilter: Pointer id %d - Pointer went up", id); |
| #endif |
| } |
| |
| // Reset pointer history. |
| mAveragingTouchFilter.historyStart[id] = 0; |
| mAveragingTouchFilter.historyEnd[id] = 0; |
| mAveragingTouchFilter.historyData[0].pointers[id].x = x; |
| mAveragingTouchFilter.historyData[0].pointers[id].y = y; |
| mAveragingTouchFilter.historyData[0].pointers[id].pressure = pressure; |
| } |
| } |
| |
| int32_t TouchInputMapper::getKeyCodeState(uint32_t sourceMask, int32_t keyCode) { |
| { // acquire lock |
| AutoMutex _l(mLock); |
| |
| if (mLocked.currentVirtualKey.down && mLocked.currentVirtualKey.keyCode == keyCode) { |
| return AKEY_STATE_VIRTUAL; |
| } |
| |
| size_t numVirtualKeys = mLocked.virtualKeys.size(); |
| for (size_t i = 0; i < numVirtualKeys; i++) { |
| const VirtualKey& virtualKey = mLocked.virtualKeys[i]; |
| if (virtualKey.keyCode == keyCode) { |
| return AKEY_STATE_UP; |
| } |
| } |
| } // release lock |
| |
| return AKEY_STATE_UNKNOWN; |
| } |
| |
| int32_t TouchInputMapper::getScanCodeState(uint32_t sourceMask, int32_t scanCode) { |
| { // acquire lock |
| AutoMutex _l(mLock); |
| |
| if (mLocked.currentVirtualKey.down && mLocked.currentVirtualKey.scanCode == scanCode) { |
| return AKEY_STATE_VIRTUAL; |
| } |
| |
| size_t numVirtualKeys = mLocked.virtualKeys.size(); |
| for (size_t i = 0; i < numVirtualKeys; i++) { |
| const VirtualKey& virtualKey = mLocked.virtualKeys[i]; |
| if (virtualKey.scanCode == scanCode) { |
| return AKEY_STATE_UP; |
| } |
| } |
| } // release lock |
| |
| return AKEY_STATE_UNKNOWN; |
| } |
| |
| bool TouchInputMapper::markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes, |
| const int32_t* keyCodes, uint8_t* outFlags) { |
| { // acquire lock |
| AutoMutex _l(mLock); |
| |
| size_t numVirtualKeys = mLocked.virtualKeys.size(); |
| for (size_t i = 0; i < numVirtualKeys; i++) { |
| const VirtualKey& virtualKey = mLocked.virtualKeys[i]; |
| |
| for (size_t i = 0; i < numCodes; i++) { |
| if (virtualKey.keyCode == keyCodes[i]) { |
| outFlags[i] = 1; |
| } |
| } |
| } |
| } // release lock |
| |
| return true; |
| } |
| |
| |
| // --- SingleTouchInputMapper --- |
| |
| SingleTouchInputMapper::SingleTouchInputMapper(InputDevice* device) : |
| TouchInputMapper(device) { |
| clearState(); |
| } |
| |
| SingleTouchInputMapper::~SingleTouchInputMapper() { |
| } |
| |
| void SingleTouchInputMapper::clearState() { |
| mAccumulator.clear(); |
| |
| mDown = false; |
| mX = 0; |
| mY = 0; |
| mPressure = 0; // default to 0 for devices that don't report pressure |
| mToolWidth = 0; // default to 0 for devices that don't report tool width |
| mButtonState = 0; |
| } |
| |
| void SingleTouchInputMapper::reset() { |
| TouchInputMapper::reset(); |
| |
| clearState(); |
| } |
| |
| void SingleTouchInputMapper::process(const RawEvent* rawEvent) { |
| switch (rawEvent->type) { |
| case EV_KEY: |
| switch (rawEvent->scanCode) { |
| case BTN_TOUCH: |
| mAccumulator.fields |= Accumulator::FIELD_BTN_TOUCH; |
| mAccumulator.btnTouch = rawEvent->value != 0; |
| // Don't sync immediately. Wait until the next SYN_REPORT since we might |
| // not have received valid position information yet. This logic assumes that |
| // BTN_TOUCH is always followed by SYN_REPORT as part of a complete packet. |
| break; |
| default: |
| if (mParameters.deviceType == Parameters::DEVICE_TYPE_POINTER) { |
| int32_t buttonState = getButtonStateForScanCode(rawEvent->scanCode); |
| if (buttonState) { |
| if (rawEvent->value) { |
| mAccumulator.buttonDown |= buttonState; |
| } else { |
| mAccumulator.buttonUp |= buttonState; |
| } |
| mAccumulator.fields |= Accumulator::FIELD_BUTTONS; |
| } |
| } |
| break; |
| } |
| break; |
| |
| case EV_ABS: |
| switch (rawEvent->scanCode) { |
| case ABS_X: |
| mAccumulator.fields |= Accumulator::FIELD_ABS_X; |
| mAccumulator.absX = rawEvent->value; |
| break; |
| case ABS_Y: |
| mAccumulator.fields |= Accumulator::FIELD_ABS_Y; |
| mAccumulator.absY = rawEvent->value; |
| break; |
| case ABS_PRESSURE: |
| mAccumulator.fields |= Accumulator::FIELD_ABS_PRESSURE; |
| mAccumulator.absPressure = rawEvent->value; |
| break; |
| case ABS_TOOL_WIDTH: |
| mAccumulator.fields |= Accumulator::FIELD_ABS_TOOL_WIDTH; |
| mAccumulator.absToolWidth = rawEvent->value; |
| break; |
| } |
| break; |
| |
| case EV_SYN: |
| switch (rawEvent->scanCode) { |
| case SYN_REPORT: |
| sync(rawEvent->when); |
| break; |
| } |
| break; |
| } |
| } |
| |
| void SingleTouchInputMapper::sync(nsecs_t when) { |
| uint32_t fields = mAccumulator.fields; |
| if (fields == 0) { |
| return; // no new state changes, so nothing to do |
| } |
| |
| if (fields & Accumulator::FIELD_BTN_TOUCH) { |
| mDown = mAccumulator.btnTouch; |
| } |
| |
| if (fields & Accumulator::FIELD_ABS_X) { |
| mX = mAccumulator.absX; |
| } |
| |
| if (fields & Accumulator::FIELD_ABS_Y) { |
| mY = mAccumulator.absY; |
| } |
| |
| if (fields & Accumulator::FIELD_ABS_PRESSURE) { |
| mPressure = mAccumulator.absPressure; |
| } |
| |
| if (fields & Accumulator::FIELD_ABS_TOOL_WIDTH) { |
| mToolWidth = mAccumulator.absToolWidth; |
| } |
| |
| if (fields & Accumulator::FIELD_BUTTONS) { |
| mButtonState = (mButtonState | mAccumulator.buttonDown) & ~mAccumulator.buttonUp; |
| } |
| |
| mCurrentTouch.clear(); |
| |
| if (mDown) { |
| mCurrentTouch.pointerCount = 1; |
| mCurrentTouch.pointers[0].id = 0; |
| mCurrentTouch.pointers[0].x = mX; |
| mCurrentTouch.pointers[0].y = mY; |
| mCurrentTouch.pointers[0].pressure = mPressure; |
| mCurrentTouch.pointers[0].touchMajor = 0; |
| mCurrentTouch.pointers[0].touchMinor = 0; |
| mCurrentTouch.pointers[0].toolMajor = mToolWidth; |
| mCurrentTouch.pointers[0].toolMinor = mToolWidth; |
| mCurrentTouch.pointers[0].orientation = 0; |
| mCurrentTouch.pointers[0].distance = 0; |
| mCurrentTouch.pointers[0].isStylus = false; // TODO: Set stylus |
| mCurrentTouch.idToIndex[0] = 0; |
| mCurrentTouch.idBits.markBit(0); |
| mCurrentTouch.buttonState = mButtonState; |
| } |
| |
| syncTouch(when, true); |
| |
| mAccumulator.clear(); |
| } |
| |
| void SingleTouchInputMapper::configureRawAxes() { |
| TouchInputMapper::configureRawAxes(); |
| |
| getEventHub()->getAbsoluteAxisInfo(getDeviceId(), ABS_X, & mRawAxes.x); |
| getEventHub()->getAbsoluteAxisInfo(getDeviceId(), ABS_Y, & mRawAxes.y); |
| getEventHub()->getAbsoluteAxisInfo(getDeviceId(), ABS_PRESSURE, & mRawAxes.pressure); |
| getEventHub()->getAbsoluteAxisInfo(getDeviceId(), ABS_TOOL_WIDTH, & mRawAxes.toolMajor); |
| } |
| |
| |
| // --- MultiTouchInputMapper --- |
| |
| MultiTouchInputMapper::MultiTouchInputMapper(InputDevice* device) : |
| TouchInputMapper(device), mSlotCount(0), mUsingSlotsProtocol(false) { |
| clearState(); |
| } |
| |
| MultiTouchInputMapper::~MultiTouchInputMapper() { |
| } |
| |
| void MultiTouchInputMapper::clearState() { |
| mAccumulator.clearSlots(mSlotCount); |
| mAccumulator.clearButtons(); |
| mButtonState = 0; |
| } |
| |
| void MultiTouchInputMapper::reset() { |
| TouchInputMapper::reset(); |
| |
| clearState(); |
| } |
| |
| void MultiTouchInputMapper::process(const RawEvent* rawEvent) { |
| switch (rawEvent->type) { |
| case EV_KEY: { |
| if (mParameters.deviceType == Parameters::DEVICE_TYPE_POINTER) { |
| int32_t buttonState = getButtonStateForScanCode(rawEvent->scanCode); |
| if (buttonState) { |
| if (rawEvent->value) { |
| mAccumulator.buttonDown |= buttonState; |
| } else { |
| mAccumulator.buttonUp |= buttonState; |
| } |
| } |
| } |
| break; |
| } |
| |
| case EV_ABS: { |
| bool newSlot = false; |
| if (mUsingSlotsProtocol && rawEvent->scanCode == ABS_MT_SLOT) { |
| mAccumulator.currentSlot = rawEvent->value; |
| newSlot = true; |
| } |
| |
| if (mAccumulator.currentSlot < 0 || size_t(mAccumulator.currentSlot) >= mSlotCount) { |
| #if DEBUG_POINTERS |
| if (newSlot) { |
| LOGW("MultiTouch device %s emitted invalid slot index %d but it " |
| "should be between 0 and %d; ignoring this slot.", |
| getDeviceName().string(), mAccumulator.currentSlot, mSlotCount); |
| } |
| #endif |
| break; |
| } |
| |
| Accumulator::Slot* slot = &mAccumulator.slots[mAccumulator.currentSlot]; |
| |
| switch (rawEvent->scanCode) { |
| case ABS_MT_POSITION_X: |
| slot->fields |= Accumulator::FIELD_ABS_MT_POSITION_X; |
| slot->absMTPositionX = rawEvent->value; |
| break; |
| case ABS_MT_POSITION_Y: |
| slot->fields |= Accumulator::FIELD_ABS_MT_POSITION_Y; |
| slot->absMTPositionY = rawEvent->value; |
| break; |
| case ABS_MT_TOUCH_MAJOR: |
| slot->fields |= Accumulator::FIELD_ABS_MT_TOUCH_MAJOR; |
| slot->absMTTouchMajor = rawEvent->value; |
| break; |
| case ABS_MT_TOUCH_MINOR: |
| slot->fields |= Accumulator::FIELD_ABS_MT_TOUCH_MINOR; |
| slot->absMTTouchMinor = rawEvent->value; |
| break; |
| case ABS_MT_WIDTH_MAJOR: |
| slot->fields |= Accumulator::FIELD_ABS_MT_WIDTH_MAJOR; |
| slot->absMTWidthMajor = rawEvent->value; |
| break; |
| case ABS_MT_WIDTH_MINOR: |
| slot->fields |= Accumulator::FIELD_ABS_MT_WIDTH_MINOR; |
| slot->absMTWidthMinor = rawEvent->value; |
| break; |
| case ABS_MT_ORIENTATION: |
| slot->fields |= Accumulator::FIELD_ABS_MT_ORIENTATION; |
| slot->absMTOrientation = rawEvent->value; |
| break; |
| case ABS_MT_TRACKING_ID: |
| if (mUsingSlotsProtocol && rawEvent->value < 0) { |
| slot->clear(); |
| } else { |
| slot->fields |= Accumulator::FIELD_ABS_MT_TRACKING_ID; |
| slot->absMTTrackingId = rawEvent->value; |
| } |
| break; |
| case ABS_MT_PRESSURE: |
| slot->fields |= Accumulator::FIELD_ABS_MT_PRESSURE; |
| slot->absMTPressure = rawEvent->value; |
| break; |
| case ABS_MT_TOOL_TYPE: |
| slot->fields |= Accumulator::FIELD_ABS_MT_TOOL_TYPE; |
| slot->absMTToolType = rawEvent->value; |
| break; |
| } |
| break; |
| } |
| |
| case EV_SYN: |
| switch (rawEvent->scanCode) { |
| case SYN_MT_REPORT: { |
| // MultiTouch Sync: The driver has returned all data for *one* of the pointers. |
| mAccumulator.currentSlot += 1; |
| break; |
| } |
| |
| case SYN_REPORT: |
| sync(rawEvent->when); |
| break; |
| } |
| break; |
| } |
| } |
| |
| void MultiTouchInputMapper::sync(nsecs_t when) { |
| static const uint32_t REQUIRED_FIELDS = |
| Accumulator::FIELD_ABS_MT_POSITION_X | Accumulator::FIELD_ABS_MT_POSITION_Y; |
| |
| size_t inCount = mSlotCount; |
| size_t outCount = 0; |
| bool havePointerIds = true; |
| |
| mCurrentTouch.clear(); |
| |
| for (size_t inIndex = 0; inIndex < inCount; inIndex++) { |
| const Accumulator::Slot& inSlot = mAccumulator.slots[inIndex]; |
| uint32_t fields = inSlot.fields; |
| |
| if ((fields & REQUIRED_FIELDS) != REQUIRED_FIELDS) { |
| // Some drivers send empty MT sync packets without X / Y to indicate a pointer up. |
| // This may also indicate an unused slot. |
| // Drop this finger. |
| continue; |
| } |
| |
| if (outCount >= MAX_POINTERS) { |
| #if DEBUG_POINTERS |
| LOGD("MultiTouch device %s emitted more than maximum of %d pointers; " |
| "ignoring the rest.", |
| getDeviceName().string(), MAX_POINTERS); |
| #endif |
| break; // too many fingers! |
| } |
| |
| PointerData& outPointer = mCurrentTouch.pointers[outCount]; |
| outPointer.x = inSlot.absMTPositionX; |
| outPointer.y = inSlot.absMTPositionY; |
| |
| if (fields & Accumulator::FIELD_ABS_MT_PRESSURE) { |
| outPointer.pressure = inSlot.absMTPressure; |
| } else { |
| // Default pressure to 0 if absent. |
| outPointer.pressure = 0; |
| } |
| |
| if (fields & Accumulator::FIELD_ABS_MT_TOUCH_MAJOR) { |
| if (inSlot.absMTTouchMajor <= 0) { |
| // Some devices send sync packets with X / Y but with a 0 touch major to indicate |
| // a pointer going up. Drop this finger. |
| continue; |
| } |
| outPointer.touchMajor = inSlot.absMTTouchMajor; |
| } else { |
| // Default touch area to 0 if absent. |
| outPointer.touchMajor = 0; |
| } |
| |
| if (fields & Accumulator::FIELD_ABS_MT_TOUCH_MINOR) { |
| outPointer.touchMinor = inSlot.absMTTouchMinor; |
| } else { |
| // Assume touch area is circular. |
| outPointer.touchMinor = outPointer.touchMajor; |
| } |
| |
| if (fields & Accumulator::FIELD_ABS_MT_WIDTH_MAJOR) { |
| outPointer.toolMajor = inSlot.absMTWidthMajor; |
| } else { |
| // Default tool area to 0 if absent. |
| outPointer.toolMajor = 0; |
| } |
| |
| if (fields & Accumulator::FIELD_ABS_MT_WIDTH_MINOR) { |
| outPointer.toolMinor = inSlot.absMTWidthMinor; |
| } else { |
| // Assume tool area is circular. |
| outPointer.toolMinor = outPointer.toolMajor; |
| } |
| |
| if (fields & Accumulator::FIELD_ABS_MT_ORIENTATION) { |
| outPointer.orientation = inSlot.absMTOrientation; |
| } else { |
| // Default orientation to vertical if absent. |
| outPointer.orientation = 0; |
| } |
| |
| if (fields & Accumulator::FIELD_ABS_MT_DISTANCE) { |
| outPointer.distance = inSlot.absMTDistance; |
| } else { |
| // Default distance is 0 (direct contact). |
| outPointer.distance = 0; |
| } |
| |
| if (fields & Accumulator::FIELD_ABS_MT_TOOL_TYPE) { |
| outPointer.isStylus = (inSlot.absMTToolType == MT_TOOL_PEN); |
| } else { |
| // Assume this is not a stylus. |
| outPointer.isStylus = false; |
| } |
| |
| // Assign pointer id using tracking id if available. |
| if (havePointerIds) { |
| int32_t id; |
| if (mUsingSlotsProtocol) { |
| id = inIndex; |
| } else if (fields & Accumulator::FIELD_ABS_MT_TRACKING_ID) { |
| id = inSlot.absMTTrackingId; |
| } else { |
| id = -1; |
| } |
| |
| if (id >= 0 && id <= MAX_POINTER_ID) { |
| outPointer.id = id; |
| mCurrentTouch.idToIndex[id] = outCount; |
| mCurrentTouch.idBits.markBit(id); |
| } else { |
| if (id >= 0) { |
| #if DEBUG_POINTERS |
| LOGD("Pointers: Ignoring driver provided slot index or tracking id %d because " |
| "it is larger than the maximum supported pointer id %d", |
| id, MAX_POINTER_ID); |
| #endif |
| } |
| havePointerIds = false; |
| } |
| } |
| |
| outCount += 1; |
| } |
| |
| mCurrentTouch.pointerCount = outCount; |
| |
| mButtonState = (mButtonState | mAccumulator.buttonDown) & ~mAccumulator.buttonUp; |
| mCurrentTouch.buttonState = mButtonState; |
| |
| syncTouch(when, havePointerIds); |
| |
| if (!mUsingSlotsProtocol) { |
| mAccumulator.clearSlots(mSlotCount); |
| } |
| mAccumulator.clearButtons(); |
| } |
| |
| void MultiTouchInputMapper::configureRawAxes() { |
| TouchInputMapper::configureRawAxes(); |
| |
| getEventHub()->getAbsoluteAxisInfo(getDeviceId(), ABS_MT_POSITION_X, &mRawAxes.x); |
| getEventHub()->getAbsoluteAxisInfo(getDeviceId(), ABS_MT_POSITION_Y, &mRawAxes.y); |
| getEventHub()->getAbsoluteAxisInfo(getDeviceId(), ABS_MT_TOUCH_MAJOR, &mRawAxes.touchMajor); |
| getEventHub()->getAbsoluteAxisInfo(getDeviceId(), ABS_MT_TOUCH_MINOR, &mRawAxes.touchMinor); |
| getEventHub()->getAbsoluteAxisInfo(getDeviceId(), ABS_MT_WIDTH_MAJOR, &mRawAxes.toolMajor); |
| getEventHub()->getAbsoluteAxisInfo(getDeviceId(), ABS_MT_WIDTH_MINOR, &mRawAxes.toolMinor); |
| getEventHub()->getAbsoluteAxisInfo(getDeviceId(), ABS_MT_ORIENTATION, &mRawAxes.orientation); |
| getEventHub()->getAbsoluteAxisInfo(getDeviceId(), ABS_MT_PRESSURE, &mRawAxes.pressure); |
| getEventHub()->getAbsoluteAxisInfo(getDeviceId(), ABS_MT_DISTANCE, &mRawAxes.distance); |
| getEventHub()->getAbsoluteAxisInfo(getDeviceId(), ABS_MT_TRACKING_ID, &mRawAxes.trackingId); |
| getEventHub()->getAbsoluteAxisInfo(getDeviceId(), ABS_MT_SLOT, &mRawAxes.slot); |
| |
| if (mRawAxes.trackingId.valid |
| && mRawAxes.slot.valid && mRawAxes.slot.minValue == 0 && mRawAxes.slot.maxValue > 0) { |
| mSlotCount = mRawAxes.slot.maxValue + 1; |
| if (mSlotCount > MAX_SLOTS) { |
| LOGW("MultiTouch Device %s reported %d slots but the framework " |
| "only supports a maximum of %d slots at this time.", |
| getDeviceName().string(), mSlotCount, MAX_SLOTS); |
| mSlotCount = MAX_SLOTS; |
| } |
| mUsingSlotsProtocol = true; |
| } else { |
| mSlotCount = MAX_POINTERS; |
| mUsingSlotsProtocol = false; |
| } |
| |
| mAccumulator.allocateSlots(mSlotCount); |
| } |
| |
| |
| // --- 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); |
| info->addMotionRange(axis.axisInfo.axis, AINPUT_SOURCE_JOYSTICK, |
| axis.min, axis.max, axis.flat, axis.fuzz); |
| if (axis.axisInfo.mode == AxisInfo::MODE_SPLIT) { |
| info->addMotionRange(axis.axisInfo.highAxis, AINPUT_SOURCE_JOYSTICK, |
| axis.min, axis.max, axis.flat, axis.fuzz); |
| } |
| } |
| } |
| |
| 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\n", |
| axis.min, axis.max, axis.flat, axis.fuzz); |
| 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(const InputReaderConfiguration* config, uint32_t changes) { |
| InputMapper::configure(config, changes); |
| |
| if (!changes) { // first time only |
| // Collect all axes. |
| for (int32_t abs = 0; abs <= ABS_MAX; abs++) { |
| RawAbsoluteAxisInfo rawAxisInfo; |
| getEventHub()->getAbsoluteAxisInfo(getDeviceId(), 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); |
| } 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); |
| } 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); |
| } |
| |
| // 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) { |
| LOGI("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 { |
| LOGI("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; |
| } |
| LOGI("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() { |
| // Recenter all axes. |
| nsecs_t when = systemTime(SYSTEM_TIME_MONOTONIC); |
| |
| size_t numAxes = mAxes.size(); |
| for (size_t i = 0; i < numAxes; i++) { |
| Axis& axis = mAxes.editValueAt(i); |
| axis.resetValue(); |
| } |
| |
| sync(when, true /*force*/); |
| |
| InputMapper::reset(); |
| } |
| |
| void JoystickInputMapper::process(const RawEvent* rawEvent) { |
| switch (rawEvent->type) { |
| case EV_ABS: { |
| ssize_t index = mAxes.indexOfKey(rawEvent->scanCode); |
| 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->scanCode) { |
| 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); |
| pointerCoords.setAxisValue(axis.axisInfo.axis, axis.currentValue); |
| if (axis.axisInfo.mode == AxisInfo::MODE_SPLIT) { |
| pointerCoords.setAxisValue(axis.axisInfo.highAxis, axis.highCurrentValue); |
| } |
| } |
| |
| // Moving a joystick axis should not wake the devide 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; |
| |
| getDispatcher()->notifyMotion(when, getDeviceId(), AINPUT_SOURCE_JOYSTICK, policyFlags, |
| AMOTION_EVENT_ACTION_MOVE, 0, metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, |
| 1, &pointerProperties, &pointerCoords, 0, 0, 0); |
| } |
| |
| 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 |