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