InputReader.cpp revision 00710e906bdafd58386ee7f81fa84addd218122f
1/* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#define LOG_TAG "InputReader" 18 19//#define LOG_NDEBUG 0 20 21// Log debug messages for each raw event received from the EventHub. 22#define DEBUG_RAW_EVENTS 0 23 24// Log debug messages about touch screen filtering hacks. 25#define DEBUG_HACKS 0 26 27// Log debug messages about virtual key processing. 28#define DEBUG_VIRTUAL_KEYS 0 29 30// Log debug messages about pointers. 31#define DEBUG_POINTERS 0 32 33// Log debug messages about pointer assignment calculations. 34#define DEBUG_POINTER_ASSIGNMENT 0 35 36// Log debug messages about gesture detection. 37#define DEBUG_GESTURES 0 38 39// Log debug messages about the vibrator. 40#define DEBUG_VIBRATOR 0 41 42#include "InputReader.h" 43 44#include <cutils/log.h> 45#include <androidfw/Keyboard.h> 46#include <androidfw/VirtualKeyMap.h> 47 48#include <stddef.h> 49#include <stdlib.h> 50#include <unistd.h> 51#include <errno.h> 52#include <limits.h> 53#include <math.h> 54 55#define INDENT " " 56#define INDENT2 " " 57#define INDENT3 " " 58#define INDENT4 " " 59#define INDENT5 " " 60 61namespace android { 62 63// --- Constants --- 64 65// Maximum number of slots supported when using the slot-based Multitouch Protocol B. 66static const size_t MAX_SLOTS = 32; 67 68// --- Static Functions --- 69 70template<typename T> 71inline static T abs(const T& value) { 72 return value < 0 ? - value : value; 73} 74 75template<typename T> 76inline static T min(const T& a, const T& b) { 77 return a < b ? a : b; 78} 79 80template<typename T> 81inline static void swap(T& a, T& b) { 82 T temp = a; 83 a = b; 84 b = temp; 85} 86 87inline static float avg(float x, float y) { 88 return (x + y) / 2; 89} 90 91inline static float distance(float x1, float y1, float x2, float y2) { 92 return hypotf(x1 - x2, y1 - y2); 93} 94 95inline static int32_t signExtendNybble(int32_t value) { 96 return value >= 8 ? value - 16 : value; 97} 98 99static inline const char* toString(bool value) { 100 return value ? "true" : "false"; 101} 102 103static int32_t rotateValueUsingRotationMap(int32_t value, int32_t orientation, 104 const int32_t map[][4], size_t mapSize) { 105 if (orientation != DISPLAY_ORIENTATION_0) { 106 for (size_t i = 0; i < mapSize; i++) { 107 if (value == map[i][0]) { 108 return map[i][orientation]; 109 } 110 } 111 } 112 return value; 113} 114 115static const int32_t keyCodeRotationMap[][4] = { 116 // key codes enumerated counter-clockwise with the original (unrotated) key first 117 // no rotation, 90 degree rotation, 180 degree rotation, 270 degree rotation 118 { AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_LEFT }, 119 { AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_DOWN }, 120 { AKEYCODE_DPAD_UP, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_RIGHT }, 121 { AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_UP }, 122}; 123static const size_t keyCodeRotationMapSize = 124 sizeof(keyCodeRotationMap) / sizeof(keyCodeRotationMap[0]); 125 126static int32_t rotateKeyCode(int32_t keyCode, int32_t orientation) { 127 return rotateValueUsingRotationMap(keyCode, orientation, 128 keyCodeRotationMap, keyCodeRotationMapSize); 129} 130 131static void rotateDelta(int32_t orientation, float* deltaX, float* deltaY) { 132 float temp; 133 switch (orientation) { 134 case DISPLAY_ORIENTATION_90: 135 temp = *deltaX; 136 *deltaX = *deltaY; 137 *deltaY = -temp; 138 break; 139 140 case DISPLAY_ORIENTATION_180: 141 *deltaX = -*deltaX; 142 *deltaY = -*deltaY; 143 break; 144 145 case DISPLAY_ORIENTATION_270: 146 temp = *deltaX; 147 *deltaX = -*deltaY; 148 *deltaY = temp; 149 break; 150 } 151} 152 153static inline bool sourcesMatchMask(uint32_t sources, uint32_t sourceMask) { 154 return (sources & sourceMask & ~ AINPUT_SOURCE_CLASS_MASK) != 0; 155} 156 157// Returns true if the pointer should be reported as being down given the specified 158// button states. This determines whether the event is reported as a touch event. 159static bool isPointerDown(int32_t buttonState) { 160 return buttonState & 161 (AMOTION_EVENT_BUTTON_PRIMARY | AMOTION_EVENT_BUTTON_SECONDARY 162 | AMOTION_EVENT_BUTTON_TERTIARY); 163} 164 165static float calculateCommonVector(float a, float b) { 166 if (a > 0 && b > 0) { 167 return a < b ? a : b; 168 } else if (a < 0 && b < 0) { 169 return a > b ? a : b; 170 } else { 171 return 0; 172 } 173} 174 175static void synthesizeButtonKey(InputReaderContext* context, int32_t action, 176 nsecs_t when, int32_t deviceId, uint32_t source, 177 uint32_t policyFlags, int32_t lastButtonState, int32_t currentButtonState, 178 int32_t buttonState, int32_t keyCode) { 179 if ( 180 (action == AKEY_EVENT_ACTION_DOWN 181 && !(lastButtonState & buttonState) 182 && (currentButtonState & buttonState)) 183 || (action == AKEY_EVENT_ACTION_UP 184 && (lastButtonState & buttonState) 185 && !(currentButtonState & buttonState))) { 186 NotifyKeyArgs args(when, deviceId, source, policyFlags, 187 action, 0, keyCode, 0, context->getGlobalMetaState(), when); 188 context->getListener()->notifyKey(&args); 189 } 190} 191 192static void synthesizeButtonKeys(InputReaderContext* context, int32_t action, 193 nsecs_t when, int32_t deviceId, uint32_t source, 194 uint32_t policyFlags, int32_t lastButtonState, int32_t currentButtonState) { 195 synthesizeButtonKey(context, action, when, deviceId, source, policyFlags, 196 lastButtonState, currentButtonState, 197 AMOTION_EVENT_BUTTON_BACK, AKEYCODE_BACK); 198 synthesizeButtonKey(context, action, when, deviceId, source, policyFlags, 199 lastButtonState, currentButtonState, 200 AMOTION_EVENT_BUTTON_FORWARD, AKEYCODE_FORWARD); 201} 202 203 204// --- InputReaderConfiguration --- 205 206bool InputReaderConfiguration::getDisplayInfo(int32_t displayId, bool external, 207 int32_t* width, int32_t* height, int32_t* orientation) const { 208 if (displayId == 0) { 209 const DisplayInfo& info = external ? mExternalDisplay : mInternalDisplay; 210 if (info.width > 0 && info.height > 0) { 211 if (width) { 212 *width = info.width; 213 } 214 if (height) { 215 *height = info.height; 216 } 217 if (orientation) { 218 *orientation = info.orientation; 219 } 220 return true; 221 } 222 } 223 return false; 224} 225 226void InputReaderConfiguration::setDisplayInfo(int32_t displayId, bool external, 227 int32_t width, int32_t height, int32_t orientation) { 228 if (displayId == 0) { 229 DisplayInfo& info = external ? mExternalDisplay : mInternalDisplay; 230 info.width = width; 231 info.height = height; 232 info.orientation = orientation; 233 } 234} 235 236 237// --- InputReader --- 238 239InputReader::InputReader(const sp<EventHubInterface>& eventHub, 240 const sp<InputReaderPolicyInterface>& policy, 241 const sp<InputListenerInterface>& listener) : 242 mContext(this), mEventHub(eventHub), mPolicy(policy), 243 mGlobalMetaState(0), mGeneration(1), 244 mDisableVirtualKeysTimeout(LLONG_MIN), mNextTimeout(LLONG_MAX), 245 mConfigurationChangesToRefresh(0) { 246 mQueuedListener = new QueuedInputListener(listener); 247 248 { // acquire lock 249 AutoMutex _l(mLock); 250 251 refreshConfigurationLocked(0); 252 updateGlobalMetaStateLocked(); 253 updateInputConfigurationLocked(); 254 } // release lock 255} 256 257InputReader::~InputReader() { 258 for (size_t i = 0; i < mDevices.size(); i++) { 259 delete mDevices.valueAt(i); 260 } 261} 262 263void InputReader::loopOnce() { 264 int32_t oldGeneration; 265 int32_t timeoutMillis; 266 bool inputDevicesChanged = false; 267 Vector<InputDeviceInfo> inputDevices; 268 { // acquire lock 269 AutoMutex _l(mLock); 270 271 oldGeneration = mGeneration; 272 timeoutMillis = -1; 273 274 uint32_t changes = mConfigurationChangesToRefresh; 275 if (changes) { 276 mConfigurationChangesToRefresh = 0; 277 timeoutMillis = 0; 278 refreshConfigurationLocked(changes); 279 } else if (mNextTimeout != LLONG_MAX) { 280 nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC); 281 timeoutMillis = toMillisecondTimeoutDelay(now, mNextTimeout); 282 } 283 } // release lock 284 285 size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE); 286 287 { // acquire lock 288 AutoMutex _l(mLock); 289 mReaderIsAliveCondition.broadcast(); 290 291 if (count) { 292 processEventsLocked(mEventBuffer, count); 293 } 294 295 if (mNextTimeout != LLONG_MAX) { 296 nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC); 297 if (now >= mNextTimeout) { 298#if DEBUG_RAW_EVENTS 299 ALOGD("Timeout expired, latency=%0.3fms", (now - mNextTimeout) * 0.000001f); 300#endif 301 mNextTimeout = LLONG_MAX; 302 timeoutExpiredLocked(now); 303 } 304 } 305 306 if (oldGeneration != mGeneration) { 307 inputDevicesChanged = true; 308 getInputDevicesLocked(inputDevices); 309 } 310 } // release lock 311 312 // Send out a message that the describes the changed input devices. 313 if (inputDevicesChanged) { 314 mPolicy->notifyInputDevicesChanged(inputDevices); 315 } 316 317 // Flush queued events out to the listener. 318 // This must happen outside of the lock because the listener could potentially call 319 // back into the InputReader's methods, such as getScanCodeState, or become blocked 320 // on another thread similarly waiting to acquire the InputReader lock thereby 321 // resulting in a deadlock. This situation is actually quite plausible because the 322 // listener is actually the input dispatcher, which calls into the window manager, 323 // which occasionally calls into the input reader. 324 mQueuedListener->flush(); 325} 326 327void InputReader::processEventsLocked(const RawEvent* rawEvents, size_t count) { 328 for (const RawEvent* rawEvent = rawEvents; count;) { 329 int32_t type = rawEvent->type; 330 size_t batchSize = 1; 331 if (type < EventHubInterface::FIRST_SYNTHETIC_EVENT) { 332 int32_t deviceId = rawEvent->deviceId; 333 while (batchSize < count) { 334 if (rawEvent[batchSize].type >= EventHubInterface::FIRST_SYNTHETIC_EVENT 335 || rawEvent[batchSize].deviceId != deviceId) { 336 break; 337 } 338 batchSize += 1; 339 } 340#if DEBUG_RAW_EVENTS 341 ALOGD("BatchSize: %d Count: %d", batchSize, count); 342#endif 343 processEventsForDeviceLocked(deviceId, rawEvent, batchSize); 344 } else { 345 switch (rawEvent->type) { 346 case EventHubInterface::DEVICE_ADDED: 347 addDeviceLocked(rawEvent->when, rawEvent->deviceId); 348 break; 349 case EventHubInterface::DEVICE_REMOVED: 350 removeDeviceLocked(rawEvent->when, rawEvent->deviceId); 351 break; 352 case EventHubInterface::FINISHED_DEVICE_SCAN: 353 handleConfigurationChangedLocked(rawEvent->when); 354 break; 355 default: 356 ALOG_ASSERT(false); // can't happen 357 break; 358 } 359 } 360 count -= batchSize; 361 rawEvent += batchSize; 362 } 363} 364 365void InputReader::addDeviceLocked(nsecs_t when, int32_t deviceId) { 366 ssize_t deviceIndex = mDevices.indexOfKey(deviceId); 367 if (deviceIndex >= 0) { 368 ALOGW("Ignoring spurious device added event for deviceId %d.", deviceId); 369 return; 370 } 371 372 InputDeviceIdentifier identifier = mEventHub->getDeviceIdentifier(deviceId); 373 uint32_t classes = mEventHub->getDeviceClasses(deviceId); 374 375 InputDevice* device = createDeviceLocked(deviceId, identifier, classes); 376 device->configure(when, &mConfig, 0); 377 device->reset(when); 378 379 if (device->isIgnored()) { 380 ALOGI("Device added: id=%d, name='%s' (ignored non-input device)", deviceId, 381 identifier.name.string()); 382 } else { 383 ALOGI("Device added: id=%d, name='%s', sources=0x%08x", deviceId, 384 identifier.name.string(), device->getSources()); 385 } 386 387 mDevices.add(deviceId, device); 388 bumpGenerationLocked(); 389} 390 391void InputReader::removeDeviceLocked(nsecs_t when, int32_t deviceId) { 392 InputDevice* device = NULL; 393 ssize_t deviceIndex = mDevices.indexOfKey(deviceId); 394 if (deviceIndex < 0) { 395 ALOGW("Ignoring spurious device removed event for deviceId %d.", deviceId); 396 return; 397 } 398 399 device = mDevices.valueAt(deviceIndex); 400 mDevices.removeItemsAt(deviceIndex, 1); 401 bumpGenerationLocked(); 402 403 if (device->isIgnored()) { 404 ALOGI("Device removed: id=%d, name='%s' (ignored non-input device)", 405 device->getId(), device->getName().string()); 406 } else { 407 ALOGI("Device removed: id=%d, name='%s', sources=0x%08x", 408 device->getId(), device->getName().string(), device->getSources()); 409 } 410 411 device->reset(when); 412 delete device; 413} 414 415InputDevice* InputReader::createDeviceLocked(int32_t deviceId, 416 const InputDeviceIdentifier& identifier, uint32_t classes) { 417 InputDevice* device = new InputDevice(&mContext, deviceId, bumpGenerationLocked(), 418 identifier, classes); 419 420 // External devices. 421 if (classes & INPUT_DEVICE_CLASS_EXTERNAL) { 422 device->setExternal(true); 423 } 424 425 // Switch-like devices. 426 if (classes & INPUT_DEVICE_CLASS_SWITCH) { 427 device->addMapper(new SwitchInputMapper(device)); 428 } 429 430 // Vibrator-like devices. 431 if (classes & INPUT_DEVICE_CLASS_VIBRATOR) { 432 device->addMapper(new VibratorInputMapper(device)); 433 } 434 435 // Keyboard-like devices. 436 uint32_t keyboardSource = 0; 437 int32_t keyboardType = AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC; 438 if (classes & INPUT_DEVICE_CLASS_KEYBOARD) { 439 keyboardSource |= AINPUT_SOURCE_KEYBOARD; 440 } 441 if (classes & INPUT_DEVICE_CLASS_ALPHAKEY) { 442 keyboardType = AINPUT_KEYBOARD_TYPE_ALPHABETIC; 443 } 444 if (classes & INPUT_DEVICE_CLASS_DPAD) { 445 keyboardSource |= AINPUT_SOURCE_DPAD; 446 } 447 if (classes & INPUT_DEVICE_CLASS_GAMEPAD) { 448 keyboardSource |= AINPUT_SOURCE_GAMEPAD; 449 } 450 451 if (keyboardSource != 0) { 452 device->addMapper(new KeyboardInputMapper(device, keyboardSource, keyboardType)); 453 } 454 455 // Cursor-like devices. 456 if (classes & INPUT_DEVICE_CLASS_CURSOR) { 457 device->addMapper(new CursorInputMapper(device)); 458 } 459 460 // Touchscreens and touchpad devices. 461 if (classes & INPUT_DEVICE_CLASS_TOUCH_MT) { 462 device->addMapper(new MultiTouchInputMapper(device)); 463 } else if (classes & INPUT_DEVICE_CLASS_TOUCH) { 464 device->addMapper(new SingleTouchInputMapper(device)); 465 } 466 467 // Joystick-like devices. 468 if (classes & INPUT_DEVICE_CLASS_JOYSTICK) { 469 device->addMapper(new JoystickInputMapper(device)); 470 } 471 472 return device; 473} 474 475void InputReader::processEventsForDeviceLocked(int32_t deviceId, 476 const RawEvent* rawEvents, size_t count) { 477 ssize_t deviceIndex = mDevices.indexOfKey(deviceId); 478 if (deviceIndex < 0) { 479 ALOGW("Discarding event for unknown deviceId %d.", deviceId); 480 return; 481 } 482 483 InputDevice* device = mDevices.valueAt(deviceIndex); 484 if (device->isIgnored()) { 485 //ALOGD("Discarding event for ignored deviceId %d.", deviceId); 486 return; 487 } 488 489 device->process(rawEvents, count); 490} 491 492void InputReader::timeoutExpiredLocked(nsecs_t when) { 493 for (size_t i = 0; i < mDevices.size(); i++) { 494 InputDevice* device = mDevices.valueAt(i); 495 if (!device->isIgnored()) { 496 device->timeoutExpired(when); 497 } 498 } 499} 500 501void InputReader::handleConfigurationChangedLocked(nsecs_t when) { 502 // Reset global meta state because it depends on the list of all configured devices. 503 updateGlobalMetaStateLocked(); 504 505 // Update input configuration. 506 updateInputConfigurationLocked(); 507 508 // Enqueue configuration changed. 509 NotifyConfigurationChangedArgs args(when); 510 mQueuedListener->notifyConfigurationChanged(&args); 511} 512 513void InputReader::refreshConfigurationLocked(uint32_t changes) { 514 mPolicy->getReaderConfiguration(&mConfig); 515 mEventHub->setExcludedDevices(mConfig.excludedDeviceNames); 516 517 if (changes) { 518 ALOGI("Reconfiguring input devices. changes=0x%08x", changes); 519 nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC); 520 521 if (changes & InputReaderConfiguration::CHANGE_MUST_REOPEN) { 522 mEventHub->requestReopenDevices(); 523 } else { 524 for (size_t i = 0; i < mDevices.size(); i++) { 525 InputDevice* device = mDevices.valueAt(i); 526 device->configure(now, &mConfig, changes); 527 } 528 } 529 } 530} 531 532void InputReader::updateGlobalMetaStateLocked() { 533 mGlobalMetaState = 0; 534 535 for (size_t i = 0; i < mDevices.size(); i++) { 536 InputDevice* device = mDevices.valueAt(i); 537 mGlobalMetaState |= device->getMetaState(); 538 } 539} 540 541int32_t InputReader::getGlobalMetaStateLocked() { 542 return mGlobalMetaState; 543} 544 545void InputReader::updateInputConfigurationLocked() { 546 int32_t touchScreenConfig = InputConfiguration::TOUCHSCREEN_NOTOUCH; 547 int32_t keyboardConfig = InputConfiguration::KEYBOARD_NOKEYS; 548 int32_t navigationConfig = InputConfiguration::NAVIGATION_NONAV; 549 InputDeviceInfo deviceInfo; 550 for (size_t i = 0; i < mDevices.size(); i++) { 551 InputDevice* device = mDevices.valueAt(i); 552 if (!(device->getClasses() & INPUT_DEVICE_CLASS_VIRTUAL)) { 553 device->getDeviceInfo(& deviceInfo); 554 uint32_t sources = deviceInfo.getSources(); 555 556 if ((sources & AINPUT_SOURCE_TOUCHSCREEN) == AINPUT_SOURCE_TOUCHSCREEN) { 557 touchScreenConfig = InputConfiguration::TOUCHSCREEN_FINGER; 558 } 559 if ((sources & AINPUT_SOURCE_TRACKBALL) == AINPUT_SOURCE_TRACKBALL) { 560 navigationConfig = InputConfiguration::NAVIGATION_TRACKBALL; 561 } else if ((sources & AINPUT_SOURCE_DPAD) == AINPUT_SOURCE_DPAD) { 562 navigationConfig = InputConfiguration::NAVIGATION_DPAD; 563 } 564 if (deviceInfo.getKeyboardType() == AINPUT_KEYBOARD_TYPE_ALPHABETIC) { 565 keyboardConfig = InputConfiguration::KEYBOARD_QWERTY; 566 } 567 } 568 } 569 570 mInputConfiguration.touchScreen = touchScreenConfig; 571 mInputConfiguration.keyboard = keyboardConfig; 572 mInputConfiguration.navigation = navigationConfig; 573} 574 575void InputReader::disableVirtualKeysUntilLocked(nsecs_t time) { 576 mDisableVirtualKeysTimeout = time; 577} 578 579bool InputReader::shouldDropVirtualKeyLocked(nsecs_t now, 580 InputDevice* device, int32_t keyCode, int32_t scanCode) { 581 if (now < mDisableVirtualKeysTimeout) { 582 ALOGI("Dropping virtual key from device %s because virtual keys are " 583 "temporarily disabled for the next %0.3fms. keyCode=%d, scanCode=%d", 584 device->getName().string(), 585 (mDisableVirtualKeysTimeout - now) * 0.000001, 586 keyCode, scanCode); 587 return true; 588 } else { 589 return false; 590 } 591} 592 593void InputReader::fadePointerLocked() { 594 for (size_t i = 0; i < mDevices.size(); i++) { 595 InputDevice* device = mDevices.valueAt(i); 596 device->fadePointer(); 597 } 598} 599 600void InputReader::requestTimeoutAtTimeLocked(nsecs_t when) { 601 if (when < mNextTimeout) { 602 mNextTimeout = when; 603 mEventHub->wake(); 604 } 605} 606 607int32_t InputReader::bumpGenerationLocked() { 608 return ++mGeneration; 609} 610 611void InputReader::getInputConfiguration(InputConfiguration* outConfiguration) { 612 AutoMutex _l(mLock); 613 614 *outConfiguration = mInputConfiguration; 615} 616 617void InputReader::getInputDevices(Vector<InputDeviceInfo>& outInputDevices) { 618 AutoMutex _l(mLock); 619 getInputDevicesLocked(outInputDevices); 620} 621 622void InputReader::getInputDevicesLocked(Vector<InputDeviceInfo>& outInputDevices) { 623 outInputDevices.clear(); 624 625 size_t numDevices = mDevices.size(); 626 for (size_t i = 0; i < numDevices; i++) { 627 InputDevice* device = mDevices.valueAt(i); 628 if (!device->isIgnored()) { 629 outInputDevices.push(); 630 device->getDeviceInfo(&outInputDevices.editTop()); 631 } 632 } 633} 634 635int32_t InputReader::getKeyCodeState(int32_t deviceId, uint32_t sourceMask, 636 int32_t keyCode) { 637 AutoMutex _l(mLock); 638 639 return getStateLocked(deviceId, sourceMask, keyCode, &InputDevice::getKeyCodeState); 640} 641 642int32_t InputReader::getScanCodeState(int32_t deviceId, uint32_t sourceMask, 643 int32_t scanCode) { 644 AutoMutex _l(mLock); 645 646 return getStateLocked(deviceId, sourceMask, scanCode, &InputDevice::getScanCodeState); 647} 648 649int32_t InputReader::getSwitchState(int32_t deviceId, uint32_t sourceMask, int32_t switchCode) { 650 AutoMutex _l(mLock); 651 652 return getStateLocked(deviceId, sourceMask, switchCode, &InputDevice::getSwitchState); 653} 654 655int32_t InputReader::getStateLocked(int32_t deviceId, uint32_t sourceMask, int32_t code, 656 GetStateFunc getStateFunc) { 657 int32_t result = AKEY_STATE_UNKNOWN; 658 if (deviceId >= 0) { 659 ssize_t deviceIndex = mDevices.indexOfKey(deviceId); 660 if (deviceIndex >= 0) { 661 InputDevice* device = mDevices.valueAt(deviceIndex); 662 if (! device->isIgnored() && sourcesMatchMask(device->getSources(), sourceMask)) { 663 result = (device->*getStateFunc)(sourceMask, code); 664 } 665 } 666 } else { 667 size_t numDevices = mDevices.size(); 668 for (size_t i = 0; i < numDevices; i++) { 669 InputDevice* device = mDevices.valueAt(i); 670 if (! device->isIgnored() && sourcesMatchMask(device->getSources(), sourceMask)) { 671 // If any device reports AKEY_STATE_DOWN or AKEY_STATE_VIRTUAL, return that 672 // value. Otherwise, return AKEY_STATE_UP as long as one device reports it. 673 int32_t currentResult = (device->*getStateFunc)(sourceMask, code); 674 if (currentResult >= AKEY_STATE_DOWN) { 675 return currentResult; 676 } else if (currentResult == AKEY_STATE_UP) { 677 result = currentResult; 678 } 679 } 680 } 681 } 682 return result; 683} 684 685bool InputReader::hasKeys(int32_t deviceId, uint32_t sourceMask, 686 size_t numCodes, const int32_t* keyCodes, uint8_t* outFlags) { 687 AutoMutex _l(mLock); 688 689 memset(outFlags, 0, numCodes); 690 return markSupportedKeyCodesLocked(deviceId, sourceMask, numCodes, keyCodes, outFlags); 691} 692 693bool InputReader::markSupportedKeyCodesLocked(int32_t deviceId, uint32_t sourceMask, 694 size_t numCodes, const int32_t* keyCodes, uint8_t* outFlags) { 695 bool result = false; 696 if (deviceId >= 0) { 697 ssize_t deviceIndex = mDevices.indexOfKey(deviceId); 698 if (deviceIndex >= 0) { 699 InputDevice* device = mDevices.valueAt(deviceIndex); 700 if (! device->isIgnored() && sourcesMatchMask(device->getSources(), sourceMask)) { 701 result = device->markSupportedKeyCodes(sourceMask, 702 numCodes, keyCodes, outFlags); 703 } 704 } 705 } else { 706 size_t numDevices = mDevices.size(); 707 for (size_t i = 0; i < numDevices; i++) { 708 InputDevice* device = mDevices.valueAt(i); 709 if (! device->isIgnored() && sourcesMatchMask(device->getSources(), sourceMask)) { 710 result |= device->markSupportedKeyCodes(sourceMask, 711 numCodes, keyCodes, outFlags); 712 } 713 } 714 } 715 return result; 716} 717 718void InputReader::requestRefreshConfiguration(uint32_t changes) { 719 AutoMutex _l(mLock); 720 721 if (changes) { 722 bool needWake = !mConfigurationChangesToRefresh; 723 mConfigurationChangesToRefresh |= changes; 724 725 if (needWake) { 726 mEventHub->wake(); 727 } 728 } 729} 730 731void InputReader::vibrate(int32_t deviceId, const nsecs_t* pattern, size_t patternSize, 732 ssize_t repeat, int32_t token) { 733 AutoMutex _l(mLock); 734 735 ssize_t deviceIndex = mDevices.indexOfKey(deviceId); 736 if (deviceIndex >= 0) { 737 InputDevice* device = mDevices.valueAt(deviceIndex); 738 device->vibrate(pattern, patternSize, repeat, token); 739 } 740} 741 742void InputReader::cancelVibrate(int32_t deviceId, int32_t token) { 743 AutoMutex _l(mLock); 744 745 ssize_t deviceIndex = mDevices.indexOfKey(deviceId); 746 if (deviceIndex >= 0) { 747 InputDevice* device = mDevices.valueAt(deviceIndex); 748 device->cancelVibrate(token); 749 } 750} 751 752void InputReader::dump(String8& dump) { 753 AutoMutex _l(mLock); 754 755 mEventHub->dump(dump); 756 dump.append("\n"); 757 758 dump.append("Input Reader State:\n"); 759 760 for (size_t i = 0; i < mDevices.size(); i++) { 761 mDevices.valueAt(i)->dump(dump); 762 } 763 764 dump.append(INDENT "Configuration:\n"); 765 dump.append(INDENT2 "ExcludedDeviceNames: ["); 766 for (size_t i = 0; i < mConfig.excludedDeviceNames.size(); i++) { 767 if (i != 0) { 768 dump.append(", "); 769 } 770 dump.append(mConfig.excludedDeviceNames.itemAt(i).string()); 771 } 772 dump.append("]\n"); 773 dump.appendFormat(INDENT2 "VirtualKeyQuietTime: %0.1fms\n", 774 mConfig.virtualKeyQuietTime * 0.000001f); 775 776 dump.appendFormat(INDENT2 "PointerVelocityControlParameters: " 777 "scale=%0.3f, lowThreshold=%0.3f, highThreshold=%0.3f, acceleration=%0.3f\n", 778 mConfig.pointerVelocityControlParameters.scale, 779 mConfig.pointerVelocityControlParameters.lowThreshold, 780 mConfig.pointerVelocityControlParameters.highThreshold, 781 mConfig.pointerVelocityControlParameters.acceleration); 782 783 dump.appendFormat(INDENT2 "WheelVelocityControlParameters: " 784 "scale=%0.3f, lowThreshold=%0.3f, highThreshold=%0.3f, acceleration=%0.3f\n", 785 mConfig.wheelVelocityControlParameters.scale, 786 mConfig.wheelVelocityControlParameters.lowThreshold, 787 mConfig.wheelVelocityControlParameters.highThreshold, 788 mConfig.wheelVelocityControlParameters.acceleration); 789 790 dump.appendFormat(INDENT2 "PointerGesture:\n"); 791 dump.appendFormat(INDENT3 "Enabled: %s\n", 792 toString(mConfig.pointerGesturesEnabled)); 793 dump.appendFormat(INDENT3 "QuietInterval: %0.1fms\n", 794 mConfig.pointerGestureQuietInterval * 0.000001f); 795 dump.appendFormat(INDENT3 "DragMinSwitchSpeed: %0.1fpx/s\n", 796 mConfig.pointerGestureDragMinSwitchSpeed); 797 dump.appendFormat(INDENT3 "TapInterval: %0.1fms\n", 798 mConfig.pointerGestureTapInterval * 0.000001f); 799 dump.appendFormat(INDENT3 "TapDragInterval: %0.1fms\n", 800 mConfig.pointerGestureTapDragInterval * 0.000001f); 801 dump.appendFormat(INDENT3 "TapSlop: %0.1fpx\n", 802 mConfig.pointerGestureTapSlop); 803 dump.appendFormat(INDENT3 "MultitouchSettleInterval: %0.1fms\n", 804 mConfig.pointerGestureMultitouchSettleInterval * 0.000001f); 805 dump.appendFormat(INDENT3 "MultitouchMinDistance: %0.1fpx\n", 806 mConfig.pointerGestureMultitouchMinDistance); 807 dump.appendFormat(INDENT3 "SwipeTransitionAngleCosine: %0.1f\n", 808 mConfig.pointerGestureSwipeTransitionAngleCosine); 809 dump.appendFormat(INDENT3 "SwipeMaxWidthRatio: %0.1f\n", 810 mConfig.pointerGestureSwipeMaxWidthRatio); 811 dump.appendFormat(INDENT3 "MovementSpeedRatio: %0.1f\n", 812 mConfig.pointerGestureMovementSpeedRatio); 813 dump.appendFormat(INDENT3 "ZoomSpeedRatio: %0.1f\n", 814 mConfig.pointerGestureZoomSpeedRatio); 815} 816 817void InputReader::monitor() { 818 // Acquire and release the lock to ensure that the reader has not deadlocked. 819 mLock.lock(); 820 mEventHub->wake(); 821 mReaderIsAliveCondition.wait(mLock); 822 mLock.unlock(); 823 824 // Check the EventHub 825 mEventHub->monitor(); 826} 827 828 829// --- InputReader::ContextImpl --- 830 831InputReader::ContextImpl::ContextImpl(InputReader* reader) : 832 mReader(reader) { 833} 834 835void InputReader::ContextImpl::updateGlobalMetaState() { 836 // lock is already held by the input loop 837 mReader->updateGlobalMetaStateLocked(); 838} 839 840int32_t InputReader::ContextImpl::getGlobalMetaState() { 841 // lock is already held by the input loop 842 return mReader->getGlobalMetaStateLocked(); 843} 844 845void InputReader::ContextImpl::disableVirtualKeysUntil(nsecs_t time) { 846 // lock is already held by the input loop 847 mReader->disableVirtualKeysUntilLocked(time); 848} 849 850bool InputReader::ContextImpl::shouldDropVirtualKey(nsecs_t now, 851 InputDevice* device, int32_t keyCode, int32_t scanCode) { 852 // lock is already held by the input loop 853 return mReader->shouldDropVirtualKeyLocked(now, device, keyCode, scanCode); 854} 855 856void InputReader::ContextImpl::fadePointer() { 857 // lock is already held by the input loop 858 mReader->fadePointerLocked(); 859} 860 861void InputReader::ContextImpl::requestTimeoutAtTime(nsecs_t when) { 862 // lock is already held by the input loop 863 mReader->requestTimeoutAtTimeLocked(when); 864} 865 866int32_t InputReader::ContextImpl::bumpGeneration() { 867 // lock is already held by the input loop 868 return mReader->bumpGenerationLocked(); 869} 870 871InputReaderPolicyInterface* InputReader::ContextImpl::getPolicy() { 872 return mReader->mPolicy.get(); 873} 874 875InputListenerInterface* InputReader::ContextImpl::getListener() { 876 return mReader->mQueuedListener.get(); 877} 878 879EventHubInterface* InputReader::ContextImpl::getEventHub() { 880 return mReader->mEventHub.get(); 881} 882 883 884// --- InputReaderThread --- 885 886InputReaderThread::InputReaderThread(const sp<InputReaderInterface>& reader) : 887 Thread(/*canCallJava*/ true), mReader(reader) { 888} 889 890InputReaderThread::~InputReaderThread() { 891} 892 893bool InputReaderThread::threadLoop() { 894 mReader->loopOnce(); 895 return true; 896} 897 898 899// --- InputDevice --- 900 901InputDevice::InputDevice(InputReaderContext* context, int32_t id, int32_t generation, 902 const InputDeviceIdentifier& identifier, uint32_t classes) : 903 mContext(context), mId(id), mGeneration(generation), 904 mIdentifier(identifier), mClasses(classes), 905 mSources(0), mIsExternal(false), mDropUntilNextSync(false) { 906} 907 908InputDevice::~InputDevice() { 909 size_t numMappers = mMappers.size(); 910 for (size_t i = 0; i < numMappers; i++) { 911 delete mMappers[i]; 912 } 913 mMappers.clear(); 914} 915 916void InputDevice::dump(String8& dump) { 917 InputDeviceInfo deviceInfo; 918 getDeviceInfo(& deviceInfo); 919 920 dump.appendFormat(INDENT "Device %d: %s\n", deviceInfo.getId(), 921 deviceInfo.getName().string()); 922 dump.appendFormat(INDENT2 "Generation: %d\n", mGeneration); 923 dump.appendFormat(INDENT2 "IsExternal: %s\n", toString(mIsExternal)); 924 dump.appendFormat(INDENT2 "Sources: 0x%08x\n", deviceInfo.getSources()); 925 dump.appendFormat(INDENT2 "KeyboardType: %d\n", deviceInfo.getKeyboardType()); 926 927 const Vector<InputDeviceInfo::MotionRange>& ranges = deviceInfo.getMotionRanges(); 928 if (!ranges.isEmpty()) { 929 dump.append(INDENT2 "Motion Ranges:\n"); 930 for (size_t i = 0; i < ranges.size(); i++) { 931 const InputDeviceInfo::MotionRange& range = ranges.itemAt(i); 932 const char* label = getAxisLabel(range.axis); 933 char name[32]; 934 if (label) { 935 strncpy(name, label, sizeof(name)); 936 name[sizeof(name) - 1] = '\0'; 937 } else { 938 snprintf(name, sizeof(name), "%d", range.axis); 939 } 940 dump.appendFormat(INDENT3 "%s: source=0x%08x, " 941 "min=%0.3f, max=%0.3f, flat=%0.3f, fuzz=%0.3f\n", 942 name, range.source, range.min, range.max, range.flat, range.fuzz); 943 } 944 } 945 946 size_t numMappers = mMappers.size(); 947 for (size_t i = 0; i < numMappers; i++) { 948 InputMapper* mapper = mMappers[i]; 949 mapper->dump(dump); 950 } 951} 952 953void InputDevice::addMapper(InputMapper* mapper) { 954 mMappers.add(mapper); 955} 956 957void InputDevice::configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes) { 958 mSources = 0; 959 960 if (!isIgnored()) { 961 if (!changes) { // first time only 962 mContext->getEventHub()->getConfiguration(mId, &mConfiguration); 963 } 964 965 if (!changes || (changes & InputReaderConfiguration::CHANGE_KEYBOARD_LAYOUTS)) { 966 if (!(mClasses & INPUT_DEVICE_CLASS_VIRTUAL)) { 967 sp<KeyCharacterMap> keyboardLayout = 968 mContext->getPolicy()->getKeyboardLayoutOverlay(mIdentifier.descriptor); 969 if (mContext->getEventHub()->setKeyboardLayoutOverlay(mId, keyboardLayout)) { 970 bumpGeneration(); 971 } 972 } 973 } 974 975 size_t numMappers = mMappers.size(); 976 for (size_t i = 0; i < numMappers; i++) { 977 InputMapper* mapper = mMappers[i]; 978 mapper->configure(when, config, changes); 979 mSources |= mapper->getSources(); 980 } 981 } 982} 983 984void InputDevice::reset(nsecs_t when) { 985 size_t numMappers = mMappers.size(); 986 for (size_t i = 0; i < numMappers; i++) { 987 InputMapper* mapper = mMappers[i]; 988 mapper->reset(when); 989 } 990 991 mContext->updateGlobalMetaState(); 992 993 notifyReset(when); 994} 995 996void InputDevice::process(const RawEvent* rawEvents, size_t count) { 997 // Process all of the events in order for each mapper. 998 // We cannot simply ask each mapper to process them in bulk because mappers may 999 // have side-effects that must be interleaved. For example, joystick movement events and 1000 // gamepad button presses are handled by different mappers but they should be dispatched 1001 // in the order received. 1002 size_t numMappers = mMappers.size(); 1003 for (const RawEvent* rawEvent = rawEvents; count--; rawEvent++) { 1004#if DEBUG_RAW_EVENTS 1005 ALOGD("Input event: device=%d type=0x%04x code=0x%04x value=0x%08x", 1006 rawEvent->deviceId, rawEvent->type, rawEvent->code, rawEvent->value); 1007#endif 1008 1009 if (mDropUntilNextSync) { 1010 if (rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT) { 1011 mDropUntilNextSync = false; 1012#if DEBUG_RAW_EVENTS 1013 ALOGD("Recovered from input event buffer overrun."); 1014#endif 1015 } else { 1016#if DEBUG_RAW_EVENTS 1017 ALOGD("Dropped input event while waiting for next input sync."); 1018#endif 1019 } 1020 } else if (rawEvent->type == EV_SYN && rawEvent->code == SYN_DROPPED) { 1021 ALOGI("Detected input event buffer overrun for device %s.", getName().string()); 1022 mDropUntilNextSync = true; 1023 reset(rawEvent->when); 1024 } else { 1025 for (size_t i = 0; i < numMappers; i++) { 1026 InputMapper* mapper = mMappers[i]; 1027 mapper->process(rawEvent); 1028 } 1029 } 1030 } 1031} 1032 1033void InputDevice::timeoutExpired(nsecs_t when) { 1034 size_t numMappers = mMappers.size(); 1035 for (size_t i = 0; i < numMappers; i++) { 1036 InputMapper* mapper = mMappers[i]; 1037 mapper->timeoutExpired(when); 1038 } 1039} 1040 1041void InputDevice::getDeviceInfo(InputDeviceInfo* outDeviceInfo) { 1042 outDeviceInfo->initialize(mId, mGeneration, mIdentifier.name, mIdentifier.descriptor); 1043 1044 size_t numMappers = mMappers.size(); 1045 for (size_t i = 0; i < numMappers; i++) { 1046 InputMapper* mapper = mMappers[i]; 1047 mapper->populateDeviceInfo(outDeviceInfo); 1048 } 1049} 1050 1051int32_t InputDevice::getKeyCodeState(uint32_t sourceMask, int32_t keyCode) { 1052 return getState(sourceMask, keyCode, & InputMapper::getKeyCodeState); 1053} 1054 1055int32_t InputDevice::getScanCodeState(uint32_t sourceMask, int32_t scanCode) { 1056 return getState(sourceMask, scanCode, & InputMapper::getScanCodeState); 1057} 1058 1059int32_t InputDevice::getSwitchState(uint32_t sourceMask, int32_t switchCode) { 1060 return getState(sourceMask, switchCode, & InputMapper::getSwitchState); 1061} 1062 1063int32_t InputDevice::getState(uint32_t sourceMask, int32_t code, GetStateFunc getStateFunc) { 1064 int32_t result = AKEY_STATE_UNKNOWN; 1065 size_t numMappers = mMappers.size(); 1066 for (size_t i = 0; i < numMappers; i++) { 1067 InputMapper* mapper = mMappers[i]; 1068 if (sourcesMatchMask(mapper->getSources(), sourceMask)) { 1069 // If any mapper reports AKEY_STATE_DOWN or AKEY_STATE_VIRTUAL, return that 1070 // value. Otherwise, return AKEY_STATE_UP as long as one mapper reports it. 1071 int32_t currentResult = (mapper->*getStateFunc)(sourceMask, code); 1072 if (currentResult >= AKEY_STATE_DOWN) { 1073 return currentResult; 1074 } else if (currentResult == AKEY_STATE_UP) { 1075 result = currentResult; 1076 } 1077 } 1078 } 1079 return result; 1080} 1081 1082bool InputDevice::markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes, 1083 const int32_t* keyCodes, uint8_t* outFlags) { 1084 bool result = false; 1085 size_t numMappers = mMappers.size(); 1086 for (size_t i = 0; i < numMappers; i++) { 1087 InputMapper* mapper = mMappers[i]; 1088 if (sourcesMatchMask(mapper->getSources(), sourceMask)) { 1089 result |= mapper->markSupportedKeyCodes(sourceMask, numCodes, keyCodes, outFlags); 1090 } 1091 } 1092 return result; 1093} 1094 1095void InputDevice::vibrate(const nsecs_t* pattern, size_t patternSize, ssize_t repeat, 1096 int32_t token) { 1097 size_t numMappers = mMappers.size(); 1098 for (size_t i = 0; i < numMappers; i++) { 1099 InputMapper* mapper = mMappers[i]; 1100 mapper->vibrate(pattern, patternSize, repeat, token); 1101 } 1102} 1103 1104void InputDevice::cancelVibrate(int32_t token) { 1105 size_t numMappers = mMappers.size(); 1106 for (size_t i = 0; i < numMappers; i++) { 1107 InputMapper* mapper = mMappers[i]; 1108 mapper->cancelVibrate(token); 1109 } 1110} 1111 1112int32_t InputDevice::getMetaState() { 1113 int32_t result = 0; 1114 size_t numMappers = mMappers.size(); 1115 for (size_t i = 0; i < numMappers; i++) { 1116 InputMapper* mapper = mMappers[i]; 1117 result |= mapper->getMetaState(); 1118 } 1119 return result; 1120} 1121 1122void InputDevice::fadePointer() { 1123 size_t numMappers = mMappers.size(); 1124 for (size_t i = 0; i < numMappers; i++) { 1125 InputMapper* mapper = mMappers[i]; 1126 mapper->fadePointer(); 1127 } 1128} 1129 1130void InputDevice::bumpGeneration() { 1131 mGeneration = mContext->bumpGeneration(); 1132} 1133 1134void InputDevice::notifyReset(nsecs_t when) { 1135 NotifyDeviceResetArgs args(when, mId); 1136 mContext->getListener()->notifyDeviceReset(&args); 1137} 1138 1139 1140// --- CursorButtonAccumulator --- 1141 1142CursorButtonAccumulator::CursorButtonAccumulator() { 1143 clearButtons(); 1144} 1145 1146void CursorButtonAccumulator::reset(InputDevice* device) { 1147 mBtnLeft = device->isKeyPressed(BTN_LEFT); 1148 mBtnRight = device->isKeyPressed(BTN_RIGHT); 1149 mBtnMiddle = device->isKeyPressed(BTN_MIDDLE); 1150 mBtnBack = device->isKeyPressed(BTN_BACK); 1151 mBtnSide = device->isKeyPressed(BTN_SIDE); 1152 mBtnForward = device->isKeyPressed(BTN_FORWARD); 1153 mBtnExtra = device->isKeyPressed(BTN_EXTRA); 1154 mBtnTask = device->isKeyPressed(BTN_TASK); 1155} 1156 1157void CursorButtonAccumulator::clearButtons() { 1158 mBtnLeft = 0; 1159 mBtnRight = 0; 1160 mBtnMiddle = 0; 1161 mBtnBack = 0; 1162 mBtnSide = 0; 1163 mBtnForward = 0; 1164 mBtnExtra = 0; 1165 mBtnTask = 0; 1166} 1167 1168void CursorButtonAccumulator::process(const RawEvent* rawEvent) { 1169 if (rawEvent->type == EV_KEY) { 1170 switch (rawEvent->code) { 1171 case BTN_LEFT: 1172 mBtnLeft = rawEvent->value; 1173 break; 1174 case BTN_RIGHT: 1175 mBtnRight = rawEvent->value; 1176 break; 1177 case BTN_MIDDLE: 1178 mBtnMiddle = rawEvent->value; 1179 break; 1180 case BTN_BACK: 1181 mBtnBack = rawEvent->value; 1182 break; 1183 case BTN_SIDE: 1184 mBtnSide = rawEvent->value; 1185 break; 1186 case BTN_FORWARD: 1187 mBtnForward = rawEvent->value; 1188 break; 1189 case BTN_EXTRA: 1190 mBtnExtra = rawEvent->value; 1191 break; 1192 case BTN_TASK: 1193 mBtnTask = rawEvent->value; 1194 break; 1195 } 1196 } 1197} 1198 1199uint32_t CursorButtonAccumulator::getButtonState() const { 1200 uint32_t result = 0; 1201 if (mBtnLeft) { 1202 result |= AMOTION_EVENT_BUTTON_PRIMARY; 1203 } 1204 if (mBtnRight) { 1205 result |= AMOTION_EVENT_BUTTON_SECONDARY; 1206 } 1207 if (mBtnMiddle) { 1208 result |= AMOTION_EVENT_BUTTON_TERTIARY; 1209 } 1210 if (mBtnBack || mBtnSide) { 1211 result |= AMOTION_EVENT_BUTTON_BACK; 1212 } 1213 if (mBtnForward || mBtnExtra) { 1214 result |= AMOTION_EVENT_BUTTON_FORWARD; 1215 } 1216 return result; 1217} 1218 1219 1220// --- CursorMotionAccumulator --- 1221 1222CursorMotionAccumulator::CursorMotionAccumulator() { 1223 clearRelativeAxes(); 1224} 1225 1226void CursorMotionAccumulator::reset(InputDevice* device) { 1227 clearRelativeAxes(); 1228} 1229 1230void CursorMotionAccumulator::clearRelativeAxes() { 1231 mRelX = 0; 1232 mRelY = 0; 1233} 1234 1235void CursorMotionAccumulator::process(const RawEvent* rawEvent) { 1236 if (rawEvent->type == EV_REL) { 1237 switch (rawEvent->code) { 1238 case REL_X: 1239 mRelX = rawEvent->value; 1240 break; 1241 case REL_Y: 1242 mRelY = rawEvent->value; 1243 break; 1244 } 1245 } 1246} 1247 1248void CursorMotionAccumulator::finishSync() { 1249 clearRelativeAxes(); 1250} 1251 1252 1253// --- CursorScrollAccumulator --- 1254 1255CursorScrollAccumulator::CursorScrollAccumulator() : 1256 mHaveRelWheel(false), mHaveRelHWheel(false) { 1257 clearRelativeAxes(); 1258} 1259 1260void CursorScrollAccumulator::configure(InputDevice* device) { 1261 mHaveRelWheel = device->getEventHub()->hasRelativeAxis(device->getId(), REL_WHEEL); 1262 mHaveRelHWheel = device->getEventHub()->hasRelativeAxis(device->getId(), REL_HWHEEL); 1263} 1264 1265void CursorScrollAccumulator::reset(InputDevice* device) { 1266 clearRelativeAxes(); 1267} 1268 1269void CursorScrollAccumulator::clearRelativeAxes() { 1270 mRelWheel = 0; 1271 mRelHWheel = 0; 1272} 1273 1274void CursorScrollAccumulator::process(const RawEvent* rawEvent) { 1275 if (rawEvent->type == EV_REL) { 1276 switch (rawEvent->code) { 1277 case REL_WHEEL: 1278 mRelWheel = rawEvent->value; 1279 break; 1280 case REL_HWHEEL: 1281 mRelHWheel = rawEvent->value; 1282 break; 1283 } 1284 } 1285} 1286 1287void CursorScrollAccumulator::finishSync() { 1288 clearRelativeAxes(); 1289} 1290 1291 1292// --- TouchButtonAccumulator --- 1293 1294TouchButtonAccumulator::TouchButtonAccumulator() : 1295 mHaveBtnTouch(false), mHaveStylus(false) { 1296 clearButtons(); 1297} 1298 1299void TouchButtonAccumulator::configure(InputDevice* device) { 1300 mHaveBtnTouch = device->hasKey(BTN_TOUCH); 1301 mHaveStylus = device->hasKey(BTN_TOOL_PEN) 1302 || device->hasKey(BTN_TOOL_RUBBER) 1303 || device->hasKey(BTN_TOOL_BRUSH) 1304 || device->hasKey(BTN_TOOL_PENCIL) 1305 || device->hasKey(BTN_TOOL_AIRBRUSH); 1306} 1307 1308void TouchButtonAccumulator::reset(InputDevice* device) { 1309 mBtnTouch = device->isKeyPressed(BTN_TOUCH); 1310 mBtnStylus = device->isKeyPressed(BTN_STYLUS); 1311 mBtnStylus2 = device->isKeyPressed(BTN_STYLUS); 1312 mBtnToolFinger = device->isKeyPressed(BTN_TOOL_FINGER); 1313 mBtnToolPen = device->isKeyPressed(BTN_TOOL_PEN); 1314 mBtnToolRubber = device->isKeyPressed(BTN_TOOL_RUBBER); 1315 mBtnToolBrush = device->isKeyPressed(BTN_TOOL_BRUSH); 1316 mBtnToolPencil = device->isKeyPressed(BTN_TOOL_PENCIL); 1317 mBtnToolAirbrush = device->isKeyPressed(BTN_TOOL_AIRBRUSH); 1318 mBtnToolMouse = device->isKeyPressed(BTN_TOOL_MOUSE); 1319 mBtnToolLens = device->isKeyPressed(BTN_TOOL_LENS); 1320 mBtnToolDoubleTap = device->isKeyPressed(BTN_TOOL_DOUBLETAP); 1321 mBtnToolTripleTap = device->isKeyPressed(BTN_TOOL_TRIPLETAP); 1322 mBtnToolQuadTap = device->isKeyPressed(BTN_TOOL_QUADTAP); 1323} 1324 1325void TouchButtonAccumulator::clearButtons() { 1326 mBtnTouch = 0; 1327 mBtnStylus = 0; 1328 mBtnStylus2 = 0; 1329 mBtnToolFinger = 0; 1330 mBtnToolPen = 0; 1331 mBtnToolRubber = 0; 1332 mBtnToolBrush = 0; 1333 mBtnToolPencil = 0; 1334 mBtnToolAirbrush = 0; 1335 mBtnToolMouse = 0; 1336 mBtnToolLens = 0; 1337 mBtnToolDoubleTap = 0; 1338 mBtnToolTripleTap = 0; 1339 mBtnToolQuadTap = 0; 1340} 1341 1342void TouchButtonAccumulator::process(const RawEvent* rawEvent) { 1343 if (rawEvent->type == EV_KEY) { 1344 switch (rawEvent->code) { 1345 case BTN_TOUCH: 1346 mBtnTouch = rawEvent->value; 1347 break; 1348 case BTN_STYLUS: 1349 mBtnStylus = rawEvent->value; 1350 break; 1351 case BTN_STYLUS2: 1352 mBtnStylus2 = rawEvent->value; 1353 break; 1354 case BTN_TOOL_FINGER: 1355 mBtnToolFinger = rawEvent->value; 1356 break; 1357 case BTN_TOOL_PEN: 1358 mBtnToolPen = rawEvent->value; 1359 break; 1360 case BTN_TOOL_RUBBER: 1361 mBtnToolRubber = rawEvent->value; 1362 break; 1363 case BTN_TOOL_BRUSH: 1364 mBtnToolBrush = rawEvent->value; 1365 break; 1366 case BTN_TOOL_PENCIL: 1367 mBtnToolPencil = rawEvent->value; 1368 break; 1369 case BTN_TOOL_AIRBRUSH: 1370 mBtnToolAirbrush = rawEvent->value; 1371 break; 1372 case BTN_TOOL_MOUSE: 1373 mBtnToolMouse = rawEvent->value; 1374 break; 1375 case BTN_TOOL_LENS: 1376 mBtnToolLens = rawEvent->value; 1377 break; 1378 case BTN_TOOL_DOUBLETAP: 1379 mBtnToolDoubleTap = rawEvent->value; 1380 break; 1381 case BTN_TOOL_TRIPLETAP: 1382 mBtnToolTripleTap = rawEvent->value; 1383 break; 1384 case BTN_TOOL_QUADTAP: 1385 mBtnToolQuadTap = rawEvent->value; 1386 break; 1387 } 1388 } 1389} 1390 1391uint32_t TouchButtonAccumulator::getButtonState() const { 1392 uint32_t result = 0; 1393 if (mBtnStylus) { 1394 result |= AMOTION_EVENT_BUTTON_SECONDARY; 1395 } 1396 if (mBtnStylus2) { 1397 result |= AMOTION_EVENT_BUTTON_TERTIARY; 1398 } 1399 return result; 1400} 1401 1402int32_t TouchButtonAccumulator::getToolType() const { 1403 if (mBtnToolMouse || mBtnToolLens) { 1404 return AMOTION_EVENT_TOOL_TYPE_MOUSE; 1405 } 1406 if (mBtnToolRubber) { 1407 return AMOTION_EVENT_TOOL_TYPE_ERASER; 1408 } 1409 if (mBtnToolPen || mBtnToolBrush || mBtnToolPencil || mBtnToolAirbrush) { 1410 return AMOTION_EVENT_TOOL_TYPE_STYLUS; 1411 } 1412 if (mBtnToolFinger || mBtnToolDoubleTap || mBtnToolTripleTap || mBtnToolQuadTap) { 1413 return AMOTION_EVENT_TOOL_TYPE_FINGER; 1414 } 1415 return AMOTION_EVENT_TOOL_TYPE_UNKNOWN; 1416} 1417 1418bool TouchButtonAccumulator::isToolActive() const { 1419 return mBtnTouch || mBtnToolFinger || mBtnToolPen || mBtnToolRubber 1420 || mBtnToolBrush || mBtnToolPencil || mBtnToolAirbrush 1421 || mBtnToolMouse || mBtnToolLens 1422 || mBtnToolDoubleTap || mBtnToolTripleTap || mBtnToolQuadTap; 1423} 1424 1425bool TouchButtonAccumulator::isHovering() const { 1426 return mHaveBtnTouch && !mBtnTouch; 1427} 1428 1429bool TouchButtonAccumulator::hasStylus() const { 1430 return mHaveStylus; 1431} 1432 1433 1434// --- RawPointerAxes --- 1435 1436RawPointerAxes::RawPointerAxes() { 1437 clear(); 1438} 1439 1440void RawPointerAxes::clear() { 1441 x.clear(); 1442 y.clear(); 1443 pressure.clear(); 1444 touchMajor.clear(); 1445 touchMinor.clear(); 1446 toolMajor.clear(); 1447 toolMinor.clear(); 1448 orientation.clear(); 1449 distance.clear(); 1450 tiltX.clear(); 1451 tiltY.clear(); 1452 trackingId.clear(); 1453 slot.clear(); 1454} 1455 1456 1457// --- RawPointerData --- 1458 1459RawPointerData::RawPointerData() { 1460 clear(); 1461} 1462 1463void RawPointerData::clear() { 1464 pointerCount = 0; 1465 clearIdBits(); 1466} 1467 1468void RawPointerData::copyFrom(const RawPointerData& other) { 1469 pointerCount = other.pointerCount; 1470 hoveringIdBits = other.hoveringIdBits; 1471 touchingIdBits = other.touchingIdBits; 1472 1473 for (uint32_t i = 0; i < pointerCount; i++) { 1474 pointers[i] = other.pointers[i]; 1475 1476 int id = pointers[i].id; 1477 idToIndex[id] = other.idToIndex[id]; 1478 } 1479} 1480 1481void RawPointerData::getCentroidOfTouchingPointers(float* outX, float* outY) const { 1482 float x = 0, y = 0; 1483 uint32_t count = touchingIdBits.count(); 1484 if (count) { 1485 for (BitSet32 idBits(touchingIdBits); !idBits.isEmpty(); ) { 1486 uint32_t id = idBits.clearFirstMarkedBit(); 1487 const Pointer& pointer = pointerForId(id); 1488 x += pointer.x; 1489 y += pointer.y; 1490 } 1491 x /= count; 1492 y /= count; 1493 } 1494 *outX = x; 1495 *outY = y; 1496} 1497 1498 1499// --- CookedPointerData --- 1500 1501CookedPointerData::CookedPointerData() { 1502 clear(); 1503} 1504 1505void CookedPointerData::clear() { 1506 pointerCount = 0; 1507 hoveringIdBits.clear(); 1508 touchingIdBits.clear(); 1509} 1510 1511void CookedPointerData::copyFrom(const CookedPointerData& other) { 1512 pointerCount = other.pointerCount; 1513 hoveringIdBits = other.hoveringIdBits; 1514 touchingIdBits = other.touchingIdBits; 1515 1516 for (uint32_t i = 0; i < pointerCount; i++) { 1517 pointerProperties[i].copyFrom(other.pointerProperties[i]); 1518 pointerCoords[i].copyFrom(other.pointerCoords[i]); 1519 1520 int id = pointerProperties[i].id; 1521 idToIndex[id] = other.idToIndex[id]; 1522 } 1523} 1524 1525 1526// --- SingleTouchMotionAccumulator --- 1527 1528SingleTouchMotionAccumulator::SingleTouchMotionAccumulator() { 1529 clearAbsoluteAxes(); 1530} 1531 1532void SingleTouchMotionAccumulator::reset(InputDevice* device) { 1533 mAbsX = device->getAbsoluteAxisValue(ABS_X); 1534 mAbsY = device->getAbsoluteAxisValue(ABS_Y); 1535 mAbsPressure = device->getAbsoluteAxisValue(ABS_PRESSURE); 1536 mAbsToolWidth = device->getAbsoluteAxisValue(ABS_TOOL_WIDTH); 1537 mAbsDistance = device->getAbsoluteAxisValue(ABS_DISTANCE); 1538 mAbsTiltX = device->getAbsoluteAxisValue(ABS_TILT_X); 1539 mAbsTiltY = device->getAbsoluteAxisValue(ABS_TILT_Y); 1540} 1541 1542void SingleTouchMotionAccumulator::clearAbsoluteAxes() { 1543 mAbsX = 0; 1544 mAbsY = 0; 1545 mAbsPressure = 0; 1546 mAbsToolWidth = 0; 1547 mAbsDistance = 0; 1548 mAbsTiltX = 0; 1549 mAbsTiltY = 0; 1550} 1551 1552void SingleTouchMotionAccumulator::process(const RawEvent* rawEvent) { 1553 if (rawEvent->type == EV_ABS) { 1554 switch (rawEvent->code) { 1555 case ABS_X: 1556 mAbsX = rawEvent->value; 1557 break; 1558 case ABS_Y: 1559 mAbsY = rawEvent->value; 1560 break; 1561 case ABS_PRESSURE: 1562 mAbsPressure = rawEvent->value; 1563 break; 1564 case ABS_TOOL_WIDTH: 1565 mAbsToolWidth = rawEvent->value; 1566 break; 1567 case ABS_DISTANCE: 1568 mAbsDistance = rawEvent->value; 1569 break; 1570 case ABS_TILT_X: 1571 mAbsTiltX = rawEvent->value; 1572 break; 1573 case ABS_TILT_Y: 1574 mAbsTiltY = rawEvent->value; 1575 break; 1576 } 1577 } 1578} 1579 1580 1581// --- MultiTouchMotionAccumulator --- 1582 1583MultiTouchMotionAccumulator::MultiTouchMotionAccumulator() : 1584 mCurrentSlot(-1), mSlots(NULL), mSlotCount(0), mUsingSlotsProtocol(false), 1585 mHaveStylus(false) { 1586} 1587 1588MultiTouchMotionAccumulator::~MultiTouchMotionAccumulator() { 1589 delete[] mSlots; 1590} 1591 1592void MultiTouchMotionAccumulator::configure(InputDevice* device, 1593 size_t slotCount, bool usingSlotsProtocol) { 1594 mSlotCount = slotCount; 1595 mUsingSlotsProtocol = usingSlotsProtocol; 1596 mHaveStylus = device->hasAbsoluteAxis(ABS_MT_TOOL_TYPE); 1597 1598 delete[] mSlots; 1599 mSlots = new Slot[slotCount]; 1600} 1601 1602void MultiTouchMotionAccumulator::reset(InputDevice* device) { 1603 // Unfortunately there is no way to read the initial contents of the slots. 1604 // So when we reset the accumulator, we must assume they are all zeroes. 1605 if (mUsingSlotsProtocol) { 1606 // Query the driver for the current slot index and use it as the initial slot 1607 // before we start reading events from the device. It is possible that the 1608 // current slot index will not be the same as it was when the first event was 1609 // written into the evdev buffer, which means the input mapper could start 1610 // out of sync with the initial state of the events in the evdev buffer. 1611 // In the extremely unlikely case that this happens, the data from 1612 // two slots will be confused until the next ABS_MT_SLOT event is received. 1613 // This can cause the touch point to "jump", but at least there will be 1614 // no stuck touches. 1615 int32_t initialSlot; 1616 status_t status = device->getEventHub()->getAbsoluteAxisValue(device->getId(), 1617 ABS_MT_SLOT, &initialSlot); 1618 if (status) { 1619 ALOGD("Could not retrieve current multitouch slot index. status=%d", status); 1620 initialSlot = -1; 1621 } 1622 clearSlots(initialSlot); 1623 } else { 1624 clearSlots(-1); 1625 } 1626} 1627 1628void MultiTouchMotionAccumulator::clearSlots(int32_t initialSlot) { 1629 if (mSlots) { 1630 for (size_t i = 0; i < mSlotCount; i++) { 1631 mSlots[i].clear(); 1632 } 1633 } 1634 mCurrentSlot = initialSlot; 1635} 1636 1637void MultiTouchMotionAccumulator::process(const RawEvent* rawEvent) { 1638 if (rawEvent->type == EV_ABS) { 1639 bool newSlot = false; 1640 if (mUsingSlotsProtocol) { 1641 if (rawEvent->code == ABS_MT_SLOT) { 1642 mCurrentSlot = rawEvent->value; 1643 newSlot = true; 1644 } 1645 } else if (mCurrentSlot < 0) { 1646 mCurrentSlot = 0; 1647 } 1648 1649 if (mCurrentSlot < 0 || size_t(mCurrentSlot) >= mSlotCount) { 1650#if DEBUG_POINTERS 1651 if (newSlot) { 1652 ALOGW("MultiTouch device emitted invalid slot index %d but it " 1653 "should be between 0 and %d; ignoring this slot.", 1654 mCurrentSlot, mSlotCount - 1); 1655 } 1656#endif 1657 } else { 1658 Slot* slot = &mSlots[mCurrentSlot]; 1659 1660 switch (rawEvent->code) { 1661 case ABS_MT_POSITION_X: 1662 slot->mInUse = true; 1663 slot->mAbsMTPositionX = rawEvent->value; 1664 break; 1665 case ABS_MT_POSITION_Y: 1666 slot->mInUse = true; 1667 slot->mAbsMTPositionY = rawEvent->value; 1668 break; 1669 case ABS_MT_TOUCH_MAJOR: 1670 slot->mInUse = true; 1671 slot->mAbsMTTouchMajor = rawEvent->value; 1672 break; 1673 case ABS_MT_TOUCH_MINOR: 1674 slot->mInUse = true; 1675 slot->mAbsMTTouchMinor = rawEvent->value; 1676 slot->mHaveAbsMTTouchMinor = true; 1677 break; 1678 case ABS_MT_WIDTH_MAJOR: 1679 slot->mInUse = true; 1680 slot->mAbsMTWidthMajor = rawEvent->value; 1681 break; 1682 case ABS_MT_WIDTH_MINOR: 1683 slot->mInUse = true; 1684 slot->mAbsMTWidthMinor = rawEvent->value; 1685 slot->mHaveAbsMTWidthMinor = true; 1686 break; 1687 case ABS_MT_ORIENTATION: 1688 slot->mInUse = true; 1689 slot->mAbsMTOrientation = rawEvent->value; 1690 break; 1691 case ABS_MT_TRACKING_ID: 1692 if (mUsingSlotsProtocol && rawEvent->value < 0) { 1693 // The slot is no longer in use but it retains its previous contents, 1694 // which may be reused for subsequent touches. 1695 slot->mInUse = false; 1696 } else { 1697 slot->mInUse = true; 1698 slot->mAbsMTTrackingId = rawEvent->value; 1699 } 1700 break; 1701 case ABS_MT_PRESSURE: 1702 slot->mInUse = true; 1703 slot->mAbsMTPressure = rawEvent->value; 1704 break; 1705 case ABS_MT_DISTANCE: 1706 slot->mInUse = true; 1707 slot->mAbsMTDistance = rawEvent->value; 1708 break; 1709 case ABS_MT_TOOL_TYPE: 1710 slot->mInUse = true; 1711 slot->mAbsMTToolType = rawEvent->value; 1712 slot->mHaveAbsMTToolType = true; 1713 break; 1714 } 1715 } 1716 } else if (rawEvent->type == EV_SYN && rawEvent->code == SYN_MT_REPORT) { 1717 // MultiTouch Sync: The driver has returned all data for *one* of the pointers. 1718 mCurrentSlot += 1; 1719 } 1720} 1721 1722void MultiTouchMotionAccumulator::finishSync() { 1723 if (!mUsingSlotsProtocol) { 1724 clearSlots(-1); 1725 } 1726} 1727 1728bool MultiTouchMotionAccumulator::hasStylus() const { 1729 return mHaveStylus; 1730} 1731 1732 1733// --- MultiTouchMotionAccumulator::Slot --- 1734 1735MultiTouchMotionAccumulator::Slot::Slot() { 1736 clear(); 1737} 1738 1739void MultiTouchMotionAccumulator::Slot::clear() { 1740 mInUse = false; 1741 mHaveAbsMTTouchMinor = false; 1742 mHaveAbsMTWidthMinor = false; 1743 mHaveAbsMTToolType = false; 1744 mAbsMTPositionX = 0; 1745 mAbsMTPositionY = 0; 1746 mAbsMTTouchMajor = 0; 1747 mAbsMTTouchMinor = 0; 1748 mAbsMTWidthMajor = 0; 1749 mAbsMTWidthMinor = 0; 1750 mAbsMTOrientation = 0; 1751 mAbsMTTrackingId = -1; 1752 mAbsMTPressure = 0; 1753 mAbsMTDistance = 0; 1754 mAbsMTToolType = 0; 1755} 1756 1757int32_t MultiTouchMotionAccumulator::Slot::getToolType() const { 1758 if (mHaveAbsMTToolType) { 1759 switch (mAbsMTToolType) { 1760 case MT_TOOL_FINGER: 1761 return AMOTION_EVENT_TOOL_TYPE_FINGER; 1762 case MT_TOOL_PEN: 1763 return AMOTION_EVENT_TOOL_TYPE_STYLUS; 1764 } 1765 } 1766 return AMOTION_EVENT_TOOL_TYPE_UNKNOWN; 1767} 1768 1769 1770// --- InputMapper --- 1771 1772InputMapper::InputMapper(InputDevice* device) : 1773 mDevice(device), mContext(device->getContext()) { 1774} 1775 1776InputMapper::~InputMapper() { 1777} 1778 1779void InputMapper::populateDeviceInfo(InputDeviceInfo* info) { 1780 info->addSource(getSources()); 1781} 1782 1783void InputMapper::dump(String8& dump) { 1784} 1785 1786void InputMapper::configure(nsecs_t when, 1787 const InputReaderConfiguration* config, uint32_t changes) { 1788} 1789 1790void InputMapper::reset(nsecs_t when) { 1791} 1792 1793void InputMapper::timeoutExpired(nsecs_t when) { 1794} 1795 1796int32_t InputMapper::getKeyCodeState(uint32_t sourceMask, int32_t keyCode) { 1797 return AKEY_STATE_UNKNOWN; 1798} 1799 1800int32_t InputMapper::getScanCodeState(uint32_t sourceMask, int32_t scanCode) { 1801 return AKEY_STATE_UNKNOWN; 1802} 1803 1804int32_t InputMapper::getSwitchState(uint32_t sourceMask, int32_t switchCode) { 1805 return AKEY_STATE_UNKNOWN; 1806} 1807 1808bool InputMapper::markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes, 1809 const int32_t* keyCodes, uint8_t* outFlags) { 1810 return false; 1811} 1812 1813void InputMapper::vibrate(const nsecs_t* pattern, size_t patternSize, ssize_t repeat, 1814 int32_t token) { 1815} 1816 1817void InputMapper::cancelVibrate(int32_t token) { 1818} 1819 1820int32_t InputMapper::getMetaState() { 1821 return 0; 1822} 1823 1824void InputMapper::fadePointer() { 1825} 1826 1827status_t InputMapper::getAbsoluteAxisInfo(int32_t axis, RawAbsoluteAxisInfo* axisInfo) { 1828 return getEventHub()->getAbsoluteAxisInfo(getDeviceId(), axis, axisInfo); 1829} 1830 1831void InputMapper::bumpGeneration() { 1832 mDevice->bumpGeneration(); 1833} 1834 1835void InputMapper::dumpRawAbsoluteAxisInfo(String8& dump, 1836 const RawAbsoluteAxisInfo& axis, const char* name) { 1837 if (axis.valid) { 1838 dump.appendFormat(INDENT4 "%s: min=%d, max=%d, flat=%d, fuzz=%d, resolution=%d\n", 1839 name, axis.minValue, axis.maxValue, axis.flat, axis.fuzz, axis.resolution); 1840 } else { 1841 dump.appendFormat(INDENT4 "%s: unknown range\n", name); 1842 } 1843} 1844 1845 1846// --- SwitchInputMapper --- 1847 1848SwitchInputMapper::SwitchInputMapper(InputDevice* device) : 1849 InputMapper(device) { 1850} 1851 1852SwitchInputMapper::~SwitchInputMapper() { 1853} 1854 1855uint32_t SwitchInputMapper::getSources() { 1856 return AINPUT_SOURCE_SWITCH; 1857} 1858 1859void SwitchInputMapper::process(const RawEvent* rawEvent) { 1860 switch (rawEvent->type) { 1861 case EV_SW: 1862 processSwitch(rawEvent->when, rawEvent->code, rawEvent->value); 1863 break; 1864 } 1865} 1866 1867void SwitchInputMapper::processSwitch(nsecs_t when, int32_t switchCode, int32_t switchValue) { 1868 NotifySwitchArgs args(when, 0, switchCode, switchValue); 1869 getListener()->notifySwitch(&args); 1870} 1871 1872int32_t SwitchInputMapper::getSwitchState(uint32_t sourceMask, int32_t switchCode) { 1873 return getEventHub()->getSwitchState(getDeviceId(), switchCode); 1874} 1875 1876 1877// --- VibratorInputMapper --- 1878 1879VibratorInputMapper::VibratorInputMapper(InputDevice* device) : 1880 InputMapper(device), mVibrating(false) { 1881} 1882 1883VibratorInputMapper::~VibratorInputMapper() { 1884} 1885 1886uint32_t VibratorInputMapper::getSources() { 1887 return 0; 1888} 1889 1890void VibratorInputMapper::populateDeviceInfo(InputDeviceInfo* info) { 1891 InputMapper::populateDeviceInfo(info); 1892 1893 info->setVibrator(true); 1894} 1895 1896void VibratorInputMapper::process(const RawEvent* rawEvent) { 1897 // TODO: Handle FF_STATUS, although it does not seem to be widely supported. 1898} 1899 1900void VibratorInputMapper::vibrate(const nsecs_t* pattern, size_t patternSize, ssize_t repeat, 1901 int32_t token) { 1902#if DEBUG_VIBRATOR 1903 String8 patternStr; 1904 for (size_t i = 0; i < patternSize; i++) { 1905 if (i != 0) { 1906 patternStr.append(", "); 1907 } 1908 patternStr.appendFormat("%lld", pattern[i]); 1909 } 1910 ALOGD("vibrate: deviceId=%d, pattern=[%s], repeat=%ld, token=%d", 1911 getDeviceId(), patternStr.string(), repeat, token); 1912#endif 1913 1914 mVibrating = true; 1915 memcpy(mPattern, pattern, patternSize * sizeof(nsecs_t)); 1916 mPatternSize = patternSize; 1917 mRepeat = repeat; 1918 mToken = token; 1919 mIndex = -1; 1920 1921 nextStep(); 1922} 1923 1924void VibratorInputMapper::cancelVibrate(int32_t token) { 1925#if DEBUG_VIBRATOR 1926 ALOGD("cancelVibrate: deviceId=%d, token=%d", getDeviceId(), token); 1927#endif 1928 1929 if (mVibrating && mToken == token) { 1930 stopVibrating(); 1931 } 1932} 1933 1934void VibratorInputMapper::timeoutExpired(nsecs_t when) { 1935 if (mVibrating) { 1936 if (when >= mNextStepTime) { 1937 nextStep(); 1938 } else { 1939 getContext()->requestTimeoutAtTime(mNextStepTime); 1940 } 1941 } 1942} 1943 1944void VibratorInputMapper::nextStep() { 1945 mIndex += 1; 1946 if (size_t(mIndex) >= mPatternSize) { 1947 if (mRepeat < 0) { 1948 // We are done. 1949 stopVibrating(); 1950 return; 1951 } 1952 mIndex = mRepeat; 1953 } 1954 1955 bool vibratorOn = mIndex & 1; 1956 nsecs_t duration = mPattern[mIndex]; 1957 if (vibratorOn) { 1958#if DEBUG_VIBRATOR 1959 ALOGD("nextStep: sending vibrate deviceId=%d, duration=%lld", 1960 getDeviceId(), duration); 1961#endif 1962 getEventHub()->vibrate(getDeviceId(), duration); 1963 } else { 1964#if DEBUG_VIBRATOR 1965 ALOGD("nextStep: sending cancel vibrate deviceId=%d", getDeviceId()); 1966#endif 1967 getEventHub()->cancelVibrate(getDeviceId()); 1968 } 1969 nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC); 1970 mNextStepTime = now + duration; 1971 getContext()->requestTimeoutAtTime(mNextStepTime); 1972#if DEBUG_VIBRATOR 1973 ALOGD("nextStep: scheduled timeout in %0.3fms", duration * 0.000001f); 1974#endif 1975} 1976 1977void VibratorInputMapper::stopVibrating() { 1978 mVibrating = false; 1979#if DEBUG_VIBRATOR 1980 ALOGD("stopVibrating: sending cancel vibrate deviceId=%d", getDeviceId()); 1981#endif 1982 getEventHub()->cancelVibrate(getDeviceId()); 1983} 1984 1985void VibratorInputMapper::dump(String8& dump) { 1986 dump.append(INDENT2 "Vibrator Input Mapper:\n"); 1987 dump.appendFormat(INDENT3 "Vibrating: %s\n", toString(mVibrating)); 1988} 1989 1990 1991// --- KeyboardInputMapper --- 1992 1993KeyboardInputMapper::KeyboardInputMapper(InputDevice* device, 1994 uint32_t source, int32_t keyboardType) : 1995 InputMapper(device), mSource(source), 1996 mKeyboardType(keyboardType) { 1997} 1998 1999KeyboardInputMapper::~KeyboardInputMapper() { 2000} 2001 2002uint32_t KeyboardInputMapper::getSources() { 2003 return mSource; 2004} 2005 2006void KeyboardInputMapper::populateDeviceInfo(InputDeviceInfo* info) { 2007 InputMapper::populateDeviceInfo(info); 2008 2009 info->setKeyboardType(mKeyboardType); 2010 info->setKeyCharacterMap(getEventHub()->getKeyCharacterMap(getDeviceId())); 2011} 2012 2013void KeyboardInputMapper::dump(String8& dump) { 2014 dump.append(INDENT2 "Keyboard Input Mapper:\n"); 2015 dumpParameters(dump); 2016 dump.appendFormat(INDENT3 "KeyboardType: %d\n", mKeyboardType); 2017 dump.appendFormat(INDENT3 "Orientation: %d\n", mOrientation); 2018 dump.appendFormat(INDENT3 "KeyDowns: %d keys currently down\n", mKeyDowns.size()); 2019 dump.appendFormat(INDENT3 "MetaState: 0x%0x\n", mMetaState); 2020 dump.appendFormat(INDENT3 "DownTime: %lld\n", mDownTime); 2021} 2022 2023 2024void KeyboardInputMapper::configure(nsecs_t when, 2025 const InputReaderConfiguration* config, uint32_t changes) { 2026 InputMapper::configure(when, config, changes); 2027 2028 if (!changes) { // first time only 2029 // Configure basic parameters. 2030 configureParameters(); 2031 } 2032 2033 if (!changes || (changes & InputReaderConfiguration::CHANGE_DISPLAY_INFO)) { 2034 if (mParameters.orientationAware && mParameters.associatedDisplayId >= 0) { 2035 if (!config->getDisplayInfo(mParameters.associatedDisplayId, 2036 false /*external*/, NULL, NULL, &mOrientation)) { 2037 mOrientation = DISPLAY_ORIENTATION_0; 2038 } 2039 } else { 2040 mOrientation = DISPLAY_ORIENTATION_0; 2041 } 2042 } 2043} 2044 2045void KeyboardInputMapper::configureParameters() { 2046 mParameters.orientationAware = false; 2047 getDevice()->getConfiguration().tryGetProperty(String8("keyboard.orientationAware"), 2048 mParameters.orientationAware); 2049 2050 mParameters.associatedDisplayId = -1; 2051 if (mParameters.orientationAware) { 2052 mParameters.associatedDisplayId = 0; 2053 } 2054} 2055 2056void KeyboardInputMapper::dumpParameters(String8& dump) { 2057 dump.append(INDENT3 "Parameters:\n"); 2058 dump.appendFormat(INDENT4 "AssociatedDisplayId: %d\n", 2059 mParameters.associatedDisplayId); 2060 dump.appendFormat(INDENT4 "OrientationAware: %s\n", 2061 toString(mParameters.orientationAware)); 2062} 2063 2064void KeyboardInputMapper::reset(nsecs_t when) { 2065 mMetaState = AMETA_NONE; 2066 mDownTime = 0; 2067 mKeyDowns.clear(); 2068 mCurrentHidUsage = 0; 2069 2070 resetLedState(); 2071 2072 InputMapper::reset(when); 2073} 2074 2075void KeyboardInputMapper::process(const RawEvent* rawEvent) { 2076 switch (rawEvent->type) { 2077 case EV_KEY: { 2078 int32_t scanCode = rawEvent->code; 2079 int32_t usageCode = mCurrentHidUsage; 2080 mCurrentHidUsage = 0; 2081 2082 if (isKeyboardOrGamepadKey(scanCode)) { 2083 int32_t keyCode; 2084 uint32_t flags; 2085 if (getEventHub()->mapKey(getDeviceId(), scanCode, usageCode, &keyCode, &flags)) { 2086 keyCode = AKEYCODE_UNKNOWN; 2087 flags = 0; 2088 } 2089 processKey(rawEvent->when, rawEvent->value != 0, keyCode, scanCode, flags); 2090 } 2091 break; 2092 } 2093 case EV_MSC: { 2094 if (rawEvent->code == MSC_SCAN) { 2095 mCurrentHidUsage = rawEvent->value; 2096 } 2097 break; 2098 } 2099 case EV_SYN: { 2100 if (rawEvent->code == SYN_REPORT) { 2101 mCurrentHidUsage = 0; 2102 } 2103 } 2104 } 2105} 2106 2107bool KeyboardInputMapper::isKeyboardOrGamepadKey(int32_t scanCode) { 2108 return scanCode < BTN_MOUSE 2109 || scanCode >= KEY_OK 2110 || (scanCode >= BTN_MISC && scanCode < BTN_MOUSE) 2111 || (scanCode >= BTN_JOYSTICK && scanCode < BTN_DIGI); 2112} 2113 2114void KeyboardInputMapper::processKey(nsecs_t when, bool down, int32_t keyCode, 2115 int32_t scanCode, uint32_t policyFlags) { 2116 2117 if (down) { 2118 // Rotate key codes according to orientation if needed. 2119 if (mParameters.orientationAware && mParameters.associatedDisplayId >= 0) { 2120 keyCode = rotateKeyCode(keyCode, mOrientation); 2121 } 2122 2123 // Add key down. 2124 ssize_t keyDownIndex = findKeyDown(scanCode); 2125 if (keyDownIndex >= 0) { 2126 // key repeat, be sure to use same keycode as before in case of rotation 2127 keyCode = mKeyDowns.itemAt(keyDownIndex).keyCode; 2128 } else { 2129 // key down 2130 if ((policyFlags & POLICY_FLAG_VIRTUAL) 2131 && mContext->shouldDropVirtualKey(when, 2132 getDevice(), keyCode, scanCode)) { 2133 return; 2134 } 2135 2136 mKeyDowns.push(); 2137 KeyDown& keyDown = mKeyDowns.editTop(); 2138 keyDown.keyCode = keyCode; 2139 keyDown.scanCode = scanCode; 2140 } 2141 2142 mDownTime = when; 2143 } else { 2144 // Remove key down. 2145 ssize_t keyDownIndex = findKeyDown(scanCode); 2146 if (keyDownIndex >= 0) { 2147 // key up, be sure to use same keycode as before in case of rotation 2148 keyCode = mKeyDowns.itemAt(keyDownIndex).keyCode; 2149 mKeyDowns.removeAt(size_t(keyDownIndex)); 2150 } else { 2151 // key was not actually down 2152 ALOGI("Dropping key up from device %s because the key was not down. " 2153 "keyCode=%d, scanCode=%d", 2154 getDeviceName().string(), keyCode, scanCode); 2155 return; 2156 } 2157 } 2158 2159 bool metaStateChanged = false; 2160 int32_t oldMetaState = mMetaState; 2161 int32_t newMetaState = updateMetaState(keyCode, down, oldMetaState); 2162 if (oldMetaState != newMetaState) { 2163 mMetaState = newMetaState; 2164 metaStateChanged = true; 2165 updateLedState(false); 2166 } 2167 2168 nsecs_t downTime = mDownTime; 2169 2170 // Key down on external an keyboard should wake the device. 2171 // We don't do this for internal keyboards to prevent them from waking up in your pocket. 2172 // For internal keyboards, the key layout file should specify the policy flags for 2173 // each wake key individually. 2174 // TODO: Use the input device configuration to control this behavior more finely. 2175 if (down && getDevice()->isExternal() 2176 && !(policyFlags & (POLICY_FLAG_WAKE | POLICY_FLAG_WAKE_DROPPED))) { 2177 policyFlags |= POLICY_FLAG_WAKE_DROPPED; 2178 } 2179 2180 if (metaStateChanged) { 2181 getContext()->updateGlobalMetaState(); 2182 } 2183 2184 if (down && !isMetaKey(keyCode)) { 2185 getContext()->fadePointer(); 2186 } 2187 2188 NotifyKeyArgs args(when, getDeviceId(), mSource, policyFlags, 2189 down ? AKEY_EVENT_ACTION_DOWN : AKEY_EVENT_ACTION_UP, 2190 AKEY_EVENT_FLAG_FROM_SYSTEM, keyCode, scanCode, newMetaState, downTime); 2191 getListener()->notifyKey(&args); 2192} 2193 2194ssize_t KeyboardInputMapper::findKeyDown(int32_t scanCode) { 2195 size_t n = mKeyDowns.size(); 2196 for (size_t i = 0; i < n; i++) { 2197 if (mKeyDowns[i].scanCode == scanCode) { 2198 return i; 2199 } 2200 } 2201 return -1; 2202} 2203 2204int32_t KeyboardInputMapper::getKeyCodeState(uint32_t sourceMask, int32_t keyCode) { 2205 return getEventHub()->getKeyCodeState(getDeviceId(), keyCode); 2206} 2207 2208int32_t KeyboardInputMapper::getScanCodeState(uint32_t sourceMask, int32_t scanCode) { 2209 return getEventHub()->getScanCodeState(getDeviceId(), scanCode); 2210} 2211 2212bool KeyboardInputMapper::markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes, 2213 const int32_t* keyCodes, uint8_t* outFlags) { 2214 return getEventHub()->markSupportedKeyCodes(getDeviceId(), numCodes, keyCodes, outFlags); 2215} 2216 2217int32_t KeyboardInputMapper::getMetaState() { 2218 return mMetaState; 2219} 2220 2221void KeyboardInputMapper::resetLedState() { 2222 initializeLedState(mCapsLockLedState, LED_CAPSL); 2223 initializeLedState(mNumLockLedState, LED_NUML); 2224 initializeLedState(mScrollLockLedState, LED_SCROLLL); 2225 2226 updateLedState(true); 2227} 2228 2229void KeyboardInputMapper::initializeLedState(LedState& ledState, int32_t led) { 2230 ledState.avail = getEventHub()->hasLed(getDeviceId(), led); 2231 ledState.on = false; 2232} 2233 2234void KeyboardInputMapper::updateLedState(bool reset) { 2235 updateLedStateForModifier(mCapsLockLedState, LED_CAPSL, 2236 AMETA_CAPS_LOCK_ON, reset); 2237 updateLedStateForModifier(mNumLockLedState, LED_NUML, 2238 AMETA_NUM_LOCK_ON, reset); 2239 updateLedStateForModifier(mScrollLockLedState, LED_SCROLLL, 2240 AMETA_SCROLL_LOCK_ON, reset); 2241} 2242 2243void KeyboardInputMapper::updateLedStateForModifier(LedState& ledState, 2244 int32_t led, int32_t modifier, bool reset) { 2245 if (ledState.avail) { 2246 bool desiredState = (mMetaState & modifier) != 0; 2247 if (reset || ledState.on != desiredState) { 2248 getEventHub()->setLedState(getDeviceId(), led, desiredState); 2249 ledState.on = desiredState; 2250 } 2251 } 2252} 2253 2254 2255// --- CursorInputMapper --- 2256 2257CursorInputMapper::CursorInputMapper(InputDevice* device) : 2258 InputMapper(device) { 2259} 2260 2261CursorInputMapper::~CursorInputMapper() { 2262} 2263 2264uint32_t CursorInputMapper::getSources() { 2265 return mSource; 2266} 2267 2268void CursorInputMapper::populateDeviceInfo(InputDeviceInfo* info) { 2269 InputMapper::populateDeviceInfo(info); 2270 2271 if (mParameters.mode == Parameters::MODE_POINTER) { 2272 float minX, minY, maxX, maxY; 2273 if (mPointerController->getBounds(&minX, &minY, &maxX, &maxY)) { 2274 info->addMotionRange(AMOTION_EVENT_AXIS_X, mSource, minX, maxX, 0.0f, 0.0f); 2275 info->addMotionRange(AMOTION_EVENT_AXIS_Y, mSource, minY, maxY, 0.0f, 0.0f); 2276 } 2277 } else { 2278 info->addMotionRange(AMOTION_EVENT_AXIS_X, mSource, -1.0f, 1.0f, 0.0f, mXScale); 2279 info->addMotionRange(AMOTION_EVENT_AXIS_Y, mSource, -1.0f, 1.0f, 0.0f, mYScale); 2280 } 2281 info->addMotionRange(AMOTION_EVENT_AXIS_PRESSURE, mSource, 0.0f, 1.0f, 0.0f, 0.0f); 2282 2283 if (mCursorScrollAccumulator.haveRelativeVWheel()) { 2284 info->addMotionRange(AMOTION_EVENT_AXIS_VSCROLL, mSource, -1.0f, 1.0f, 0.0f, 0.0f); 2285 } 2286 if (mCursorScrollAccumulator.haveRelativeHWheel()) { 2287 info->addMotionRange(AMOTION_EVENT_AXIS_HSCROLL, mSource, -1.0f, 1.0f, 0.0f, 0.0f); 2288 } 2289} 2290 2291void CursorInputMapper::dump(String8& dump) { 2292 dump.append(INDENT2 "Cursor Input Mapper:\n"); 2293 dumpParameters(dump); 2294 dump.appendFormat(INDENT3 "XScale: %0.3f\n", mXScale); 2295 dump.appendFormat(INDENT3 "YScale: %0.3f\n", mYScale); 2296 dump.appendFormat(INDENT3 "XPrecision: %0.3f\n", mXPrecision); 2297 dump.appendFormat(INDENT3 "YPrecision: %0.3f\n", mYPrecision); 2298 dump.appendFormat(INDENT3 "HaveVWheel: %s\n", 2299 toString(mCursorScrollAccumulator.haveRelativeVWheel())); 2300 dump.appendFormat(INDENT3 "HaveHWheel: %s\n", 2301 toString(mCursorScrollAccumulator.haveRelativeHWheel())); 2302 dump.appendFormat(INDENT3 "VWheelScale: %0.3f\n", mVWheelScale); 2303 dump.appendFormat(INDENT3 "HWheelScale: %0.3f\n", mHWheelScale); 2304 dump.appendFormat(INDENT3 "Orientation: %d\n", mOrientation); 2305 dump.appendFormat(INDENT3 "ButtonState: 0x%08x\n", mButtonState); 2306 dump.appendFormat(INDENT3 "Down: %s\n", toString(isPointerDown(mButtonState))); 2307 dump.appendFormat(INDENT3 "DownTime: %lld\n", mDownTime); 2308} 2309 2310void CursorInputMapper::configure(nsecs_t when, 2311 const InputReaderConfiguration* config, uint32_t changes) { 2312 InputMapper::configure(when, config, changes); 2313 2314 if (!changes) { // first time only 2315 mCursorScrollAccumulator.configure(getDevice()); 2316 2317 // Configure basic parameters. 2318 configureParameters(); 2319 2320 // Configure device mode. 2321 switch (mParameters.mode) { 2322 case Parameters::MODE_POINTER: 2323 mSource = AINPUT_SOURCE_MOUSE; 2324 mXPrecision = 1.0f; 2325 mYPrecision = 1.0f; 2326 mXScale = 1.0f; 2327 mYScale = 1.0f; 2328 mPointerController = getPolicy()->obtainPointerController(getDeviceId()); 2329 break; 2330 case Parameters::MODE_NAVIGATION: 2331 mSource = AINPUT_SOURCE_TRACKBALL; 2332 mXPrecision = TRACKBALL_MOVEMENT_THRESHOLD; 2333 mYPrecision = TRACKBALL_MOVEMENT_THRESHOLD; 2334 mXScale = 1.0f / TRACKBALL_MOVEMENT_THRESHOLD; 2335 mYScale = 1.0f / TRACKBALL_MOVEMENT_THRESHOLD; 2336 break; 2337 } 2338 2339 mVWheelScale = 1.0f; 2340 mHWheelScale = 1.0f; 2341 } 2342 2343 if (!changes || (changes & InputReaderConfiguration::CHANGE_POINTER_SPEED)) { 2344 mPointerVelocityControl.setParameters(config->pointerVelocityControlParameters); 2345 mWheelXVelocityControl.setParameters(config->wheelVelocityControlParameters); 2346 mWheelYVelocityControl.setParameters(config->wheelVelocityControlParameters); 2347 } 2348 2349 if (!changes || (changes & InputReaderConfiguration::CHANGE_DISPLAY_INFO)) { 2350 if (mParameters.orientationAware && mParameters.associatedDisplayId >= 0) { 2351 if (!config->getDisplayInfo(mParameters.associatedDisplayId, 2352 false /*external*/, NULL, NULL, &mOrientation)) { 2353 mOrientation = DISPLAY_ORIENTATION_0; 2354 } 2355 } else { 2356 mOrientation = DISPLAY_ORIENTATION_0; 2357 } 2358 bumpGeneration(); 2359 } 2360} 2361 2362void CursorInputMapper::configureParameters() { 2363 mParameters.mode = Parameters::MODE_POINTER; 2364 String8 cursorModeString; 2365 if (getDevice()->getConfiguration().tryGetProperty(String8("cursor.mode"), cursorModeString)) { 2366 if (cursorModeString == "navigation") { 2367 mParameters.mode = Parameters::MODE_NAVIGATION; 2368 } else if (cursorModeString != "pointer" && cursorModeString != "default") { 2369 ALOGW("Invalid value for cursor.mode: '%s'", cursorModeString.string()); 2370 } 2371 } 2372 2373 mParameters.orientationAware = false; 2374 getDevice()->getConfiguration().tryGetProperty(String8("cursor.orientationAware"), 2375 mParameters.orientationAware); 2376 2377 mParameters.associatedDisplayId = -1; 2378 if (mParameters.mode == Parameters::MODE_POINTER || mParameters.orientationAware) { 2379 mParameters.associatedDisplayId = 0; 2380 } 2381} 2382 2383void CursorInputMapper::dumpParameters(String8& dump) { 2384 dump.append(INDENT3 "Parameters:\n"); 2385 dump.appendFormat(INDENT4 "AssociatedDisplayId: %d\n", 2386 mParameters.associatedDisplayId); 2387 2388 switch (mParameters.mode) { 2389 case Parameters::MODE_POINTER: 2390 dump.append(INDENT4 "Mode: pointer\n"); 2391 break; 2392 case Parameters::MODE_NAVIGATION: 2393 dump.append(INDENT4 "Mode: navigation\n"); 2394 break; 2395 default: 2396 ALOG_ASSERT(false); 2397 } 2398 2399 dump.appendFormat(INDENT4 "OrientationAware: %s\n", 2400 toString(mParameters.orientationAware)); 2401} 2402 2403void CursorInputMapper::reset(nsecs_t when) { 2404 mButtonState = 0; 2405 mDownTime = 0; 2406 2407 mPointerVelocityControl.reset(); 2408 mWheelXVelocityControl.reset(); 2409 mWheelYVelocityControl.reset(); 2410 2411 mCursorButtonAccumulator.reset(getDevice()); 2412 mCursorMotionAccumulator.reset(getDevice()); 2413 mCursorScrollAccumulator.reset(getDevice()); 2414 2415 InputMapper::reset(when); 2416} 2417 2418void CursorInputMapper::process(const RawEvent* rawEvent) { 2419 mCursorButtonAccumulator.process(rawEvent); 2420 mCursorMotionAccumulator.process(rawEvent); 2421 mCursorScrollAccumulator.process(rawEvent); 2422 2423 if (rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT) { 2424 sync(rawEvent->when); 2425 } 2426} 2427 2428void CursorInputMapper::sync(nsecs_t when) { 2429 int32_t lastButtonState = mButtonState; 2430 int32_t currentButtonState = mCursorButtonAccumulator.getButtonState(); 2431 mButtonState = currentButtonState; 2432 2433 bool wasDown = isPointerDown(lastButtonState); 2434 bool down = isPointerDown(currentButtonState); 2435 bool downChanged; 2436 if (!wasDown && down) { 2437 mDownTime = when; 2438 downChanged = true; 2439 } else if (wasDown && !down) { 2440 downChanged = true; 2441 } else { 2442 downChanged = false; 2443 } 2444 nsecs_t downTime = mDownTime; 2445 bool buttonsChanged = currentButtonState != lastButtonState; 2446 bool buttonsPressed = currentButtonState & ~lastButtonState; 2447 2448 float deltaX = mCursorMotionAccumulator.getRelativeX() * mXScale; 2449 float deltaY = mCursorMotionAccumulator.getRelativeY() * mYScale; 2450 bool moved = deltaX != 0 || deltaY != 0; 2451 2452 // Rotate delta according to orientation if needed. 2453 if (mParameters.orientationAware && mParameters.associatedDisplayId >= 0 2454 && (deltaX != 0.0f || deltaY != 0.0f)) { 2455 rotateDelta(mOrientation, &deltaX, &deltaY); 2456 } 2457 2458 // Move the pointer. 2459 PointerProperties pointerProperties; 2460 pointerProperties.clear(); 2461 pointerProperties.id = 0; 2462 pointerProperties.toolType = AMOTION_EVENT_TOOL_TYPE_MOUSE; 2463 2464 PointerCoords pointerCoords; 2465 pointerCoords.clear(); 2466 2467 float vscroll = mCursorScrollAccumulator.getRelativeVWheel(); 2468 float hscroll = mCursorScrollAccumulator.getRelativeHWheel(); 2469 bool scrolled = vscroll != 0 || hscroll != 0; 2470 2471 mWheelYVelocityControl.move(when, NULL, &vscroll); 2472 mWheelXVelocityControl.move(when, &hscroll, NULL); 2473 2474 mPointerVelocityControl.move(when, &deltaX, &deltaY); 2475 2476 if (mPointerController != NULL) { 2477 if (moved || scrolled || buttonsChanged) { 2478 mPointerController->setPresentation( 2479 PointerControllerInterface::PRESENTATION_POINTER); 2480 2481 if (moved) { 2482 mPointerController->move(deltaX, deltaY); 2483 } 2484 2485 if (buttonsChanged) { 2486 mPointerController->setButtonState(currentButtonState); 2487 } 2488 2489 mPointerController->unfade(PointerControllerInterface::TRANSITION_IMMEDIATE); 2490 } 2491 2492 float x, y; 2493 mPointerController->getPosition(&x, &y); 2494 pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_X, x); 2495 pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_Y, y); 2496 } else { 2497 pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_X, deltaX); 2498 pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_Y, deltaY); 2499 } 2500 2501 pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, down ? 1.0f : 0.0f); 2502 2503 // Moving an external trackball or mouse should wake the device. 2504 // We don't do this for internal cursor devices to prevent them from waking up 2505 // the device in your pocket. 2506 // TODO: Use the input device configuration to control this behavior more finely. 2507 uint32_t policyFlags = 0; 2508 if ((buttonsPressed || moved || scrolled) && getDevice()->isExternal()) { 2509 policyFlags |= POLICY_FLAG_WAKE_DROPPED; 2510 } 2511 2512 // Synthesize key down from buttons if needed. 2513 synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_DOWN, when, getDeviceId(), mSource, 2514 policyFlags, lastButtonState, currentButtonState); 2515 2516 // Send motion event. 2517 if (downChanged || moved || scrolled || buttonsChanged) { 2518 int32_t metaState = mContext->getGlobalMetaState(); 2519 int32_t motionEventAction; 2520 if (downChanged) { 2521 motionEventAction = down ? AMOTION_EVENT_ACTION_DOWN : AMOTION_EVENT_ACTION_UP; 2522 } else if (down || mPointerController == NULL) { 2523 motionEventAction = AMOTION_EVENT_ACTION_MOVE; 2524 } else { 2525 motionEventAction = AMOTION_EVENT_ACTION_HOVER_MOVE; 2526 } 2527 2528 NotifyMotionArgs args(when, getDeviceId(), mSource, policyFlags, 2529 motionEventAction, 0, metaState, currentButtonState, 0, 2530 1, &pointerProperties, &pointerCoords, mXPrecision, mYPrecision, downTime); 2531 getListener()->notifyMotion(&args); 2532 2533 // Send hover move after UP to tell the application that the mouse is hovering now. 2534 if (motionEventAction == AMOTION_EVENT_ACTION_UP 2535 && mPointerController != NULL) { 2536 NotifyMotionArgs hoverArgs(when, getDeviceId(), mSource, policyFlags, 2537 AMOTION_EVENT_ACTION_HOVER_MOVE, 0, 2538 metaState, currentButtonState, AMOTION_EVENT_EDGE_FLAG_NONE, 2539 1, &pointerProperties, &pointerCoords, mXPrecision, mYPrecision, downTime); 2540 getListener()->notifyMotion(&hoverArgs); 2541 } 2542 2543 // Send scroll events. 2544 if (scrolled) { 2545 pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_VSCROLL, vscroll); 2546 pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_HSCROLL, hscroll); 2547 2548 NotifyMotionArgs scrollArgs(when, getDeviceId(), mSource, policyFlags, 2549 AMOTION_EVENT_ACTION_SCROLL, 0, metaState, currentButtonState, 2550 AMOTION_EVENT_EDGE_FLAG_NONE, 2551 1, &pointerProperties, &pointerCoords, mXPrecision, mYPrecision, downTime); 2552 getListener()->notifyMotion(&scrollArgs); 2553 } 2554 } 2555 2556 // Synthesize key up from buttons if needed. 2557 synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_UP, when, getDeviceId(), mSource, 2558 policyFlags, lastButtonState, currentButtonState); 2559 2560 mCursorMotionAccumulator.finishSync(); 2561 mCursorScrollAccumulator.finishSync(); 2562} 2563 2564int32_t CursorInputMapper::getScanCodeState(uint32_t sourceMask, int32_t scanCode) { 2565 if (scanCode >= BTN_MOUSE && scanCode < BTN_JOYSTICK) { 2566 return getEventHub()->getScanCodeState(getDeviceId(), scanCode); 2567 } else { 2568 return AKEY_STATE_UNKNOWN; 2569 } 2570} 2571 2572void CursorInputMapper::fadePointer() { 2573 if (mPointerController != NULL) { 2574 mPointerController->fade(PointerControllerInterface::TRANSITION_GRADUAL); 2575 } 2576} 2577 2578 2579// --- TouchInputMapper --- 2580 2581TouchInputMapper::TouchInputMapper(InputDevice* device) : 2582 InputMapper(device), 2583 mSource(0), mDeviceMode(DEVICE_MODE_DISABLED), 2584 mSurfaceOrientation(-1), mSurfaceWidth(-1), mSurfaceHeight(-1) { 2585} 2586 2587TouchInputMapper::~TouchInputMapper() { 2588} 2589 2590uint32_t TouchInputMapper::getSources() { 2591 return mSource; 2592} 2593 2594void TouchInputMapper::populateDeviceInfo(InputDeviceInfo* info) { 2595 InputMapper::populateDeviceInfo(info); 2596 2597 if (mDeviceMode != DEVICE_MODE_DISABLED) { 2598 info->addMotionRange(mOrientedRanges.x); 2599 info->addMotionRange(mOrientedRanges.y); 2600 info->addMotionRange(mOrientedRanges.pressure); 2601 2602 if (mOrientedRanges.haveSize) { 2603 info->addMotionRange(mOrientedRanges.size); 2604 } 2605 2606 if (mOrientedRanges.haveTouchSize) { 2607 info->addMotionRange(mOrientedRanges.touchMajor); 2608 info->addMotionRange(mOrientedRanges.touchMinor); 2609 } 2610 2611 if (mOrientedRanges.haveToolSize) { 2612 info->addMotionRange(mOrientedRanges.toolMajor); 2613 info->addMotionRange(mOrientedRanges.toolMinor); 2614 } 2615 2616 if (mOrientedRanges.haveOrientation) { 2617 info->addMotionRange(mOrientedRanges.orientation); 2618 } 2619 2620 if (mOrientedRanges.haveDistance) { 2621 info->addMotionRange(mOrientedRanges.distance); 2622 } 2623 2624 if (mOrientedRanges.haveTilt) { 2625 info->addMotionRange(mOrientedRanges.tilt); 2626 } 2627 2628 if (mCursorScrollAccumulator.haveRelativeVWheel()) { 2629 info->addMotionRange(AMOTION_EVENT_AXIS_VSCROLL, mSource, -1.0f, 1.0f, 0.0f, 0.0f); 2630 } 2631 if (mCursorScrollAccumulator.haveRelativeHWheel()) { 2632 info->addMotionRange(AMOTION_EVENT_AXIS_HSCROLL, mSource, -1.0f, 1.0f, 0.0f, 0.0f); 2633 } 2634 } 2635} 2636 2637void TouchInputMapper::dump(String8& dump) { 2638 dump.append(INDENT2 "Touch Input Mapper:\n"); 2639 dumpParameters(dump); 2640 dumpVirtualKeys(dump); 2641 dumpRawPointerAxes(dump); 2642 dumpCalibration(dump); 2643 dumpSurface(dump); 2644 2645 dump.appendFormat(INDENT3 "Translation and Scaling Factors:\n"); 2646 dump.appendFormat(INDENT4 "XScale: %0.3f\n", mXScale); 2647 dump.appendFormat(INDENT4 "YScale: %0.3f\n", mYScale); 2648 dump.appendFormat(INDENT4 "XPrecision: %0.3f\n", mXPrecision); 2649 dump.appendFormat(INDENT4 "YPrecision: %0.3f\n", mYPrecision); 2650 dump.appendFormat(INDENT4 "GeometricScale: %0.3f\n", mGeometricScale); 2651 dump.appendFormat(INDENT4 "PressureScale: %0.3f\n", mPressureScale); 2652 dump.appendFormat(INDENT4 "SizeScale: %0.3f\n", mSizeScale); 2653 dump.appendFormat(INDENT4 "OrientationCenter: %0.3f\n", mOrientationCenter); 2654 dump.appendFormat(INDENT4 "OrientationScale: %0.3f\n", mOrientationScale); 2655 dump.appendFormat(INDENT4 "DistanceScale: %0.3f\n", mDistanceScale); 2656 dump.appendFormat(INDENT4 "HaveTilt: %s\n", toString(mHaveTilt)); 2657 dump.appendFormat(INDENT4 "TiltXCenter: %0.3f\n", mTiltXCenter); 2658 dump.appendFormat(INDENT4 "TiltXScale: %0.3f\n", mTiltXScale); 2659 dump.appendFormat(INDENT4 "TiltYCenter: %0.3f\n", mTiltYCenter); 2660 dump.appendFormat(INDENT4 "TiltYScale: %0.3f\n", mTiltYScale); 2661 2662 dump.appendFormat(INDENT3 "Last Button State: 0x%08x\n", mLastButtonState); 2663 2664 dump.appendFormat(INDENT3 "Last Raw Touch: pointerCount=%d\n", 2665 mLastRawPointerData.pointerCount); 2666 for (uint32_t i = 0; i < mLastRawPointerData.pointerCount; i++) { 2667 const RawPointerData::Pointer& pointer = mLastRawPointerData.pointers[i]; 2668 dump.appendFormat(INDENT4 "[%d]: id=%d, x=%d, y=%d, pressure=%d, " 2669 "touchMajor=%d, touchMinor=%d, toolMajor=%d, toolMinor=%d, " 2670 "orientation=%d, tiltX=%d, tiltY=%d, distance=%d, " 2671 "toolType=%d, isHovering=%s\n", i, 2672 pointer.id, pointer.x, pointer.y, pointer.pressure, 2673 pointer.touchMajor, pointer.touchMinor, 2674 pointer.toolMajor, pointer.toolMinor, 2675 pointer.orientation, pointer.tiltX, pointer.tiltY, pointer.distance, 2676 pointer.toolType, toString(pointer.isHovering)); 2677 } 2678 2679 dump.appendFormat(INDENT3 "Last Cooked Touch: pointerCount=%d\n", 2680 mLastCookedPointerData.pointerCount); 2681 for (uint32_t i = 0; i < mLastCookedPointerData.pointerCount; i++) { 2682 const PointerProperties& pointerProperties = mLastCookedPointerData.pointerProperties[i]; 2683 const PointerCoords& pointerCoords = mLastCookedPointerData.pointerCoords[i]; 2684 dump.appendFormat(INDENT4 "[%d]: id=%d, x=%0.3f, y=%0.3f, pressure=%0.3f, " 2685 "touchMajor=%0.3f, touchMinor=%0.3f, toolMajor=%0.3f, toolMinor=%0.3f, " 2686 "orientation=%0.3f, tilt=%0.3f, distance=%0.3f, " 2687 "toolType=%d, isHovering=%s\n", i, 2688 pointerProperties.id, 2689 pointerCoords.getX(), 2690 pointerCoords.getY(), 2691 pointerCoords.getAxisValue(AMOTION_EVENT_AXIS_PRESSURE), 2692 pointerCoords.getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR), 2693 pointerCoords.getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR), 2694 pointerCoords.getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR), 2695 pointerCoords.getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR), 2696 pointerCoords.getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION), 2697 pointerCoords.getAxisValue(AMOTION_EVENT_AXIS_TILT), 2698 pointerCoords.getAxisValue(AMOTION_EVENT_AXIS_DISTANCE), 2699 pointerProperties.toolType, 2700 toString(mLastCookedPointerData.isHovering(i))); 2701 } 2702 2703 if (mDeviceMode == DEVICE_MODE_POINTER) { 2704 dump.appendFormat(INDENT3 "Pointer Gesture Detector:\n"); 2705 dump.appendFormat(INDENT4 "XMovementScale: %0.3f\n", 2706 mPointerXMovementScale); 2707 dump.appendFormat(INDENT4 "YMovementScale: %0.3f\n", 2708 mPointerYMovementScale); 2709 dump.appendFormat(INDENT4 "XZoomScale: %0.3f\n", 2710 mPointerXZoomScale); 2711 dump.appendFormat(INDENT4 "YZoomScale: %0.3f\n", 2712 mPointerYZoomScale); 2713 dump.appendFormat(INDENT4 "MaxSwipeWidth: %f\n", 2714 mPointerGestureMaxSwipeWidth); 2715 } 2716} 2717 2718void TouchInputMapper::configure(nsecs_t when, 2719 const InputReaderConfiguration* config, uint32_t changes) { 2720 InputMapper::configure(when, config, changes); 2721 2722 mConfig = *config; 2723 2724 if (!changes) { // first time only 2725 // Configure basic parameters. 2726 configureParameters(); 2727 2728 // Configure common accumulators. 2729 mCursorScrollAccumulator.configure(getDevice()); 2730 mTouchButtonAccumulator.configure(getDevice()); 2731 2732 // Configure absolute axis information. 2733 configureRawPointerAxes(); 2734 2735 // Prepare input device calibration. 2736 parseCalibration(); 2737 resolveCalibration(); 2738 } 2739 2740 if (!changes || (changes & InputReaderConfiguration::CHANGE_POINTER_SPEED)) { 2741 // Update pointer speed. 2742 mPointerVelocityControl.setParameters(mConfig.pointerVelocityControlParameters); 2743 mWheelXVelocityControl.setParameters(mConfig.wheelVelocityControlParameters); 2744 mWheelYVelocityControl.setParameters(mConfig.wheelVelocityControlParameters); 2745 } 2746 2747 bool resetNeeded = false; 2748 if (!changes || (changes & (InputReaderConfiguration::CHANGE_DISPLAY_INFO 2749 | InputReaderConfiguration::CHANGE_POINTER_GESTURE_ENABLEMENT 2750 | InputReaderConfiguration::CHANGE_SHOW_TOUCHES))) { 2751 // Configure device sources, surface dimensions, orientation and 2752 // scaling factors. 2753 configureSurface(when, &resetNeeded); 2754 } 2755 2756 if (changes && resetNeeded) { 2757 // Send reset, unless this is the first time the device has been configured, 2758 // in which case the reader will call reset itself after all mappers are ready. 2759 getDevice()->notifyReset(when); 2760 } 2761} 2762 2763void TouchInputMapper::configureParameters() { 2764 // Use the pointer presentation mode for devices that do not support distinct 2765 // multitouch. The spot-based presentation relies on being able to accurately 2766 // locate two or more fingers on the touch pad. 2767 mParameters.gestureMode = getEventHub()->hasInputProperty(getDeviceId(), INPUT_PROP_SEMI_MT) 2768 ? Parameters::GESTURE_MODE_POINTER : Parameters::GESTURE_MODE_SPOTS; 2769 2770 String8 gestureModeString; 2771 if (getDevice()->getConfiguration().tryGetProperty(String8("touch.gestureMode"), 2772 gestureModeString)) { 2773 if (gestureModeString == "pointer") { 2774 mParameters.gestureMode = Parameters::GESTURE_MODE_POINTER; 2775 } else if (gestureModeString == "spots") { 2776 mParameters.gestureMode = Parameters::GESTURE_MODE_SPOTS; 2777 } else if (gestureModeString != "default") { 2778 ALOGW("Invalid value for touch.gestureMode: '%s'", gestureModeString.string()); 2779 } 2780 } 2781 2782 if (getEventHub()->hasInputProperty(getDeviceId(), INPUT_PROP_DIRECT)) { 2783 // The device is a touch screen. 2784 mParameters.deviceType = Parameters::DEVICE_TYPE_TOUCH_SCREEN; 2785 } else if (getEventHub()->hasInputProperty(getDeviceId(), INPUT_PROP_POINTER)) { 2786 // The device is a pointing device like a track pad. 2787 mParameters.deviceType = Parameters::DEVICE_TYPE_POINTER; 2788 } else if (getEventHub()->hasRelativeAxis(getDeviceId(), REL_X) 2789 || getEventHub()->hasRelativeAxis(getDeviceId(), REL_Y)) { 2790 // The device is a cursor device with a touch pad attached. 2791 // By default don't use the touch pad to move the pointer. 2792 mParameters.deviceType = Parameters::DEVICE_TYPE_TOUCH_PAD; 2793 } else { 2794 // The device is a touch pad of unknown purpose. 2795 mParameters.deviceType = Parameters::DEVICE_TYPE_POINTER; 2796 } 2797 2798 String8 deviceTypeString; 2799 if (getDevice()->getConfiguration().tryGetProperty(String8("touch.deviceType"), 2800 deviceTypeString)) { 2801 if (deviceTypeString == "touchScreen") { 2802 mParameters.deviceType = Parameters::DEVICE_TYPE_TOUCH_SCREEN; 2803 } else if (deviceTypeString == "touchPad") { 2804 mParameters.deviceType = Parameters::DEVICE_TYPE_TOUCH_PAD; 2805 } else if (deviceTypeString == "pointer") { 2806 mParameters.deviceType = Parameters::DEVICE_TYPE_POINTER; 2807 } else if (deviceTypeString != "default") { 2808 ALOGW("Invalid value for touch.deviceType: '%s'", deviceTypeString.string()); 2809 } 2810 } 2811 2812 mParameters.orientationAware = mParameters.deviceType == Parameters::DEVICE_TYPE_TOUCH_SCREEN; 2813 getDevice()->getConfiguration().tryGetProperty(String8("touch.orientationAware"), 2814 mParameters.orientationAware); 2815 2816 mParameters.associatedDisplayId = -1; 2817 mParameters.associatedDisplayIsExternal = false; 2818 if (mParameters.orientationAware 2819 || mParameters.deviceType == Parameters::DEVICE_TYPE_TOUCH_SCREEN 2820 || mParameters.deviceType == Parameters::DEVICE_TYPE_POINTER) { 2821 mParameters.associatedDisplayIsExternal = 2822 mParameters.deviceType == Parameters::DEVICE_TYPE_TOUCH_SCREEN 2823 && getDevice()->isExternal(); 2824 mParameters.associatedDisplayId = 0; 2825 } 2826} 2827 2828void TouchInputMapper::dumpParameters(String8& dump) { 2829 dump.append(INDENT3 "Parameters:\n"); 2830 2831 switch (mParameters.gestureMode) { 2832 case Parameters::GESTURE_MODE_POINTER: 2833 dump.append(INDENT4 "GestureMode: pointer\n"); 2834 break; 2835 case Parameters::GESTURE_MODE_SPOTS: 2836 dump.append(INDENT4 "GestureMode: spots\n"); 2837 break; 2838 default: 2839 assert(false); 2840 } 2841 2842 switch (mParameters.deviceType) { 2843 case Parameters::DEVICE_TYPE_TOUCH_SCREEN: 2844 dump.append(INDENT4 "DeviceType: touchScreen\n"); 2845 break; 2846 case Parameters::DEVICE_TYPE_TOUCH_PAD: 2847 dump.append(INDENT4 "DeviceType: touchPad\n"); 2848 break; 2849 case Parameters::DEVICE_TYPE_POINTER: 2850 dump.append(INDENT4 "DeviceType: pointer\n"); 2851 break; 2852 default: 2853 ALOG_ASSERT(false); 2854 } 2855 2856 dump.appendFormat(INDENT4 "AssociatedDisplay: id=%d, isExternal=%s\n", 2857 mParameters.associatedDisplayId, toString(mParameters.associatedDisplayIsExternal)); 2858 dump.appendFormat(INDENT4 "OrientationAware: %s\n", 2859 toString(mParameters.orientationAware)); 2860} 2861 2862void TouchInputMapper::configureRawPointerAxes() { 2863 mRawPointerAxes.clear(); 2864} 2865 2866void TouchInputMapper::dumpRawPointerAxes(String8& dump) { 2867 dump.append(INDENT3 "Raw Touch Axes:\n"); 2868 dumpRawAbsoluteAxisInfo(dump, mRawPointerAxes.x, "X"); 2869 dumpRawAbsoluteAxisInfo(dump, mRawPointerAxes.y, "Y"); 2870 dumpRawAbsoluteAxisInfo(dump, mRawPointerAxes.pressure, "Pressure"); 2871 dumpRawAbsoluteAxisInfo(dump, mRawPointerAxes.touchMajor, "TouchMajor"); 2872 dumpRawAbsoluteAxisInfo(dump, mRawPointerAxes.touchMinor, "TouchMinor"); 2873 dumpRawAbsoluteAxisInfo(dump, mRawPointerAxes.toolMajor, "ToolMajor"); 2874 dumpRawAbsoluteAxisInfo(dump, mRawPointerAxes.toolMinor, "ToolMinor"); 2875 dumpRawAbsoluteAxisInfo(dump, mRawPointerAxes.orientation, "Orientation"); 2876 dumpRawAbsoluteAxisInfo(dump, mRawPointerAxes.distance, "Distance"); 2877 dumpRawAbsoluteAxisInfo(dump, mRawPointerAxes.tiltX, "TiltX"); 2878 dumpRawAbsoluteAxisInfo(dump, mRawPointerAxes.tiltY, "TiltY"); 2879 dumpRawAbsoluteAxisInfo(dump, mRawPointerAxes.trackingId, "TrackingId"); 2880 dumpRawAbsoluteAxisInfo(dump, mRawPointerAxes.slot, "Slot"); 2881} 2882 2883void TouchInputMapper::configureSurface(nsecs_t when, bool* outResetNeeded) { 2884 int32_t oldDeviceMode = mDeviceMode; 2885 2886 // Determine device mode. 2887 if (mParameters.deviceType == Parameters::DEVICE_TYPE_POINTER 2888 && mConfig.pointerGesturesEnabled) { 2889 mSource = AINPUT_SOURCE_MOUSE; 2890 mDeviceMode = DEVICE_MODE_POINTER; 2891 if (hasStylus()) { 2892 mSource |= AINPUT_SOURCE_STYLUS; 2893 } 2894 } else if (mParameters.deviceType == Parameters::DEVICE_TYPE_TOUCH_SCREEN 2895 && mParameters.associatedDisplayId >= 0) { 2896 mSource = AINPUT_SOURCE_TOUCHSCREEN; 2897 mDeviceMode = DEVICE_MODE_DIRECT; 2898 if (hasStylus()) { 2899 mSource |= AINPUT_SOURCE_STYLUS; 2900 } 2901 } else { 2902 mSource = AINPUT_SOURCE_TOUCHPAD; 2903 mDeviceMode = DEVICE_MODE_UNSCALED; 2904 } 2905 2906 // Ensure we have valid X and Y axes. 2907 if (!mRawPointerAxes.x.valid || !mRawPointerAxes.y.valid) { 2908 ALOGW(INDENT "Touch device '%s' did not report support for X or Y axis! " 2909 "The device will be inoperable.", getDeviceName().string()); 2910 mDeviceMode = DEVICE_MODE_DISABLED; 2911 return; 2912 } 2913 2914 // Get associated display dimensions. 2915 if (mParameters.associatedDisplayId >= 0) { 2916 if (!mConfig.getDisplayInfo(mParameters.associatedDisplayId, 2917 mParameters.associatedDisplayIsExternal, 2918 &mAssociatedDisplayWidth, &mAssociatedDisplayHeight, 2919 &mAssociatedDisplayOrientation)) { 2920 ALOGI(INDENT "Touch device '%s' could not query the properties of its associated " 2921 "display %d. The device will be inoperable until the display size " 2922 "becomes available.", 2923 getDeviceName().string(), mParameters.associatedDisplayId); 2924 mDeviceMode = DEVICE_MODE_DISABLED; 2925 return; 2926 } 2927 } 2928 2929 // Configure dimensions. 2930 int32_t width, height, orientation; 2931 if (mDeviceMode == DEVICE_MODE_DIRECT || mDeviceMode == DEVICE_MODE_POINTER) { 2932 width = mAssociatedDisplayWidth; 2933 height = mAssociatedDisplayHeight; 2934 orientation = mParameters.orientationAware ? 2935 mAssociatedDisplayOrientation : DISPLAY_ORIENTATION_0; 2936 } else { 2937 width = mRawPointerAxes.x.maxValue - mRawPointerAxes.x.minValue + 1; 2938 height = mRawPointerAxes.y.maxValue - mRawPointerAxes.y.minValue + 1; 2939 orientation = DISPLAY_ORIENTATION_0; 2940 } 2941 2942 // If moving between pointer modes, need to reset some state. 2943 bool deviceModeChanged; 2944 if (mDeviceMode != oldDeviceMode) { 2945 deviceModeChanged = true; 2946 mOrientedRanges.clear(); 2947 } 2948 2949 // Create pointer controller if needed. 2950 if (mDeviceMode == DEVICE_MODE_POINTER || 2951 (mDeviceMode == DEVICE_MODE_DIRECT && mConfig.showTouches)) { 2952 if (mPointerController == NULL) { 2953 mPointerController = getPolicy()->obtainPointerController(getDeviceId()); 2954 } 2955 } else { 2956 mPointerController.clear(); 2957 } 2958 2959 bool orientationChanged = mSurfaceOrientation != orientation; 2960 if (orientationChanged) { 2961 mSurfaceOrientation = orientation; 2962 } 2963 2964 bool sizeChanged = mSurfaceWidth != width || mSurfaceHeight != height; 2965 if (sizeChanged || deviceModeChanged) { 2966 ALOGI("Device reconfigured: id=%d, name='%s', surface size is now %dx%d, mode is %d", 2967 getDeviceId(), getDeviceName().string(), width, height, mDeviceMode); 2968 2969 mSurfaceWidth = width; 2970 mSurfaceHeight = height; 2971 2972 // Configure X and Y factors. 2973 mXScale = float(width) / (mRawPointerAxes.x.maxValue - mRawPointerAxes.x.minValue + 1); 2974 mYScale = float(height) / (mRawPointerAxes.y.maxValue - mRawPointerAxes.y.minValue + 1); 2975 mXPrecision = 1.0f / mXScale; 2976 mYPrecision = 1.0f / mYScale; 2977 2978 mOrientedRanges.x.axis = AMOTION_EVENT_AXIS_X; 2979 mOrientedRanges.x.source = mSource; 2980 mOrientedRanges.y.axis = AMOTION_EVENT_AXIS_Y; 2981 mOrientedRanges.y.source = mSource; 2982 2983 configureVirtualKeys(); 2984 2985 // Scale factor for terms that are not oriented in a particular axis. 2986 // If the pixels are square then xScale == yScale otherwise we fake it 2987 // by choosing an average. 2988 mGeometricScale = avg(mXScale, mYScale); 2989 2990 // Size of diagonal axis. 2991 float diagonalSize = hypotf(width, height); 2992 2993 // Size factors. 2994 if (mCalibration.sizeCalibration != Calibration::SIZE_CALIBRATION_NONE) { 2995 if (mRawPointerAxes.touchMajor.valid 2996 && mRawPointerAxes.touchMajor.maxValue != 0) { 2997 mSizeScale = 1.0f / mRawPointerAxes.touchMajor.maxValue; 2998 } else if (mRawPointerAxes.toolMajor.valid 2999 && mRawPointerAxes.toolMajor.maxValue != 0) { 3000 mSizeScale = 1.0f / mRawPointerAxes.toolMajor.maxValue; 3001 } else { 3002 mSizeScale = 0.0f; 3003 } 3004 3005 mOrientedRanges.haveTouchSize = true; 3006 mOrientedRanges.haveToolSize = true; 3007 mOrientedRanges.haveSize = true; 3008 3009 mOrientedRanges.touchMajor.axis = AMOTION_EVENT_AXIS_TOUCH_MAJOR; 3010 mOrientedRanges.touchMajor.source = mSource; 3011 mOrientedRanges.touchMajor.min = 0; 3012 mOrientedRanges.touchMajor.max = diagonalSize; 3013 mOrientedRanges.touchMajor.flat = 0; 3014 mOrientedRanges.touchMajor.fuzz = 0; 3015 3016 mOrientedRanges.touchMinor = mOrientedRanges.touchMajor; 3017 mOrientedRanges.touchMinor.axis = AMOTION_EVENT_AXIS_TOUCH_MINOR; 3018 3019 mOrientedRanges.toolMajor.axis = AMOTION_EVENT_AXIS_TOOL_MAJOR; 3020 mOrientedRanges.toolMajor.source = mSource; 3021 mOrientedRanges.toolMajor.min = 0; 3022 mOrientedRanges.toolMajor.max = diagonalSize; 3023 mOrientedRanges.toolMajor.flat = 0; 3024 mOrientedRanges.toolMajor.fuzz = 0; 3025 3026 mOrientedRanges.toolMinor = mOrientedRanges.toolMajor; 3027 mOrientedRanges.toolMinor.axis = AMOTION_EVENT_AXIS_TOOL_MINOR; 3028 3029 mOrientedRanges.size.axis = AMOTION_EVENT_AXIS_SIZE; 3030 mOrientedRanges.size.source = mSource; 3031 mOrientedRanges.size.min = 0; 3032 mOrientedRanges.size.max = 1.0; 3033 mOrientedRanges.size.flat = 0; 3034 mOrientedRanges.size.fuzz = 0; 3035 } else { 3036 mSizeScale = 0.0f; 3037 } 3038 3039 // Pressure factors. 3040 mPressureScale = 0; 3041 if (mCalibration.pressureCalibration == Calibration::PRESSURE_CALIBRATION_PHYSICAL 3042 || mCalibration.pressureCalibration 3043 == Calibration::PRESSURE_CALIBRATION_AMPLITUDE) { 3044 if (mCalibration.havePressureScale) { 3045 mPressureScale = mCalibration.pressureScale; 3046 } else if (mRawPointerAxes.pressure.valid 3047 && mRawPointerAxes.pressure.maxValue != 0) { 3048 mPressureScale = 1.0f / mRawPointerAxes.pressure.maxValue; 3049 } 3050 } 3051 3052 mOrientedRanges.pressure.axis = AMOTION_EVENT_AXIS_PRESSURE; 3053 mOrientedRanges.pressure.source = mSource; 3054 mOrientedRanges.pressure.min = 0; 3055 mOrientedRanges.pressure.max = 1.0; 3056 mOrientedRanges.pressure.flat = 0; 3057 mOrientedRanges.pressure.fuzz = 0; 3058 3059 // Tilt 3060 mTiltXCenter = 0; 3061 mTiltXScale = 0; 3062 mTiltYCenter = 0; 3063 mTiltYScale = 0; 3064 mHaveTilt = mRawPointerAxes.tiltX.valid && mRawPointerAxes.tiltY.valid; 3065 if (mHaveTilt) { 3066 mTiltXCenter = avg(mRawPointerAxes.tiltX.minValue, 3067 mRawPointerAxes.tiltX.maxValue); 3068 mTiltYCenter = avg(mRawPointerAxes.tiltY.minValue, 3069 mRawPointerAxes.tiltY.maxValue); 3070 mTiltXScale = M_PI / 180; 3071 mTiltYScale = M_PI / 180; 3072 3073 mOrientedRanges.haveTilt = true; 3074 3075 mOrientedRanges.tilt.axis = AMOTION_EVENT_AXIS_TILT; 3076 mOrientedRanges.tilt.source = mSource; 3077 mOrientedRanges.tilt.min = 0; 3078 mOrientedRanges.tilt.max = M_PI_2; 3079 mOrientedRanges.tilt.flat = 0; 3080 mOrientedRanges.tilt.fuzz = 0; 3081 } 3082 3083 // Orientation 3084 mOrientationCenter = 0; 3085 mOrientationScale = 0; 3086 if (mHaveTilt) { 3087 mOrientedRanges.haveOrientation = true; 3088 3089 mOrientedRanges.orientation.axis = AMOTION_EVENT_AXIS_ORIENTATION; 3090 mOrientedRanges.orientation.source = mSource; 3091 mOrientedRanges.orientation.min = -M_PI; 3092 mOrientedRanges.orientation.max = M_PI; 3093 mOrientedRanges.orientation.flat = 0; 3094 mOrientedRanges.orientation.fuzz = 0; 3095 } else if (mCalibration.orientationCalibration != 3096 Calibration::ORIENTATION_CALIBRATION_NONE) { 3097 if (mCalibration.orientationCalibration 3098 == Calibration::ORIENTATION_CALIBRATION_INTERPOLATED) { 3099 if (mRawPointerAxes.orientation.valid) { 3100 mOrientationCenter = avg(mRawPointerAxes.orientation.minValue, 3101 mRawPointerAxes.orientation.maxValue); 3102 mOrientationScale = M_PI / (mRawPointerAxes.orientation.maxValue - 3103 mRawPointerAxes.orientation.minValue); 3104 } 3105 } 3106 3107 mOrientedRanges.haveOrientation = true; 3108 3109 mOrientedRanges.orientation.axis = AMOTION_EVENT_AXIS_ORIENTATION; 3110 mOrientedRanges.orientation.source = mSource; 3111 mOrientedRanges.orientation.min = -M_PI_2; 3112 mOrientedRanges.orientation.max = M_PI_2; 3113 mOrientedRanges.orientation.flat = 0; 3114 mOrientedRanges.orientation.fuzz = 0; 3115 } 3116 3117 // Distance 3118 mDistanceScale = 0; 3119 if (mCalibration.distanceCalibration != Calibration::DISTANCE_CALIBRATION_NONE) { 3120 if (mCalibration.distanceCalibration 3121 == Calibration::DISTANCE_CALIBRATION_SCALED) { 3122 if (mCalibration.haveDistanceScale) { 3123 mDistanceScale = mCalibration.distanceScale; 3124 } else { 3125 mDistanceScale = 1.0f; 3126 } 3127 } 3128 3129 mOrientedRanges.haveDistance = true; 3130 3131 mOrientedRanges.distance.axis = AMOTION_EVENT_AXIS_DISTANCE; 3132 mOrientedRanges.distance.source = mSource; 3133 mOrientedRanges.distance.min = 3134 mRawPointerAxes.distance.minValue * mDistanceScale; 3135 mOrientedRanges.distance.max = 3136 mRawPointerAxes.distance.minValue * mDistanceScale; 3137 mOrientedRanges.distance.flat = 0; 3138 mOrientedRanges.distance.fuzz = 3139 mRawPointerAxes.distance.fuzz * mDistanceScale; 3140 } 3141 } 3142 3143 if (orientationChanged || sizeChanged || deviceModeChanged) { 3144 // Compute oriented surface dimensions, precision, scales and ranges. 3145 // Note that the maximum value reported is an inclusive maximum value so it is one 3146 // unit less than the total width or height of surface. 3147 switch (mSurfaceOrientation) { 3148 case DISPLAY_ORIENTATION_90: 3149 case DISPLAY_ORIENTATION_270: 3150 mOrientedSurfaceWidth = mSurfaceHeight; 3151 mOrientedSurfaceHeight = mSurfaceWidth; 3152 3153 mOrientedXPrecision = mYPrecision; 3154 mOrientedYPrecision = mXPrecision; 3155 3156 mOrientedRanges.x.min = 0; 3157 mOrientedRanges.x.max = (mRawPointerAxes.y.maxValue - mRawPointerAxes.y.minValue) 3158 * mYScale; 3159 mOrientedRanges.x.flat = 0; 3160 mOrientedRanges.x.fuzz = mYScale; 3161 3162 mOrientedRanges.y.min = 0; 3163 mOrientedRanges.y.max = (mRawPointerAxes.x.maxValue - mRawPointerAxes.x.minValue) 3164 * mXScale; 3165 mOrientedRanges.y.flat = 0; 3166 mOrientedRanges.y.fuzz = mXScale; 3167 break; 3168 3169 default: 3170 mOrientedSurfaceWidth = mSurfaceWidth; 3171 mOrientedSurfaceHeight = mSurfaceHeight; 3172 3173 mOrientedXPrecision = mXPrecision; 3174 mOrientedYPrecision = mYPrecision; 3175 3176 mOrientedRanges.x.min = 0; 3177 mOrientedRanges.x.max = (mRawPointerAxes.x.maxValue - mRawPointerAxes.x.minValue) 3178 * mXScale; 3179 mOrientedRanges.x.flat = 0; 3180 mOrientedRanges.x.fuzz = mXScale; 3181 3182 mOrientedRanges.y.min = 0; 3183 mOrientedRanges.y.max = (mRawPointerAxes.y.maxValue - mRawPointerAxes.y.minValue) 3184 * mYScale; 3185 mOrientedRanges.y.flat = 0; 3186 mOrientedRanges.y.fuzz = mYScale; 3187 break; 3188 } 3189 3190 // Compute pointer gesture detection parameters. 3191 if (mDeviceMode == DEVICE_MODE_POINTER) { 3192 int32_t rawWidth = mRawPointerAxes.x.maxValue - mRawPointerAxes.x.minValue + 1; 3193 int32_t rawHeight = mRawPointerAxes.y.maxValue - mRawPointerAxes.y.minValue + 1; 3194 float rawDiagonal = hypotf(rawWidth, rawHeight); 3195 float displayDiagonal = hypotf(mAssociatedDisplayWidth, 3196 mAssociatedDisplayHeight); 3197 3198 // Scale movements such that one whole swipe of the touch pad covers a 3199 // given area relative to the diagonal size of the display when no acceleration 3200 // is applied. 3201 // Assume that the touch pad has a square aspect ratio such that movements in 3202 // X and Y of the same number of raw units cover the same physical distance. 3203 mPointerXMovementScale = mConfig.pointerGestureMovementSpeedRatio 3204 * displayDiagonal / rawDiagonal; 3205 mPointerYMovementScale = mPointerXMovementScale; 3206 3207 // Scale zooms to cover a smaller range of the display than movements do. 3208 // This value determines the area around the pointer that is affected by freeform 3209 // pointer gestures. 3210 mPointerXZoomScale = mConfig.pointerGestureZoomSpeedRatio 3211 * displayDiagonal / rawDiagonal; 3212 mPointerYZoomScale = mPointerXZoomScale; 3213 3214 // Max width between pointers to detect a swipe gesture is more than some fraction 3215 // of the diagonal axis of the touch pad. Touches that are wider than this are 3216 // translated into freeform gestures. 3217 mPointerGestureMaxSwipeWidth = 3218 mConfig.pointerGestureSwipeMaxWidthRatio * rawDiagonal; 3219 } 3220 3221 // Abort current pointer usages because the state has changed. 3222 abortPointerUsage(when, 0 /*policyFlags*/); 3223 3224 // Inform the dispatcher about the changes. 3225 *outResetNeeded = true; 3226 bumpGeneration(); 3227 } 3228} 3229 3230void TouchInputMapper::dumpSurface(String8& dump) { 3231 dump.appendFormat(INDENT3 "SurfaceWidth: %dpx\n", mSurfaceWidth); 3232 dump.appendFormat(INDENT3 "SurfaceHeight: %dpx\n", mSurfaceHeight); 3233 dump.appendFormat(INDENT3 "SurfaceOrientation: %d\n", mSurfaceOrientation); 3234} 3235 3236void TouchInputMapper::configureVirtualKeys() { 3237 Vector<VirtualKeyDefinition> virtualKeyDefinitions; 3238 getEventHub()->getVirtualKeyDefinitions(getDeviceId(), virtualKeyDefinitions); 3239 3240 mVirtualKeys.clear(); 3241 3242 if (virtualKeyDefinitions.size() == 0) { 3243 return; 3244 } 3245 3246 mVirtualKeys.setCapacity(virtualKeyDefinitions.size()); 3247 3248 int32_t touchScreenLeft = mRawPointerAxes.x.minValue; 3249 int32_t touchScreenTop = mRawPointerAxes.y.minValue; 3250 int32_t touchScreenWidth = mRawPointerAxes.x.maxValue - mRawPointerAxes.x.minValue + 1; 3251 int32_t touchScreenHeight = mRawPointerAxes.y.maxValue - mRawPointerAxes.y.minValue + 1; 3252 3253 for (size_t i = 0; i < virtualKeyDefinitions.size(); i++) { 3254 const VirtualKeyDefinition& virtualKeyDefinition = 3255 virtualKeyDefinitions[i]; 3256 3257 mVirtualKeys.add(); 3258 VirtualKey& virtualKey = mVirtualKeys.editTop(); 3259 3260 virtualKey.scanCode = virtualKeyDefinition.scanCode; 3261 int32_t keyCode; 3262 uint32_t flags; 3263 if (getEventHub()->mapKey(getDeviceId(), virtualKey.scanCode, 0, &keyCode, &flags)) { 3264 ALOGW(INDENT "VirtualKey %d: could not obtain key code, ignoring", 3265 virtualKey.scanCode); 3266 mVirtualKeys.pop(); // drop the key 3267 continue; 3268 } 3269 3270 virtualKey.keyCode = keyCode; 3271 virtualKey.flags = flags; 3272 3273 // convert the key definition's display coordinates into touch coordinates for a hit box 3274 int32_t halfWidth = virtualKeyDefinition.width / 2; 3275 int32_t halfHeight = virtualKeyDefinition.height / 2; 3276 3277 virtualKey.hitLeft = (virtualKeyDefinition.centerX - halfWidth) 3278 * touchScreenWidth / mSurfaceWidth + touchScreenLeft; 3279 virtualKey.hitRight= (virtualKeyDefinition.centerX + halfWidth) 3280 * touchScreenWidth / mSurfaceWidth + touchScreenLeft; 3281 virtualKey.hitTop = (virtualKeyDefinition.centerY - halfHeight) 3282 * touchScreenHeight / mSurfaceHeight + touchScreenTop; 3283 virtualKey.hitBottom = (virtualKeyDefinition.centerY + halfHeight) 3284 * touchScreenHeight / mSurfaceHeight + touchScreenTop; 3285 } 3286} 3287 3288void TouchInputMapper::dumpVirtualKeys(String8& dump) { 3289 if (!mVirtualKeys.isEmpty()) { 3290 dump.append(INDENT3 "Virtual Keys:\n"); 3291 3292 for (size_t i = 0; i < mVirtualKeys.size(); i++) { 3293 const VirtualKey& virtualKey = mVirtualKeys.itemAt(i); 3294 dump.appendFormat(INDENT4 "%d: scanCode=%d, keyCode=%d, " 3295 "hitLeft=%d, hitRight=%d, hitTop=%d, hitBottom=%d\n", 3296 i, virtualKey.scanCode, virtualKey.keyCode, 3297 virtualKey.hitLeft, virtualKey.hitRight, 3298 virtualKey.hitTop, virtualKey.hitBottom); 3299 } 3300 } 3301} 3302 3303void TouchInputMapper::parseCalibration() { 3304 const PropertyMap& in = getDevice()->getConfiguration(); 3305 Calibration& out = mCalibration; 3306 3307 // Size 3308 out.sizeCalibration = Calibration::SIZE_CALIBRATION_DEFAULT; 3309 String8 sizeCalibrationString; 3310 if (in.tryGetProperty(String8("touch.size.calibration"), sizeCalibrationString)) { 3311 if (sizeCalibrationString == "none") { 3312 out.sizeCalibration = Calibration::SIZE_CALIBRATION_NONE; 3313 } else if (sizeCalibrationString == "geometric") { 3314 out.sizeCalibration = Calibration::SIZE_CALIBRATION_GEOMETRIC; 3315 } else if (sizeCalibrationString == "diameter") { 3316 out.sizeCalibration = Calibration::SIZE_CALIBRATION_DIAMETER; 3317 } else if (sizeCalibrationString == "area") { 3318 out.sizeCalibration = Calibration::SIZE_CALIBRATION_AREA; 3319 } else if (sizeCalibrationString != "default") { 3320 ALOGW("Invalid value for touch.size.calibration: '%s'", 3321 sizeCalibrationString.string()); 3322 } 3323 } 3324 3325 out.haveSizeScale = in.tryGetProperty(String8("touch.size.scale"), 3326 out.sizeScale); 3327 out.haveSizeBias = in.tryGetProperty(String8("touch.size.bias"), 3328 out.sizeBias); 3329 out.haveSizeIsSummed = in.tryGetProperty(String8("touch.size.isSummed"), 3330 out.sizeIsSummed); 3331 3332 // Pressure 3333 out.pressureCalibration = Calibration::PRESSURE_CALIBRATION_DEFAULT; 3334 String8 pressureCalibrationString; 3335 if (in.tryGetProperty(String8("touch.pressure.calibration"), pressureCalibrationString)) { 3336 if (pressureCalibrationString == "none") { 3337 out.pressureCalibration = Calibration::PRESSURE_CALIBRATION_NONE; 3338 } else if (pressureCalibrationString == "physical") { 3339 out.pressureCalibration = Calibration::PRESSURE_CALIBRATION_PHYSICAL; 3340 } else if (pressureCalibrationString == "amplitude") { 3341 out.pressureCalibration = Calibration::PRESSURE_CALIBRATION_AMPLITUDE; 3342 } else if (pressureCalibrationString != "default") { 3343 ALOGW("Invalid value for touch.pressure.calibration: '%s'", 3344 pressureCalibrationString.string()); 3345 } 3346 } 3347 3348 out.havePressureScale = in.tryGetProperty(String8("touch.pressure.scale"), 3349 out.pressureScale); 3350 3351 // Orientation 3352 out.orientationCalibration = Calibration::ORIENTATION_CALIBRATION_DEFAULT; 3353 String8 orientationCalibrationString; 3354 if (in.tryGetProperty(String8("touch.orientation.calibration"), orientationCalibrationString)) { 3355 if (orientationCalibrationString == "none") { 3356 out.orientationCalibration = Calibration::ORIENTATION_CALIBRATION_NONE; 3357 } else if (orientationCalibrationString == "interpolated") { 3358 out.orientationCalibration = Calibration::ORIENTATION_CALIBRATION_INTERPOLATED; 3359 } else if (orientationCalibrationString == "vector") { 3360 out.orientationCalibration = Calibration::ORIENTATION_CALIBRATION_VECTOR; 3361 } else if (orientationCalibrationString != "default") { 3362 ALOGW("Invalid value for touch.orientation.calibration: '%s'", 3363 orientationCalibrationString.string()); 3364 } 3365 } 3366 3367 // Distance 3368 out.distanceCalibration = Calibration::DISTANCE_CALIBRATION_DEFAULT; 3369 String8 distanceCalibrationString; 3370 if (in.tryGetProperty(String8("touch.distance.calibration"), distanceCalibrationString)) { 3371 if (distanceCalibrationString == "none") { 3372 out.distanceCalibration = Calibration::DISTANCE_CALIBRATION_NONE; 3373 } else if (distanceCalibrationString == "scaled") { 3374 out.distanceCalibration = Calibration::DISTANCE_CALIBRATION_SCALED; 3375 } else if (distanceCalibrationString != "default") { 3376 ALOGW("Invalid value for touch.distance.calibration: '%s'", 3377 distanceCalibrationString.string()); 3378 } 3379 } 3380 3381 out.haveDistanceScale = in.tryGetProperty(String8("touch.distance.scale"), 3382 out.distanceScale); 3383} 3384 3385void TouchInputMapper::resolveCalibration() { 3386 // Size 3387 if (mRawPointerAxes.touchMajor.valid || mRawPointerAxes.toolMajor.valid) { 3388 if (mCalibration.sizeCalibration == Calibration::SIZE_CALIBRATION_DEFAULT) { 3389 mCalibration.sizeCalibration = Calibration::SIZE_CALIBRATION_GEOMETRIC; 3390 } 3391 } else { 3392 mCalibration.sizeCalibration = Calibration::SIZE_CALIBRATION_NONE; 3393 } 3394 3395 // Pressure 3396 if (mRawPointerAxes.pressure.valid) { 3397 if (mCalibration.pressureCalibration == Calibration::PRESSURE_CALIBRATION_DEFAULT) { 3398 mCalibration.pressureCalibration = Calibration::PRESSURE_CALIBRATION_PHYSICAL; 3399 } 3400 } else { 3401 mCalibration.pressureCalibration = Calibration::PRESSURE_CALIBRATION_NONE; 3402 } 3403 3404 // Orientation 3405 if (mRawPointerAxes.orientation.valid) { 3406 if (mCalibration.orientationCalibration == Calibration::ORIENTATION_CALIBRATION_DEFAULT) { 3407 mCalibration.orientationCalibration = Calibration::ORIENTATION_CALIBRATION_INTERPOLATED; 3408 } 3409 } else { 3410 mCalibration.orientationCalibration = Calibration::ORIENTATION_CALIBRATION_NONE; 3411 } 3412 3413 // Distance 3414 if (mRawPointerAxes.distance.valid) { 3415 if (mCalibration.distanceCalibration == Calibration::DISTANCE_CALIBRATION_DEFAULT) { 3416 mCalibration.distanceCalibration = Calibration::DISTANCE_CALIBRATION_SCALED; 3417 } 3418 } else { 3419 mCalibration.distanceCalibration = Calibration::DISTANCE_CALIBRATION_NONE; 3420 } 3421} 3422 3423void TouchInputMapper::dumpCalibration(String8& dump) { 3424 dump.append(INDENT3 "Calibration:\n"); 3425 3426 // Size 3427 switch (mCalibration.sizeCalibration) { 3428 case Calibration::SIZE_CALIBRATION_NONE: 3429 dump.append(INDENT4 "touch.size.calibration: none\n"); 3430 break; 3431 case Calibration::SIZE_CALIBRATION_GEOMETRIC: 3432 dump.append(INDENT4 "touch.size.calibration: geometric\n"); 3433 break; 3434 case Calibration::SIZE_CALIBRATION_DIAMETER: 3435 dump.append(INDENT4 "touch.size.calibration: diameter\n"); 3436 break; 3437 case Calibration::SIZE_CALIBRATION_AREA: 3438 dump.append(INDENT4 "touch.size.calibration: area\n"); 3439 break; 3440 default: 3441 ALOG_ASSERT(false); 3442 } 3443 3444 if (mCalibration.haveSizeScale) { 3445 dump.appendFormat(INDENT4 "touch.size.scale: %0.3f\n", 3446 mCalibration.sizeScale); 3447 } 3448 3449 if (mCalibration.haveSizeBias) { 3450 dump.appendFormat(INDENT4 "touch.size.bias: %0.3f\n", 3451 mCalibration.sizeBias); 3452 } 3453 3454 if (mCalibration.haveSizeIsSummed) { 3455 dump.appendFormat(INDENT4 "touch.size.isSummed: %s\n", 3456 toString(mCalibration.sizeIsSummed)); 3457 } 3458 3459 // Pressure 3460 switch (mCalibration.pressureCalibration) { 3461 case Calibration::PRESSURE_CALIBRATION_NONE: 3462 dump.append(INDENT4 "touch.pressure.calibration: none\n"); 3463 break; 3464 case Calibration::PRESSURE_CALIBRATION_PHYSICAL: 3465 dump.append(INDENT4 "touch.pressure.calibration: physical\n"); 3466 break; 3467 case Calibration::PRESSURE_CALIBRATION_AMPLITUDE: 3468 dump.append(INDENT4 "touch.pressure.calibration: amplitude\n"); 3469 break; 3470 default: 3471 ALOG_ASSERT(false); 3472 } 3473 3474 if (mCalibration.havePressureScale) { 3475 dump.appendFormat(INDENT4 "touch.pressure.scale: %0.3f\n", 3476 mCalibration.pressureScale); 3477 } 3478 3479 // Orientation 3480 switch (mCalibration.orientationCalibration) { 3481 case Calibration::ORIENTATION_CALIBRATION_NONE: 3482 dump.append(INDENT4 "touch.orientation.calibration: none\n"); 3483 break; 3484 case Calibration::ORIENTATION_CALIBRATION_INTERPOLATED: 3485 dump.append(INDENT4 "touch.orientation.calibration: interpolated\n"); 3486 break; 3487 case Calibration::ORIENTATION_CALIBRATION_VECTOR: 3488 dump.append(INDENT4 "touch.orientation.calibration: vector\n"); 3489 break; 3490 default: 3491 ALOG_ASSERT(false); 3492 } 3493 3494 // Distance 3495 switch (mCalibration.distanceCalibration) { 3496 case Calibration::DISTANCE_CALIBRATION_NONE: 3497 dump.append(INDENT4 "touch.distance.calibration: none\n"); 3498 break; 3499 case Calibration::DISTANCE_CALIBRATION_SCALED: 3500 dump.append(INDENT4 "touch.distance.calibration: scaled\n"); 3501 break; 3502 default: 3503 ALOG_ASSERT(false); 3504 } 3505 3506 if (mCalibration.haveDistanceScale) { 3507 dump.appendFormat(INDENT4 "touch.distance.scale: %0.3f\n", 3508 mCalibration.distanceScale); 3509 } 3510} 3511 3512void TouchInputMapper::reset(nsecs_t when) { 3513 mCursorButtonAccumulator.reset(getDevice()); 3514 mCursorScrollAccumulator.reset(getDevice()); 3515 mTouchButtonAccumulator.reset(getDevice()); 3516 3517 mPointerVelocityControl.reset(); 3518 mWheelXVelocityControl.reset(); 3519 mWheelYVelocityControl.reset(); 3520 3521 mCurrentRawPointerData.clear(); 3522 mLastRawPointerData.clear(); 3523 mCurrentCookedPointerData.clear(); 3524 mLastCookedPointerData.clear(); 3525 mCurrentButtonState = 0; 3526 mLastButtonState = 0; 3527 mCurrentRawVScroll = 0; 3528 mCurrentRawHScroll = 0; 3529 mCurrentFingerIdBits.clear(); 3530 mLastFingerIdBits.clear(); 3531 mCurrentStylusIdBits.clear(); 3532 mLastStylusIdBits.clear(); 3533 mCurrentMouseIdBits.clear(); 3534 mLastMouseIdBits.clear(); 3535 mPointerUsage = POINTER_USAGE_NONE; 3536 mSentHoverEnter = false; 3537 mDownTime = 0; 3538 3539 mCurrentVirtualKey.down = false; 3540 3541 mPointerGesture.reset(); 3542 mPointerSimple.reset(); 3543 3544 if (mPointerController != NULL) { 3545 mPointerController->fade(PointerControllerInterface::TRANSITION_GRADUAL); 3546 mPointerController->clearSpots(); 3547 } 3548 3549 InputMapper::reset(when); 3550} 3551 3552void TouchInputMapper::process(const RawEvent* rawEvent) { 3553 mCursorButtonAccumulator.process(rawEvent); 3554 mCursorScrollAccumulator.process(rawEvent); 3555 mTouchButtonAccumulator.process(rawEvent); 3556 3557 if (rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT) { 3558 sync(rawEvent->when); 3559 } 3560} 3561 3562void TouchInputMapper::sync(nsecs_t when) { 3563 // Sync button state. 3564 mCurrentButtonState = mTouchButtonAccumulator.getButtonState() 3565 | mCursorButtonAccumulator.getButtonState(); 3566 3567 // Sync scroll state. 3568 mCurrentRawVScroll = mCursorScrollAccumulator.getRelativeVWheel(); 3569 mCurrentRawHScroll = mCursorScrollAccumulator.getRelativeHWheel(); 3570 mCursorScrollAccumulator.finishSync(); 3571 3572 // Sync touch state. 3573 bool havePointerIds = true; 3574 mCurrentRawPointerData.clear(); 3575 syncTouch(when, &havePointerIds); 3576 3577#if DEBUG_RAW_EVENTS 3578 if (!havePointerIds) { 3579 ALOGD("syncTouch: pointerCount %d -> %d, no pointer ids", 3580 mLastRawPointerData.pointerCount, 3581 mCurrentRawPointerData.pointerCount); 3582 } else { 3583 ALOGD("syncTouch: pointerCount %d -> %d, touching ids 0x%08x -> 0x%08x, " 3584 "hovering ids 0x%08x -> 0x%08x", 3585 mLastRawPointerData.pointerCount, 3586 mCurrentRawPointerData.pointerCount, 3587 mLastRawPointerData.touchingIdBits.value, 3588 mCurrentRawPointerData.touchingIdBits.value, 3589 mLastRawPointerData.hoveringIdBits.value, 3590 mCurrentRawPointerData.hoveringIdBits.value); 3591 } 3592#endif 3593 3594 // Reset state that we will compute below. 3595 mCurrentFingerIdBits.clear(); 3596 mCurrentStylusIdBits.clear(); 3597 mCurrentMouseIdBits.clear(); 3598 mCurrentCookedPointerData.clear(); 3599 3600 if (mDeviceMode == DEVICE_MODE_DISABLED) { 3601 // Drop all input if the device is disabled. 3602 mCurrentRawPointerData.clear(); 3603 mCurrentButtonState = 0; 3604 } else { 3605 // Preprocess pointer data. 3606 if (!havePointerIds) { 3607 assignPointerIds(); 3608 } 3609 3610 // Handle policy on initial down or hover events. 3611 uint32_t policyFlags = 0; 3612 bool initialDown = mLastRawPointerData.pointerCount == 0 3613 && mCurrentRawPointerData.pointerCount != 0; 3614 bool buttonsPressed = mCurrentButtonState & ~mLastButtonState; 3615 if (initialDown || buttonsPressed) { 3616 // If this is a touch screen, hide the pointer on an initial down. 3617 if (mDeviceMode == DEVICE_MODE_DIRECT) { 3618 getContext()->fadePointer(); 3619 } 3620 3621 // Initial downs on external touch devices should wake the device. 3622 // We don't do this for internal touch screens to prevent them from waking 3623 // up in your pocket. 3624 // TODO: Use the input device configuration to control this behavior more finely. 3625 if (getDevice()->isExternal()) { 3626 policyFlags |= POLICY_FLAG_WAKE_DROPPED; 3627 } 3628 } 3629 3630 // Synthesize key down from raw buttons if needed. 3631 synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_DOWN, when, getDeviceId(), mSource, 3632 policyFlags, mLastButtonState, mCurrentButtonState); 3633 3634 // Consume raw off-screen touches before cooking pointer data. 3635 // If touches are consumed, subsequent code will not receive any pointer data. 3636 if (consumeRawTouches(when, policyFlags)) { 3637 mCurrentRawPointerData.clear(); 3638 } 3639 3640 // Cook pointer data. This call populates the mCurrentCookedPointerData structure 3641 // with cooked pointer data that has the same ids and indices as the raw data. 3642 // The following code can use either the raw or cooked data, as needed. 3643 cookPointerData(); 3644 3645 // Dispatch the touches either directly or by translation through a pointer on screen. 3646 if (mDeviceMode == DEVICE_MODE_POINTER) { 3647 for (BitSet32 idBits(mCurrentRawPointerData.touchingIdBits); !idBits.isEmpty(); ) { 3648 uint32_t id = idBits.clearFirstMarkedBit(); 3649 const RawPointerData::Pointer& pointer = mCurrentRawPointerData.pointerForId(id); 3650 if (pointer.toolType == AMOTION_EVENT_TOOL_TYPE_STYLUS 3651 || pointer.toolType == AMOTION_EVENT_TOOL_TYPE_ERASER) { 3652 mCurrentStylusIdBits.markBit(id); 3653 } else if (pointer.toolType == AMOTION_EVENT_TOOL_TYPE_FINGER 3654 || pointer.toolType == AMOTION_EVENT_TOOL_TYPE_UNKNOWN) { 3655 mCurrentFingerIdBits.markBit(id); 3656 } else if (pointer.toolType == AMOTION_EVENT_TOOL_TYPE_MOUSE) { 3657 mCurrentMouseIdBits.markBit(id); 3658 } 3659 } 3660 for (BitSet32 idBits(mCurrentRawPointerData.hoveringIdBits); !idBits.isEmpty(); ) { 3661 uint32_t id = idBits.clearFirstMarkedBit(); 3662 const RawPointerData::Pointer& pointer = mCurrentRawPointerData.pointerForId(id); 3663 if (pointer.toolType == AMOTION_EVENT_TOOL_TYPE_STYLUS 3664 || pointer.toolType == AMOTION_EVENT_TOOL_TYPE_ERASER) { 3665 mCurrentStylusIdBits.markBit(id); 3666 } 3667 } 3668 3669 // Stylus takes precedence over all tools, then mouse, then finger. 3670 PointerUsage pointerUsage = mPointerUsage; 3671 if (!mCurrentStylusIdBits.isEmpty()) { 3672 mCurrentMouseIdBits.clear(); 3673 mCurrentFingerIdBits.clear(); 3674 pointerUsage = POINTER_USAGE_STYLUS; 3675 } else if (!mCurrentMouseIdBits.isEmpty()) { 3676 mCurrentFingerIdBits.clear(); 3677 pointerUsage = POINTER_USAGE_MOUSE; 3678 } else if (!mCurrentFingerIdBits.isEmpty() || isPointerDown(mCurrentButtonState)) { 3679 pointerUsage = POINTER_USAGE_GESTURES; 3680 } 3681 3682 dispatchPointerUsage(when, policyFlags, pointerUsage); 3683 } else { 3684 if (mDeviceMode == DEVICE_MODE_DIRECT 3685 && mConfig.showTouches && mPointerController != NULL) { 3686 mPointerController->setPresentation(PointerControllerInterface::PRESENTATION_SPOT); 3687 mPointerController->fade(PointerControllerInterface::TRANSITION_GRADUAL); 3688 3689 mPointerController->setButtonState(mCurrentButtonState); 3690 mPointerController->setSpots(mCurrentCookedPointerData.pointerCoords, 3691 mCurrentCookedPointerData.idToIndex, 3692 mCurrentCookedPointerData.touchingIdBits); 3693 } 3694 3695 dispatchHoverExit(when, policyFlags); 3696 dispatchTouches(when, policyFlags); 3697 dispatchHoverEnterAndMove(when, policyFlags); 3698 } 3699 3700 // Synthesize key up from raw buttons if needed. 3701 synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_UP, when, getDeviceId(), mSource, 3702 policyFlags, mLastButtonState, mCurrentButtonState); 3703 } 3704 3705 // Copy current touch to last touch in preparation for the next cycle. 3706 mLastRawPointerData.copyFrom(mCurrentRawPointerData); 3707 mLastCookedPointerData.copyFrom(mCurrentCookedPointerData); 3708 mLastButtonState = mCurrentButtonState; 3709 mLastFingerIdBits = mCurrentFingerIdBits; 3710 mLastStylusIdBits = mCurrentStylusIdBits; 3711 mLastMouseIdBits = mCurrentMouseIdBits; 3712 3713 // Clear some transient state. 3714 mCurrentRawVScroll = 0; 3715 mCurrentRawHScroll = 0; 3716} 3717 3718void TouchInputMapper::timeoutExpired(nsecs_t when) { 3719 if (mDeviceMode == DEVICE_MODE_POINTER) { 3720 if (mPointerUsage == POINTER_USAGE_GESTURES) { 3721 dispatchPointerGestures(when, 0 /*policyFlags*/, true /*isTimeout*/); 3722 } 3723 } 3724} 3725 3726bool TouchInputMapper::consumeRawTouches(nsecs_t when, uint32_t policyFlags) { 3727 // Check for release of a virtual key. 3728 if (mCurrentVirtualKey.down) { 3729 if (mCurrentRawPointerData.touchingIdBits.isEmpty()) { 3730 // Pointer went up while virtual key was down. 3731 mCurrentVirtualKey.down = false; 3732 if (!mCurrentVirtualKey.ignored) { 3733#if DEBUG_VIRTUAL_KEYS 3734 ALOGD("VirtualKeys: Generating key up: keyCode=%d, scanCode=%d", 3735 mCurrentVirtualKey.keyCode, mCurrentVirtualKey.scanCode); 3736#endif 3737 dispatchVirtualKey(when, policyFlags, 3738 AKEY_EVENT_ACTION_UP, 3739 AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY); 3740 } 3741 return true; 3742 } 3743 3744 if (mCurrentRawPointerData.touchingIdBits.count() == 1) { 3745 uint32_t id = mCurrentRawPointerData.touchingIdBits.firstMarkedBit(); 3746 const RawPointerData::Pointer& pointer = mCurrentRawPointerData.pointerForId(id); 3747 const VirtualKey* virtualKey = findVirtualKeyHit(pointer.x, pointer.y); 3748 if (virtualKey && virtualKey->keyCode == mCurrentVirtualKey.keyCode) { 3749 // Pointer is still within the space of the virtual key. 3750 return true; 3751 } 3752 } 3753 3754 // Pointer left virtual key area or another pointer also went down. 3755 // Send key cancellation but do not consume the touch yet. 3756 // This is useful when the user swipes through from the virtual key area 3757 // into the main display surface. 3758 mCurrentVirtualKey.down = false; 3759 if (!mCurrentVirtualKey.ignored) { 3760#if DEBUG_VIRTUAL_KEYS 3761 ALOGD("VirtualKeys: Canceling key: keyCode=%d, scanCode=%d", 3762 mCurrentVirtualKey.keyCode, mCurrentVirtualKey.scanCode); 3763#endif 3764 dispatchVirtualKey(when, policyFlags, 3765 AKEY_EVENT_ACTION_UP, 3766 AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY 3767 | AKEY_EVENT_FLAG_CANCELED); 3768 } 3769 } 3770 3771 if (mLastRawPointerData.touchingIdBits.isEmpty() 3772 && !mCurrentRawPointerData.touchingIdBits.isEmpty()) { 3773 // Pointer just went down. Check for virtual key press or off-screen touches. 3774 uint32_t id = mCurrentRawPointerData.touchingIdBits.firstMarkedBit(); 3775 const RawPointerData::Pointer& pointer = mCurrentRawPointerData.pointerForId(id); 3776 if (!isPointInsideSurface(pointer.x, pointer.y)) { 3777 // If exactly one pointer went down, check for virtual key hit. 3778 // Otherwise we will drop the entire stroke. 3779 if (mCurrentRawPointerData.touchingIdBits.count() == 1) { 3780 const VirtualKey* virtualKey = findVirtualKeyHit(pointer.x, pointer.y); 3781 if (virtualKey) { 3782 mCurrentVirtualKey.down = true; 3783 mCurrentVirtualKey.downTime = when; 3784 mCurrentVirtualKey.keyCode = virtualKey->keyCode; 3785 mCurrentVirtualKey.scanCode = virtualKey->scanCode; 3786 mCurrentVirtualKey.ignored = mContext->shouldDropVirtualKey( 3787 when, getDevice(), virtualKey->keyCode, virtualKey->scanCode); 3788 3789 if (!mCurrentVirtualKey.ignored) { 3790#if DEBUG_VIRTUAL_KEYS 3791 ALOGD("VirtualKeys: Generating key down: keyCode=%d, scanCode=%d", 3792 mCurrentVirtualKey.keyCode, 3793 mCurrentVirtualKey.scanCode); 3794#endif 3795 dispatchVirtualKey(when, policyFlags, 3796 AKEY_EVENT_ACTION_DOWN, 3797 AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY); 3798 } 3799 } 3800 } 3801 return true; 3802 } 3803 } 3804 3805 // Disable all virtual key touches that happen within a short time interval of the 3806 // most recent touch within the screen area. The idea is to filter out stray 3807 // virtual key presses when interacting with the touch screen. 3808 // 3809 // Problems we're trying to solve: 3810 // 3811 // 1. While scrolling a list or dragging the window shade, the user swipes down into a 3812 // virtual key area that is implemented by a separate touch panel and accidentally 3813 // triggers a virtual key. 3814 // 3815 // 2. While typing in the on screen keyboard, the user taps slightly outside the screen 3816 // area and accidentally triggers a virtual key. This often happens when virtual keys 3817 // are layed out below the screen near to where the on screen keyboard's space bar 3818 // is displayed. 3819 if (mConfig.virtualKeyQuietTime > 0 && !mCurrentRawPointerData.touchingIdBits.isEmpty()) { 3820 mContext->disableVirtualKeysUntil(when + mConfig.virtualKeyQuietTime); 3821 } 3822 return false; 3823} 3824 3825void TouchInputMapper::dispatchVirtualKey(nsecs_t when, uint32_t policyFlags, 3826 int32_t keyEventAction, int32_t keyEventFlags) { 3827 int32_t keyCode = mCurrentVirtualKey.keyCode; 3828 int32_t scanCode = mCurrentVirtualKey.scanCode; 3829 nsecs_t downTime = mCurrentVirtualKey.downTime; 3830 int32_t metaState = mContext->getGlobalMetaState(); 3831 policyFlags |= POLICY_FLAG_VIRTUAL; 3832 3833 NotifyKeyArgs args(when, getDeviceId(), AINPUT_SOURCE_KEYBOARD, policyFlags, 3834 keyEventAction, keyEventFlags, keyCode, scanCode, metaState, downTime); 3835 getListener()->notifyKey(&args); 3836} 3837 3838void TouchInputMapper::dispatchTouches(nsecs_t when, uint32_t policyFlags) { 3839 BitSet32 currentIdBits = mCurrentCookedPointerData.touchingIdBits; 3840 BitSet32 lastIdBits = mLastCookedPointerData.touchingIdBits; 3841 int32_t metaState = getContext()->getGlobalMetaState(); 3842 int32_t buttonState = mCurrentButtonState; 3843 3844 if (currentIdBits == lastIdBits) { 3845 if (!currentIdBits.isEmpty()) { 3846 // No pointer id changes so this is a move event. 3847 // The listener takes care of batching moves so we don't have to deal with that here. 3848 dispatchMotion(when, policyFlags, mSource, 3849 AMOTION_EVENT_ACTION_MOVE, 0, metaState, buttonState, 3850 AMOTION_EVENT_EDGE_FLAG_NONE, 3851 mCurrentCookedPointerData.pointerProperties, 3852 mCurrentCookedPointerData.pointerCoords, 3853 mCurrentCookedPointerData.idToIndex, 3854 currentIdBits, -1, 3855 mOrientedXPrecision, mOrientedYPrecision, mDownTime); 3856 } 3857 } else { 3858 // There may be pointers going up and pointers going down and pointers moving 3859 // all at the same time. 3860 BitSet32 upIdBits(lastIdBits.value & ~currentIdBits.value); 3861 BitSet32 downIdBits(currentIdBits.value & ~lastIdBits.value); 3862 BitSet32 moveIdBits(lastIdBits.value & currentIdBits.value); 3863 BitSet32 dispatchedIdBits(lastIdBits.value); 3864 3865 // Update last coordinates of pointers that have moved so that we observe the new 3866 // pointer positions at the same time as other pointers that have just gone up. 3867 bool moveNeeded = updateMovedPointers( 3868 mCurrentCookedPointerData.pointerProperties, 3869 mCurrentCookedPointerData.pointerCoords, 3870 mCurrentCookedPointerData.idToIndex, 3871 mLastCookedPointerData.pointerProperties, 3872 mLastCookedPointerData.pointerCoords, 3873 mLastCookedPointerData.idToIndex, 3874 moveIdBits); 3875 if (buttonState != mLastButtonState) { 3876 moveNeeded = true; 3877 } 3878 3879 // Dispatch pointer up events. 3880 while (!upIdBits.isEmpty()) { 3881 uint32_t upId = upIdBits.clearFirstMarkedBit(); 3882 3883 dispatchMotion(when, policyFlags, mSource, 3884 AMOTION_EVENT_ACTION_POINTER_UP, 0, metaState, buttonState, 0, 3885 mLastCookedPointerData.pointerProperties, 3886 mLastCookedPointerData.pointerCoords, 3887 mLastCookedPointerData.idToIndex, 3888 dispatchedIdBits, upId, 3889 mOrientedXPrecision, mOrientedYPrecision, mDownTime); 3890 dispatchedIdBits.clearBit(upId); 3891 } 3892 3893 // Dispatch move events if any of the remaining pointers moved from their old locations. 3894 // Although applications receive new locations as part of individual pointer up 3895 // events, they do not generally handle them except when presented in a move event. 3896 if (moveNeeded) { 3897 ALOG_ASSERT(moveIdBits.value == dispatchedIdBits.value); 3898 dispatchMotion(when, policyFlags, mSource, 3899 AMOTION_EVENT_ACTION_MOVE, 0, metaState, buttonState, 0, 3900 mCurrentCookedPointerData.pointerProperties, 3901 mCurrentCookedPointerData.pointerCoords, 3902 mCurrentCookedPointerData.idToIndex, 3903 dispatchedIdBits, -1, 3904 mOrientedXPrecision, mOrientedYPrecision, mDownTime); 3905 } 3906 3907 // Dispatch pointer down events using the new pointer locations. 3908 while (!downIdBits.isEmpty()) { 3909 uint32_t downId = downIdBits.clearFirstMarkedBit(); 3910 dispatchedIdBits.markBit(downId); 3911 3912 if (dispatchedIdBits.count() == 1) { 3913 // First pointer is going down. Set down time. 3914 mDownTime = when; 3915 } 3916 3917 dispatchMotion(when, policyFlags, mSource, 3918 AMOTION_EVENT_ACTION_POINTER_DOWN, 0, metaState, buttonState, 0, 3919 mCurrentCookedPointerData.pointerProperties, 3920 mCurrentCookedPointerData.pointerCoords, 3921 mCurrentCookedPointerData.idToIndex, 3922 dispatchedIdBits, downId, 3923 mOrientedXPrecision, mOrientedYPrecision, mDownTime); 3924 } 3925 } 3926} 3927 3928void TouchInputMapper::dispatchHoverExit(nsecs_t when, uint32_t policyFlags) { 3929 if (mSentHoverEnter && 3930 (mCurrentCookedPointerData.hoveringIdBits.isEmpty() 3931 || !mCurrentCookedPointerData.touchingIdBits.isEmpty())) { 3932 int32_t metaState = getContext()->getGlobalMetaState(); 3933 dispatchMotion(when, policyFlags, mSource, 3934 AMOTION_EVENT_ACTION_HOVER_EXIT, 0, metaState, mLastButtonState, 0, 3935 mLastCookedPointerData.pointerProperties, 3936 mLastCookedPointerData.pointerCoords, 3937 mLastCookedPointerData.idToIndex, 3938 mLastCookedPointerData.hoveringIdBits, -1, 3939 mOrientedXPrecision, mOrientedYPrecision, mDownTime); 3940 mSentHoverEnter = false; 3941 } 3942} 3943 3944void TouchInputMapper::dispatchHoverEnterAndMove(nsecs_t when, uint32_t policyFlags) { 3945 if (mCurrentCookedPointerData.touchingIdBits.isEmpty() 3946 && !mCurrentCookedPointerData.hoveringIdBits.isEmpty()) { 3947 int32_t metaState = getContext()->getGlobalMetaState(); 3948 if (!mSentHoverEnter) { 3949 dispatchMotion(when, policyFlags, mSource, 3950 AMOTION_EVENT_ACTION_HOVER_ENTER, 0, metaState, mCurrentButtonState, 0, 3951 mCurrentCookedPointerData.pointerProperties, 3952 mCurrentCookedPointerData.pointerCoords, 3953 mCurrentCookedPointerData.idToIndex, 3954 mCurrentCookedPointerData.hoveringIdBits, -1, 3955 mOrientedXPrecision, mOrientedYPrecision, mDownTime); 3956 mSentHoverEnter = true; 3957 } 3958 3959 dispatchMotion(when, policyFlags, mSource, 3960 AMOTION_EVENT_ACTION_HOVER_MOVE, 0, metaState, mCurrentButtonState, 0, 3961 mCurrentCookedPointerData.pointerProperties, 3962 mCurrentCookedPointerData.pointerCoords, 3963 mCurrentCookedPointerData.idToIndex, 3964 mCurrentCookedPointerData.hoveringIdBits, -1, 3965 mOrientedXPrecision, mOrientedYPrecision, mDownTime); 3966 } 3967} 3968 3969void TouchInputMapper::cookPointerData() { 3970 uint32_t currentPointerCount = mCurrentRawPointerData.pointerCount; 3971 3972 mCurrentCookedPointerData.clear(); 3973 mCurrentCookedPointerData.pointerCount = currentPointerCount; 3974 mCurrentCookedPointerData.hoveringIdBits = mCurrentRawPointerData.hoveringIdBits; 3975 mCurrentCookedPointerData.touchingIdBits = mCurrentRawPointerData.touchingIdBits; 3976 3977 // Walk through the the active pointers and map device coordinates onto 3978 // surface coordinates and adjust for display orientation. 3979 for (uint32_t i = 0; i < currentPointerCount; i++) { 3980 const RawPointerData::Pointer& in = mCurrentRawPointerData.pointers[i]; 3981 3982 // Size 3983 float touchMajor, touchMinor, toolMajor, toolMinor, size; 3984 switch (mCalibration.sizeCalibration) { 3985 case Calibration::SIZE_CALIBRATION_GEOMETRIC: 3986 case Calibration::SIZE_CALIBRATION_DIAMETER: 3987 case Calibration::SIZE_CALIBRATION_AREA: 3988 if (mRawPointerAxes.touchMajor.valid && mRawPointerAxes.toolMajor.valid) { 3989 touchMajor = in.touchMajor; 3990 touchMinor = mRawPointerAxes.touchMinor.valid ? in.touchMinor : in.touchMajor; 3991 toolMajor = in.toolMajor; 3992 toolMinor = mRawPointerAxes.toolMinor.valid ? in.toolMinor : in.toolMajor; 3993 size = mRawPointerAxes.touchMinor.valid 3994 ? avg(in.touchMajor, in.touchMinor) : in.touchMajor; 3995 } else if (mRawPointerAxes.touchMajor.valid) { 3996 toolMajor = touchMajor = in.touchMajor; 3997 toolMinor = touchMinor = mRawPointerAxes.touchMinor.valid 3998 ? in.touchMinor : in.touchMajor; 3999 size = mRawPointerAxes.touchMinor.valid 4000 ? avg(in.touchMajor, in.touchMinor) : in.touchMajor; 4001 } else if (mRawPointerAxes.toolMajor.valid) { 4002 touchMajor = toolMajor = in.toolMajor; 4003 touchMinor = toolMinor = mRawPointerAxes.toolMinor.valid 4004 ? in.toolMinor : in.toolMajor; 4005 size = mRawPointerAxes.toolMinor.valid 4006 ? avg(in.toolMajor, in.toolMinor) : in.toolMajor; 4007 } else { 4008 ALOG_ASSERT(false, "No touch or tool axes. " 4009 "Size calibration should have been resolved to NONE."); 4010 touchMajor = 0; 4011 touchMinor = 0; 4012 toolMajor = 0; 4013 toolMinor = 0; 4014 size = 0; 4015 } 4016 4017 if (mCalibration.haveSizeIsSummed && mCalibration.sizeIsSummed) { 4018 uint32_t touchingCount = mCurrentRawPointerData.touchingIdBits.count(); 4019 if (touchingCount > 1) { 4020 touchMajor /= touchingCount; 4021 touchMinor /= touchingCount; 4022 toolMajor /= touchingCount; 4023 toolMinor /= touchingCount; 4024 size /= touchingCount; 4025 } 4026 } 4027 4028 if (mCalibration.sizeCalibration == Calibration::SIZE_CALIBRATION_GEOMETRIC) { 4029 touchMajor *= mGeometricScale; 4030 touchMinor *= mGeometricScale; 4031 toolMajor *= mGeometricScale; 4032 toolMinor *= mGeometricScale; 4033 } else if (mCalibration.sizeCalibration == Calibration::SIZE_CALIBRATION_AREA) { 4034 touchMajor = touchMajor > 0 ? sqrtf(touchMajor) : 0; 4035 touchMinor = touchMajor; 4036 toolMajor = toolMajor > 0 ? sqrtf(toolMajor) : 0; 4037 toolMinor = toolMajor; 4038 } else if (mCalibration.sizeCalibration == Calibration::SIZE_CALIBRATION_DIAMETER) { 4039 touchMinor = touchMajor; 4040 toolMinor = toolMajor; 4041 } 4042 4043 mCalibration.applySizeScaleAndBias(&touchMajor); 4044 mCalibration.applySizeScaleAndBias(&touchMinor); 4045 mCalibration.applySizeScaleAndBias(&toolMajor); 4046 mCalibration.applySizeScaleAndBias(&toolMinor); 4047 size *= mSizeScale; 4048 break; 4049 default: 4050 touchMajor = 0; 4051 touchMinor = 0; 4052 toolMajor = 0; 4053 toolMinor = 0; 4054 size = 0; 4055 break; 4056 } 4057 4058 // Pressure 4059 float pressure; 4060 switch (mCalibration.pressureCalibration) { 4061 case Calibration::PRESSURE_CALIBRATION_PHYSICAL: 4062 case Calibration::PRESSURE_CALIBRATION_AMPLITUDE: 4063 pressure = in.pressure * mPressureScale; 4064 break; 4065 default: 4066 pressure = in.isHovering ? 0 : 1; 4067 break; 4068 } 4069 4070 // Tilt and Orientation 4071 float tilt; 4072 float orientation; 4073 if (mHaveTilt) { 4074 float tiltXAngle = (in.tiltX - mTiltXCenter) * mTiltXScale; 4075 float tiltYAngle = (in.tiltY - mTiltYCenter) * mTiltYScale; 4076 orientation = atan2f(-sinf(tiltXAngle), sinf(tiltYAngle)); 4077 tilt = acosf(cosf(tiltXAngle) * cosf(tiltYAngle)); 4078 } else { 4079 tilt = 0; 4080 4081 switch (mCalibration.orientationCalibration) { 4082 case Calibration::ORIENTATION_CALIBRATION_INTERPOLATED: 4083 orientation = (in.orientation - mOrientationCenter) * mOrientationScale; 4084 break; 4085 case Calibration::ORIENTATION_CALIBRATION_VECTOR: { 4086 int32_t c1 = signExtendNybble((in.orientation & 0xf0) >> 4); 4087 int32_t c2 = signExtendNybble(in.orientation & 0x0f); 4088 if (c1 != 0 || c2 != 0) { 4089 orientation = atan2f(c1, c2) * 0.5f; 4090 float confidence = hypotf(c1, c2); 4091 float scale = 1.0f + confidence / 16.0f; 4092 touchMajor *= scale; 4093 touchMinor /= scale; 4094 toolMajor *= scale; 4095 toolMinor /= scale; 4096 } else { 4097 orientation = 0; 4098 } 4099 break; 4100 } 4101 default: 4102 orientation = 0; 4103 } 4104 } 4105 4106 // Distance 4107 float distance; 4108 switch (mCalibration.distanceCalibration) { 4109 case Calibration::DISTANCE_CALIBRATION_SCALED: 4110 distance = in.distance * mDistanceScale; 4111 break; 4112 default: 4113 distance = 0; 4114 } 4115 4116 // X and Y 4117 // Adjust coords for surface orientation. 4118 float x, y; 4119 switch (mSurfaceOrientation) { 4120 case DISPLAY_ORIENTATION_90: 4121 x = float(in.y - mRawPointerAxes.y.minValue) * mYScale; 4122 y = float(mRawPointerAxes.x.maxValue - in.x) * mXScale; 4123 orientation -= M_PI_2; 4124 if (orientation < - M_PI_2) { 4125 orientation += M_PI; 4126 } 4127 break; 4128 case DISPLAY_ORIENTATION_180: 4129 x = float(mRawPointerAxes.x.maxValue - in.x) * mXScale; 4130 y = float(mRawPointerAxes.y.maxValue - in.y) * mYScale; 4131 break; 4132 case DISPLAY_ORIENTATION_270: 4133 x = float(mRawPointerAxes.y.maxValue - in.y) * mYScale; 4134 y = float(in.x - mRawPointerAxes.x.minValue) * mXScale; 4135 orientation += M_PI_2; 4136 if (orientation > M_PI_2) { 4137 orientation -= M_PI; 4138 } 4139 break; 4140 default: 4141 x = float(in.x - mRawPointerAxes.x.minValue) * mXScale; 4142 y = float(in.y - mRawPointerAxes.y.minValue) * mYScale; 4143 break; 4144 } 4145 4146 // Write output coords. 4147 PointerCoords& out = mCurrentCookedPointerData.pointerCoords[i]; 4148 out.clear(); 4149 out.setAxisValue(AMOTION_EVENT_AXIS_X, x); 4150 out.setAxisValue(AMOTION_EVENT_AXIS_Y, y); 4151 out.setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, pressure); 4152 out.setAxisValue(AMOTION_EVENT_AXIS_SIZE, size); 4153 out.setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, touchMajor); 4154 out.setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, touchMinor); 4155 out.setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, toolMajor); 4156 out.setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, toolMinor); 4157 out.setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, orientation); 4158 out.setAxisValue(AMOTION_EVENT_AXIS_TILT, tilt); 4159 out.setAxisValue(AMOTION_EVENT_AXIS_DISTANCE, distance); 4160 4161 // Write output properties. 4162 PointerProperties& properties = mCurrentCookedPointerData.pointerProperties[i]; 4163 uint32_t id = in.id; 4164 properties.clear(); 4165 properties.id = id; 4166 properties.toolType = in.toolType; 4167 4168 // Write id index. 4169 mCurrentCookedPointerData.idToIndex[id] = i; 4170 } 4171} 4172 4173void TouchInputMapper::dispatchPointerUsage(nsecs_t when, uint32_t policyFlags, 4174 PointerUsage pointerUsage) { 4175 if (pointerUsage != mPointerUsage) { 4176 abortPointerUsage(when, policyFlags); 4177 mPointerUsage = pointerUsage; 4178 } 4179 4180 switch (mPointerUsage) { 4181 case POINTER_USAGE_GESTURES: 4182 dispatchPointerGestures(when, policyFlags, false /*isTimeout*/); 4183 break; 4184 case POINTER_USAGE_STYLUS: 4185 dispatchPointerStylus(when, policyFlags); 4186 break; 4187 case POINTER_USAGE_MOUSE: 4188 dispatchPointerMouse(when, policyFlags); 4189 break; 4190 default: 4191 break; 4192 } 4193} 4194 4195void TouchInputMapper::abortPointerUsage(nsecs_t when, uint32_t policyFlags) { 4196 switch (mPointerUsage) { 4197 case POINTER_USAGE_GESTURES: 4198 abortPointerGestures(when, policyFlags); 4199 break; 4200 case POINTER_USAGE_STYLUS: 4201 abortPointerStylus(when, policyFlags); 4202 break; 4203 case POINTER_USAGE_MOUSE: 4204 abortPointerMouse(when, policyFlags); 4205 break; 4206 default: 4207 break; 4208 } 4209 4210 mPointerUsage = POINTER_USAGE_NONE; 4211} 4212 4213void TouchInputMapper::dispatchPointerGestures(nsecs_t when, uint32_t policyFlags, 4214 bool isTimeout) { 4215 // Update current gesture coordinates. 4216 bool cancelPreviousGesture, finishPreviousGesture; 4217 bool sendEvents = preparePointerGestures(when, 4218 &cancelPreviousGesture, &finishPreviousGesture, isTimeout); 4219 if (!sendEvents) { 4220 return; 4221 } 4222 if (finishPreviousGesture) { 4223 cancelPreviousGesture = false; 4224 } 4225 4226 // Update the pointer presentation and spots. 4227 if (mParameters.gestureMode == Parameters::GESTURE_MODE_SPOTS) { 4228 mPointerController->setPresentation(PointerControllerInterface::PRESENTATION_SPOT); 4229 if (finishPreviousGesture || cancelPreviousGesture) { 4230 mPointerController->clearSpots(); 4231 } 4232 mPointerController->setSpots(mPointerGesture.currentGestureCoords, 4233 mPointerGesture.currentGestureIdToIndex, 4234 mPointerGesture.currentGestureIdBits); 4235 } else { 4236 mPointerController->setPresentation(PointerControllerInterface::PRESENTATION_POINTER); 4237 } 4238 4239 // Show or hide the pointer if needed. 4240 switch (mPointerGesture.currentGestureMode) { 4241 case PointerGesture::NEUTRAL: 4242 case PointerGesture::QUIET: 4243 if (mParameters.gestureMode == Parameters::GESTURE_MODE_SPOTS 4244 && (mPointerGesture.lastGestureMode == PointerGesture::SWIPE 4245 || mPointerGesture.lastGestureMode == PointerGesture::FREEFORM)) { 4246 // Remind the user of where the pointer is after finishing a gesture with spots. 4247 mPointerController->unfade(PointerControllerInterface::TRANSITION_GRADUAL); 4248 } 4249 break; 4250 case PointerGesture::TAP: 4251 case PointerGesture::TAP_DRAG: 4252 case PointerGesture::BUTTON_CLICK_OR_DRAG: 4253 case PointerGesture::HOVER: 4254 case PointerGesture::PRESS: 4255 // Unfade the pointer when the current gesture manipulates the 4256 // area directly under the pointer. 4257 mPointerController->unfade(PointerControllerInterface::TRANSITION_IMMEDIATE); 4258 break; 4259 case PointerGesture::SWIPE: 4260 case PointerGesture::FREEFORM: 4261 // Fade the pointer when the current gesture manipulates a different 4262 // area and there are spots to guide the user experience. 4263 if (mParameters.gestureMode == Parameters::GESTURE_MODE_SPOTS) { 4264 mPointerController->fade(PointerControllerInterface::TRANSITION_GRADUAL); 4265 } else { 4266 mPointerController->unfade(PointerControllerInterface::TRANSITION_IMMEDIATE); 4267 } 4268 break; 4269 } 4270 4271 // Send events! 4272 int32_t metaState = getContext()->getGlobalMetaState(); 4273 int32_t buttonState = mCurrentButtonState; 4274 4275 // Update last coordinates of pointers that have moved so that we observe the new 4276 // pointer positions at the same time as other pointers that have just gone up. 4277 bool down = mPointerGesture.currentGestureMode == PointerGesture::TAP 4278 || mPointerGesture.currentGestureMode == PointerGesture::TAP_DRAG 4279 || mPointerGesture.currentGestureMode == PointerGesture::BUTTON_CLICK_OR_DRAG 4280 || mPointerGesture.currentGestureMode == PointerGesture::PRESS 4281 || mPointerGesture.currentGestureMode == PointerGesture::SWIPE 4282 || mPointerGesture.currentGestureMode == PointerGesture::FREEFORM; 4283 bool moveNeeded = false; 4284 if (down && !cancelPreviousGesture && !finishPreviousGesture 4285 && !mPointerGesture.lastGestureIdBits.isEmpty() 4286 && !mPointerGesture.currentGestureIdBits.isEmpty()) { 4287 BitSet32 movedGestureIdBits(mPointerGesture.currentGestureIdBits.value 4288 & mPointerGesture.lastGestureIdBits.value); 4289 moveNeeded = updateMovedPointers(mPointerGesture.currentGestureProperties, 4290 mPointerGesture.currentGestureCoords, mPointerGesture.currentGestureIdToIndex, 4291 mPointerGesture.lastGestureProperties, 4292 mPointerGesture.lastGestureCoords, mPointerGesture.lastGestureIdToIndex, 4293 movedGestureIdBits); 4294 if (buttonState != mLastButtonState) { 4295 moveNeeded = true; 4296 } 4297 } 4298 4299 // Send motion events for all pointers that went up or were canceled. 4300 BitSet32 dispatchedGestureIdBits(mPointerGesture.lastGestureIdBits); 4301 if (!dispatchedGestureIdBits.isEmpty()) { 4302 if (cancelPreviousGesture) { 4303 dispatchMotion(when, policyFlags, mSource, 4304 AMOTION_EVENT_ACTION_CANCEL, 0, metaState, buttonState, 4305 AMOTION_EVENT_EDGE_FLAG_NONE, 4306 mPointerGesture.lastGestureProperties, 4307 mPointerGesture.lastGestureCoords, mPointerGesture.lastGestureIdToIndex, 4308 dispatchedGestureIdBits, -1, 4309 0, 0, mPointerGesture.downTime); 4310 4311 dispatchedGestureIdBits.clear(); 4312 } else { 4313 BitSet32 upGestureIdBits; 4314 if (finishPreviousGesture) { 4315 upGestureIdBits = dispatchedGestureIdBits; 4316 } else { 4317 upGestureIdBits.value = dispatchedGestureIdBits.value 4318 & ~mPointerGesture.currentGestureIdBits.value; 4319 } 4320 while (!upGestureIdBits.isEmpty()) { 4321 uint32_t id = upGestureIdBits.clearFirstMarkedBit(); 4322 4323 dispatchMotion(when, policyFlags, mSource, 4324 AMOTION_EVENT_ACTION_POINTER_UP, 0, 4325 metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, 4326 mPointerGesture.lastGestureProperties, 4327 mPointerGesture.lastGestureCoords, mPointerGesture.lastGestureIdToIndex, 4328 dispatchedGestureIdBits, id, 4329 0, 0, mPointerGesture.downTime); 4330 4331 dispatchedGestureIdBits.clearBit(id); 4332 } 4333 } 4334 } 4335 4336 // Send motion events for all pointers that moved. 4337 if (moveNeeded) { 4338 dispatchMotion(when, policyFlags, mSource, 4339 AMOTION_EVENT_ACTION_MOVE, 0, metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, 4340 mPointerGesture.currentGestureProperties, 4341 mPointerGesture.currentGestureCoords, mPointerGesture.currentGestureIdToIndex, 4342 dispatchedGestureIdBits, -1, 4343 0, 0, mPointerGesture.downTime); 4344 } 4345 4346 // Send motion events for all pointers that went down. 4347 if (down) { 4348 BitSet32 downGestureIdBits(mPointerGesture.currentGestureIdBits.value 4349 & ~dispatchedGestureIdBits.value); 4350 while (!downGestureIdBits.isEmpty()) { 4351 uint32_t id = downGestureIdBits.clearFirstMarkedBit(); 4352 dispatchedGestureIdBits.markBit(id); 4353 4354 if (dispatchedGestureIdBits.count() == 1) { 4355 mPointerGesture.downTime = when; 4356 } 4357 4358 dispatchMotion(when, policyFlags, mSource, 4359 AMOTION_EVENT_ACTION_POINTER_DOWN, 0, metaState, buttonState, 0, 4360 mPointerGesture.currentGestureProperties, 4361 mPointerGesture.currentGestureCoords, mPointerGesture.currentGestureIdToIndex, 4362 dispatchedGestureIdBits, id, 4363 0, 0, mPointerGesture.downTime); 4364 } 4365 } 4366 4367 // Send motion events for hover. 4368 if (mPointerGesture.currentGestureMode == PointerGesture::HOVER) { 4369 dispatchMotion(when, policyFlags, mSource, 4370 AMOTION_EVENT_ACTION_HOVER_MOVE, 0, 4371 metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, 4372 mPointerGesture.currentGestureProperties, 4373 mPointerGesture.currentGestureCoords, mPointerGesture.currentGestureIdToIndex, 4374 mPointerGesture.currentGestureIdBits, -1, 4375 0, 0, mPointerGesture.downTime); 4376 } else if (dispatchedGestureIdBits.isEmpty() 4377 && !mPointerGesture.lastGestureIdBits.isEmpty()) { 4378 // Synthesize a hover move event after all pointers go up to indicate that 4379 // the pointer is hovering again even if the user is not currently touching 4380 // the touch pad. This ensures that a view will receive a fresh hover enter 4381 // event after a tap. 4382 float x, y; 4383 mPointerController->getPosition(&x, &y); 4384 4385 PointerProperties pointerProperties; 4386 pointerProperties.clear(); 4387 pointerProperties.id = 0; 4388 pointerProperties.toolType = AMOTION_EVENT_TOOL_TYPE_FINGER; 4389 4390 PointerCoords pointerCoords; 4391 pointerCoords.clear(); 4392 pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_X, x); 4393 pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_Y, y); 4394 4395 NotifyMotionArgs args(when, getDeviceId(), mSource, policyFlags, 4396 AMOTION_EVENT_ACTION_HOVER_MOVE, 0, 4397 metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, 4398 1, &pointerProperties, &pointerCoords, 0, 0, mPointerGesture.downTime); 4399 getListener()->notifyMotion(&args); 4400 } 4401 4402 // Update state. 4403 mPointerGesture.lastGestureMode = mPointerGesture.currentGestureMode; 4404 if (!down) { 4405 mPointerGesture.lastGestureIdBits.clear(); 4406 } else { 4407 mPointerGesture.lastGestureIdBits = mPointerGesture.currentGestureIdBits; 4408 for (BitSet32 idBits(mPointerGesture.currentGestureIdBits); !idBits.isEmpty(); ) { 4409 uint32_t id = idBits.clearFirstMarkedBit(); 4410 uint32_t index = mPointerGesture.currentGestureIdToIndex[id]; 4411 mPointerGesture.lastGestureProperties[index].copyFrom( 4412 mPointerGesture.currentGestureProperties[index]); 4413 mPointerGesture.lastGestureCoords[index].copyFrom( 4414 mPointerGesture.currentGestureCoords[index]); 4415 mPointerGesture.lastGestureIdToIndex[id] = index; 4416 } 4417 } 4418} 4419 4420void TouchInputMapper::abortPointerGestures(nsecs_t when, uint32_t policyFlags) { 4421 // Cancel previously dispatches pointers. 4422 if (!mPointerGesture.lastGestureIdBits.isEmpty()) { 4423 int32_t metaState = getContext()->getGlobalMetaState(); 4424 int32_t buttonState = mCurrentButtonState; 4425 dispatchMotion(when, policyFlags, mSource, 4426 AMOTION_EVENT_ACTION_CANCEL, 0, metaState, buttonState, 4427 AMOTION_EVENT_EDGE_FLAG_NONE, 4428 mPointerGesture.lastGestureProperties, 4429 mPointerGesture.lastGestureCoords, mPointerGesture.lastGestureIdToIndex, 4430 mPointerGesture.lastGestureIdBits, -1, 4431 0, 0, mPointerGesture.downTime); 4432 } 4433 4434 // Reset the current pointer gesture. 4435 mPointerGesture.reset(); 4436 mPointerVelocityControl.reset(); 4437 4438 // Remove any current spots. 4439 if (mPointerController != NULL) { 4440 mPointerController->fade(PointerControllerInterface::TRANSITION_GRADUAL); 4441 mPointerController->clearSpots(); 4442 } 4443} 4444 4445bool TouchInputMapper::preparePointerGestures(nsecs_t when, 4446 bool* outCancelPreviousGesture, bool* outFinishPreviousGesture, bool isTimeout) { 4447 *outCancelPreviousGesture = false; 4448 *outFinishPreviousGesture = false; 4449 4450 // Handle TAP timeout. 4451 if (isTimeout) { 4452#if DEBUG_GESTURES 4453 ALOGD("Gestures: Processing timeout"); 4454#endif 4455 4456 if (mPointerGesture.lastGestureMode == PointerGesture::TAP) { 4457 if (when <= mPointerGesture.tapUpTime + mConfig.pointerGestureTapDragInterval) { 4458 // The tap/drag timeout has not yet expired. 4459 getContext()->requestTimeoutAtTime(mPointerGesture.tapUpTime 4460 + mConfig.pointerGestureTapDragInterval); 4461 } else { 4462 // The tap is finished. 4463#if DEBUG_GESTURES 4464 ALOGD("Gestures: TAP finished"); 4465#endif 4466 *outFinishPreviousGesture = true; 4467 4468 mPointerGesture.activeGestureId = -1; 4469 mPointerGesture.currentGestureMode = PointerGesture::NEUTRAL; 4470 mPointerGesture.currentGestureIdBits.clear(); 4471 4472 mPointerVelocityControl.reset(); 4473 return true; 4474 } 4475 } 4476 4477 // We did not handle this timeout. 4478 return false; 4479 } 4480 4481 const uint32_t currentFingerCount = mCurrentFingerIdBits.count(); 4482 const uint32_t lastFingerCount = mLastFingerIdBits.count(); 4483 4484 // Update the velocity tracker. 4485 { 4486 VelocityTracker::Position positions[MAX_POINTERS]; 4487 uint32_t count = 0; 4488 for (BitSet32 idBits(mCurrentFingerIdBits); !idBits.isEmpty(); count++) { 4489 uint32_t id = idBits.clearFirstMarkedBit(); 4490 const RawPointerData::Pointer& pointer = mCurrentRawPointerData.pointerForId(id); 4491 positions[count].x = pointer.x * mPointerXMovementScale; 4492 positions[count].y = pointer.y * mPointerYMovementScale; 4493 } 4494 mPointerGesture.velocityTracker.addMovement(when, 4495 mCurrentFingerIdBits, positions); 4496 } 4497 4498 // Pick a new active touch id if needed. 4499 // Choose an arbitrary pointer that just went down, if there is one. 4500 // Otherwise choose an arbitrary remaining pointer. 4501 // This guarantees we always have an active touch id when there is at least one pointer. 4502 // We keep the same active touch id for as long as possible. 4503 bool activeTouchChanged = false; 4504 int32_t lastActiveTouchId = mPointerGesture.activeTouchId; 4505 int32_t activeTouchId = lastActiveTouchId; 4506 if (activeTouchId < 0) { 4507 if (!mCurrentFingerIdBits.isEmpty()) { 4508 activeTouchChanged = true; 4509 activeTouchId = mPointerGesture.activeTouchId = 4510 mCurrentFingerIdBits.firstMarkedBit(); 4511 mPointerGesture.firstTouchTime = when; 4512 } 4513 } else if (!mCurrentFingerIdBits.hasBit(activeTouchId)) { 4514 activeTouchChanged = true; 4515 if (!mCurrentFingerIdBits.isEmpty()) { 4516 activeTouchId = mPointerGesture.activeTouchId = 4517 mCurrentFingerIdBits.firstMarkedBit(); 4518 } else { 4519 activeTouchId = mPointerGesture.activeTouchId = -1; 4520 } 4521 } 4522 4523 // Determine whether we are in quiet time. 4524 bool isQuietTime = false; 4525 if (activeTouchId < 0) { 4526 mPointerGesture.resetQuietTime(); 4527 } else { 4528 isQuietTime = when < mPointerGesture.quietTime + mConfig.pointerGestureQuietInterval; 4529 if (!isQuietTime) { 4530 if ((mPointerGesture.lastGestureMode == PointerGesture::PRESS 4531 || mPointerGesture.lastGestureMode == PointerGesture::SWIPE 4532 || mPointerGesture.lastGestureMode == PointerGesture::FREEFORM) 4533 && currentFingerCount < 2) { 4534 // Enter quiet time when exiting swipe or freeform state. 4535 // This is to prevent accidentally entering the hover state and flinging the 4536 // pointer when finishing a swipe and there is still one pointer left onscreen. 4537 isQuietTime = true; 4538 } else if (mPointerGesture.lastGestureMode == PointerGesture::BUTTON_CLICK_OR_DRAG 4539 && currentFingerCount >= 2 4540 && !isPointerDown(mCurrentButtonState)) { 4541 // Enter quiet time when releasing the button and there are still two or more 4542 // fingers down. This may indicate that one finger was used to press the button 4543 // but it has not gone up yet. 4544 isQuietTime = true; 4545 } 4546 if (isQuietTime) { 4547 mPointerGesture.quietTime = when; 4548 } 4549 } 4550 } 4551 4552 // Switch states based on button and pointer state. 4553 if (isQuietTime) { 4554 // Case 1: Quiet time. (QUIET) 4555#if DEBUG_GESTURES 4556 ALOGD("Gestures: QUIET for next %0.3fms", (mPointerGesture.quietTime 4557 + mConfig.pointerGestureQuietInterval - when) * 0.000001f); 4558#endif 4559 if (mPointerGesture.lastGestureMode != PointerGesture::QUIET) { 4560 *outFinishPreviousGesture = true; 4561 } 4562 4563 mPointerGesture.activeGestureId = -1; 4564 mPointerGesture.currentGestureMode = PointerGesture::QUIET; 4565 mPointerGesture.currentGestureIdBits.clear(); 4566 4567 mPointerVelocityControl.reset(); 4568 } else if (isPointerDown(mCurrentButtonState)) { 4569 // Case 2: Button is pressed. (BUTTON_CLICK_OR_DRAG) 4570 // The pointer follows the active touch point. 4571 // Emit DOWN, MOVE, UP events at the pointer location. 4572 // 4573 // Only the active touch matters; other fingers are ignored. This policy helps 4574 // to handle the case where the user places a second finger on the touch pad 4575 // to apply the necessary force to depress an integrated button below the surface. 4576 // We don't want the second finger to be delivered to applications. 4577 // 4578 // For this to work well, we need to make sure to track the pointer that is really 4579 // active. If the user first puts one finger down to click then adds another 4580 // finger to drag then the active pointer should switch to the finger that is 4581 // being dragged. 4582#if DEBUG_GESTURES 4583 ALOGD("Gestures: BUTTON_CLICK_OR_DRAG activeTouchId=%d, " 4584 "currentFingerCount=%d", activeTouchId, currentFingerCount); 4585#endif 4586 // Reset state when just starting. 4587 if (mPointerGesture.lastGestureMode != PointerGesture::BUTTON_CLICK_OR_DRAG) { 4588 *outFinishPreviousGesture = true; 4589 mPointerGesture.activeGestureId = 0; 4590 } 4591 4592 // Switch pointers if needed. 4593 // Find the fastest pointer and follow it. 4594 if (activeTouchId >= 0 && currentFingerCount > 1) { 4595 int32_t bestId = -1; 4596 float bestSpeed = mConfig.pointerGestureDragMinSwitchSpeed; 4597 for (BitSet32 idBits(mCurrentFingerIdBits); !idBits.isEmpty(); ) { 4598 uint32_t id = idBits.clearFirstMarkedBit(); 4599 float vx, vy; 4600 if (mPointerGesture.velocityTracker.getVelocity(id, &vx, &vy)) { 4601 float speed = hypotf(vx, vy); 4602 if (speed > bestSpeed) { 4603 bestId = id; 4604 bestSpeed = speed; 4605 } 4606 } 4607 } 4608 if (bestId >= 0 && bestId != activeTouchId) { 4609 mPointerGesture.activeTouchId = activeTouchId = bestId; 4610 activeTouchChanged = true; 4611#if DEBUG_GESTURES 4612 ALOGD("Gestures: BUTTON_CLICK_OR_DRAG switched pointers, " 4613 "bestId=%d, bestSpeed=%0.3f", bestId, bestSpeed); 4614#endif 4615 } 4616 } 4617 4618 if (activeTouchId >= 0 && mLastFingerIdBits.hasBit(activeTouchId)) { 4619 const RawPointerData::Pointer& currentPointer = 4620 mCurrentRawPointerData.pointerForId(activeTouchId); 4621 const RawPointerData::Pointer& lastPointer = 4622 mLastRawPointerData.pointerForId(activeTouchId); 4623 float deltaX = (currentPointer.x - lastPointer.x) * mPointerXMovementScale; 4624 float deltaY = (currentPointer.y - lastPointer.y) * mPointerYMovementScale; 4625 4626 rotateDelta(mSurfaceOrientation, &deltaX, &deltaY); 4627 mPointerVelocityControl.move(when, &deltaX, &deltaY); 4628 4629 // Move the pointer using a relative motion. 4630 // When using spots, the click will occur at the position of the anchor 4631 // spot and all other spots will move there. 4632 mPointerController->move(deltaX, deltaY); 4633 } else { 4634 mPointerVelocityControl.reset(); 4635 } 4636 4637 float x, y; 4638 mPointerController->getPosition(&x, &y); 4639 4640 mPointerGesture.currentGestureMode = PointerGesture::BUTTON_CLICK_OR_DRAG; 4641 mPointerGesture.currentGestureIdBits.clear(); 4642 mPointerGesture.currentGestureIdBits.markBit(mPointerGesture.activeGestureId); 4643 mPointerGesture.currentGestureIdToIndex[mPointerGesture.activeGestureId] = 0; 4644 mPointerGesture.currentGestureProperties[0].clear(); 4645 mPointerGesture.currentGestureProperties[0].id = mPointerGesture.activeGestureId; 4646 mPointerGesture.currentGestureProperties[0].toolType = AMOTION_EVENT_TOOL_TYPE_FINGER; 4647 mPointerGesture.currentGestureCoords[0].clear(); 4648 mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X, x); 4649 mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y, y); 4650 mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 1.0f); 4651 } else if (currentFingerCount == 0) { 4652 // Case 3. No fingers down and button is not pressed. (NEUTRAL) 4653 if (mPointerGesture.lastGestureMode != PointerGesture::NEUTRAL) { 4654 *outFinishPreviousGesture = true; 4655 } 4656 4657 // Watch for taps coming out of HOVER or TAP_DRAG mode. 4658 // Checking for taps after TAP_DRAG allows us to detect double-taps. 4659 bool tapped = false; 4660 if ((mPointerGesture.lastGestureMode == PointerGesture::HOVER 4661 || mPointerGesture.lastGestureMode == PointerGesture::TAP_DRAG) 4662 && lastFingerCount == 1) { 4663 if (when <= mPointerGesture.tapDownTime + mConfig.pointerGestureTapInterval) { 4664 float x, y; 4665 mPointerController->getPosition(&x, &y); 4666 if (fabs(x - mPointerGesture.tapX) <= mConfig.pointerGestureTapSlop 4667 && fabs(y - mPointerGesture.tapY) <= mConfig.pointerGestureTapSlop) { 4668#if DEBUG_GESTURES 4669 ALOGD("Gestures: TAP"); 4670#endif 4671 4672 mPointerGesture.tapUpTime = when; 4673 getContext()->requestTimeoutAtTime(when 4674 + mConfig.pointerGestureTapDragInterval); 4675 4676 mPointerGesture.activeGestureId = 0; 4677 mPointerGesture.currentGestureMode = PointerGesture::TAP; 4678 mPointerGesture.currentGestureIdBits.clear(); 4679 mPointerGesture.currentGestureIdBits.markBit( 4680 mPointerGesture.activeGestureId); 4681 mPointerGesture.currentGestureIdToIndex[ 4682 mPointerGesture.activeGestureId] = 0; 4683 mPointerGesture.currentGestureProperties[0].clear(); 4684 mPointerGesture.currentGestureProperties[0].id = 4685 mPointerGesture.activeGestureId; 4686 mPointerGesture.currentGestureProperties[0].toolType = 4687 AMOTION_EVENT_TOOL_TYPE_FINGER; 4688 mPointerGesture.currentGestureCoords[0].clear(); 4689 mPointerGesture.currentGestureCoords[0].setAxisValue( 4690 AMOTION_EVENT_AXIS_X, mPointerGesture.tapX); 4691 mPointerGesture.currentGestureCoords[0].setAxisValue( 4692 AMOTION_EVENT_AXIS_Y, mPointerGesture.tapY); 4693 mPointerGesture.currentGestureCoords[0].setAxisValue( 4694 AMOTION_EVENT_AXIS_PRESSURE, 1.0f); 4695 4696 tapped = true; 4697 } else { 4698#if DEBUG_GESTURES 4699 ALOGD("Gestures: Not a TAP, deltaX=%f, deltaY=%f", 4700 x - mPointerGesture.tapX, 4701 y - mPointerGesture.tapY); 4702#endif 4703 } 4704 } else { 4705#if DEBUG_GESTURES 4706 ALOGD("Gestures: Not a TAP, %0.3fms since down", 4707 (when - mPointerGesture.tapDownTime) * 0.000001f); 4708#endif 4709 } 4710 } 4711 4712 mPointerVelocityControl.reset(); 4713 4714 if (!tapped) { 4715#if DEBUG_GESTURES 4716 ALOGD("Gestures: NEUTRAL"); 4717#endif 4718 mPointerGesture.activeGestureId = -1; 4719 mPointerGesture.currentGestureMode = PointerGesture::NEUTRAL; 4720 mPointerGesture.currentGestureIdBits.clear(); 4721 } 4722 } else if (currentFingerCount == 1) { 4723 // Case 4. Exactly one finger down, button is not pressed. (HOVER or TAP_DRAG) 4724 // The pointer follows the active touch point. 4725 // When in HOVER, emit HOVER_MOVE events at the pointer location. 4726 // When in TAP_DRAG, emit MOVE events at the pointer location. 4727 ALOG_ASSERT(activeTouchId >= 0); 4728 4729 mPointerGesture.currentGestureMode = PointerGesture::HOVER; 4730 if (mPointerGesture.lastGestureMode == PointerGesture::TAP) { 4731 if (when <= mPointerGesture.tapUpTime + mConfig.pointerGestureTapDragInterval) { 4732 float x, y; 4733 mPointerController->getPosition(&x, &y); 4734 if (fabs(x - mPointerGesture.tapX) <= mConfig.pointerGestureTapSlop 4735 && fabs(y - mPointerGesture.tapY) <= mConfig.pointerGestureTapSlop) { 4736 mPointerGesture.currentGestureMode = PointerGesture::TAP_DRAG; 4737 } else { 4738#if DEBUG_GESTURES 4739 ALOGD("Gestures: Not a TAP_DRAG, deltaX=%f, deltaY=%f", 4740 x - mPointerGesture.tapX, 4741 y - mPointerGesture.tapY); 4742#endif 4743 } 4744 } else { 4745#if DEBUG_GESTURES 4746 ALOGD("Gestures: Not a TAP_DRAG, %0.3fms time since up", 4747 (when - mPointerGesture.tapUpTime) * 0.000001f); 4748#endif 4749 } 4750 } else if (mPointerGesture.lastGestureMode == PointerGesture::TAP_DRAG) { 4751 mPointerGesture.currentGestureMode = PointerGesture::TAP_DRAG; 4752 } 4753 4754 if (mLastFingerIdBits.hasBit(activeTouchId)) { 4755 const RawPointerData::Pointer& currentPointer = 4756 mCurrentRawPointerData.pointerForId(activeTouchId); 4757 const RawPointerData::Pointer& lastPointer = 4758 mLastRawPointerData.pointerForId(activeTouchId); 4759 float deltaX = (currentPointer.x - lastPointer.x) 4760 * mPointerXMovementScale; 4761 float deltaY = (currentPointer.y - lastPointer.y) 4762 * mPointerYMovementScale; 4763 4764 rotateDelta(mSurfaceOrientation, &deltaX, &deltaY); 4765 mPointerVelocityControl.move(when, &deltaX, &deltaY); 4766 4767 // Move the pointer using a relative motion. 4768 // When using spots, the hover or drag will occur at the position of the anchor spot. 4769 mPointerController->move(deltaX, deltaY); 4770 } else { 4771 mPointerVelocityControl.reset(); 4772 } 4773 4774 bool down; 4775 if (mPointerGesture.currentGestureMode == PointerGesture::TAP_DRAG) { 4776#if DEBUG_GESTURES 4777 ALOGD("Gestures: TAP_DRAG"); 4778#endif 4779 down = true; 4780 } else { 4781#if DEBUG_GESTURES 4782 ALOGD("Gestures: HOVER"); 4783#endif 4784 if (mPointerGesture.lastGestureMode != PointerGesture::HOVER) { 4785 *outFinishPreviousGesture = true; 4786 } 4787 mPointerGesture.activeGestureId = 0; 4788 down = false; 4789 } 4790 4791 float x, y; 4792 mPointerController->getPosition(&x, &y); 4793 4794 mPointerGesture.currentGestureIdBits.clear(); 4795 mPointerGesture.currentGestureIdBits.markBit(mPointerGesture.activeGestureId); 4796 mPointerGesture.currentGestureIdToIndex[mPointerGesture.activeGestureId] = 0; 4797 mPointerGesture.currentGestureProperties[0].clear(); 4798 mPointerGesture.currentGestureProperties[0].id = mPointerGesture.activeGestureId; 4799 mPointerGesture.currentGestureProperties[0].toolType = 4800 AMOTION_EVENT_TOOL_TYPE_FINGER; 4801 mPointerGesture.currentGestureCoords[0].clear(); 4802 mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X, x); 4803 mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y, y); 4804 mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 4805 down ? 1.0f : 0.0f); 4806 4807 if (lastFingerCount == 0 && currentFingerCount != 0) { 4808 mPointerGesture.resetTap(); 4809 mPointerGesture.tapDownTime = when; 4810 mPointerGesture.tapX = x; 4811 mPointerGesture.tapY = y; 4812 } 4813 } else { 4814 // Case 5. At least two fingers down, button is not pressed. (PRESS, SWIPE or FREEFORM) 4815 // We need to provide feedback for each finger that goes down so we cannot wait 4816 // for the fingers to move before deciding what to do. 4817 // 4818 // The ambiguous case is deciding what to do when there are two fingers down but they 4819 // have not moved enough to determine whether they are part of a drag or part of a 4820 // freeform gesture, or just a press or long-press at the pointer location. 4821 // 4822 // When there are two fingers we start with the PRESS hypothesis and we generate a 4823 // down at the pointer location. 4824 // 4825 // When the two fingers move enough or when additional fingers are added, we make 4826 // a decision to transition into SWIPE or FREEFORM mode accordingly. 4827 ALOG_ASSERT(activeTouchId >= 0); 4828 4829 bool settled = when >= mPointerGesture.firstTouchTime 4830 + mConfig.pointerGestureMultitouchSettleInterval; 4831 if (mPointerGesture.lastGestureMode != PointerGesture::PRESS 4832 && mPointerGesture.lastGestureMode != PointerGesture::SWIPE 4833 && mPointerGesture.lastGestureMode != PointerGesture::FREEFORM) { 4834 *outFinishPreviousGesture = true; 4835 } else if (!settled && currentFingerCount > lastFingerCount) { 4836 // Additional pointers have gone down but not yet settled. 4837 // Reset the gesture. 4838#if DEBUG_GESTURES 4839 ALOGD("Gestures: Resetting gesture since additional pointers went down for MULTITOUCH, " 4840 "settle time remaining %0.3fms", (mPointerGesture.firstTouchTime 4841 + mConfig.pointerGestureMultitouchSettleInterval - when) 4842 * 0.000001f); 4843#endif 4844 *outCancelPreviousGesture = true; 4845 } else { 4846 // Continue previous gesture. 4847 mPointerGesture.currentGestureMode = mPointerGesture.lastGestureMode; 4848 } 4849 4850 if (*outFinishPreviousGesture || *outCancelPreviousGesture) { 4851 mPointerGesture.currentGestureMode = PointerGesture::PRESS; 4852 mPointerGesture.activeGestureId = 0; 4853 mPointerGesture.referenceIdBits.clear(); 4854 mPointerVelocityControl.reset(); 4855 4856 // Use the centroid and pointer location as the reference points for the gesture. 4857#if DEBUG_GESTURES 4858 ALOGD("Gestures: Using centroid as reference for MULTITOUCH, " 4859 "settle time remaining %0.3fms", (mPointerGesture.firstTouchTime 4860 + mConfig.pointerGestureMultitouchSettleInterval - when) 4861 * 0.000001f); 4862#endif 4863 mCurrentRawPointerData.getCentroidOfTouchingPointers( 4864 &mPointerGesture.referenceTouchX, 4865 &mPointerGesture.referenceTouchY); 4866 mPointerController->getPosition(&mPointerGesture.referenceGestureX, 4867 &mPointerGesture.referenceGestureY); 4868 } 4869 4870 // Clear the reference deltas for fingers not yet included in the reference calculation. 4871 for (BitSet32 idBits(mCurrentFingerIdBits.value 4872 & ~mPointerGesture.referenceIdBits.value); !idBits.isEmpty(); ) { 4873 uint32_t id = idBits.clearFirstMarkedBit(); 4874 mPointerGesture.referenceDeltas[id].dx = 0; 4875 mPointerGesture.referenceDeltas[id].dy = 0; 4876 } 4877 mPointerGesture.referenceIdBits = mCurrentFingerIdBits; 4878 4879 // Add delta for all fingers and calculate a common movement delta. 4880 float commonDeltaX = 0, commonDeltaY = 0; 4881 BitSet32 commonIdBits(mLastFingerIdBits.value 4882 & mCurrentFingerIdBits.value); 4883 for (BitSet32 idBits(commonIdBits); !idBits.isEmpty(); ) { 4884 bool first = (idBits == commonIdBits); 4885 uint32_t id = idBits.clearFirstMarkedBit(); 4886 const RawPointerData::Pointer& cpd = mCurrentRawPointerData.pointerForId(id); 4887 const RawPointerData::Pointer& lpd = mLastRawPointerData.pointerForId(id); 4888 PointerGesture::Delta& delta = mPointerGesture.referenceDeltas[id]; 4889 delta.dx += cpd.x - lpd.x; 4890 delta.dy += cpd.y - lpd.y; 4891 4892 if (first) { 4893 commonDeltaX = delta.dx; 4894 commonDeltaY = delta.dy; 4895 } else { 4896 commonDeltaX = calculateCommonVector(commonDeltaX, delta.dx); 4897 commonDeltaY = calculateCommonVector(commonDeltaY, delta.dy); 4898 } 4899 } 4900 4901 // Consider transitions from PRESS to SWIPE or MULTITOUCH. 4902 if (mPointerGesture.currentGestureMode == PointerGesture::PRESS) { 4903 float dist[MAX_POINTER_ID + 1]; 4904 int32_t distOverThreshold = 0; 4905 for (BitSet32 idBits(mPointerGesture.referenceIdBits); !idBits.isEmpty(); ) { 4906 uint32_t id = idBits.clearFirstMarkedBit(); 4907 PointerGesture::Delta& delta = mPointerGesture.referenceDeltas[id]; 4908 dist[id] = hypotf(delta.dx * mPointerXZoomScale, 4909 delta.dy * mPointerYZoomScale); 4910 if (dist[id] > mConfig.pointerGestureMultitouchMinDistance) { 4911 distOverThreshold += 1; 4912 } 4913 } 4914 4915 // Only transition when at least two pointers have moved further than 4916 // the minimum distance threshold. 4917 if (distOverThreshold >= 2) { 4918 if (currentFingerCount > 2) { 4919 // There are more than two pointers, switch to FREEFORM. 4920#if DEBUG_GESTURES 4921 ALOGD("Gestures: PRESS transitioned to FREEFORM, number of pointers %d > 2", 4922 currentFingerCount); 4923#endif 4924 *outCancelPreviousGesture = true; 4925 mPointerGesture.currentGestureMode = PointerGesture::FREEFORM; 4926 } else { 4927 // There are exactly two pointers. 4928 BitSet32 idBits(mCurrentFingerIdBits); 4929 uint32_t id1 = idBits.clearFirstMarkedBit(); 4930 uint32_t id2 = idBits.firstMarkedBit(); 4931 const RawPointerData::Pointer& p1 = mCurrentRawPointerData.pointerForId(id1); 4932 const RawPointerData::Pointer& p2 = mCurrentRawPointerData.pointerForId(id2); 4933 float mutualDistance = distance(p1.x, p1.y, p2.x, p2.y); 4934 if (mutualDistance > mPointerGestureMaxSwipeWidth) { 4935 // There are two pointers but they are too far apart for a SWIPE, 4936 // switch to FREEFORM. 4937#if DEBUG_GESTURES 4938 ALOGD("Gestures: PRESS transitioned to FREEFORM, distance %0.3f > %0.3f", 4939 mutualDistance, mPointerGestureMaxSwipeWidth); 4940#endif 4941 *outCancelPreviousGesture = true; 4942 mPointerGesture.currentGestureMode = PointerGesture::FREEFORM; 4943 } else { 4944 // There are two pointers. Wait for both pointers to start moving 4945 // before deciding whether this is a SWIPE or FREEFORM gesture. 4946 float dist1 = dist[id1]; 4947 float dist2 = dist[id2]; 4948 if (dist1 >= mConfig.pointerGestureMultitouchMinDistance 4949 && dist2 >= mConfig.pointerGestureMultitouchMinDistance) { 4950 // Calculate the dot product of the displacement vectors. 4951 // When the vectors are oriented in approximately the same direction, 4952 // the angle betweeen them is near zero and the cosine of the angle 4953 // approches 1.0. Recall that dot(v1, v2) = cos(angle) * mag(v1) * mag(v2). 4954 PointerGesture::Delta& delta1 = mPointerGesture.referenceDeltas[id1]; 4955 PointerGesture::Delta& delta2 = mPointerGesture.referenceDeltas[id2]; 4956 float dx1 = delta1.dx * mPointerXZoomScale; 4957 float dy1 = delta1.dy * mPointerYZoomScale; 4958 float dx2 = delta2.dx * mPointerXZoomScale; 4959 float dy2 = delta2.dy * mPointerYZoomScale; 4960 float dot = dx1 * dx2 + dy1 * dy2; 4961 float cosine = dot / (dist1 * dist2); // denominator always > 0 4962 if (cosine >= mConfig.pointerGestureSwipeTransitionAngleCosine) { 4963 // Pointers are moving in the same direction. Switch to SWIPE. 4964#if DEBUG_GESTURES 4965 ALOGD("Gestures: PRESS transitioned to SWIPE, " 4966 "dist1 %0.3f >= %0.3f, dist2 %0.3f >= %0.3f, " 4967 "cosine %0.3f >= %0.3f", 4968 dist1, mConfig.pointerGestureMultitouchMinDistance, 4969 dist2, mConfig.pointerGestureMultitouchMinDistance, 4970 cosine, mConfig.pointerGestureSwipeTransitionAngleCosine); 4971#endif 4972 mPointerGesture.currentGestureMode = PointerGesture::SWIPE; 4973 } else { 4974 // Pointers are moving in different directions. Switch to FREEFORM. 4975#if DEBUG_GESTURES 4976 ALOGD("Gestures: PRESS transitioned to FREEFORM, " 4977 "dist1 %0.3f >= %0.3f, dist2 %0.3f >= %0.3f, " 4978 "cosine %0.3f < %0.3f", 4979 dist1, mConfig.pointerGestureMultitouchMinDistance, 4980 dist2, mConfig.pointerGestureMultitouchMinDistance, 4981 cosine, mConfig.pointerGestureSwipeTransitionAngleCosine); 4982#endif 4983 *outCancelPreviousGesture = true; 4984 mPointerGesture.currentGestureMode = PointerGesture::FREEFORM; 4985 } 4986 } 4987 } 4988 } 4989 } 4990 } else if (mPointerGesture.currentGestureMode == PointerGesture::SWIPE) { 4991 // Switch from SWIPE to FREEFORM if additional pointers go down. 4992 // Cancel previous gesture. 4993 if (currentFingerCount > 2) { 4994#if DEBUG_GESTURES 4995 ALOGD("Gestures: SWIPE transitioned to FREEFORM, number of pointers %d > 2", 4996 currentFingerCount); 4997#endif 4998 *outCancelPreviousGesture = true; 4999 mPointerGesture.currentGestureMode = PointerGesture::FREEFORM; 5000 } 5001 } 5002 5003 // Move the reference points based on the overall group motion of the fingers 5004 // except in PRESS mode while waiting for a transition to occur. 5005 if (mPointerGesture.currentGestureMode != PointerGesture::PRESS 5006 && (commonDeltaX || commonDeltaY)) { 5007 for (BitSet32 idBits(mPointerGesture.referenceIdBits); !idBits.isEmpty(); ) { 5008 uint32_t id = idBits.clearFirstMarkedBit(); 5009 PointerGesture::Delta& delta = mPointerGesture.referenceDeltas[id]; 5010 delta.dx = 0; 5011 delta.dy = 0; 5012 } 5013 5014 mPointerGesture.referenceTouchX += commonDeltaX; 5015 mPointerGesture.referenceTouchY += commonDeltaY; 5016 5017 commonDeltaX *= mPointerXMovementScale; 5018 commonDeltaY *= mPointerYMovementScale; 5019 5020 rotateDelta(mSurfaceOrientation, &commonDeltaX, &commonDeltaY); 5021 mPointerVelocityControl.move(when, &commonDeltaX, &commonDeltaY); 5022 5023 mPointerGesture.referenceGestureX += commonDeltaX; 5024 mPointerGesture.referenceGestureY += commonDeltaY; 5025 } 5026 5027 // Report gestures. 5028 if (mPointerGesture.currentGestureMode == PointerGesture::PRESS 5029 || mPointerGesture.currentGestureMode == PointerGesture::SWIPE) { 5030 // PRESS or SWIPE mode. 5031#if DEBUG_GESTURES 5032 ALOGD("Gestures: PRESS or SWIPE activeTouchId=%d," 5033 "activeGestureId=%d, currentTouchPointerCount=%d", 5034 activeTouchId, mPointerGesture.activeGestureId, currentFingerCount); 5035#endif 5036 ALOG_ASSERT(mPointerGesture.activeGestureId >= 0); 5037 5038 mPointerGesture.currentGestureIdBits.clear(); 5039 mPointerGesture.currentGestureIdBits.markBit(mPointerGesture.activeGestureId); 5040 mPointerGesture.currentGestureIdToIndex[mPointerGesture.activeGestureId] = 0; 5041 mPointerGesture.currentGestureProperties[0].clear(); 5042 mPointerGesture.currentGestureProperties[0].id = mPointerGesture.activeGestureId; 5043 mPointerGesture.currentGestureProperties[0].toolType = 5044 AMOTION_EVENT_TOOL_TYPE_FINGER; 5045 mPointerGesture.currentGestureCoords[0].clear(); 5046 mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X, 5047 mPointerGesture.referenceGestureX); 5048 mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y, 5049 mPointerGesture.referenceGestureY); 5050 mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 1.0f); 5051 } else if (mPointerGesture.currentGestureMode == PointerGesture::FREEFORM) { 5052 // FREEFORM mode. 5053#if DEBUG_GESTURES 5054 ALOGD("Gestures: FREEFORM activeTouchId=%d," 5055 "activeGestureId=%d, currentTouchPointerCount=%d", 5056 activeTouchId, mPointerGesture.activeGestureId, currentFingerCount); 5057#endif 5058 ALOG_ASSERT(mPointerGesture.activeGestureId >= 0); 5059 5060 mPointerGesture.currentGestureIdBits.clear(); 5061 5062 BitSet32 mappedTouchIdBits; 5063 BitSet32 usedGestureIdBits; 5064 if (mPointerGesture.lastGestureMode != PointerGesture::FREEFORM) { 5065 // Initially, assign the active gesture id to the active touch point 5066 // if there is one. No other touch id bits are mapped yet. 5067 if (!*outCancelPreviousGesture) { 5068 mappedTouchIdBits.markBit(activeTouchId); 5069 usedGestureIdBits.markBit(mPointerGesture.activeGestureId); 5070 mPointerGesture.freeformTouchToGestureIdMap[activeTouchId] = 5071 mPointerGesture.activeGestureId; 5072 } else { 5073 mPointerGesture.activeGestureId = -1; 5074 } 5075 } else { 5076 // Otherwise, assume we mapped all touches from the previous frame. 5077 // Reuse all mappings that are still applicable. 5078 mappedTouchIdBits.value = mLastFingerIdBits.value 5079 & mCurrentFingerIdBits.value; 5080 usedGestureIdBits = mPointerGesture.lastGestureIdBits; 5081 5082 // Check whether we need to choose a new active gesture id because the 5083 // current went went up. 5084 for (BitSet32 upTouchIdBits(mLastFingerIdBits.value 5085 & ~mCurrentFingerIdBits.value); 5086 !upTouchIdBits.isEmpty(); ) { 5087 uint32_t upTouchId = upTouchIdBits.clearFirstMarkedBit(); 5088 uint32_t upGestureId = mPointerGesture.freeformTouchToGestureIdMap[upTouchId]; 5089 if (upGestureId == uint32_t(mPointerGesture.activeGestureId)) { 5090 mPointerGesture.activeGestureId = -1; 5091 break; 5092 } 5093 } 5094 } 5095 5096#if DEBUG_GESTURES 5097 ALOGD("Gestures: FREEFORM follow up " 5098 "mappedTouchIdBits=0x%08x, usedGestureIdBits=0x%08x, " 5099 "activeGestureId=%d", 5100 mappedTouchIdBits.value, usedGestureIdBits.value, 5101 mPointerGesture.activeGestureId); 5102#endif 5103 5104 BitSet32 idBits(mCurrentFingerIdBits); 5105 for (uint32_t i = 0; i < currentFingerCount; i++) { 5106 uint32_t touchId = idBits.clearFirstMarkedBit(); 5107 uint32_t gestureId; 5108 if (!mappedTouchIdBits.hasBit(touchId)) { 5109 gestureId = usedGestureIdBits.markFirstUnmarkedBit(); 5110 mPointerGesture.freeformTouchToGestureIdMap[touchId] = gestureId; 5111#if DEBUG_GESTURES 5112 ALOGD("Gestures: FREEFORM " 5113 "new mapping for touch id %d -> gesture id %d", 5114 touchId, gestureId); 5115#endif 5116 } else { 5117 gestureId = mPointerGesture.freeformTouchToGestureIdMap[touchId]; 5118#if DEBUG_GESTURES 5119 ALOGD("Gestures: FREEFORM " 5120 "existing mapping for touch id %d -> gesture id %d", 5121 touchId, gestureId); 5122#endif 5123 } 5124 mPointerGesture.currentGestureIdBits.markBit(gestureId); 5125 mPointerGesture.currentGestureIdToIndex[gestureId] = i; 5126 5127 const RawPointerData::Pointer& pointer = 5128 mCurrentRawPointerData.pointerForId(touchId); 5129 float deltaX = (pointer.x - mPointerGesture.referenceTouchX) 5130 * mPointerXZoomScale; 5131 float deltaY = (pointer.y - mPointerGesture.referenceTouchY) 5132 * mPointerYZoomScale; 5133 rotateDelta(mSurfaceOrientation, &deltaX, &deltaY); 5134 5135 mPointerGesture.currentGestureProperties[i].clear(); 5136 mPointerGesture.currentGestureProperties[i].id = gestureId; 5137 mPointerGesture.currentGestureProperties[i].toolType = 5138 AMOTION_EVENT_TOOL_TYPE_FINGER; 5139 mPointerGesture.currentGestureCoords[i].clear(); 5140 mPointerGesture.currentGestureCoords[i].setAxisValue( 5141 AMOTION_EVENT_AXIS_X, mPointerGesture.referenceGestureX + deltaX); 5142 mPointerGesture.currentGestureCoords[i].setAxisValue( 5143 AMOTION_EVENT_AXIS_Y, mPointerGesture.referenceGestureY + deltaY); 5144 mPointerGesture.currentGestureCoords[i].setAxisValue( 5145 AMOTION_EVENT_AXIS_PRESSURE, 1.0f); 5146 } 5147 5148 if (mPointerGesture.activeGestureId < 0) { 5149 mPointerGesture.activeGestureId = 5150 mPointerGesture.currentGestureIdBits.firstMarkedBit(); 5151#if DEBUG_GESTURES 5152 ALOGD("Gestures: FREEFORM new " 5153 "activeGestureId=%d", mPointerGesture.activeGestureId); 5154#endif 5155 } 5156 } 5157 } 5158 5159 mPointerController->setButtonState(mCurrentButtonState); 5160 5161#if DEBUG_GESTURES 5162 ALOGD("Gestures: finishPreviousGesture=%s, cancelPreviousGesture=%s, " 5163 "currentGestureMode=%d, currentGestureIdBits=0x%08x, " 5164 "lastGestureMode=%d, lastGestureIdBits=0x%08x", 5165 toString(*outFinishPreviousGesture), toString(*outCancelPreviousGesture), 5166 mPointerGesture.currentGestureMode, mPointerGesture.currentGestureIdBits.value, 5167 mPointerGesture.lastGestureMode, mPointerGesture.lastGestureIdBits.value); 5168 for (BitSet32 idBits = mPointerGesture.currentGestureIdBits; !idBits.isEmpty(); ) { 5169 uint32_t id = idBits.clearFirstMarkedBit(); 5170 uint32_t index = mPointerGesture.currentGestureIdToIndex[id]; 5171 const PointerProperties& properties = mPointerGesture.currentGestureProperties[index]; 5172 const PointerCoords& coords = mPointerGesture.currentGestureCoords[index]; 5173 ALOGD(" currentGesture[%d]: index=%d, toolType=%d, " 5174 "x=%0.3f, y=%0.3f, pressure=%0.3f", 5175 id, index, properties.toolType, 5176 coords.getAxisValue(AMOTION_EVENT_AXIS_X), 5177 coords.getAxisValue(AMOTION_EVENT_AXIS_Y), 5178 coords.getAxisValue(AMOTION_EVENT_AXIS_PRESSURE)); 5179 } 5180 for (BitSet32 idBits = mPointerGesture.lastGestureIdBits; !idBits.isEmpty(); ) { 5181 uint32_t id = idBits.clearFirstMarkedBit(); 5182 uint32_t index = mPointerGesture.lastGestureIdToIndex[id]; 5183 const PointerProperties& properties = mPointerGesture.lastGestureProperties[index]; 5184 const PointerCoords& coords = mPointerGesture.lastGestureCoords[index]; 5185 ALOGD(" lastGesture[%d]: index=%d, toolType=%d, " 5186 "x=%0.3f, y=%0.3f, pressure=%0.3f", 5187 id, index, properties.toolType, 5188 coords.getAxisValue(AMOTION_EVENT_AXIS_X), 5189 coords.getAxisValue(AMOTION_EVENT_AXIS_Y), 5190 coords.getAxisValue(AMOTION_EVENT_AXIS_PRESSURE)); 5191 } 5192#endif 5193 return true; 5194} 5195 5196void TouchInputMapper::dispatchPointerStylus(nsecs_t when, uint32_t policyFlags) { 5197 mPointerSimple.currentCoords.clear(); 5198 mPointerSimple.currentProperties.clear(); 5199 5200 bool down, hovering; 5201 if (!mCurrentStylusIdBits.isEmpty()) { 5202 uint32_t id = mCurrentStylusIdBits.firstMarkedBit(); 5203 uint32_t index = mCurrentCookedPointerData.idToIndex[id]; 5204 float x = mCurrentCookedPointerData.pointerCoords[index].getX(); 5205 float y = mCurrentCookedPointerData.pointerCoords[index].getY(); 5206 mPointerController->setPosition(x, y); 5207 5208 hovering = mCurrentCookedPointerData.hoveringIdBits.hasBit(id); 5209 down = !hovering; 5210 5211 mPointerController->getPosition(&x, &y); 5212 mPointerSimple.currentCoords.copyFrom(mCurrentCookedPointerData.pointerCoords[index]); 5213 mPointerSimple.currentCoords.setAxisValue(AMOTION_EVENT_AXIS_X, x); 5214 mPointerSimple.currentCoords.setAxisValue(AMOTION_EVENT_AXIS_Y, y); 5215 mPointerSimple.currentProperties.id = 0; 5216 mPointerSimple.currentProperties.toolType = 5217 mCurrentCookedPointerData.pointerProperties[index].toolType; 5218 } else { 5219 down = false; 5220 hovering = false; 5221 } 5222 5223 dispatchPointerSimple(when, policyFlags, down, hovering); 5224} 5225 5226void TouchInputMapper::abortPointerStylus(nsecs_t when, uint32_t policyFlags) { 5227 abortPointerSimple(when, policyFlags); 5228} 5229 5230void TouchInputMapper::dispatchPointerMouse(nsecs_t when, uint32_t policyFlags) { 5231 mPointerSimple.currentCoords.clear(); 5232 mPointerSimple.currentProperties.clear(); 5233 5234 bool down, hovering; 5235 if (!mCurrentMouseIdBits.isEmpty()) { 5236 uint32_t id = mCurrentMouseIdBits.firstMarkedBit(); 5237 uint32_t currentIndex = mCurrentRawPointerData.idToIndex[id]; 5238 if (mLastMouseIdBits.hasBit(id)) { 5239 uint32_t lastIndex = mCurrentRawPointerData.idToIndex[id]; 5240 float deltaX = (mCurrentRawPointerData.pointers[currentIndex].x 5241 - mLastRawPointerData.pointers[lastIndex].x) 5242 * mPointerXMovementScale; 5243 float deltaY = (mCurrentRawPointerData.pointers[currentIndex].y 5244 - mLastRawPointerData.pointers[lastIndex].y) 5245 * mPointerYMovementScale; 5246 5247 rotateDelta(mSurfaceOrientation, &deltaX, &deltaY); 5248 mPointerVelocityControl.move(when, &deltaX, &deltaY); 5249 5250 mPointerController->move(deltaX, deltaY); 5251 } else { 5252 mPointerVelocityControl.reset(); 5253 } 5254 5255 down = isPointerDown(mCurrentButtonState); 5256 hovering = !down; 5257 5258 float x, y; 5259 mPointerController->getPosition(&x, &y); 5260 mPointerSimple.currentCoords.copyFrom( 5261 mCurrentCookedPointerData.pointerCoords[currentIndex]); 5262 mPointerSimple.currentCoords.setAxisValue(AMOTION_EVENT_AXIS_X, x); 5263 mPointerSimple.currentCoords.setAxisValue(AMOTION_EVENT_AXIS_Y, y); 5264 mPointerSimple.currentCoords.setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 5265 hovering ? 0.0f : 1.0f); 5266 mPointerSimple.currentProperties.id = 0; 5267 mPointerSimple.currentProperties.toolType = 5268 mCurrentCookedPointerData.pointerProperties[currentIndex].toolType; 5269 } else { 5270 mPointerVelocityControl.reset(); 5271 5272 down = false; 5273 hovering = false; 5274 } 5275 5276 dispatchPointerSimple(when, policyFlags, down, hovering); 5277} 5278 5279void TouchInputMapper::abortPointerMouse(nsecs_t when, uint32_t policyFlags) { 5280 abortPointerSimple(when, policyFlags); 5281 5282 mPointerVelocityControl.reset(); 5283} 5284 5285void TouchInputMapper::dispatchPointerSimple(nsecs_t when, uint32_t policyFlags, 5286 bool down, bool hovering) { 5287 int32_t metaState = getContext()->getGlobalMetaState(); 5288 5289 if (mPointerController != NULL) { 5290 if (down || hovering) { 5291 mPointerController->setPresentation(PointerControllerInterface::PRESENTATION_POINTER); 5292 mPointerController->clearSpots(); 5293 mPointerController->setButtonState(mCurrentButtonState); 5294 mPointerController->unfade(PointerControllerInterface::TRANSITION_IMMEDIATE); 5295 } else if (!down && !hovering && (mPointerSimple.down || mPointerSimple.hovering)) { 5296 mPointerController->fade(PointerControllerInterface::TRANSITION_GRADUAL); 5297 } 5298 } 5299 5300 if (mPointerSimple.down && !down) { 5301 mPointerSimple.down = false; 5302 5303 // Send up. 5304 NotifyMotionArgs args(when, getDeviceId(), mSource, policyFlags, 5305 AMOTION_EVENT_ACTION_UP, 0, metaState, mLastButtonState, 0, 5306 1, &mPointerSimple.lastProperties, &mPointerSimple.lastCoords, 5307 mOrientedXPrecision, mOrientedYPrecision, 5308 mPointerSimple.downTime); 5309 getListener()->notifyMotion(&args); 5310 } 5311 5312 if (mPointerSimple.hovering && !hovering) { 5313 mPointerSimple.hovering = false; 5314 5315 // Send hover exit. 5316 NotifyMotionArgs args(when, getDeviceId(), mSource, policyFlags, 5317 AMOTION_EVENT_ACTION_HOVER_EXIT, 0, metaState, mLastButtonState, 0, 5318 1, &mPointerSimple.lastProperties, &mPointerSimple.lastCoords, 5319 mOrientedXPrecision, mOrientedYPrecision, 5320 mPointerSimple.downTime); 5321 getListener()->notifyMotion(&args); 5322 } 5323 5324 if (down) { 5325 if (!mPointerSimple.down) { 5326 mPointerSimple.down = true; 5327 mPointerSimple.downTime = when; 5328 5329 // Send down. 5330 NotifyMotionArgs args(when, getDeviceId(), mSource, policyFlags, 5331 AMOTION_EVENT_ACTION_DOWN, 0, metaState, mCurrentButtonState, 0, 5332 1, &mPointerSimple.currentProperties, &mPointerSimple.currentCoords, 5333 mOrientedXPrecision, mOrientedYPrecision, 5334 mPointerSimple.downTime); 5335 getListener()->notifyMotion(&args); 5336 } 5337 5338 // Send move. 5339 NotifyMotionArgs args(when, getDeviceId(), mSource, policyFlags, 5340 AMOTION_EVENT_ACTION_MOVE, 0, metaState, mCurrentButtonState, 0, 5341 1, &mPointerSimple.currentProperties, &mPointerSimple.currentCoords, 5342 mOrientedXPrecision, mOrientedYPrecision, 5343 mPointerSimple.downTime); 5344 getListener()->notifyMotion(&args); 5345 } 5346 5347 if (hovering) { 5348 if (!mPointerSimple.hovering) { 5349 mPointerSimple.hovering = true; 5350 5351 // Send hover enter. 5352 NotifyMotionArgs args(when, getDeviceId(), mSource, policyFlags, 5353 AMOTION_EVENT_ACTION_HOVER_ENTER, 0, metaState, mCurrentButtonState, 0, 5354 1, &mPointerSimple.currentProperties, &mPointerSimple.currentCoords, 5355 mOrientedXPrecision, mOrientedYPrecision, 5356 mPointerSimple.downTime); 5357 getListener()->notifyMotion(&args); 5358 } 5359 5360 // Send hover move. 5361 NotifyMotionArgs args(when, getDeviceId(), mSource, policyFlags, 5362 AMOTION_EVENT_ACTION_HOVER_MOVE, 0, metaState, mCurrentButtonState, 0, 5363 1, &mPointerSimple.currentProperties, &mPointerSimple.currentCoords, 5364 mOrientedXPrecision, mOrientedYPrecision, 5365 mPointerSimple.downTime); 5366 getListener()->notifyMotion(&args); 5367 } 5368 5369 if (mCurrentRawVScroll || mCurrentRawHScroll) { 5370 float vscroll = mCurrentRawVScroll; 5371 float hscroll = mCurrentRawHScroll; 5372 mWheelYVelocityControl.move(when, NULL, &vscroll); 5373 mWheelXVelocityControl.move(when, &hscroll, NULL); 5374 5375 // Send scroll. 5376 PointerCoords pointerCoords; 5377 pointerCoords.copyFrom(mPointerSimple.currentCoords); 5378 pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_VSCROLL, vscroll); 5379 pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_HSCROLL, hscroll); 5380 5381 NotifyMotionArgs args(when, getDeviceId(), mSource, policyFlags, 5382 AMOTION_EVENT_ACTION_SCROLL, 0, metaState, mCurrentButtonState, 0, 5383 1, &mPointerSimple.currentProperties, &pointerCoords, 5384 mOrientedXPrecision, mOrientedYPrecision, 5385 mPointerSimple.downTime); 5386 getListener()->notifyMotion(&args); 5387 } 5388 5389 // Save state. 5390 if (down || hovering) { 5391 mPointerSimple.lastCoords.copyFrom(mPointerSimple.currentCoords); 5392 mPointerSimple.lastProperties.copyFrom(mPointerSimple.currentProperties); 5393 } else { 5394 mPointerSimple.reset(); 5395 } 5396} 5397 5398void TouchInputMapper::abortPointerSimple(nsecs_t when, uint32_t policyFlags) { 5399 mPointerSimple.currentCoords.clear(); 5400 mPointerSimple.currentProperties.clear(); 5401 5402 dispatchPointerSimple(when, policyFlags, false, false); 5403} 5404 5405void TouchInputMapper::dispatchMotion(nsecs_t when, uint32_t policyFlags, uint32_t source, 5406 int32_t action, int32_t flags, int32_t metaState, int32_t buttonState, int32_t edgeFlags, 5407 const PointerProperties* properties, const PointerCoords* coords, 5408 const uint32_t* idToIndex, BitSet32 idBits, 5409 int32_t changedId, float xPrecision, float yPrecision, nsecs_t downTime) { 5410 PointerCoords pointerCoords[MAX_POINTERS]; 5411 PointerProperties pointerProperties[MAX_POINTERS]; 5412 uint32_t pointerCount = 0; 5413 while (!idBits.isEmpty()) { 5414 uint32_t id = idBits.clearFirstMarkedBit(); 5415 uint32_t index = idToIndex[id]; 5416 pointerProperties[pointerCount].copyFrom(properties[index]); 5417 pointerCoords[pointerCount].copyFrom(coords[index]); 5418 5419 if (changedId >= 0 && id == uint32_t(changedId)) { 5420 action |= pointerCount << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT; 5421 } 5422 5423 pointerCount += 1; 5424 } 5425 5426 ALOG_ASSERT(pointerCount != 0); 5427 5428 if (changedId >= 0 && pointerCount == 1) { 5429 // Replace initial down and final up action. 5430 // We can compare the action without masking off the changed pointer index 5431 // because we know the index is 0. 5432 if (action == AMOTION_EVENT_ACTION_POINTER_DOWN) { 5433 action = AMOTION_EVENT_ACTION_DOWN; 5434 } else if (action == AMOTION_EVENT_ACTION_POINTER_UP) { 5435 action = AMOTION_EVENT_ACTION_UP; 5436 } else { 5437 // Can't happen. 5438 ALOG_ASSERT(false); 5439 } 5440 } 5441 5442 NotifyMotionArgs args(when, getDeviceId(), source, policyFlags, 5443 action, flags, metaState, buttonState, edgeFlags, 5444 pointerCount, pointerProperties, pointerCoords, xPrecision, yPrecision, downTime); 5445 getListener()->notifyMotion(&args); 5446} 5447 5448bool TouchInputMapper::updateMovedPointers(const PointerProperties* inProperties, 5449 const PointerCoords* inCoords, const uint32_t* inIdToIndex, 5450 PointerProperties* outProperties, PointerCoords* outCoords, const uint32_t* outIdToIndex, 5451 BitSet32 idBits) const { 5452 bool changed = false; 5453 while (!idBits.isEmpty()) { 5454 uint32_t id = idBits.clearFirstMarkedBit(); 5455 uint32_t inIndex = inIdToIndex[id]; 5456 uint32_t outIndex = outIdToIndex[id]; 5457 5458 const PointerProperties& curInProperties = inProperties[inIndex]; 5459 const PointerCoords& curInCoords = inCoords[inIndex]; 5460 PointerProperties& curOutProperties = outProperties[outIndex]; 5461 PointerCoords& curOutCoords = outCoords[outIndex]; 5462 5463 if (curInProperties != curOutProperties) { 5464 curOutProperties.copyFrom(curInProperties); 5465 changed = true; 5466 } 5467 5468 if (curInCoords != curOutCoords) { 5469 curOutCoords.copyFrom(curInCoords); 5470 changed = true; 5471 } 5472 } 5473 return changed; 5474} 5475 5476void TouchInputMapper::fadePointer() { 5477 if (mPointerController != NULL) { 5478 mPointerController->fade(PointerControllerInterface::TRANSITION_GRADUAL); 5479 } 5480} 5481 5482bool TouchInputMapper::isPointInsideSurface(int32_t x, int32_t y) { 5483 return x >= mRawPointerAxes.x.minValue && x <= mRawPointerAxes.x.maxValue 5484 && y >= mRawPointerAxes.y.minValue && y <= mRawPointerAxes.y.maxValue; 5485} 5486 5487const TouchInputMapper::VirtualKey* TouchInputMapper::findVirtualKeyHit( 5488 int32_t x, int32_t y) { 5489 size_t numVirtualKeys = mVirtualKeys.size(); 5490 for (size_t i = 0; i < numVirtualKeys; i++) { 5491 const VirtualKey& virtualKey = mVirtualKeys[i]; 5492 5493#if DEBUG_VIRTUAL_KEYS 5494 ALOGD("VirtualKeys: Hit test (%d, %d): keyCode=%d, scanCode=%d, " 5495 "left=%d, top=%d, right=%d, bottom=%d", 5496 x, y, 5497 virtualKey.keyCode, virtualKey.scanCode, 5498 virtualKey.hitLeft, virtualKey.hitTop, 5499 virtualKey.hitRight, virtualKey.hitBottom); 5500#endif 5501 5502 if (virtualKey.isHit(x, y)) { 5503 return & virtualKey; 5504 } 5505 } 5506 5507 return NULL; 5508} 5509 5510void TouchInputMapper::assignPointerIds() { 5511 uint32_t currentPointerCount = mCurrentRawPointerData.pointerCount; 5512 uint32_t lastPointerCount = mLastRawPointerData.pointerCount; 5513 5514 mCurrentRawPointerData.clearIdBits(); 5515 5516 if (currentPointerCount == 0) { 5517 // No pointers to assign. 5518 return; 5519 } 5520 5521 if (lastPointerCount == 0) { 5522 // All pointers are new. 5523 for (uint32_t i = 0; i < currentPointerCount; i++) { 5524 uint32_t id = i; 5525 mCurrentRawPointerData.pointers[i].id = id; 5526 mCurrentRawPointerData.idToIndex[id] = i; 5527 mCurrentRawPointerData.markIdBit(id, mCurrentRawPointerData.isHovering(i)); 5528 } 5529 return; 5530 } 5531 5532 if (currentPointerCount == 1 && lastPointerCount == 1 5533 && mCurrentRawPointerData.pointers[0].toolType 5534 == mLastRawPointerData.pointers[0].toolType) { 5535 // Only one pointer and no change in count so it must have the same id as before. 5536 uint32_t id = mLastRawPointerData.pointers[0].id; 5537 mCurrentRawPointerData.pointers[0].id = id; 5538 mCurrentRawPointerData.idToIndex[id] = 0; 5539 mCurrentRawPointerData.markIdBit(id, mCurrentRawPointerData.isHovering(0)); 5540 return; 5541 } 5542 5543 // General case. 5544 // We build a heap of squared euclidean distances between current and last pointers 5545 // associated with the current and last pointer indices. Then, we find the best 5546 // match (by distance) for each current pointer. 5547 // The pointers must have the same tool type but it is possible for them to 5548 // transition from hovering to touching or vice-versa while retaining the same id. 5549 PointerDistanceHeapElement heap[MAX_POINTERS * MAX_POINTERS]; 5550 5551 uint32_t heapSize = 0; 5552 for (uint32_t currentPointerIndex = 0; currentPointerIndex < currentPointerCount; 5553 currentPointerIndex++) { 5554 for (uint32_t lastPointerIndex = 0; lastPointerIndex < lastPointerCount; 5555 lastPointerIndex++) { 5556 const RawPointerData::Pointer& currentPointer = 5557 mCurrentRawPointerData.pointers[currentPointerIndex]; 5558 const RawPointerData::Pointer& lastPointer = 5559 mLastRawPointerData.pointers[lastPointerIndex]; 5560 if (currentPointer.toolType == lastPointer.toolType) { 5561 int64_t deltaX = currentPointer.x - lastPointer.x; 5562 int64_t deltaY = currentPointer.y - lastPointer.y; 5563 5564 uint64_t distance = uint64_t(deltaX * deltaX + deltaY * deltaY); 5565 5566 // Insert new element into the heap (sift up). 5567 heap[heapSize].currentPointerIndex = currentPointerIndex; 5568 heap[heapSize].lastPointerIndex = lastPointerIndex; 5569 heap[heapSize].distance = distance; 5570 heapSize += 1; 5571 } 5572 } 5573 } 5574 5575 // Heapify 5576 for (uint32_t startIndex = heapSize / 2; startIndex != 0; ) { 5577 startIndex -= 1; 5578 for (uint32_t parentIndex = startIndex; ;) { 5579 uint32_t childIndex = parentIndex * 2 + 1; 5580 if (childIndex >= heapSize) { 5581 break; 5582 } 5583 5584 if (childIndex + 1 < heapSize 5585 && heap[childIndex + 1].distance < heap[childIndex].distance) { 5586 childIndex += 1; 5587 } 5588 5589 if (heap[parentIndex].distance <= heap[childIndex].distance) { 5590 break; 5591 } 5592 5593 swap(heap[parentIndex], heap[childIndex]); 5594 parentIndex = childIndex; 5595 } 5596 } 5597 5598#if DEBUG_POINTER_ASSIGNMENT 5599 ALOGD("assignPointerIds - initial distance min-heap: size=%d", heapSize); 5600 for (size_t i = 0; i < heapSize; i++) { 5601 ALOGD(" heap[%d]: cur=%d, last=%d, distance=%lld", 5602 i, heap[i].currentPointerIndex, heap[i].lastPointerIndex, 5603 heap[i].distance); 5604 } 5605#endif 5606 5607 // Pull matches out by increasing order of distance. 5608 // To avoid reassigning pointers that have already been matched, the loop keeps track 5609 // of which last and current pointers have been matched using the matchedXXXBits variables. 5610 // It also tracks the used pointer id bits. 5611 BitSet32 matchedLastBits(0); 5612 BitSet32 matchedCurrentBits(0); 5613 BitSet32 usedIdBits(0); 5614 bool first = true; 5615 for (uint32_t i = min(currentPointerCount, lastPointerCount); heapSize > 0 && i > 0; i--) { 5616 while (heapSize > 0) { 5617 if (first) { 5618 // The first time through the loop, we just consume the root element of 5619 // the heap (the one with smallest distance). 5620 first = false; 5621 } else { 5622 // Previous iterations consumed the root element of the heap. 5623 // Pop root element off of the heap (sift down). 5624 heap[0] = heap[heapSize]; 5625 for (uint32_t parentIndex = 0; ;) { 5626 uint32_t childIndex = parentIndex * 2 + 1; 5627 if (childIndex >= heapSize) { 5628 break; 5629 } 5630 5631 if (childIndex + 1 < heapSize 5632 && heap[childIndex + 1].distance < heap[childIndex].distance) { 5633 childIndex += 1; 5634 } 5635 5636 if (heap[parentIndex].distance <= heap[childIndex].distance) { 5637 break; 5638 } 5639 5640 swap(heap[parentIndex], heap[childIndex]); 5641 parentIndex = childIndex; 5642 } 5643 5644#if DEBUG_POINTER_ASSIGNMENT 5645 ALOGD("assignPointerIds - reduced distance min-heap: size=%d", heapSize); 5646 for (size_t i = 0; i < heapSize; i++) { 5647 ALOGD(" heap[%d]: cur=%d, last=%d, distance=%lld", 5648 i, heap[i].currentPointerIndex, heap[i].lastPointerIndex, 5649 heap[i].distance); 5650 } 5651#endif 5652 } 5653 5654 heapSize -= 1; 5655 5656 uint32_t currentPointerIndex = heap[0].currentPointerIndex; 5657 if (matchedCurrentBits.hasBit(currentPointerIndex)) continue; // already matched 5658 5659 uint32_t lastPointerIndex = heap[0].lastPointerIndex; 5660 if (matchedLastBits.hasBit(lastPointerIndex)) continue; // already matched 5661 5662 matchedCurrentBits.markBit(currentPointerIndex); 5663 matchedLastBits.markBit(lastPointerIndex); 5664 5665 uint32_t id = mLastRawPointerData.pointers[lastPointerIndex].id; 5666 mCurrentRawPointerData.pointers[currentPointerIndex].id = id; 5667 mCurrentRawPointerData.idToIndex[id] = currentPointerIndex; 5668 mCurrentRawPointerData.markIdBit(id, 5669 mCurrentRawPointerData.isHovering(currentPointerIndex)); 5670 usedIdBits.markBit(id); 5671 5672#if DEBUG_POINTER_ASSIGNMENT 5673 ALOGD("assignPointerIds - matched: cur=%d, last=%d, id=%d, distance=%lld", 5674 lastPointerIndex, currentPointerIndex, id, heap[0].distance); 5675#endif 5676 break; 5677 } 5678 } 5679 5680 // Assign fresh ids to pointers that were not matched in the process. 5681 for (uint32_t i = currentPointerCount - matchedCurrentBits.count(); i != 0; i--) { 5682 uint32_t currentPointerIndex = matchedCurrentBits.markFirstUnmarkedBit(); 5683 uint32_t id = usedIdBits.markFirstUnmarkedBit(); 5684 5685 mCurrentRawPointerData.pointers[currentPointerIndex].id = id; 5686 mCurrentRawPointerData.idToIndex[id] = currentPointerIndex; 5687 mCurrentRawPointerData.markIdBit(id, 5688 mCurrentRawPointerData.isHovering(currentPointerIndex)); 5689 5690#if DEBUG_POINTER_ASSIGNMENT 5691 ALOGD("assignPointerIds - assigned: cur=%d, id=%d", 5692 currentPointerIndex, id); 5693#endif 5694 } 5695} 5696 5697int32_t TouchInputMapper::getKeyCodeState(uint32_t sourceMask, int32_t keyCode) { 5698 if (mCurrentVirtualKey.down && mCurrentVirtualKey.keyCode == keyCode) { 5699 return AKEY_STATE_VIRTUAL; 5700 } 5701 5702 size_t numVirtualKeys = mVirtualKeys.size(); 5703 for (size_t i = 0; i < numVirtualKeys; i++) { 5704 const VirtualKey& virtualKey = mVirtualKeys[i]; 5705 if (virtualKey.keyCode == keyCode) { 5706 return AKEY_STATE_UP; 5707 } 5708 } 5709 5710 return AKEY_STATE_UNKNOWN; 5711} 5712 5713int32_t TouchInputMapper::getScanCodeState(uint32_t sourceMask, int32_t scanCode) { 5714 if (mCurrentVirtualKey.down && mCurrentVirtualKey.scanCode == scanCode) { 5715 return AKEY_STATE_VIRTUAL; 5716 } 5717 5718 size_t numVirtualKeys = mVirtualKeys.size(); 5719 for (size_t i = 0; i < numVirtualKeys; i++) { 5720 const VirtualKey& virtualKey = mVirtualKeys[i]; 5721 if (virtualKey.scanCode == scanCode) { 5722 return AKEY_STATE_UP; 5723 } 5724 } 5725 5726 return AKEY_STATE_UNKNOWN; 5727} 5728 5729bool TouchInputMapper::markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes, 5730 const int32_t* keyCodes, uint8_t* outFlags) { 5731 size_t numVirtualKeys = mVirtualKeys.size(); 5732 for (size_t i = 0; i < numVirtualKeys; i++) { 5733 const VirtualKey& virtualKey = mVirtualKeys[i]; 5734 5735 for (size_t i = 0; i < numCodes; i++) { 5736 if (virtualKey.keyCode == keyCodes[i]) { 5737 outFlags[i] = 1; 5738 } 5739 } 5740 } 5741 5742 return true; 5743} 5744 5745 5746// --- SingleTouchInputMapper --- 5747 5748SingleTouchInputMapper::SingleTouchInputMapper(InputDevice* device) : 5749 TouchInputMapper(device) { 5750} 5751 5752SingleTouchInputMapper::~SingleTouchInputMapper() { 5753} 5754 5755void SingleTouchInputMapper::reset(nsecs_t when) { 5756 mSingleTouchMotionAccumulator.reset(getDevice()); 5757 5758 TouchInputMapper::reset(when); 5759} 5760 5761void SingleTouchInputMapper::process(const RawEvent* rawEvent) { 5762 TouchInputMapper::process(rawEvent); 5763 5764 mSingleTouchMotionAccumulator.process(rawEvent); 5765} 5766 5767void SingleTouchInputMapper::syncTouch(nsecs_t when, bool* outHavePointerIds) { 5768 if (mTouchButtonAccumulator.isToolActive()) { 5769 mCurrentRawPointerData.pointerCount = 1; 5770 mCurrentRawPointerData.idToIndex[0] = 0; 5771 5772 bool isHovering = mTouchButtonAccumulator.getToolType() != AMOTION_EVENT_TOOL_TYPE_MOUSE 5773 && (mTouchButtonAccumulator.isHovering() 5774 || (mRawPointerAxes.pressure.valid 5775 && mSingleTouchMotionAccumulator.getAbsolutePressure() <= 0)); 5776 mCurrentRawPointerData.markIdBit(0, isHovering); 5777 5778 RawPointerData::Pointer& outPointer = mCurrentRawPointerData.pointers[0]; 5779 outPointer.id = 0; 5780 outPointer.x = mSingleTouchMotionAccumulator.getAbsoluteX(); 5781 outPointer.y = mSingleTouchMotionAccumulator.getAbsoluteY(); 5782 outPointer.pressure = mSingleTouchMotionAccumulator.getAbsolutePressure(); 5783 outPointer.touchMajor = 0; 5784 outPointer.touchMinor = 0; 5785 outPointer.toolMajor = mSingleTouchMotionAccumulator.getAbsoluteToolWidth(); 5786 outPointer.toolMinor = mSingleTouchMotionAccumulator.getAbsoluteToolWidth(); 5787 outPointer.orientation = 0; 5788 outPointer.distance = mSingleTouchMotionAccumulator.getAbsoluteDistance(); 5789 outPointer.tiltX = mSingleTouchMotionAccumulator.getAbsoluteTiltX(); 5790 outPointer.tiltY = mSingleTouchMotionAccumulator.getAbsoluteTiltY(); 5791 outPointer.toolType = mTouchButtonAccumulator.getToolType(); 5792 if (outPointer.toolType == AMOTION_EVENT_TOOL_TYPE_UNKNOWN) { 5793 outPointer.toolType = AMOTION_EVENT_TOOL_TYPE_FINGER; 5794 } 5795 outPointer.isHovering = isHovering; 5796 } 5797} 5798 5799void SingleTouchInputMapper::configureRawPointerAxes() { 5800 TouchInputMapper::configureRawPointerAxes(); 5801 5802 getAbsoluteAxisInfo(ABS_X, &mRawPointerAxes.x); 5803 getAbsoluteAxisInfo(ABS_Y, &mRawPointerAxes.y); 5804 getAbsoluteAxisInfo(ABS_PRESSURE, &mRawPointerAxes.pressure); 5805 getAbsoluteAxisInfo(ABS_TOOL_WIDTH, &mRawPointerAxes.toolMajor); 5806 getAbsoluteAxisInfo(ABS_DISTANCE, &mRawPointerAxes.distance); 5807 getAbsoluteAxisInfo(ABS_TILT_X, &mRawPointerAxes.tiltX); 5808 getAbsoluteAxisInfo(ABS_TILT_Y, &mRawPointerAxes.tiltY); 5809} 5810 5811bool SingleTouchInputMapper::hasStylus() const { 5812 return mTouchButtonAccumulator.hasStylus(); 5813} 5814 5815 5816// --- MultiTouchInputMapper --- 5817 5818MultiTouchInputMapper::MultiTouchInputMapper(InputDevice* device) : 5819 TouchInputMapper(device) { 5820} 5821 5822MultiTouchInputMapper::~MultiTouchInputMapper() { 5823} 5824 5825void MultiTouchInputMapper::reset(nsecs_t when) { 5826 mMultiTouchMotionAccumulator.reset(getDevice()); 5827 5828 mPointerIdBits.clear(); 5829 5830 TouchInputMapper::reset(when); 5831} 5832 5833void MultiTouchInputMapper::process(const RawEvent* rawEvent) { 5834 TouchInputMapper::process(rawEvent); 5835 5836 mMultiTouchMotionAccumulator.process(rawEvent); 5837} 5838 5839void MultiTouchInputMapper::syncTouch(nsecs_t when, bool* outHavePointerIds) { 5840 size_t inCount = mMultiTouchMotionAccumulator.getSlotCount(); 5841 size_t outCount = 0; 5842 BitSet32 newPointerIdBits; 5843 5844 for (size_t inIndex = 0; inIndex < inCount; inIndex++) { 5845 const MultiTouchMotionAccumulator::Slot* inSlot = 5846 mMultiTouchMotionAccumulator.getSlot(inIndex); 5847 if (!inSlot->isInUse()) { 5848 continue; 5849 } 5850 5851 if (outCount >= MAX_POINTERS) { 5852#if DEBUG_POINTERS 5853 ALOGD("MultiTouch device %s emitted more than maximum of %d pointers; " 5854 "ignoring the rest.", 5855 getDeviceName().string(), MAX_POINTERS); 5856#endif 5857 break; // too many fingers! 5858 } 5859 5860 RawPointerData::Pointer& outPointer = mCurrentRawPointerData.pointers[outCount]; 5861 outPointer.x = inSlot->getX(); 5862 outPointer.y = inSlot->getY(); 5863 outPointer.pressure = inSlot->getPressure(); 5864 outPointer.touchMajor = inSlot->getTouchMajor(); 5865 outPointer.touchMinor = inSlot->getTouchMinor(); 5866 outPointer.toolMajor = inSlot->getToolMajor(); 5867 outPointer.toolMinor = inSlot->getToolMinor(); 5868 outPointer.orientation = inSlot->getOrientation(); 5869 outPointer.distance = inSlot->getDistance(); 5870 outPointer.tiltX = 0; 5871 outPointer.tiltY = 0; 5872 5873 outPointer.toolType = inSlot->getToolType(); 5874 if (outPointer.toolType == AMOTION_EVENT_TOOL_TYPE_UNKNOWN) { 5875 outPointer.toolType = mTouchButtonAccumulator.getToolType(); 5876 if (outPointer.toolType == AMOTION_EVENT_TOOL_TYPE_UNKNOWN) { 5877 outPointer.toolType = AMOTION_EVENT_TOOL_TYPE_FINGER; 5878 } 5879 } 5880 5881 bool isHovering = mTouchButtonAccumulator.getToolType() != AMOTION_EVENT_TOOL_TYPE_MOUSE 5882 && (mTouchButtonAccumulator.isHovering() 5883 || (mRawPointerAxes.pressure.valid && inSlot->getPressure() <= 0)); 5884 outPointer.isHovering = isHovering; 5885 5886 // Assign pointer id using tracking id if available. 5887 if (*outHavePointerIds) { 5888 int32_t trackingId = inSlot->getTrackingId(); 5889 int32_t id = -1; 5890 if (trackingId >= 0) { 5891 for (BitSet32 idBits(mPointerIdBits); !idBits.isEmpty(); ) { 5892 uint32_t n = idBits.clearFirstMarkedBit(); 5893 if (mPointerTrackingIdMap[n] == trackingId) { 5894 id = n; 5895 } 5896 } 5897 5898 if (id < 0 && !mPointerIdBits.isFull()) { 5899 id = mPointerIdBits.markFirstUnmarkedBit(); 5900 mPointerTrackingIdMap[id] = trackingId; 5901 } 5902 } 5903 if (id < 0) { 5904 *outHavePointerIds = false; 5905 mCurrentRawPointerData.clearIdBits(); 5906 newPointerIdBits.clear(); 5907 } else { 5908 outPointer.id = id; 5909 mCurrentRawPointerData.idToIndex[id] = outCount; 5910 mCurrentRawPointerData.markIdBit(id, isHovering); 5911 newPointerIdBits.markBit(id); 5912 } 5913 } 5914 5915 outCount += 1; 5916 } 5917 5918 mCurrentRawPointerData.pointerCount = outCount; 5919 mPointerIdBits = newPointerIdBits; 5920 5921 mMultiTouchMotionAccumulator.finishSync(); 5922} 5923 5924void MultiTouchInputMapper::configureRawPointerAxes() { 5925 TouchInputMapper::configureRawPointerAxes(); 5926 5927 getAbsoluteAxisInfo(ABS_MT_POSITION_X, &mRawPointerAxes.x); 5928 getAbsoluteAxisInfo(ABS_MT_POSITION_Y, &mRawPointerAxes.y); 5929 getAbsoluteAxisInfo(ABS_MT_TOUCH_MAJOR, &mRawPointerAxes.touchMajor); 5930 getAbsoluteAxisInfo(ABS_MT_TOUCH_MINOR, &mRawPointerAxes.touchMinor); 5931 getAbsoluteAxisInfo(ABS_MT_WIDTH_MAJOR, &mRawPointerAxes.toolMajor); 5932 getAbsoluteAxisInfo(ABS_MT_WIDTH_MINOR, &mRawPointerAxes.toolMinor); 5933 getAbsoluteAxisInfo(ABS_MT_ORIENTATION, &mRawPointerAxes.orientation); 5934 getAbsoluteAxisInfo(ABS_MT_PRESSURE, &mRawPointerAxes.pressure); 5935 getAbsoluteAxisInfo(ABS_MT_DISTANCE, &mRawPointerAxes.distance); 5936 getAbsoluteAxisInfo(ABS_MT_TRACKING_ID, &mRawPointerAxes.trackingId); 5937 getAbsoluteAxisInfo(ABS_MT_SLOT, &mRawPointerAxes.slot); 5938 5939 if (mRawPointerAxes.trackingId.valid 5940 && mRawPointerAxes.slot.valid 5941 && mRawPointerAxes.slot.minValue == 0 && mRawPointerAxes.slot.maxValue > 0) { 5942 size_t slotCount = mRawPointerAxes.slot.maxValue + 1; 5943 if (slotCount > MAX_SLOTS) { 5944 ALOGW("MultiTouch Device %s reported %d slots but the framework " 5945 "only supports a maximum of %d slots at this time.", 5946 getDeviceName().string(), slotCount, MAX_SLOTS); 5947 slotCount = MAX_SLOTS; 5948 } 5949 mMultiTouchMotionAccumulator.configure(getDevice(), 5950 slotCount, true /*usingSlotsProtocol*/); 5951 } else { 5952 mMultiTouchMotionAccumulator.configure(getDevice(), 5953 MAX_POINTERS, false /*usingSlotsProtocol*/); 5954 } 5955} 5956 5957bool MultiTouchInputMapper::hasStylus() const { 5958 return mMultiTouchMotionAccumulator.hasStylus() 5959 || mTouchButtonAccumulator.hasStylus(); 5960} 5961 5962 5963// --- JoystickInputMapper --- 5964 5965JoystickInputMapper::JoystickInputMapper(InputDevice* device) : 5966 InputMapper(device) { 5967} 5968 5969JoystickInputMapper::~JoystickInputMapper() { 5970} 5971 5972uint32_t JoystickInputMapper::getSources() { 5973 return AINPUT_SOURCE_JOYSTICK; 5974} 5975 5976void JoystickInputMapper::populateDeviceInfo(InputDeviceInfo* info) { 5977 InputMapper::populateDeviceInfo(info); 5978 5979 for (size_t i = 0; i < mAxes.size(); i++) { 5980 const Axis& axis = mAxes.valueAt(i); 5981 info->addMotionRange(axis.axisInfo.axis, AINPUT_SOURCE_JOYSTICK, 5982 axis.min, axis.max, axis.flat, axis.fuzz); 5983 if (axis.axisInfo.mode == AxisInfo::MODE_SPLIT) { 5984 info->addMotionRange(axis.axisInfo.highAxis, AINPUT_SOURCE_JOYSTICK, 5985 axis.min, axis.max, axis.flat, axis.fuzz); 5986 } 5987 } 5988} 5989 5990void JoystickInputMapper::dump(String8& dump) { 5991 dump.append(INDENT2 "Joystick Input Mapper:\n"); 5992 5993 dump.append(INDENT3 "Axes:\n"); 5994 size_t numAxes = mAxes.size(); 5995 for (size_t i = 0; i < numAxes; i++) { 5996 const Axis& axis = mAxes.valueAt(i); 5997 const char* label = getAxisLabel(axis.axisInfo.axis); 5998 if (label) { 5999 dump.appendFormat(INDENT4 "%s", label); 6000 } else { 6001 dump.appendFormat(INDENT4 "%d", axis.axisInfo.axis); 6002 } 6003 if (axis.axisInfo.mode == AxisInfo::MODE_SPLIT) { 6004 label = getAxisLabel(axis.axisInfo.highAxis); 6005 if (label) { 6006 dump.appendFormat(" / %s (split at %d)", label, axis.axisInfo.splitValue); 6007 } else { 6008 dump.appendFormat(" / %d (split at %d)", axis.axisInfo.highAxis, 6009 axis.axisInfo.splitValue); 6010 } 6011 } else if (axis.axisInfo.mode == AxisInfo::MODE_INVERT) { 6012 dump.append(" (invert)"); 6013 } 6014 6015 dump.appendFormat(": min=%0.5f, max=%0.5f, flat=%0.5f, fuzz=%0.5f\n", 6016 axis.min, axis.max, axis.flat, axis.fuzz); 6017 dump.appendFormat(INDENT4 " scale=%0.5f, offset=%0.5f, " 6018 "highScale=%0.5f, highOffset=%0.5f\n", 6019 axis.scale, axis.offset, axis.highScale, axis.highOffset); 6020 dump.appendFormat(INDENT4 " rawAxis=%d, rawMin=%d, rawMax=%d, " 6021 "rawFlat=%d, rawFuzz=%d, rawResolution=%d\n", 6022 mAxes.keyAt(i), axis.rawAxisInfo.minValue, axis.rawAxisInfo.maxValue, 6023 axis.rawAxisInfo.flat, axis.rawAxisInfo.fuzz, axis.rawAxisInfo.resolution); 6024 } 6025} 6026 6027void JoystickInputMapper::configure(nsecs_t when, 6028 const InputReaderConfiguration* config, uint32_t changes) { 6029 InputMapper::configure(when, config, changes); 6030 6031 if (!changes) { // first time only 6032 // Collect all axes. 6033 for (int32_t abs = 0; abs <= ABS_MAX; abs++) { 6034 if (!(getAbsAxisUsage(abs, getDevice()->getClasses()) 6035 & INPUT_DEVICE_CLASS_JOYSTICK)) { 6036 continue; // axis must be claimed by a different device 6037 } 6038 6039 RawAbsoluteAxisInfo rawAxisInfo; 6040 getAbsoluteAxisInfo(abs, &rawAxisInfo); 6041 if (rawAxisInfo.valid) { 6042 // Map axis. 6043 AxisInfo axisInfo; 6044 bool explicitlyMapped = !getEventHub()->mapAxis(getDeviceId(), abs, &axisInfo); 6045 if (!explicitlyMapped) { 6046 // Axis is not explicitly mapped, will choose a generic axis later. 6047 axisInfo.mode = AxisInfo::MODE_NORMAL; 6048 axisInfo.axis = -1; 6049 } 6050 6051 // Apply flat override. 6052 int32_t rawFlat = axisInfo.flatOverride < 0 6053 ? rawAxisInfo.flat : axisInfo.flatOverride; 6054 6055 // Calculate scaling factors and limits. 6056 Axis axis; 6057 if (axisInfo.mode == AxisInfo::MODE_SPLIT) { 6058 float scale = 1.0f / (axisInfo.splitValue - rawAxisInfo.minValue); 6059 float highScale = 1.0f / (rawAxisInfo.maxValue - axisInfo.splitValue); 6060 axis.initialize(rawAxisInfo, axisInfo, explicitlyMapped, 6061 scale, 0.0f, highScale, 0.0f, 6062 0.0f, 1.0f, rawFlat * scale, rawAxisInfo.fuzz * scale); 6063 } else if (isCenteredAxis(axisInfo.axis)) { 6064 float scale = 2.0f / (rawAxisInfo.maxValue - rawAxisInfo.minValue); 6065 float offset = avg(rawAxisInfo.minValue, rawAxisInfo.maxValue) * -scale; 6066 axis.initialize(rawAxisInfo, axisInfo, explicitlyMapped, 6067 scale, offset, scale, offset, 6068 -1.0f, 1.0f, rawFlat * scale, rawAxisInfo.fuzz * scale); 6069 } else { 6070 float scale = 1.0f / (rawAxisInfo.maxValue - rawAxisInfo.minValue); 6071 axis.initialize(rawAxisInfo, axisInfo, explicitlyMapped, 6072 scale, 0.0f, scale, 0.0f, 6073 0.0f, 1.0f, rawFlat * scale, rawAxisInfo.fuzz * scale); 6074 } 6075 6076 // To eliminate noise while the joystick is at rest, filter out small variations 6077 // in axis values up front. 6078 axis.filter = axis.flat * 0.25f; 6079 6080 mAxes.add(abs, axis); 6081 } 6082 } 6083 6084 // If there are too many axes, start dropping them. 6085 // Prefer to keep explicitly mapped axes. 6086 if (mAxes.size() > PointerCoords::MAX_AXES) { 6087 ALOGI("Joystick '%s' has %d axes but the framework only supports a maximum of %d.", 6088 getDeviceName().string(), mAxes.size(), PointerCoords::MAX_AXES); 6089 pruneAxes(true); 6090 pruneAxes(false); 6091 } 6092 6093 // Assign generic axis ids to remaining axes. 6094 int32_t nextGenericAxisId = AMOTION_EVENT_AXIS_GENERIC_1; 6095 size_t numAxes = mAxes.size(); 6096 for (size_t i = 0; i < numAxes; i++) { 6097 Axis& axis = mAxes.editValueAt(i); 6098 if (axis.axisInfo.axis < 0) { 6099 while (nextGenericAxisId <= AMOTION_EVENT_AXIS_GENERIC_16 6100 && haveAxis(nextGenericAxisId)) { 6101 nextGenericAxisId += 1; 6102 } 6103 6104 if (nextGenericAxisId <= AMOTION_EVENT_AXIS_GENERIC_16) { 6105 axis.axisInfo.axis = nextGenericAxisId; 6106 nextGenericAxisId += 1; 6107 } else { 6108 ALOGI("Ignoring joystick '%s' axis %d because all of the generic axis ids " 6109 "have already been assigned to other axes.", 6110 getDeviceName().string(), mAxes.keyAt(i)); 6111 mAxes.removeItemsAt(i--); 6112 numAxes -= 1; 6113 } 6114 } 6115 } 6116 } 6117} 6118 6119bool JoystickInputMapper::haveAxis(int32_t axisId) { 6120 size_t numAxes = mAxes.size(); 6121 for (size_t i = 0; i < numAxes; i++) { 6122 const Axis& axis = mAxes.valueAt(i); 6123 if (axis.axisInfo.axis == axisId 6124 || (axis.axisInfo.mode == AxisInfo::MODE_SPLIT 6125 && axis.axisInfo.highAxis == axisId)) { 6126 return true; 6127 } 6128 } 6129 return false; 6130} 6131 6132void JoystickInputMapper::pruneAxes(bool ignoreExplicitlyMappedAxes) { 6133 size_t i = mAxes.size(); 6134 while (mAxes.size() > PointerCoords::MAX_AXES && i-- > 0) { 6135 if (ignoreExplicitlyMappedAxes && mAxes.valueAt(i).explicitlyMapped) { 6136 continue; 6137 } 6138 ALOGI("Discarding joystick '%s' axis %d because there are too many axes.", 6139 getDeviceName().string(), mAxes.keyAt(i)); 6140 mAxes.removeItemsAt(i); 6141 } 6142} 6143 6144bool JoystickInputMapper::isCenteredAxis(int32_t axis) { 6145 switch (axis) { 6146 case AMOTION_EVENT_AXIS_X: 6147 case AMOTION_EVENT_AXIS_Y: 6148 case AMOTION_EVENT_AXIS_Z: 6149 case AMOTION_EVENT_AXIS_RX: 6150 case AMOTION_EVENT_AXIS_RY: 6151 case AMOTION_EVENT_AXIS_RZ: 6152 case AMOTION_EVENT_AXIS_HAT_X: 6153 case AMOTION_EVENT_AXIS_HAT_Y: 6154 case AMOTION_EVENT_AXIS_ORIENTATION: 6155 case AMOTION_EVENT_AXIS_RUDDER: 6156 case AMOTION_EVENT_AXIS_WHEEL: 6157 return true; 6158 default: 6159 return false; 6160 } 6161} 6162 6163void JoystickInputMapper::reset(nsecs_t when) { 6164 // Recenter all axes. 6165 size_t numAxes = mAxes.size(); 6166 for (size_t i = 0; i < numAxes; i++) { 6167 Axis& axis = mAxes.editValueAt(i); 6168 axis.resetValue(); 6169 } 6170 6171 InputMapper::reset(when); 6172} 6173 6174void JoystickInputMapper::process(const RawEvent* rawEvent) { 6175 switch (rawEvent->type) { 6176 case EV_ABS: { 6177 ssize_t index = mAxes.indexOfKey(rawEvent->code); 6178 if (index >= 0) { 6179 Axis& axis = mAxes.editValueAt(index); 6180 float newValue, highNewValue; 6181 switch (axis.axisInfo.mode) { 6182 case AxisInfo::MODE_INVERT: 6183 newValue = (axis.rawAxisInfo.maxValue - rawEvent->value) 6184 * axis.scale + axis.offset; 6185 highNewValue = 0.0f; 6186 break; 6187 case AxisInfo::MODE_SPLIT: 6188 if (rawEvent->value < axis.axisInfo.splitValue) { 6189 newValue = (axis.axisInfo.splitValue - rawEvent->value) 6190 * axis.scale + axis.offset; 6191 highNewValue = 0.0f; 6192 } else if (rawEvent->value > axis.axisInfo.splitValue) { 6193 newValue = 0.0f; 6194 highNewValue = (rawEvent->value - axis.axisInfo.splitValue) 6195 * axis.highScale + axis.highOffset; 6196 } else { 6197 newValue = 0.0f; 6198 highNewValue = 0.0f; 6199 } 6200 break; 6201 default: 6202 newValue = rawEvent->value * axis.scale + axis.offset; 6203 highNewValue = 0.0f; 6204 break; 6205 } 6206 axis.newValue = newValue; 6207 axis.highNewValue = highNewValue; 6208 } 6209 break; 6210 } 6211 6212 case EV_SYN: 6213 switch (rawEvent->code) { 6214 case SYN_REPORT: 6215 sync(rawEvent->when, false /*force*/); 6216 break; 6217 } 6218 break; 6219 } 6220} 6221 6222void JoystickInputMapper::sync(nsecs_t when, bool force) { 6223 if (!filterAxes(force)) { 6224 return; 6225 } 6226 6227 int32_t metaState = mContext->getGlobalMetaState(); 6228 int32_t buttonState = 0; 6229 6230 PointerProperties pointerProperties; 6231 pointerProperties.clear(); 6232 pointerProperties.id = 0; 6233 pointerProperties.toolType = AMOTION_EVENT_TOOL_TYPE_UNKNOWN; 6234 6235 PointerCoords pointerCoords; 6236 pointerCoords.clear(); 6237 6238 size_t numAxes = mAxes.size(); 6239 for (size_t i = 0; i < numAxes; i++) { 6240 const Axis& axis = mAxes.valueAt(i); 6241 pointerCoords.setAxisValue(axis.axisInfo.axis, axis.currentValue); 6242 if (axis.axisInfo.mode == AxisInfo::MODE_SPLIT) { 6243 pointerCoords.setAxisValue(axis.axisInfo.highAxis, axis.highCurrentValue); 6244 } 6245 } 6246 6247 // Moving a joystick axis should not wake the devide because joysticks can 6248 // be fairly noisy even when not in use. On the other hand, pushing a gamepad 6249 // button will likely wake the device. 6250 // TODO: Use the input device configuration to control this behavior more finely. 6251 uint32_t policyFlags = 0; 6252 6253 NotifyMotionArgs args(when, getDeviceId(), AINPUT_SOURCE_JOYSTICK, policyFlags, 6254 AMOTION_EVENT_ACTION_MOVE, 0, metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, 6255 1, &pointerProperties, &pointerCoords, 0, 0, 0); 6256 getListener()->notifyMotion(&args); 6257} 6258 6259bool JoystickInputMapper::filterAxes(bool force) { 6260 bool atLeastOneSignificantChange = force; 6261 size_t numAxes = mAxes.size(); 6262 for (size_t i = 0; i < numAxes; i++) { 6263 Axis& axis = mAxes.editValueAt(i); 6264 if (force || hasValueChangedSignificantly(axis.filter, 6265 axis.newValue, axis.currentValue, axis.min, axis.max)) { 6266 axis.currentValue = axis.newValue; 6267 atLeastOneSignificantChange = true; 6268 } 6269 if (axis.axisInfo.mode == AxisInfo::MODE_SPLIT) { 6270 if (force || hasValueChangedSignificantly(axis.filter, 6271 axis.highNewValue, axis.highCurrentValue, axis.min, axis.max)) { 6272 axis.highCurrentValue = axis.highNewValue; 6273 atLeastOneSignificantChange = true; 6274 } 6275 } 6276 } 6277 return atLeastOneSignificantChange; 6278} 6279 6280bool JoystickInputMapper::hasValueChangedSignificantly( 6281 float filter, float newValue, float currentValue, float min, float max) { 6282 if (newValue != currentValue) { 6283 // Filter out small changes in value unless the value is converging on the axis 6284 // bounds or center point. This is intended to reduce the amount of information 6285 // sent to applications by particularly noisy joysticks (such as PS3). 6286 if (fabs(newValue - currentValue) > filter 6287 || hasMovedNearerToValueWithinFilteredRange(filter, newValue, currentValue, min) 6288 || hasMovedNearerToValueWithinFilteredRange(filter, newValue, currentValue, max) 6289 || hasMovedNearerToValueWithinFilteredRange(filter, newValue, currentValue, 0)) { 6290 return true; 6291 } 6292 } 6293 return false; 6294} 6295 6296bool JoystickInputMapper::hasMovedNearerToValueWithinFilteredRange( 6297 float filter, float newValue, float currentValue, float thresholdValue) { 6298 float newDistance = fabs(newValue - thresholdValue); 6299 if (newDistance < filter) { 6300 float oldDistance = fabs(currentValue - thresholdValue); 6301 if (newDistance < oldDistance) { 6302 return true; 6303 } 6304 } 6305 return false; 6306} 6307 6308} // namespace android 6309