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