1 // 2 // Copyright 2010 The Android Open Source Project 3 // 4 // The input dispatcher. 5 // 6 #define LOG_TAG "InputDispatcher" 7 8 //#define LOG_NDEBUG 0 9 10 // Log detailed debug messages about each inbound event notification to the dispatcher. 11 #define DEBUG_INBOUND_EVENT_DETAILS 0 12 13 // Log detailed debug messages about each outbound event processed by the dispatcher. 14 #define DEBUG_OUTBOUND_EVENT_DETAILS 0 15 16 // Log debug messages about batching. 17 #define DEBUG_BATCHING 0 18 19 // Log debug messages about the dispatch cycle. 20 #define DEBUG_DISPATCH_CYCLE 0 21 22 // Log debug messages about registrations. 23 #define DEBUG_REGISTRATION 0 24 25 // Log debug messages about performance statistics. 26 #define DEBUG_PERFORMANCE_STATISTICS 0 27 28 // Log debug messages about input event injection. 29 #define DEBUG_INJECTION 0 30 31 // Log debug messages about input event throttling. 32 #define DEBUG_THROTTLING 0 33 34 // Log debug messages about input focus tracking. 35 #define DEBUG_FOCUS 0 36 37 // Log debug messages about the app switch latency optimization. 38 #define DEBUG_APP_SWITCH 0 39 40 #include <cutils/log.h> 41 #include <ui/InputDispatcher.h> 42 #include <ui/PowerManager.h> 43 44 #include <stddef.h> 45 #include <unistd.h> 46 #include <errno.h> 47 #include <limits.h> 48 49 #define INDENT " " 50 #define INDENT2 " " 51 52 namespace android { 53 54 // Delay before reporting long touch events to the power manager. 55 const nsecs_t LONG_TOUCH_DELAY = 300 * 1000000LL; // 300 ms 56 57 // Default input dispatching timeout if there is no focused application or paused window 58 // from which to determine an appropriate dispatching timeout. 59 const nsecs_t DEFAULT_INPUT_DISPATCHING_TIMEOUT = 5000 * 1000000LL; // 5 sec 60 61 // Amount of time to allow for all pending events to be processed when an app switch 62 // key is on the way. This is used to preempt input dispatch and drop input events 63 // when an application takes too long to respond and the user has pressed an app switch key. 64 const nsecs_t APP_SWITCH_TIMEOUT = 500 * 1000000LL; // 0.5sec 65 66 67 static inline nsecs_t now() { 68 return systemTime(SYSTEM_TIME_MONOTONIC); 69 } 70 71 static inline const char* toString(bool value) { 72 return value ? "true" : "false"; 73 } 74 75 static inline int32_t getMotionEventActionPointerIndex(int32_t action) { 76 return (action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) 77 >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT; 78 } 79 80 static bool isValidKeyAction(int32_t action) { 81 switch (action) { 82 case AKEY_EVENT_ACTION_DOWN: 83 case AKEY_EVENT_ACTION_UP: 84 return true; 85 default: 86 return false; 87 } 88 } 89 90 static bool validateKeyEvent(int32_t action) { 91 if (! isValidKeyAction(action)) { 92 LOGE("Key event has invalid action code 0x%x", action); 93 return false; 94 } 95 return true; 96 } 97 98 static bool isValidMotionAction(int32_t action, size_t pointerCount) { 99 switch (action & AMOTION_EVENT_ACTION_MASK) { 100 case AMOTION_EVENT_ACTION_DOWN: 101 case AMOTION_EVENT_ACTION_UP: 102 case AMOTION_EVENT_ACTION_CANCEL: 103 case AMOTION_EVENT_ACTION_MOVE: 104 case AMOTION_EVENT_ACTION_OUTSIDE: 105 return true; 106 case AMOTION_EVENT_ACTION_POINTER_DOWN: 107 case AMOTION_EVENT_ACTION_POINTER_UP: { 108 int32_t index = getMotionEventActionPointerIndex(action); 109 return index >= 0 && size_t(index) < pointerCount; 110 } 111 default: 112 return false; 113 } 114 } 115 116 static bool validateMotionEvent(int32_t action, size_t pointerCount, 117 const int32_t* pointerIds) { 118 if (! isValidMotionAction(action, pointerCount)) { 119 LOGE("Motion event has invalid action code 0x%x", action); 120 return false; 121 } 122 if (pointerCount < 1 || pointerCount > MAX_POINTERS) { 123 LOGE("Motion event has invalid pointer count %d; value must be between 1 and %d.", 124 pointerCount, MAX_POINTERS); 125 return false; 126 } 127 BitSet32 pointerIdBits; 128 for (size_t i = 0; i < pointerCount; i++) { 129 int32_t id = pointerIds[i]; 130 if (id < 0 || id > MAX_POINTER_ID) { 131 LOGE("Motion event has invalid pointer id %d; value must be between 0 and %d", 132 id, MAX_POINTER_ID); 133 return false; 134 } 135 if (pointerIdBits.hasBit(id)) { 136 LOGE("Motion event has duplicate pointer id %d", id); 137 return false; 138 } 139 pointerIdBits.markBit(id); 140 } 141 return true; 142 } 143 144 145 // --- InputWindow --- 146 147 bool InputWindow::touchableAreaContainsPoint(int32_t x, int32_t y) const { 148 return x >= touchableAreaLeft && x <= touchableAreaRight 149 && y >= touchableAreaTop && y <= touchableAreaBottom; 150 } 151 152 bool InputWindow::frameContainsPoint(int32_t x, int32_t y) const { 153 return x >= frameLeft && x <= frameRight 154 && y >= frameTop && y <= frameBottom; 155 } 156 157 bool InputWindow::isTrustedOverlay() const { 158 return layoutParamsType == TYPE_INPUT_METHOD 159 || layoutParamsType == TYPE_INPUT_METHOD_DIALOG 160 || layoutParamsType == TYPE_SECURE_SYSTEM_OVERLAY; 161 } 162 163 164 // --- InputDispatcher --- 165 166 InputDispatcher::InputDispatcher(const sp<InputDispatcherPolicyInterface>& policy) : 167 mPolicy(policy), 168 mPendingEvent(NULL), mAppSwitchDueTime(LONG_LONG_MAX), 169 mDispatchEnabled(true), mDispatchFrozen(false), 170 mFocusedWindow(NULL), 171 mFocusedApplication(NULL), 172 mCurrentInputTargetsValid(false), 173 mInputTargetWaitCause(INPUT_TARGET_WAIT_CAUSE_NONE) { 174 mLooper = new Looper(false); 175 176 mInboundQueue.headSentinel.refCount = -1; 177 mInboundQueue.headSentinel.type = EventEntry::TYPE_SENTINEL; 178 mInboundQueue.headSentinel.eventTime = LONG_LONG_MIN; 179 180 mInboundQueue.tailSentinel.refCount = -1; 181 mInboundQueue.tailSentinel.type = EventEntry::TYPE_SENTINEL; 182 mInboundQueue.tailSentinel.eventTime = LONG_LONG_MAX; 183 184 mKeyRepeatState.lastKeyEntry = NULL; 185 186 int32_t maxEventsPerSecond = policy->getMaxEventsPerSecond(); 187 mThrottleState.minTimeBetweenEvents = 1000000000LL / maxEventsPerSecond; 188 mThrottleState.lastDeviceId = -1; 189 190 #if DEBUG_THROTTLING 191 mThrottleState.originalSampleCount = 0; 192 LOGD("Throttling - Max events per second = %d", maxEventsPerSecond); 193 #endif 194 } 195 196 InputDispatcher::~InputDispatcher() { 197 { // acquire lock 198 AutoMutex _l(mLock); 199 200 resetKeyRepeatLocked(); 201 releasePendingEventLocked(); 202 drainInboundQueueLocked(); 203 } 204 205 while (mConnectionsByReceiveFd.size() != 0) { 206 unregisterInputChannel(mConnectionsByReceiveFd.valueAt(0)->inputChannel); 207 } 208 } 209 210 void InputDispatcher::dispatchOnce() { 211 nsecs_t keyRepeatTimeout = mPolicy->getKeyRepeatTimeout(); 212 nsecs_t keyRepeatDelay = mPolicy->getKeyRepeatDelay(); 213 214 nsecs_t nextWakeupTime = LONG_LONG_MAX; 215 { // acquire lock 216 AutoMutex _l(mLock); 217 dispatchOnceInnerLocked(keyRepeatTimeout, keyRepeatDelay, & nextWakeupTime); 218 219 if (runCommandsLockedInterruptible()) { 220 nextWakeupTime = LONG_LONG_MIN; // force next poll to wake up immediately 221 } 222 } // release lock 223 224 // Wait for callback or timeout or wake. (make sure we round up, not down) 225 nsecs_t currentTime = now(); 226 int32_t timeoutMillis; 227 if (nextWakeupTime > currentTime) { 228 uint64_t timeout = uint64_t(nextWakeupTime - currentTime); 229 timeout = (timeout + 999999LL) / 1000000LL; 230 timeoutMillis = timeout > INT_MAX ? -1 : int32_t(timeout); 231 } else { 232 timeoutMillis = 0; 233 } 234 235 mLooper->pollOnce(timeoutMillis); 236 } 237 238 void InputDispatcher::dispatchOnceInnerLocked(nsecs_t keyRepeatTimeout, 239 nsecs_t keyRepeatDelay, nsecs_t* nextWakeupTime) { 240 nsecs_t currentTime = now(); 241 242 // Reset the key repeat timer whenever we disallow key events, even if the next event 243 // is not a key. This is to ensure that we abort a key repeat if the device is just coming 244 // out of sleep. 245 if (keyRepeatTimeout < 0) { 246 resetKeyRepeatLocked(); 247 } 248 249 // If dispatching is frozen, do not process timeouts or try to deliver any new events. 250 if (mDispatchFrozen) { 251 #if DEBUG_FOCUS 252 LOGD("Dispatch frozen. Waiting some more."); 253 #endif 254 return; 255 } 256 257 // Optimize latency of app switches. 258 // Essentially we start a short timeout when an app switch key (HOME / ENDCALL) has 259 // been pressed. When it expires, we preempt dispatch and drop all other pending events. 260 bool isAppSwitchDue = mAppSwitchDueTime <= currentTime; 261 if (mAppSwitchDueTime < *nextWakeupTime) { 262 *nextWakeupTime = mAppSwitchDueTime; 263 } 264 265 // Ready to start a new event. 266 // If we don't already have a pending event, go grab one. 267 if (! mPendingEvent) { 268 if (mInboundQueue.isEmpty()) { 269 if (isAppSwitchDue) { 270 // The inbound queue is empty so the app switch key we were waiting 271 // for will never arrive. Stop waiting for it. 272 resetPendingAppSwitchLocked(false); 273 isAppSwitchDue = false; 274 } 275 276 // Synthesize a key repeat if appropriate. 277 if (mKeyRepeatState.lastKeyEntry) { 278 if (currentTime >= mKeyRepeatState.nextRepeatTime) { 279 mPendingEvent = synthesizeKeyRepeatLocked(currentTime, keyRepeatDelay); 280 } else { 281 if (mKeyRepeatState.nextRepeatTime < *nextWakeupTime) { 282 *nextWakeupTime = mKeyRepeatState.nextRepeatTime; 283 } 284 } 285 } 286 if (! mPendingEvent) { 287 return; 288 } 289 } else { 290 // Inbound queue has at least one entry. 291 EventEntry* entry = mInboundQueue.headSentinel.next; 292 293 // Throttle the entry if it is a move event and there are no 294 // other events behind it in the queue. Due to movement batching, additional 295 // samples may be appended to this event by the time the throttling timeout 296 // expires. 297 // TODO Make this smarter and consider throttling per device independently. 298 if (entry->type == EventEntry::TYPE_MOTION 299 && !isAppSwitchDue 300 && mDispatchEnabled 301 && (entry->policyFlags & POLICY_FLAG_PASS_TO_USER) 302 && !entry->isInjected()) { 303 MotionEntry* motionEntry = static_cast<MotionEntry*>(entry); 304 int32_t deviceId = motionEntry->deviceId; 305 uint32_t source = motionEntry->source; 306 if (! isAppSwitchDue 307 && motionEntry->next == & mInboundQueue.tailSentinel // exactly one event 308 && motionEntry->action == AMOTION_EVENT_ACTION_MOVE 309 && deviceId == mThrottleState.lastDeviceId 310 && source == mThrottleState.lastSource) { 311 nsecs_t nextTime = mThrottleState.lastEventTime 312 + mThrottleState.minTimeBetweenEvents; 313 if (currentTime < nextTime) { 314 // Throttle it! 315 #if DEBUG_THROTTLING 316 LOGD("Throttling - Delaying motion event for " 317 "device 0x%x, source 0x%08x by up to %0.3fms.", 318 deviceId, source, (nextTime - currentTime) * 0.000001); 319 #endif 320 if (nextTime < *nextWakeupTime) { 321 *nextWakeupTime = nextTime; 322 } 323 if (mThrottleState.originalSampleCount == 0) { 324 mThrottleState.originalSampleCount = 325 motionEntry->countSamples(); 326 } 327 return; 328 } 329 } 330 331 #if DEBUG_THROTTLING 332 if (mThrottleState.originalSampleCount != 0) { 333 uint32_t count = motionEntry->countSamples(); 334 LOGD("Throttling - Motion event sample count grew by %d from %d to %d.", 335 count - mThrottleState.originalSampleCount, 336 mThrottleState.originalSampleCount, count); 337 mThrottleState.originalSampleCount = 0; 338 } 339 #endif 340 341 mThrottleState.lastEventTime = entry->eventTime < currentTime 342 ? entry->eventTime : currentTime; 343 mThrottleState.lastDeviceId = deviceId; 344 mThrottleState.lastSource = source; 345 } 346 347 mInboundQueue.dequeue(entry); 348 mPendingEvent = entry; 349 } 350 351 // Poke user activity for this event. 352 if (mPendingEvent->policyFlags & POLICY_FLAG_PASS_TO_USER) { 353 pokeUserActivityLocked(mPendingEvent); 354 } 355 } 356 357 // Now we have an event to dispatch. 358 assert(mPendingEvent != NULL); 359 bool done = false; 360 DropReason dropReason = DROP_REASON_NOT_DROPPED; 361 if (!(mPendingEvent->policyFlags & POLICY_FLAG_PASS_TO_USER)) { 362 dropReason = DROP_REASON_POLICY; 363 } else if (!mDispatchEnabled) { 364 dropReason = DROP_REASON_DISABLED; 365 } 366 switch (mPendingEvent->type) { 367 case EventEntry::TYPE_CONFIGURATION_CHANGED: { 368 ConfigurationChangedEntry* typedEntry = 369 static_cast<ConfigurationChangedEntry*>(mPendingEvent); 370 done = dispatchConfigurationChangedLocked(currentTime, typedEntry); 371 dropReason = DROP_REASON_NOT_DROPPED; // configuration changes are never dropped 372 break; 373 } 374 375 case EventEntry::TYPE_KEY: { 376 KeyEntry* typedEntry = static_cast<KeyEntry*>(mPendingEvent); 377 if (isAppSwitchDue) { 378 if (isAppSwitchKeyEventLocked(typedEntry)) { 379 resetPendingAppSwitchLocked(true); 380 isAppSwitchDue = false; 381 } else if (dropReason == DROP_REASON_NOT_DROPPED) { 382 dropReason = DROP_REASON_APP_SWITCH; 383 } 384 } 385 done = dispatchKeyLocked(currentTime, typedEntry, keyRepeatTimeout, 386 &dropReason, nextWakeupTime); 387 break; 388 } 389 390 case EventEntry::TYPE_MOTION: { 391 MotionEntry* typedEntry = static_cast<MotionEntry*>(mPendingEvent); 392 if (dropReason == DROP_REASON_NOT_DROPPED && isAppSwitchDue) { 393 dropReason = DROP_REASON_APP_SWITCH; 394 } 395 done = dispatchMotionLocked(currentTime, typedEntry, 396 &dropReason, nextWakeupTime); 397 break; 398 } 399 400 default: 401 assert(false); 402 break; 403 } 404 405 if (done) { 406 if (dropReason != DROP_REASON_NOT_DROPPED) { 407 dropInboundEventLocked(mPendingEvent, dropReason); 408 } 409 410 releasePendingEventLocked(); 411 *nextWakeupTime = LONG_LONG_MIN; // force next poll to wake up immediately 412 } 413 } 414 415 bool InputDispatcher::enqueueInboundEventLocked(EventEntry* entry) { 416 bool needWake = mInboundQueue.isEmpty(); 417 mInboundQueue.enqueueAtTail(entry); 418 419 switch (entry->type) { 420 case EventEntry::TYPE_KEY: { 421 KeyEntry* keyEntry = static_cast<KeyEntry*>(entry); 422 if (isAppSwitchKeyEventLocked(keyEntry)) { 423 if (keyEntry->action == AKEY_EVENT_ACTION_DOWN) { 424 mAppSwitchSawKeyDown = true; 425 } else if (keyEntry->action == AKEY_EVENT_ACTION_UP) { 426 if (mAppSwitchSawKeyDown) { 427 #if DEBUG_APP_SWITCH 428 LOGD("App switch is pending!"); 429 #endif 430 mAppSwitchDueTime = keyEntry->eventTime + APP_SWITCH_TIMEOUT; 431 mAppSwitchSawKeyDown = false; 432 needWake = true; 433 } 434 } 435 } 436 break; 437 } 438 } 439 440 return needWake; 441 } 442 443 void InputDispatcher::dropInboundEventLocked(EventEntry* entry, DropReason dropReason) { 444 const char* reason; 445 switch (dropReason) { 446 case DROP_REASON_POLICY: 447 #if DEBUG_INBOUND_EVENT_DETAILS 448 LOGD("Dropped event because policy consumed it."); 449 #endif 450 reason = "inbound event was dropped because the policy consumed it"; 451 break; 452 case DROP_REASON_DISABLED: 453 LOGI("Dropped event because input dispatch is disabled."); 454 reason = "inbound event was dropped because input dispatch is disabled"; 455 break; 456 case DROP_REASON_APP_SWITCH: 457 LOGI("Dropped event because of pending overdue app switch."); 458 reason = "inbound event was dropped because of pending overdue app switch"; 459 break; 460 default: 461 assert(false); 462 return; 463 } 464 465 switch (entry->type) { 466 case EventEntry::TYPE_KEY: 467 synthesizeCancelationEventsForAllConnectionsLocked( 468 InputState::CANCEL_NON_POINTER_EVENTS, reason); 469 break; 470 case EventEntry::TYPE_MOTION: { 471 MotionEntry* motionEntry = static_cast<MotionEntry*>(entry); 472 if (motionEntry->source & AINPUT_SOURCE_CLASS_POINTER) { 473 synthesizeCancelationEventsForAllConnectionsLocked( 474 InputState::CANCEL_POINTER_EVENTS, reason); 475 } else { 476 synthesizeCancelationEventsForAllConnectionsLocked( 477 InputState::CANCEL_NON_POINTER_EVENTS, reason); 478 } 479 break; 480 } 481 } 482 } 483 484 bool InputDispatcher::isAppSwitchKeyCode(int32_t keyCode) { 485 return keyCode == AKEYCODE_HOME || keyCode == AKEYCODE_ENDCALL; 486 } 487 488 bool InputDispatcher::isAppSwitchKeyEventLocked(KeyEntry* keyEntry) { 489 return ! (keyEntry->flags & AKEY_EVENT_FLAG_CANCELED) 490 && isAppSwitchKeyCode(keyEntry->keyCode) 491 && (keyEntry->policyFlags & POLICY_FLAG_TRUSTED) 492 && (keyEntry->policyFlags & POLICY_FLAG_PASS_TO_USER); 493 } 494 495 bool InputDispatcher::isAppSwitchPendingLocked() { 496 return mAppSwitchDueTime != LONG_LONG_MAX; 497 } 498 499 void InputDispatcher::resetPendingAppSwitchLocked(bool handled) { 500 mAppSwitchDueTime = LONG_LONG_MAX; 501 502 #if DEBUG_APP_SWITCH 503 if (handled) { 504 LOGD("App switch has arrived."); 505 } else { 506 LOGD("App switch was abandoned."); 507 } 508 #endif 509 } 510 511 bool InputDispatcher::runCommandsLockedInterruptible() { 512 if (mCommandQueue.isEmpty()) { 513 return false; 514 } 515 516 do { 517 CommandEntry* commandEntry = mCommandQueue.dequeueAtHead(); 518 519 Command command = commandEntry->command; 520 (this->*command)(commandEntry); // commands are implicitly 'LockedInterruptible' 521 522 commandEntry->connection.clear(); 523 mAllocator.releaseCommandEntry(commandEntry); 524 } while (! mCommandQueue.isEmpty()); 525 return true; 526 } 527 528 InputDispatcher::CommandEntry* InputDispatcher::postCommandLocked(Command command) { 529 CommandEntry* commandEntry = mAllocator.obtainCommandEntry(command); 530 mCommandQueue.enqueueAtTail(commandEntry); 531 return commandEntry; 532 } 533 534 void InputDispatcher::drainInboundQueueLocked() { 535 while (! mInboundQueue.isEmpty()) { 536 EventEntry* entry = mInboundQueue.dequeueAtHead(); 537 releaseInboundEventLocked(entry); 538 } 539 } 540 541 void InputDispatcher::releasePendingEventLocked() { 542 if (mPendingEvent) { 543 releaseInboundEventLocked(mPendingEvent); 544 mPendingEvent = NULL; 545 } 546 } 547 548 void InputDispatcher::releaseInboundEventLocked(EventEntry* entry) { 549 InjectionState* injectionState = entry->injectionState; 550 if (injectionState && injectionState->injectionResult == INPUT_EVENT_INJECTION_PENDING) { 551 #if DEBUG_DISPATCH_CYCLE 552 LOGD("Injected inbound event was dropped."); 553 #endif 554 setInjectionResultLocked(entry, INPUT_EVENT_INJECTION_FAILED); 555 } 556 mAllocator.releaseEventEntry(entry); 557 } 558 559 void InputDispatcher::resetKeyRepeatLocked() { 560 if (mKeyRepeatState.lastKeyEntry) { 561 mAllocator.releaseKeyEntry(mKeyRepeatState.lastKeyEntry); 562 mKeyRepeatState.lastKeyEntry = NULL; 563 } 564 } 565 566 InputDispatcher::KeyEntry* InputDispatcher::synthesizeKeyRepeatLocked( 567 nsecs_t currentTime, nsecs_t keyRepeatDelay) { 568 KeyEntry* entry = mKeyRepeatState.lastKeyEntry; 569 570 // Reuse the repeated key entry if it is otherwise unreferenced. 571 uint32_t policyFlags = (entry->policyFlags & POLICY_FLAG_RAW_MASK) 572 | POLICY_FLAG_PASS_TO_USER | POLICY_FLAG_TRUSTED; 573 if (entry->refCount == 1) { 574 mAllocator.recycleKeyEntry(entry); 575 entry->eventTime = currentTime; 576 entry->policyFlags = policyFlags; 577 entry->repeatCount += 1; 578 } else { 579 KeyEntry* newEntry = mAllocator.obtainKeyEntry(currentTime, 580 entry->deviceId, entry->source, policyFlags, 581 entry->action, entry->flags, entry->keyCode, entry->scanCode, 582 entry->metaState, entry->repeatCount + 1, entry->downTime); 583 584 mKeyRepeatState.lastKeyEntry = newEntry; 585 mAllocator.releaseKeyEntry(entry); 586 587 entry = newEntry; 588 } 589 entry->syntheticRepeat = true; 590 591 // Increment reference count since we keep a reference to the event in 592 // mKeyRepeatState.lastKeyEntry in addition to the one we return. 593 entry->refCount += 1; 594 595 if (entry->repeatCount == 1) { 596 entry->flags |= AKEY_EVENT_FLAG_LONG_PRESS; 597 } 598 599 mKeyRepeatState.nextRepeatTime = currentTime + keyRepeatDelay; 600 return entry; 601 } 602 603 bool InputDispatcher::dispatchConfigurationChangedLocked( 604 nsecs_t currentTime, ConfigurationChangedEntry* entry) { 605 #if DEBUG_OUTBOUND_EVENT_DETAILS 606 LOGD("dispatchConfigurationChanged - eventTime=%lld", entry->eventTime); 607 #endif 608 609 // Reset key repeating in case a keyboard device was added or removed or something. 610 resetKeyRepeatLocked(); 611 612 // Enqueue a command to run outside the lock to tell the policy that the configuration changed. 613 CommandEntry* commandEntry = postCommandLocked( 614 & InputDispatcher::doNotifyConfigurationChangedInterruptible); 615 commandEntry->eventTime = entry->eventTime; 616 return true; 617 } 618 619 bool InputDispatcher::dispatchKeyLocked( 620 nsecs_t currentTime, KeyEntry* entry, nsecs_t keyRepeatTimeout, 621 DropReason* dropReason, nsecs_t* nextWakeupTime) { 622 // Preprocessing. 623 if (! entry->dispatchInProgress) { 624 if (entry->repeatCount == 0 625 && entry->action == AKEY_EVENT_ACTION_DOWN 626 && (entry->policyFlags & POLICY_FLAG_TRUSTED) 627 && !entry->isInjected()) { 628 if (mKeyRepeatState.lastKeyEntry 629 && mKeyRepeatState.lastKeyEntry->keyCode == entry->keyCode) { 630 // We have seen two identical key downs in a row which indicates that the device 631 // driver is automatically generating key repeats itself. We take note of the 632 // repeat here, but we disable our own next key repeat timer since it is clear that 633 // we will not need to synthesize key repeats ourselves. 634 entry->repeatCount = mKeyRepeatState.lastKeyEntry->repeatCount + 1; 635 resetKeyRepeatLocked(); 636 mKeyRepeatState.nextRepeatTime = LONG_LONG_MAX; // don't generate repeats ourselves 637 } else { 638 // Not a repeat. Save key down state in case we do see a repeat later. 639 resetKeyRepeatLocked(); 640 mKeyRepeatState.nextRepeatTime = entry->eventTime + keyRepeatTimeout; 641 } 642 mKeyRepeatState.lastKeyEntry = entry; 643 entry->refCount += 1; 644 } else if (! entry->syntheticRepeat) { 645 resetKeyRepeatLocked(); 646 } 647 648 entry->dispatchInProgress = true; 649 resetTargetsLocked(); 650 651 logOutboundKeyDetailsLocked("dispatchKey - ", entry); 652 } 653 654 // Give the policy a chance to intercept the key. 655 if (entry->interceptKeyResult == KeyEntry::INTERCEPT_KEY_RESULT_UNKNOWN) { 656 if (entry->policyFlags & POLICY_FLAG_PASS_TO_USER) { 657 CommandEntry* commandEntry = postCommandLocked( 658 & InputDispatcher::doInterceptKeyBeforeDispatchingLockedInterruptible); 659 if (mFocusedWindow) { 660 commandEntry->inputChannel = mFocusedWindow->inputChannel; 661 } 662 commandEntry->keyEntry = entry; 663 entry->refCount += 1; 664 return false; // wait for the command to run 665 } else { 666 entry->interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_CONTINUE; 667 } 668 } else if (entry->interceptKeyResult == KeyEntry::INTERCEPT_KEY_RESULT_SKIP) { 669 if (*dropReason == DROP_REASON_NOT_DROPPED) { 670 *dropReason = DROP_REASON_POLICY; 671 } 672 } 673 674 // Clean up if dropping the event. 675 if (*dropReason != DROP_REASON_NOT_DROPPED) { 676 resetTargetsLocked(); 677 setInjectionResultLocked(entry, *dropReason == DROP_REASON_POLICY 678 ? INPUT_EVENT_INJECTION_SUCCEEDED : INPUT_EVENT_INJECTION_FAILED); 679 return true; 680 } 681 682 // Identify targets. 683 if (! mCurrentInputTargetsValid) { 684 int32_t injectionResult = findFocusedWindowTargetsLocked(currentTime, 685 entry, nextWakeupTime); 686 if (injectionResult == INPUT_EVENT_INJECTION_PENDING) { 687 return false; 688 } 689 690 setInjectionResultLocked(entry, injectionResult); 691 if (injectionResult != INPUT_EVENT_INJECTION_SUCCEEDED) { 692 return true; 693 } 694 695 addMonitoringTargetsLocked(); 696 commitTargetsLocked(); 697 } 698 699 // Dispatch the key. 700 dispatchEventToCurrentInputTargetsLocked(currentTime, entry, false); 701 return true; 702 } 703 704 void InputDispatcher::logOutboundKeyDetailsLocked(const char* prefix, const KeyEntry* entry) { 705 #if DEBUG_OUTBOUND_EVENT_DETAILS 706 LOGD("%seventTime=%lld, deviceId=0x%x, source=0x%x, policyFlags=0x%x, " 707 "action=0x%x, flags=0x%x, keyCode=0x%x, scanCode=0x%x, metaState=0x%x, " 708 "repeatCount=%d, downTime=%lld", 709 prefix, 710 entry->eventTime, entry->deviceId, entry->source, entry->policyFlags, 711 entry->action, entry->flags, entry->keyCode, entry->scanCode, entry->metaState, 712 entry->repeatCount, entry->downTime); 713 #endif 714 } 715 716 bool InputDispatcher::dispatchMotionLocked( 717 nsecs_t currentTime, MotionEntry* entry, DropReason* dropReason, nsecs_t* nextWakeupTime) { 718 // Preprocessing. 719 if (! entry->dispatchInProgress) { 720 entry->dispatchInProgress = true; 721 resetTargetsLocked(); 722 723 logOutboundMotionDetailsLocked("dispatchMotion - ", entry); 724 } 725 726 // Clean up if dropping the event. 727 if (*dropReason != DROP_REASON_NOT_DROPPED) { 728 resetTargetsLocked(); 729 setInjectionResultLocked(entry, *dropReason == DROP_REASON_POLICY 730 ? INPUT_EVENT_INJECTION_SUCCEEDED : INPUT_EVENT_INJECTION_FAILED); 731 return true; 732 } 733 734 bool isPointerEvent = entry->source & AINPUT_SOURCE_CLASS_POINTER; 735 736 // Identify targets. 737 if (! mCurrentInputTargetsValid) { 738 int32_t injectionResult; 739 if (isPointerEvent) { 740 // Pointer event. (eg. touchscreen) 741 injectionResult = findTouchedWindowTargetsLocked(currentTime, 742 entry, nextWakeupTime); 743 } else { 744 // Non touch event. (eg. trackball) 745 injectionResult = findFocusedWindowTargetsLocked(currentTime, 746 entry, nextWakeupTime); 747 } 748 if (injectionResult == INPUT_EVENT_INJECTION_PENDING) { 749 return false; 750 } 751 752 setInjectionResultLocked(entry, injectionResult); 753 if (injectionResult != INPUT_EVENT_INJECTION_SUCCEEDED) { 754 return true; 755 } 756 757 addMonitoringTargetsLocked(); 758 commitTargetsLocked(); 759 } 760 761 // Dispatch the motion. 762 dispatchEventToCurrentInputTargetsLocked(currentTime, entry, false); 763 return true; 764 } 765 766 767 void InputDispatcher::logOutboundMotionDetailsLocked(const char* prefix, const MotionEntry* entry) { 768 #if DEBUG_OUTBOUND_EVENT_DETAILS 769 LOGD("%seventTime=%lld, deviceId=0x%x, source=0x%x, policyFlags=0x%x, " 770 "action=0x%x, flags=0x%x, " 771 "metaState=0x%x, edgeFlags=0x%x, xPrecision=%f, yPrecision=%f, downTime=%lld", 772 prefix, 773 entry->eventTime, entry->deviceId, entry->source, entry->policyFlags, 774 entry->action, entry->flags, 775 entry->metaState, entry->edgeFlags, entry->xPrecision, entry->yPrecision, 776 entry->downTime); 777 778 // Print the most recent sample that we have available, this may change due to batching. 779 size_t sampleCount = 1; 780 const MotionSample* sample = & entry->firstSample; 781 for (; sample->next != NULL; sample = sample->next) { 782 sampleCount += 1; 783 } 784 for (uint32_t i = 0; i < entry->pointerCount; i++) { 785 LOGD(" Pointer %d: id=%d, x=%f, y=%f, pressure=%f, size=%f, " 786 "touchMajor=%f, touchMinor=%f, toolMajor=%f, toolMinor=%f, " 787 "orientation=%f", 788 i, entry->pointerIds[i], 789 sample->pointerCoords[i].x, sample->pointerCoords[i].y, 790 sample->pointerCoords[i].pressure, sample->pointerCoords[i].size, 791 sample->pointerCoords[i].touchMajor, sample->pointerCoords[i].touchMinor, 792 sample->pointerCoords[i].toolMajor, sample->pointerCoords[i].toolMinor, 793 sample->pointerCoords[i].orientation); 794 } 795 796 // Keep in mind that due to batching, it is possible for the number of samples actually 797 // dispatched to change before the application finally consumed them. 798 if (entry->action == AMOTION_EVENT_ACTION_MOVE) { 799 LOGD(" ... Total movement samples currently batched %d ...", sampleCount); 800 } 801 #endif 802 } 803 804 void InputDispatcher::dispatchEventToCurrentInputTargetsLocked(nsecs_t currentTime, 805 EventEntry* eventEntry, bool resumeWithAppendedMotionSample) { 806 #if DEBUG_DISPATCH_CYCLE 807 LOGD("dispatchEventToCurrentInputTargets - " 808 "resumeWithAppendedMotionSample=%s", 809 toString(resumeWithAppendedMotionSample)); 810 #endif 811 812 assert(eventEntry->dispatchInProgress); // should already have been set to true 813 814 pokeUserActivityLocked(eventEntry); 815 816 for (size_t i = 0; i < mCurrentInputTargets.size(); i++) { 817 const InputTarget& inputTarget = mCurrentInputTargets.itemAt(i); 818 819 ssize_t connectionIndex = getConnectionIndexLocked(inputTarget.inputChannel); 820 if (connectionIndex >= 0) { 821 sp<Connection> connection = mConnectionsByReceiveFd.valueAt(connectionIndex); 822 prepareDispatchCycleLocked(currentTime, connection, eventEntry, & inputTarget, 823 resumeWithAppendedMotionSample); 824 } else { 825 #if DEBUG_FOCUS 826 LOGD("Dropping event delivery to target with channel '%s' because it " 827 "is no longer registered with the input dispatcher.", 828 inputTarget.inputChannel->getName().string()); 829 #endif 830 } 831 } 832 } 833 834 void InputDispatcher::resetTargetsLocked() { 835 mCurrentInputTargetsValid = false; 836 mCurrentInputTargets.clear(); 837 mInputTargetWaitCause = INPUT_TARGET_WAIT_CAUSE_NONE; 838 } 839 840 void InputDispatcher::commitTargetsLocked() { 841 mCurrentInputTargetsValid = true; 842 } 843 844 int32_t InputDispatcher::handleTargetsNotReadyLocked(nsecs_t currentTime, 845 const EventEntry* entry, const InputApplication* application, const InputWindow* window, 846 nsecs_t* nextWakeupTime) { 847 if (application == NULL && window == NULL) { 848 if (mInputTargetWaitCause != INPUT_TARGET_WAIT_CAUSE_SYSTEM_NOT_READY) { 849 #if DEBUG_FOCUS 850 LOGD("Waiting for system to become ready for input."); 851 #endif 852 mInputTargetWaitCause = INPUT_TARGET_WAIT_CAUSE_SYSTEM_NOT_READY; 853 mInputTargetWaitStartTime = currentTime; 854 mInputTargetWaitTimeoutTime = LONG_LONG_MAX; 855 mInputTargetWaitTimeoutExpired = false; 856 } 857 } else { 858 if (mInputTargetWaitCause != INPUT_TARGET_WAIT_CAUSE_APPLICATION_NOT_READY) { 859 #if DEBUG_FOCUS 860 LOGD("Waiting for application to become ready for input: %s", 861 getApplicationWindowLabelLocked(application, window).string()); 862 #endif 863 nsecs_t timeout = window ? window->dispatchingTimeout : 864 application ? application->dispatchingTimeout : DEFAULT_INPUT_DISPATCHING_TIMEOUT; 865 866 mInputTargetWaitCause = INPUT_TARGET_WAIT_CAUSE_APPLICATION_NOT_READY; 867 mInputTargetWaitStartTime = currentTime; 868 mInputTargetWaitTimeoutTime = currentTime + timeout; 869 mInputTargetWaitTimeoutExpired = false; 870 } 871 } 872 873 if (mInputTargetWaitTimeoutExpired) { 874 return INPUT_EVENT_INJECTION_TIMED_OUT; 875 } 876 877 if (currentTime >= mInputTargetWaitTimeoutTime) { 878 onANRLocked(currentTime, application, window, entry->eventTime, mInputTargetWaitStartTime); 879 880 // Force poll loop to wake up immediately on next iteration once we get the 881 // ANR response back from the policy. 882 *nextWakeupTime = LONG_LONG_MIN; 883 return INPUT_EVENT_INJECTION_PENDING; 884 } else { 885 // Force poll loop to wake up when timeout is due. 886 if (mInputTargetWaitTimeoutTime < *nextWakeupTime) { 887 *nextWakeupTime = mInputTargetWaitTimeoutTime; 888 } 889 return INPUT_EVENT_INJECTION_PENDING; 890 } 891 } 892 893 void InputDispatcher::resumeAfterTargetsNotReadyTimeoutLocked(nsecs_t newTimeout, 894 const sp<InputChannel>& inputChannel) { 895 if (newTimeout > 0) { 896 // Extend the timeout. 897 mInputTargetWaitTimeoutTime = now() + newTimeout; 898 } else { 899 // Give up. 900 mInputTargetWaitTimeoutExpired = true; 901 902 // Release the touch targets. 903 mTouchState.reset(); 904 905 // Input state will not be realistic. Mark it out of sync. 906 if (inputChannel.get()) { 907 ssize_t connectionIndex = getConnectionIndexLocked(inputChannel); 908 if (connectionIndex >= 0) { 909 sp<Connection> connection = mConnectionsByReceiveFd.valueAt(connectionIndex); 910 synthesizeCancelationEventsForConnectionLocked( 911 connection, InputState::CANCEL_ALL_EVENTS, 912 "application not responding"); 913 } 914 } 915 } 916 } 917 918 nsecs_t InputDispatcher::getTimeSpentWaitingForApplicationLocked( 919 nsecs_t currentTime) { 920 if (mInputTargetWaitCause == INPUT_TARGET_WAIT_CAUSE_APPLICATION_NOT_READY) { 921 return currentTime - mInputTargetWaitStartTime; 922 } 923 return 0; 924 } 925 926 void InputDispatcher::resetANRTimeoutsLocked() { 927 #if DEBUG_FOCUS 928 LOGD("Resetting ANR timeouts."); 929 #endif 930 931 // Reset input target wait timeout. 932 mInputTargetWaitCause = INPUT_TARGET_WAIT_CAUSE_NONE; 933 } 934 935 int32_t InputDispatcher::findFocusedWindowTargetsLocked(nsecs_t currentTime, 936 const EventEntry* entry, nsecs_t* nextWakeupTime) { 937 mCurrentInputTargets.clear(); 938 939 int32_t injectionResult; 940 941 // If there is no currently focused window and no focused application 942 // then drop the event. 943 if (! mFocusedWindow) { 944 if (mFocusedApplication) { 945 #if DEBUG_FOCUS 946 LOGD("Waiting because there is no focused window but there is a " 947 "focused application that may eventually add a window: %s.", 948 getApplicationWindowLabelLocked(mFocusedApplication, NULL).string()); 949 #endif 950 injectionResult = handleTargetsNotReadyLocked(currentTime, entry, 951 mFocusedApplication, NULL, nextWakeupTime); 952 goto Unresponsive; 953 } 954 955 LOGI("Dropping event because there is no focused window or focused application."); 956 injectionResult = INPUT_EVENT_INJECTION_FAILED; 957 goto Failed; 958 } 959 960 // Check permissions. 961 if (! checkInjectionPermission(mFocusedWindow, entry->injectionState)) { 962 injectionResult = INPUT_EVENT_INJECTION_PERMISSION_DENIED; 963 goto Failed; 964 } 965 966 // If the currently focused window is paused then keep waiting. 967 if (mFocusedWindow->paused) { 968 #if DEBUG_FOCUS 969 LOGD("Waiting because focused window is paused."); 970 #endif 971 injectionResult = handleTargetsNotReadyLocked(currentTime, entry, 972 mFocusedApplication, mFocusedWindow, nextWakeupTime); 973 goto Unresponsive; 974 } 975 976 // If the currently focused window is still working on previous events then keep waiting. 977 if (! isWindowFinishedWithPreviousInputLocked(mFocusedWindow)) { 978 #if DEBUG_FOCUS 979 LOGD("Waiting because focused window still processing previous input."); 980 #endif 981 injectionResult = handleTargetsNotReadyLocked(currentTime, entry, 982 mFocusedApplication, mFocusedWindow, nextWakeupTime); 983 goto Unresponsive; 984 } 985 986 // Success! Output targets. 987 injectionResult = INPUT_EVENT_INJECTION_SUCCEEDED; 988 addWindowTargetLocked(mFocusedWindow, InputTarget::FLAG_FOREGROUND, BitSet32(0)); 989 990 // Done. 991 Failed: 992 Unresponsive: 993 nsecs_t timeSpentWaitingForApplication = getTimeSpentWaitingForApplicationLocked(currentTime); 994 updateDispatchStatisticsLocked(currentTime, entry, 995 injectionResult, timeSpentWaitingForApplication); 996 #if DEBUG_FOCUS 997 LOGD("findFocusedWindow finished: injectionResult=%d, " 998 "timeSpendWaitingForApplication=%0.1fms", 999 injectionResult, timeSpentWaitingForApplication / 1000000.0); 1000 #endif 1001 return injectionResult; 1002 } 1003 1004 int32_t InputDispatcher::findTouchedWindowTargetsLocked(nsecs_t currentTime, 1005 const MotionEntry* entry, nsecs_t* nextWakeupTime) { 1006 enum InjectionPermission { 1007 INJECTION_PERMISSION_UNKNOWN, 1008 INJECTION_PERMISSION_GRANTED, 1009 INJECTION_PERMISSION_DENIED 1010 }; 1011 1012 mCurrentInputTargets.clear(); 1013 1014 nsecs_t startTime = now(); 1015 1016 // For security reasons, we defer updating the touch state until we are sure that 1017 // event injection will be allowed. 1018 // 1019 // FIXME In the original code, screenWasOff could never be set to true. 1020 // The reason is that the POLICY_FLAG_WOKE_HERE 1021 // and POLICY_FLAG_BRIGHT_HERE flags were set only when preprocessing raw 1022 // EV_KEY, EV_REL and EV_ABS events. As it happens, the touch event was 1023 // actually enqueued using the policyFlags that appeared in the final EV_SYN 1024 // events upon which no preprocessing took place. So policyFlags was always 0. 1025 // In the new native input dispatcher we're a bit more careful about event 1026 // preprocessing so the touches we receive can actually have non-zero policyFlags. 1027 // Unfortunately we obtain undesirable behavior. 1028 // 1029 // Here's what happens: 1030 // 1031 // When the device dims in anticipation of going to sleep, touches 1032 // in windows which have FLAG_TOUCHABLE_WHEN_WAKING cause 1033 // the device to brighten and reset the user activity timer. 1034 // Touches on other windows (such as the launcher window) 1035 // are dropped. Then after a moment, the device goes to sleep. Oops. 1036 // 1037 // Also notice how screenWasOff was being initialized using POLICY_FLAG_BRIGHT_HERE 1038 // instead of POLICY_FLAG_WOKE_HERE... 1039 // 1040 bool screenWasOff = false; // original policy: policyFlags & POLICY_FLAG_BRIGHT_HERE; 1041 1042 int32_t action = entry->action; 1043 int32_t maskedAction = action & AMOTION_EVENT_ACTION_MASK; 1044 1045 // Update the touch state as needed based on the properties of the touch event. 1046 int32_t injectionResult = INPUT_EVENT_INJECTION_PENDING; 1047 InjectionPermission injectionPermission = INJECTION_PERMISSION_UNKNOWN; 1048 if (maskedAction == AMOTION_EVENT_ACTION_DOWN) { 1049 mTempTouchState.reset(); 1050 mTempTouchState.down = true; 1051 } else { 1052 mTempTouchState.copyFrom(mTouchState); 1053 } 1054 1055 bool isSplit = mTempTouchState.split && mTempTouchState.down; 1056 if (maskedAction == AMOTION_EVENT_ACTION_DOWN 1057 || (isSplit && maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN)) { 1058 /* Case 1: New splittable pointer going down. */ 1059 1060 int32_t pointerIndex = getMotionEventActionPointerIndex(action); 1061 int32_t x = int32_t(entry->firstSample.pointerCoords[pointerIndex].x); 1062 int32_t y = int32_t(entry->firstSample.pointerCoords[pointerIndex].y); 1063 const InputWindow* newTouchedWindow = NULL; 1064 const InputWindow* topErrorWindow = NULL; 1065 1066 // Traverse windows from front to back to find touched window and outside targets. 1067 size_t numWindows = mWindows.size(); 1068 for (size_t i = 0; i < numWindows; i++) { 1069 const InputWindow* window = & mWindows.editItemAt(i); 1070 int32_t flags = window->layoutParamsFlags; 1071 1072 if (flags & InputWindow::FLAG_SYSTEM_ERROR) { 1073 if (! topErrorWindow) { 1074 topErrorWindow = window; 1075 } 1076 } 1077 1078 if (window->visible) { 1079 if (! (flags & InputWindow::FLAG_NOT_TOUCHABLE)) { 1080 bool isTouchModal = (flags & (InputWindow::FLAG_NOT_FOCUSABLE 1081 | InputWindow::FLAG_NOT_TOUCH_MODAL)) == 0; 1082 if (isTouchModal || window->touchableAreaContainsPoint(x, y)) { 1083 if (! screenWasOff || flags & InputWindow::FLAG_TOUCHABLE_WHEN_WAKING) { 1084 newTouchedWindow = window; 1085 } 1086 break; // found touched window, exit window loop 1087 } 1088 } 1089 1090 if (maskedAction == AMOTION_EVENT_ACTION_DOWN 1091 && (flags & InputWindow::FLAG_WATCH_OUTSIDE_TOUCH)) { 1092 int32_t outsideTargetFlags = InputTarget::FLAG_OUTSIDE; 1093 if (isWindowObscuredAtPointLocked(window, x, y)) { 1094 outsideTargetFlags |= InputTarget::FLAG_WINDOW_IS_OBSCURED; 1095 } 1096 1097 mTempTouchState.addOrUpdateWindow(window, outsideTargetFlags, BitSet32(0)); 1098 } 1099 } 1100 } 1101 1102 // If there is an error window but it is not taking focus (typically because 1103 // it is invisible) then wait for it. Any other focused window may in 1104 // fact be in ANR state. 1105 if (topErrorWindow && newTouchedWindow != topErrorWindow) { 1106 #if DEBUG_FOCUS 1107 LOGD("Waiting because system error window is pending."); 1108 #endif 1109 injectionResult = handleTargetsNotReadyLocked(currentTime, entry, 1110 NULL, NULL, nextWakeupTime); 1111 injectionPermission = INJECTION_PERMISSION_UNKNOWN; 1112 goto Unresponsive; 1113 } 1114 1115 // Figure out whether splitting will be allowed for this window. 1116 if (newTouchedWindow 1117 && (newTouchedWindow->layoutParamsFlags & InputWindow::FLAG_SPLIT_TOUCH)) { 1118 // New window supports splitting. 1119 isSplit = true; 1120 } else if (isSplit) { 1121 // New window does not support splitting but we have already split events. 1122 // Assign the pointer to the first foreground window we find. 1123 // (May be NULL which is why we put this code block before the next check.) 1124 newTouchedWindow = mTempTouchState.getFirstForegroundWindow(); 1125 } 1126 1127 // If we did not find a touched window then fail. 1128 if (! newTouchedWindow) { 1129 if (mFocusedApplication) { 1130 #if DEBUG_FOCUS 1131 LOGD("Waiting because there is no touched window but there is a " 1132 "focused application that may eventually add a new window: %s.", 1133 getApplicationWindowLabelLocked(mFocusedApplication, NULL).string()); 1134 #endif 1135 injectionResult = handleTargetsNotReadyLocked(currentTime, entry, 1136 mFocusedApplication, NULL, nextWakeupTime); 1137 goto Unresponsive; 1138 } 1139 1140 LOGI("Dropping event because there is no touched window or focused application."); 1141 injectionResult = INPUT_EVENT_INJECTION_FAILED; 1142 goto Failed; 1143 } 1144 1145 // Set target flags. 1146 int32_t targetFlags = InputTarget::FLAG_FOREGROUND; 1147 if (isSplit) { 1148 targetFlags |= InputTarget::FLAG_SPLIT; 1149 } 1150 if (isWindowObscuredAtPointLocked(newTouchedWindow, x, y)) { 1151 targetFlags |= InputTarget::FLAG_WINDOW_IS_OBSCURED; 1152 } 1153 1154 // Update the temporary touch state. 1155 BitSet32 pointerIds; 1156 if (isSplit) { 1157 uint32_t pointerId = entry->pointerIds[pointerIndex]; 1158 pointerIds.markBit(pointerId); 1159 } 1160 mTempTouchState.addOrUpdateWindow(newTouchedWindow, targetFlags, pointerIds); 1161 } else { 1162 /* Case 2: Pointer move, up, cancel or non-splittable pointer down. */ 1163 1164 // If the pointer is not currently down, then ignore the event. 1165 if (! mTempTouchState.down) { 1166 LOGI("Dropping event because the pointer is not down."); 1167 injectionResult = INPUT_EVENT_INJECTION_FAILED; 1168 goto Failed; 1169 } 1170 } 1171 1172 // Check permission to inject into all touched foreground windows and ensure there 1173 // is at least one touched foreground window. 1174 { 1175 bool haveForegroundWindow = false; 1176 for (size_t i = 0; i < mTempTouchState.windows.size(); i++) { 1177 const TouchedWindow& touchedWindow = mTempTouchState.windows[i]; 1178 if (touchedWindow.targetFlags & InputTarget::FLAG_FOREGROUND) { 1179 haveForegroundWindow = true; 1180 if (! checkInjectionPermission(touchedWindow.window, entry->injectionState)) { 1181 injectionResult = INPUT_EVENT_INJECTION_PERMISSION_DENIED; 1182 injectionPermission = INJECTION_PERMISSION_DENIED; 1183 goto Failed; 1184 } 1185 } 1186 } 1187 if (! haveForegroundWindow) { 1188 #if DEBUG_INPUT_DISPATCHER_POLICY 1189 LOGD("Dropping event because there is no touched foreground window to receive it."); 1190 #endif 1191 injectionResult = INPUT_EVENT_INJECTION_FAILED; 1192 goto Failed; 1193 } 1194 1195 // Permission granted to injection into all touched foreground windows. 1196 injectionPermission = INJECTION_PERMISSION_GRANTED; 1197 } 1198 1199 // Ensure all touched foreground windows are ready for new input. 1200 for (size_t i = 0; i < mTempTouchState.windows.size(); i++) { 1201 const TouchedWindow& touchedWindow = mTempTouchState.windows[i]; 1202 if (touchedWindow.targetFlags & InputTarget::FLAG_FOREGROUND) { 1203 // If the touched window is paused then keep waiting. 1204 if (touchedWindow.window->paused) { 1205 #if DEBUG_INPUT_DISPATCHER_POLICY 1206 LOGD("Waiting because touched window is paused."); 1207 #endif 1208 injectionResult = handleTargetsNotReadyLocked(currentTime, entry, 1209 NULL, touchedWindow.window, nextWakeupTime); 1210 goto Unresponsive; 1211 } 1212 1213 // If the touched window is still working on previous events then keep waiting. 1214 if (! isWindowFinishedWithPreviousInputLocked(touchedWindow.window)) { 1215 #if DEBUG_FOCUS 1216 LOGD("Waiting because touched window still processing previous input."); 1217 #endif 1218 injectionResult = handleTargetsNotReadyLocked(currentTime, entry, 1219 NULL, touchedWindow.window, nextWakeupTime); 1220 goto Unresponsive; 1221 } 1222 } 1223 } 1224 1225 // If this is the first pointer going down and the touched window has a wallpaper 1226 // then also add the touched wallpaper windows so they are locked in for the duration 1227 // of the touch gesture. 1228 if (maskedAction == AMOTION_EVENT_ACTION_DOWN) { 1229 const InputWindow* foregroundWindow = mTempTouchState.getFirstForegroundWindow(); 1230 if (foregroundWindow->hasWallpaper) { 1231 for (size_t i = 0; i < mWindows.size(); i++) { 1232 const InputWindow* window = & mWindows[i]; 1233 if (window->layoutParamsType == InputWindow::TYPE_WALLPAPER) { 1234 mTempTouchState.addOrUpdateWindow(window, 1235 InputTarget::FLAG_WINDOW_IS_OBSCURED, BitSet32(0)); 1236 } 1237 } 1238 } 1239 } 1240 1241 // Success! Output targets. 1242 injectionResult = INPUT_EVENT_INJECTION_SUCCEEDED; 1243 1244 for (size_t i = 0; i < mTempTouchState.windows.size(); i++) { 1245 const TouchedWindow& touchedWindow = mTempTouchState.windows.itemAt(i); 1246 addWindowTargetLocked(touchedWindow.window, touchedWindow.targetFlags, 1247 touchedWindow.pointerIds); 1248 } 1249 1250 // Drop the outside touch window since we will not care about them in the next iteration. 1251 mTempTouchState.removeOutsideTouchWindows(); 1252 1253 Failed: 1254 // Check injection permission once and for all. 1255 if (injectionPermission == INJECTION_PERMISSION_UNKNOWN) { 1256 if (checkInjectionPermission(NULL, entry->injectionState)) { 1257 injectionPermission = INJECTION_PERMISSION_GRANTED; 1258 } else { 1259 injectionPermission = INJECTION_PERMISSION_DENIED; 1260 } 1261 } 1262 1263 // Update final pieces of touch state if the injector had permission. 1264 if (injectionPermission == INJECTION_PERMISSION_GRANTED) { 1265 if (maskedAction == AMOTION_EVENT_ACTION_UP 1266 || maskedAction == AMOTION_EVENT_ACTION_CANCEL) { 1267 // All pointers up or canceled. 1268 mTempTouchState.reset(); 1269 } else if (maskedAction == AMOTION_EVENT_ACTION_DOWN) { 1270 // First pointer went down. 1271 if (mTouchState.down) { 1272 #if DEBUG_FOCUS 1273 LOGD("Pointer down received while already down."); 1274 #endif 1275 } 1276 } else if (maskedAction == AMOTION_EVENT_ACTION_POINTER_UP) { 1277 // One pointer went up. 1278 if (isSplit) { 1279 int32_t pointerIndex = getMotionEventActionPointerIndex(action); 1280 uint32_t pointerId = entry->pointerIds[pointerIndex]; 1281 1282 for (size_t i = 0; i < mTempTouchState.windows.size(); ) { 1283 TouchedWindow& touchedWindow = mTempTouchState.windows.editItemAt(i); 1284 if (touchedWindow.targetFlags & InputTarget::FLAG_SPLIT) { 1285 touchedWindow.pointerIds.clearBit(pointerId); 1286 if (touchedWindow.pointerIds.isEmpty()) { 1287 mTempTouchState.windows.removeAt(i); 1288 continue; 1289 } 1290 } 1291 i += 1; 1292 } 1293 } 1294 } 1295 1296 // Save changes to touch state. 1297 mTouchState.copyFrom(mTempTouchState); 1298 } else { 1299 #if DEBUG_FOCUS 1300 LOGD("Not updating touch focus because injection was denied."); 1301 #endif 1302 } 1303 1304 Unresponsive: 1305 // Reset temporary touch state to ensure we release unnecessary references to input channels. 1306 mTempTouchState.reset(); 1307 1308 nsecs_t timeSpentWaitingForApplication = getTimeSpentWaitingForApplicationLocked(currentTime); 1309 updateDispatchStatisticsLocked(currentTime, entry, 1310 injectionResult, timeSpentWaitingForApplication); 1311 #if DEBUG_FOCUS 1312 LOGD("findTouchedWindow finished: injectionResult=%d, injectionPermission=%d, " 1313 "timeSpentWaitingForApplication=%0.1fms", 1314 injectionResult, injectionPermission, timeSpentWaitingForApplication / 1000000.0); 1315 #endif 1316 return injectionResult; 1317 } 1318 1319 void InputDispatcher::addWindowTargetLocked(const InputWindow* window, int32_t targetFlags, 1320 BitSet32 pointerIds) { 1321 mCurrentInputTargets.push(); 1322 1323 InputTarget& target = mCurrentInputTargets.editTop(); 1324 target.inputChannel = window->inputChannel; 1325 target.flags = targetFlags; 1326 target.xOffset = - window->frameLeft; 1327 target.yOffset = - window->frameTop; 1328 target.pointerIds = pointerIds; 1329 } 1330 1331 void InputDispatcher::addMonitoringTargetsLocked() { 1332 for (size_t i = 0; i < mMonitoringChannels.size(); i++) { 1333 mCurrentInputTargets.push(); 1334 1335 InputTarget& target = mCurrentInputTargets.editTop(); 1336 target.inputChannel = mMonitoringChannels[i]; 1337 target.flags = 0; 1338 target.xOffset = 0; 1339 target.yOffset = 0; 1340 } 1341 } 1342 1343 bool InputDispatcher::checkInjectionPermission(const InputWindow* window, 1344 const InjectionState* injectionState) { 1345 if (injectionState 1346 && (window == NULL || window->ownerUid != injectionState->injectorUid) 1347 && !hasInjectionPermission(injectionState->injectorPid, injectionState->injectorUid)) { 1348 if (window) { 1349 LOGW("Permission denied: injecting event from pid %d uid %d to window " 1350 "with input channel %s owned by uid %d", 1351 injectionState->injectorPid, injectionState->injectorUid, 1352 window->inputChannel->getName().string(), 1353 window->ownerUid); 1354 } else { 1355 LOGW("Permission denied: injecting event from pid %d uid %d", 1356 injectionState->injectorPid, injectionState->injectorUid); 1357 } 1358 return false; 1359 } 1360 return true; 1361 } 1362 1363 bool InputDispatcher::isWindowObscuredAtPointLocked( 1364 const InputWindow* window, int32_t x, int32_t y) const { 1365 size_t numWindows = mWindows.size(); 1366 for (size_t i = 0; i < numWindows; i++) { 1367 const InputWindow* other = & mWindows.itemAt(i); 1368 if (other == window) { 1369 break; 1370 } 1371 if (other->visible && ! other->isTrustedOverlay() && other->frameContainsPoint(x, y)) { 1372 return true; 1373 } 1374 } 1375 return false; 1376 } 1377 1378 bool InputDispatcher::isWindowFinishedWithPreviousInputLocked(const InputWindow* window) { 1379 ssize_t connectionIndex = getConnectionIndexLocked(window->inputChannel); 1380 if (connectionIndex >= 0) { 1381 sp<Connection> connection = mConnectionsByReceiveFd.valueAt(connectionIndex); 1382 return connection->outboundQueue.isEmpty(); 1383 } else { 1384 return true; 1385 } 1386 } 1387 1388 String8 InputDispatcher::getApplicationWindowLabelLocked(const InputApplication* application, 1389 const InputWindow* window) { 1390 if (application) { 1391 if (window) { 1392 String8 label(application->name); 1393 label.append(" - "); 1394 label.append(window->name); 1395 return label; 1396 } else { 1397 return application->name; 1398 } 1399 } else if (window) { 1400 return window->name; 1401 } else { 1402 return String8("<unknown application or window>"); 1403 } 1404 } 1405 1406 void InputDispatcher::pokeUserActivityLocked(const EventEntry* eventEntry) { 1407 int32_t eventType = POWER_MANAGER_BUTTON_EVENT; 1408 if (eventEntry->type == EventEntry::TYPE_MOTION) { 1409 const MotionEntry* motionEntry = static_cast<const MotionEntry*>(eventEntry); 1410 if (motionEntry->source & AINPUT_SOURCE_CLASS_POINTER) { 1411 switch (motionEntry->action) { 1412 case AMOTION_EVENT_ACTION_DOWN: 1413 eventType = POWER_MANAGER_TOUCH_EVENT; 1414 break; 1415 case AMOTION_EVENT_ACTION_UP: 1416 eventType = POWER_MANAGER_TOUCH_UP_EVENT; 1417 break; 1418 default: 1419 if (motionEntry->eventTime - motionEntry->downTime < LONG_TOUCH_DELAY) { 1420 eventType = POWER_MANAGER_TOUCH_EVENT; 1421 } else { 1422 eventType = POWER_MANAGER_LONG_TOUCH_EVENT; 1423 } 1424 break; 1425 } 1426 } 1427 } 1428 1429 CommandEntry* commandEntry = postCommandLocked( 1430 & InputDispatcher::doPokeUserActivityLockedInterruptible); 1431 commandEntry->eventTime = eventEntry->eventTime; 1432 commandEntry->userActivityEventType = eventType; 1433 } 1434 1435 void InputDispatcher::prepareDispatchCycleLocked(nsecs_t currentTime, 1436 const sp<Connection>& connection, EventEntry* eventEntry, const InputTarget* inputTarget, 1437 bool resumeWithAppendedMotionSample) { 1438 #if DEBUG_DISPATCH_CYCLE 1439 LOGD("channel '%s' ~ prepareDispatchCycle - flags=%d, " 1440 "xOffset=%f, yOffset=%f, " 1441 "windowType=%d, pointerIds=0x%x, " 1442 "resumeWithAppendedMotionSample=%s", 1443 connection->getInputChannelName(), inputTarget->flags, 1444 inputTarget->xOffset, inputTarget->yOffset, 1445 inputTarget->windowType, inputTarget->pointerIds.value, 1446 toString(resumeWithAppendedMotionSample)); 1447 #endif 1448 1449 // Make sure we are never called for streaming when splitting across multiple windows. 1450 bool isSplit = inputTarget->flags & InputTarget::FLAG_SPLIT; 1451 assert(! (resumeWithAppendedMotionSample && isSplit)); 1452 1453 // Skip this event if the connection status is not normal. 1454 // We don't want to enqueue additional outbound events if the connection is broken. 1455 if (connection->status != Connection::STATUS_NORMAL) { 1456 #if DEBUG_DISPATCH_CYCLE 1457 LOGD("channel '%s' ~ Dropping event because the channel status is %s", 1458 connection->getInputChannelName(), connection->getStatusLabel()); 1459 #endif 1460 return; 1461 } 1462 1463 // Split a motion event if needed. 1464 if (isSplit) { 1465 assert(eventEntry->type == EventEntry::TYPE_MOTION); 1466 1467 MotionEntry* originalMotionEntry = static_cast<MotionEntry*>(eventEntry); 1468 if (inputTarget->pointerIds.count() != originalMotionEntry->pointerCount) { 1469 MotionEntry* splitMotionEntry = splitMotionEvent( 1470 originalMotionEntry, inputTarget->pointerIds); 1471 #if DEBUG_FOCUS 1472 LOGD("channel '%s' ~ Split motion event.", 1473 connection->getInputChannelName()); 1474 logOutboundMotionDetailsLocked(" ", splitMotionEntry); 1475 #endif 1476 eventEntry = splitMotionEntry; 1477 } 1478 } 1479 1480 // Resume the dispatch cycle with a freshly appended motion sample. 1481 // First we check that the last dispatch entry in the outbound queue is for the same 1482 // motion event to which we appended the motion sample. If we find such a dispatch 1483 // entry, and if it is currently in progress then we try to stream the new sample. 1484 bool wasEmpty = connection->outboundQueue.isEmpty(); 1485 1486 if (! wasEmpty && resumeWithAppendedMotionSample) { 1487 DispatchEntry* motionEventDispatchEntry = 1488 connection->findQueuedDispatchEntryForEvent(eventEntry); 1489 if (motionEventDispatchEntry) { 1490 // If the dispatch entry is not in progress, then we must be busy dispatching an 1491 // earlier event. Not a problem, the motion event is on the outbound queue and will 1492 // be dispatched later. 1493 if (! motionEventDispatchEntry->inProgress) { 1494 #if DEBUG_BATCHING 1495 LOGD("channel '%s' ~ Not streaming because the motion event has " 1496 "not yet been dispatched. " 1497 "(Waiting for earlier events to be consumed.)", 1498 connection->getInputChannelName()); 1499 #endif 1500 return; 1501 } 1502 1503 // If the dispatch entry is in progress but it already has a tail of pending 1504 // motion samples, then it must mean that the shared memory buffer filled up. 1505 // Not a problem, when this dispatch cycle is finished, we will eventually start 1506 // a new dispatch cycle to process the tail and that tail includes the newly 1507 // appended motion sample. 1508 if (motionEventDispatchEntry->tailMotionSample) { 1509 #if DEBUG_BATCHING 1510 LOGD("channel '%s' ~ Not streaming because no new samples can " 1511 "be appended to the motion event in this dispatch cycle. " 1512 "(Waiting for next dispatch cycle to start.)", 1513 connection->getInputChannelName()); 1514 #endif 1515 return; 1516 } 1517 1518 // The dispatch entry is in progress and is still potentially open for streaming. 1519 // Try to stream the new motion sample. This might fail if the consumer has already 1520 // consumed the motion event (or if the channel is broken). 1521 MotionEntry* motionEntry = static_cast<MotionEntry*>(eventEntry); 1522 MotionSample* appendedMotionSample = motionEntry->lastSample; 1523 status_t status = connection->inputPublisher.appendMotionSample( 1524 appendedMotionSample->eventTime, appendedMotionSample->pointerCoords); 1525 if (status == OK) { 1526 #if DEBUG_BATCHING 1527 LOGD("channel '%s' ~ Successfully streamed new motion sample.", 1528 connection->getInputChannelName()); 1529 #endif 1530 return; 1531 } 1532 1533 #if DEBUG_BATCHING 1534 if (status == NO_MEMORY) { 1535 LOGD("channel '%s' ~ Could not append motion sample to currently " 1536 "dispatched move event because the shared memory buffer is full. " 1537 "(Waiting for next dispatch cycle to start.)", 1538 connection->getInputChannelName()); 1539 } else if (status == status_t(FAILED_TRANSACTION)) { 1540 LOGD("channel '%s' ~ Could not append motion sample to currently " 1541 "dispatched move event because the event has already been consumed. " 1542 "(Waiting for next dispatch cycle to start.)", 1543 connection->getInputChannelName()); 1544 } else { 1545 LOGD("channel '%s' ~ Could not append motion sample to currently " 1546 "dispatched move event due to an error, status=%d. " 1547 "(Waiting for next dispatch cycle to start.)", 1548 connection->getInputChannelName(), status); 1549 } 1550 #endif 1551 // Failed to stream. Start a new tail of pending motion samples to dispatch 1552 // in the next cycle. 1553 motionEventDispatchEntry->tailMotionSample = appendedMotionSample; 1554 return; 1555 } 1556 } 1557 1558 // This is a new event. 1559 // Enqueue a new dispatch entry onto the outbound queue for this connection. 1560 DispatchEntry* dispatchEntry = mAllocator.obtainDispatchEntry(eventEntry, // increments ref 1561 inputTarget->flags, inputTarget->xOffset, inputTarget->yOffset); 1562 if (dispatchEntry->hasForegroundTarget()) { 1563 incrementPendingForegroundDispatchesLocked(eventEntry); 1564 } 1565 1566 // Handle the case where we could not stream a new motion sample because the consumer has 1567 // already consumed the motion event (otherwise the corresponding dispatch entry would 1568 // still be in the outbound queue for this connection). We set the head motion sample 1569 // to the list starting with the newly appended motion sample. 1570 if (resumeWithAppendedMotionSample) { 1571 #if DEBUG_BATCHING 1572 LOGD("channel '%s' ~ Preparing a new dispatch cycle for additional motion samples " 1573 "that cannot be streamed because the motion event has already been consumed.", 1574 connection->getInputChannelName()); 1575 #endif 1576 MotionSample* appendedMotionSample = static_cast<MotionEntry*>(eventEntry)->lastSample; 1577 dispatchEntry->headMotionSample = appendedMotionSample; 1578 } 1579 1580 // Enqueue the dispatch entry. 1581 connection->outboundQueue.enqueueAtTail(dispatchEntry); 1582 1583 // If the outbound queue was previously empty, start the dispatch cycle going. 1584 if (wasEmpty) { 1585 activateConnectionLocked(connection.get()); 1586 startDispatchCycleLocked(currentTime, connection); 1587 } 1588 } 1589 1590 void InputDispatcher::startDispatchCycleLocked(nsecs_t currentTime, 1591 const sp<Connection>& connection) { 1592 #if DEBUG_DISPATCH_CYCLE 1593 LOGD("channel '%s' ~ startDispatchCycle", 1594 connection->getInputChannelName()); 1595 #endif 1596 1597 assert(connection->status == Connection::STATUS_NORMAL); 1598 assert(! connection->outboundQueue.isEmpty()); 1599 1600 DispatchEntry* dispatchEntry = connection->outboundQueue.headSentinel.next; 1601 assert(! dispatchEntry->inProgress); 1602 1603 // Mark the dispatch entry as in progress. 1604 dispatchEntry->inProgress = true; 1605 1606 // Update the connection's input state. 1607 EventEntry* eventEntry = dispatchEntry->eventEntry; 1608 InputState::Consistency consistency = connection->inputState.trackEvent(eventEntry); 1609 1610 #if FILTER_INPUT_EVENTS 1611 // Filter out inconsistent sequences of input events. 1612 // The input system may drop or inject events in a way that could violate implicit 1613 // invariants on input state and potentially cause an application to crash 1614 // or think that a key or pointer is stuck down. Technically we make no guarantees 1615 // of consistency but it would be nice to improve on this where possible. 1616 // XXX: This code is a proof of concept only. Not ready for prime time. 1617 if (consistency == InputState::TOLERABLE) { 1618 #if DEBUG_DISPATCH_CYCLE 1619 LOGD("channel '%s' ~ Sending an event that is inconsistent with the connection's " 1620 "current input state but that is likely to be tolerated by the application.", 1621 connection->getInputChannelName()); 1622 #endif 1623 } else if (consistency == InputState::BROKEN) { 1624 LOGI("channel '%s' ~ Dropping an event that is inconsistent with the connection's " 1625 "current input state and that is likely to cause the application to crash.", 1626 connection->getInputChannelName()); 1627 startNextDispatchCycleLocked(currentTime, connection); 1628 return; 1629 } 1630 #endif 1631 1632 // Publish the event. 1633 status_t status; 1634 switch (eventEntry->type) { 1635 case EventEntry::TYPE_KEY: { 1636 KeyEntry* keyEntry = static_cast<KeyEntry*>(eventEntry); 1637 1638 // Apply target flags. 1639 int32_t action = keyEntry->action; 1640 int32_t flags = keyEntry->flags; 1641 1642 // Publish the key event. 1643 status = connection->inputPublisher.publishKeyEvent(keyEntry->deviceId, keyEntry->source, 1644 action, flags, keyEntry->keyCode, keyEntry->scanCode, 1645 keyEntry->metaState, keyEntry->repeatCount, keyEntry->downTime, 1646 keyEntry->eventTime); 1647 1648 if (status) { 1649 LOGE("channel '%s' ~ Could not publish key event, " 1650 "status=%d", connection->getInputChannelName(), status); 1651 abortBrokenDispatchCycleLocked(currentTime, connection); 1652 return; 1653 } 1654 break; 1655 } 1656 1657 case EventEntry::TYPE_MOTION: { 1658 MotionEntry* motionEntry = static_cast<MotionEntry*>(eventEntry); 1659 1660 // Apply target flags. 1661 int32_t action = motionEntry->action; 1662 int32_t flags = motionEntry->flags; 1663 if (dispatchEntry->targetFlags & InputTarget::FLAG_OUTSIDE) { 1664 action = AMOTION_EVENT_ACTION_OUTSIDE; 1665 } 1666 if (dispatchEntry->targetFlags & InputTarget::FLAG_WINDOW_IS_OBSCURED) { 1667 flags |= AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED; 1668 } 1669 1670 // If headMotionSample is non-NULL, then it points to the first new sample that we 1671 // were unable to dispatch during the previous cycle so we resume dispatching from 1672 // that point in the list of motion samples. 1673 // Otherwise, we just start from the first sample of the motion event. 1674 MotionSample* firstMotionSample = dispatchEntry->headMotionSample; 1675 if (! firstMotionSample) { 1676 firstMotionSample = & motionEntry->firstSample; 1677 } 1678 1679 // Set the X and Y offset depending on the input source. 1680 float xOffset, yOffset; 1681 if (motionEntry->source & AINPUT_SOURCE_CLASS_POINTER) { 1682 xOffset = dispatchEntry->xOffset; 1683 yOffset = dispatchEntry->yOffset; 1684 } else { 1685 xOffset = 0.0f; 1686 yOffset = 0.0f; 1687 } 1688 1689 // Publish the motion event and the first motion sample. 1690 status = connection->inputPublisher.publishMotionEvent(motionEntry->deviceId, 1691 motionEntry->source, action, flags, motionEntry->edgeFlags, motionEntry->metaState, 1692 xOffset, yOffset, 1693 motionEntry->xPrecision, motionEntry->yPrecision, 1694 motionEntry->downTime, firstMotionSample->eventTime, 1695 motionEntry->pointerCount, motionEntry->pointerIds, 1696 firstMotionSample->pointerCoords); 1697 1698 if (status) { 1699 LOGE("channel '%s' ~ Could not publish motion event, " 1700 "status=%d", connection->getInputChannelName(), status); 1701 abortBrokenDispatchCycleLocked(currentTime, connection); 1702 return; 1703 } 1704 1705 // Append additional motion samples. 1706 MotionSample* nextMotionSample = firstMotionSample->next; 1707 for (; nextMotionSample != NULL; nextMotionSample = nextMotionSample->next) { 1708 status = connection->inputPublisher.appendMotionSample( 1709 nextMotionSample->eventTime, nextMotionSample->pointerCoords); 1710 if (status == NO_MEMORY) { 1711 #if DEBUG_DISPATCH_CYCLE 1712 LOGD("channel '%s' ~ Shared memory buffer full. Some motion samples will " 1713 "be sent in the next dispatch cycle.", 1714 connection->getInputChannelName()); 1715 #endif 1716 break; 1717 } 1718 if (status != OK) { 1719 LOGE("channel '%s' ~ Could not append motion sample " 1720 "for a reason other than out of memory, status=%d", 1721 connection->getInputChannelName(), status); 1722 abortBrokenDispatchCycleLocked(currentTime, connection); 1723 return; 1724 } 1725 } 1726 1727 // Remember the next motion sample that we could not dispatch, in case we ran out 1728 // of space in the shared memory buffer. 1729 dispatchEntry->tailMotionSample = nextMotionSample; 1730 break; 1731 } 1732 1733 default: { 1734 assert(false); 1735 } 1736 } 1737 1738 // Send the dispatch signal. 1739 status = connection->inputPublisher.sendDispatchSignal(); 1740 if (status) { 1741 LOGE("channel '%s' ~ Could not send dispatch signal, status=%d", 1742 connection->getInputChannelName(), status); 1743 abortBrokenDispatchCycleLocked(currentTime, connection); 1744 return; 1745 } 1746 1747 // Record information about the newly started dispatch cycle. 1748 connection->lastEventTime = eventEntry->eventTime; 1749 connection->lastDispatchTime = currentTime; 1750 1751 // Notify other system components. 1752 onDispatchCycleStartedLocked(currentTime, connection); 1753 } 1754 1755 void InputDispatcher::finishDispatchCycleLocked(nsecs_t currentTime, 1756 const sp<Connection>& connection) { 1757 #if DEBUG_DISPATCH_CYCLE 1758 LOGD("channel '%s' ~ finishDispatchCycle - %01.1fms since event, " 1759 "%01.1fms since dispatch", 1760 connection->getInputChannelName(), 1761 connection->getEventLatencyMillis(currentTime), 1762 connection->getDispatchLatencyMillis(currentTime)); 1763 #endif 1764 1765 if (connection->status == Connection::STATUS_BROKEN 1766 || connection->status == Connection::STATUS_ZOMBIE) { 1767 return; 1768 } 1769 1770 // Notify other system components. 1771 onDispatchCycleFinishedLocked(currentTime, connection); 1772 1773 // Reset the publisher since the event has been consumed. 1774 // We do this now so that the publisher can release some of its internal resources 1775 // while waiting for the next dispatch cycle to begin. 1776 status_t status = connection->inputPublisher.reset(); 1777 if (status) { 1778 LOGE("channel '%s' ~ Could not reset publisher, status=%d", 1779 connection->getInputChannelName(), status); 1780 abortBrokenDispatchCycleLocked(currentTime, connection); 1781 return; 1782 } 1783 1784 startNextDispatchCycleLocked(currentTime, connection); 1785 } 1786 1787 void InputDispatcher::startNextDispatchCycleLocked(nsecs_t currentTime, 1788 const sp<Connection>& connection) { 1789 // Start the next dispatch cycle for this connection. 1790 while (! connection->outboundQueue.isEmpty()) { 1791 DispatchEntry* dispatchEntry = connection->outboundQueue.headSentinel.next; 1792 if (dispatchEntry->inProgress) { 1793 // Finish or resume current event in progress. 1794 if (dispatchEntry->tailMotionSample) { 1795 // We have a tail of undispatched motion samples. 1796 // Reuse the same DispatchEntry and start a new cycle. 1797 dispatchEntry->inProgress = false; 1798 dispatchEntry->headMotionSample = dispatchEntry->tailMotionSample; 1799 dispatchEntry->tailMotionSample = NULL; 1800 startDispatchCycleLocked(currentTime, connection); 1801 return; 1802 } 1803 // Finished. 1804 connection->outboundQueue.dequeueAtHead(); 1805 if (dispatchEntry->hasForegroundTarget()) { 1806 decrementPendingForegroundDispatchesLocked(dispatchEntry->eventEntry); 1807 } 1808 mAllocator.releaseDispatchEntry(dispatchEntry); 1809 } else { 1810 // If the head is not in progress, then we must have already dequeued the in 1811 // progress event, which means we actually aborted it. 1812 // So just start the next event for this connection. 1813 startDispatchCycleLocked(currentTime, connection); 1814 return; 1815 } 1816 } 1817 1818 // Outbound queue is empty, deactivate the connection. 1819 deactivateConnectionLocked(connection.get()); 1820 } 1821 1822 void InputDispatcher::abortBrokenDispatchCycleLocked(nsecs_t currentTime, 1823 const sp<Connection>& connection) { 1824 #if DEBUG_DISPATCH_CYCLE 1825 LOGD("channel '%s' ~ abortBrokenDispatchCycle - broken=%s", 1826 connection->getInputChannelName(), toString(broken)); 1827 #endif 1828 1829 // Clear the outbound queue. 1830 drainOutboundQueueLocked(connection.get()); 1831 1832 // The connection appears to be unrecoverably broken. 1833 // Ignore already broken or zombie connections. 1834 if (connection->status == Connection::STATUS_NORMAL) { 1835 connection->status = Connection::STATUS_BROKEN; 1836 1837 // Notify other system components. 1838 onDispatchCycleBrokenLocked(currentTime, connection); 1839 } 1840 } 1841 1842 void InputDispatcher::drainOutboundQueueLocked(Connection* connection) { 1843 while (! connection->outboundQueue.isEmpty()) { 1844 DispatchEntry* dispatchEntry = connection->outboundQueue.dequeueAtHead(); 1845 if (dispatchEntry->hasForegroundTarget()) { 1846 decrementPendingForegroundDispatchesLocked(dispatchEntry->eventEntry); 1847 } 1848 mAllocator.releaseDispatchEntry(dispatchEntry); 1849 } 1850 1851 deactivateConnectionLocked(connection); 1852 } 1853 1854 int InputDispatcher::handleReceiveCallback(int receiveFd, int events, void* data) { 1855 InputDispatcher* d = static_cast<InputDispatcher*>(data); 1856 1857 { // acquire lock 1858 AutoMutex _l(d->mLock); 1859 1860 ssize_t connectionIndex = d->mConnectionsByReceiveFd.indexOfKey(receiveFd); 1861 if (connectionIndex < 0) { 1862 LOGE("Received spurious receive callback for unknown input channel. " 1863 "fd=%d, events=0x%x", receiveFd, events); 1864 return 0; // remove the callback 1865 } 1866 1867 nsecs_t currentTime = now(); 1868 1869 sp<Connection> connection = d->mConnectionsByReceiveFd.valueAt(connectionIndex); 1870 if (events & (ALOOPER_EVENT_ERROR | ALOOPER_EVENT_HANGUP)) { 1871 LOGE("channel '%s' ~ Consumer closed input channel or an error occurred. " 1872 "events=0x%x", connection->getInputChannelName(), events); 1873 d->abortBrokenDispatchCycleLocked(currentTime, connection); 1874 d->runCommandsLockedInterruptible(); 1875 return 0; // remove the callback 1876 } 1877 1878 if (! (events & ALOOPER_EVENT_INPUT)) { 1879 LOGW("channel '%s' ~ Received spurious callback for unhandled poll event. " 1880 "events=0x%x", connection->getInputChannelName(), events); 1881 return 1; 1882 } 1883 1884 status_t status = connection->inputPublisher.receiveFinishedSignal(); 1885 if (status) { 1886 LOGE("channel '%s' ~ Failed to receive finished signal. status=%d", 1887 connection->getInputChannelName(), status); 1888 d->abortBrokenDispatchCycleLocked(currentTime, connection); 1889 d->runCommandsLockedInterruptible(); 1890 return 0; // remove the callback 1891 } 1892 1893 d->finishDispatchCycleLocked(currentTime, connection); 1894 d->runCommandsLockedInterruptible(); 1895 return 1; 1896 } // release lock 1897 } 1898 1899 void InputDispatcher::synthesizeCancelationEventsForAllConnectionsLocked( 1900 InputState::CancelationOptions options, const char* reason) { 1901 for (size_t i = 0; i < mConnectionsByReceiveFd.size(); i++) { 1902 synthesizeCancelationEventsForConnectionLocked( 1903 mConnectionsByReceiveFd.valueAt(i), options, reason); 1904 } 1905 } 1906 1907 void InputDispatcher::synthesizeCancelationEventsForInputChannelLocked( 1908 const sp<InputChannel>& channel, InputState::CancelationOptions options, 1909 const char* reason) { 1910 ssize_t index = getConnectionIndexLocked(channel); 1911 if (index >= 0) { 1912 synthesizeCancelationEventsForConnectionLocked( 1913 mConnectionsByReceiveFd.valueAt(index), options, reason); 1914 } 1915 } 1916 1917 void InputDispatcher::synthesizeCancelationEventsForConnectionLocked( 1918 const sp<Connection>& connection, InputState::CancelationOptions options, 1919 const char* reason) { 1920 nsecs_t currentTime = now(); 1921 1922 mTempCancelationEvents.clear(); 1923 connection->inputState.synthesizeCancelationEvents(currentTime, & mAllocator, 1924 mTempCancelationEvents, options); 1925 1926 if (! mTempCancelationEvents.isEmpty() 1927 && connection->status != Connection::STATUS_BROKEN) { 1928 #if DEBUG_OUTBOUND_EVENT_DETAILS 1929 LOGD("channel '%s' ~ Synthesized %d cancelation events to bring channel back in sync " 1930 "with reality: %s, options=%d.", 1931 connection->getInputChannelName(), mTempCancelationEvents.size(), reason, options); 1932 #endif 1933 for (size_t i = 0; i < mTempCancelationEvents.size(); i++) { 1934 EventEntry* cancelationEventEntry = mTempCancelationEvents.itemAt(i); 1935 switch (cancelationEventEntry->type) { 1936 case EventEntry::TYPE_KEY: 1937 logOutboundKeyDetailsLocked("cancel - ", 1938 static_cast<KeyEntry*>(cancelationEventEntry)); 1939 break; 1940 case EventEntry::TYPE_MOTION: 1941 logOutboundMotionDetailsLocked("cancel - ", 1942 static_cast<MotionEntry*>(cancelationEventEntry)); 1943 break; 1944 } 1945 1946 int32_t xOffset, yOffset; 1947 const InputWindow* window = getWindowLocked(connection->inputChannel); 1948 if (window) { 1949 xOffset = -window->frameLeft; 1950 yOffset = -window->frameTop; 1951 } else { 1952 xOffset = 0; 1953 yOffset = 0; 1954 } 1955 1956 DispatchEntry* cancelationDispatchEntry = 1957 mAllocator.obtainDispatchEntry(cancelationEventEntry, // increments ref 1958 0, xOffset, yOffset); 1959 connection->outboundQueue.enqueueAtTail(cancelationDispatchEntry); 1960 1961 mAllocator.releaseEventEntry(cancelationEventEntry); 1962 } 1963 1964 if (!connection->outboundQueue.headSentinel.next->inProgress) { 1965 startDispatchCycleLocked(currentTime, connection); 1966 } 1967 } 1968 } 1969 1970 InputDispatcher::MotionEntry* 1971 InputDispatcher::splitMotionEvent(const MotionEntry* originalMotionEntry, BitSet32 pointerIds) { 1972 assert(pointerIds.value != 0); 1973 1974 uint32_t splitPointerIndexMap[MAX_POINTERS]; 1975 int32_t splitPointerIds[MAX_POINTERS]; 1976 PointerCoords splitPointerCoords[MAX_POINTERS]; 1977 1978 uint32_t originalPointerCount = originalMotionEntry->pointerCount; 1979 uint32_t splitPointerCount = 0; 1980 1981 for (uint32_t originalPointerIndex = 0; originalPointerIndex < originalPointerCount; 1982 originalPointerIndex++) { 1983 int32_t pointerId = uint32_t(originalMotionEntry->pointerIds[originalPointerIndex]); 1984 if (pointerIds.hasBit(pointerId)) { 1985 splitPointerIndexMap[splitPointerCount] = originalPointerIndex; 1986 splitPointerIds[splitPointerCount] = pointerId; 1987 splitPointerCoords[splitPointerCount] = 1988 originalMotionEntry->firstSample.pointerCoords[originalPointerIndex]; 1989 splitPointerCount += 1; 1990 } 1991 } 1992 assert(splitPointerCount == pointerIds.count()); 1993 1994 int32_t action = originalMotionEntry->action; 1995 int32_t maskedAction = action & AMOTION_EVENT_ACTION_MASK; 1996 if (maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN 1997 || maskedAction == AMOTION_EVENT_ACTION_POINTER_UP) { 1998 int32_t originalPointerIndex = getMotionEventActionPointerIndex(action); 1999 int32_t pointerId = originalMotionEntry->pointerIds[originalPointerIndex]; 2000 if (pointerIds.hasBit(pointerId)) { 2001 if (pointerIds.count() == 1) { 2002 // The first/last pointer went down/up. 2003 action = maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN 2004 ? AMOTION_EVENT_ACTION_DOWN : AMOTION_EVENT_ACTION_UP; 2005 } else { 2006 // A secondary pointer went down/up. 2007 uint32_t splitPointerIndex = 0; 2008 while (pointerId != splitPointerIds[splitPointerIndex]) { 2009 splitPointerIndex += 1; 2010 } 2011 action = maskedAction | (splitPointerIndex 2012 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT); 2013 } 2014 } else { 2015 // An unrelated pointer changed. 2016 action = AMOTION_EVENT_ACTION_MOVE; 2017 } 2018 } 2019 2020 MotionEntry* splitMotionEntry = mAllocator.obtainMotionEntry( 2021 originalMotionEntry->eventTime, 2022 originalMotionEntry->deviceId, 2023 originalMotionEntry->source, 2024 originalMotionEntry->policyFlags, 2025 action, 2026 originalMotionEntry->flags, 2027 originalMotionEntry->metaState, 2028 originalMotionEntry->edgeFlags, 2029 originalMotionEntry->xPrecision, 2030 originalMotionEntry->yPrecision, 2031 originalMotionEntry->downTime, 2032 splitPointerCount, splitPointerIds, splitPointerCoords); 2033 2034 for (MotionSample* originalMotionSample = originalMotionEntry->firstSample.next; 2035 originalMotionSample != NULL; originalMotionSample = originalMotionSample->next) { 2036 for (uint32_t splitPointerIndex = 0; splitPointerIndex < splitPointerCount; 2037 splitPointerIndex++) { 2038 uint32_t originalPointerIndex = splitPointerIndexMap[splitPointerIndex]; 2039 splitPointerCoords[splitPointerIndex] = 2040 originalMotionSample->pointerCoords[originalPointerIndex]; 2041 } 2042 2043 mAllocator.appendMotionSample(splitMotionEntry, originalMotionSample->eventTime, 2044 splitPointerCoords); 2045 } 2046 2047 return splitMotionEntry; 2048 } 2049 2050 void InputDispatcher::notifyConfigurationChanged(nsecs_t eventTime) { 2051 #if DEBUG_INBOUND_EVENT_DETAILS 2052 LOGD("notifyConfigurationChanged - eventTime=%lld", eventTime); 2053 #endif 2054 2055 bool needWake; 2056 { // acquire lock 2057 AutoMutex _l(mLock); 2058 2059 ConfigurationChangedEntry* newEntry = mAllocator.obtainConfigurationChangedEntry(eventTime); 2060 needWake = enqueueInboundEventLocked(newEntry); 2061 } // release lock 2062 2063 if (needWake) { 2064 mLooper->wake(); 2065 } 2066 } 2067 2068 void InputDispatcher::notifyKey(nsecs_t eventTime, int32_t deviceId, int32_t source, 2069 uint32_t policyFlags, int32_t action, int32_t flags, 2070 int32_t keyCode, int32_t scanCode, int32_t metaState, nsecs_t downTime) { 2071 #if DEBUG_INBOUND_EVENT_DETAILS 2072 LOGD("notifyKey - eventTime=%lld, deviceId=0x%x, source=0x%x, policyFlags=0x%x, action=0x%x, " 2073 "flags=0x%x, keyCode=0x%x, scanCode=0x%x, metaState=0x%x, downTime=%lld", 2074 eventTime, deviceId, source, policyFlags, action, flags, 2075 keyCode, scanCode, metaState, downTime); 2076 #endif 2077 if (! validateKeyEvent(action)) { 2078 return; 2079 } 2080 2081 policyFlags |= POLICY_FLAG_TRUSTED; 2082 mPolicy->interceptKeyBeforeQueueing(eventTime, deviceId, action, /*byref*/ flags, 2083 keyCode, scanCode, /*byref*/ policyFlags); 2084 2085 bool needWake; 2086 { // acquire lock 2087 AutoMutex _l(mLock); 2088 2089 int32_t repeatCount = 0; 2090 KeyEntry* newEntry = mAllocator.obtainKeyEntry(eventTime, 2091 deviceId, source, policyFlags, action, flags, keyCode, scanCode, 2092 metaState, repeatCount, downTime); 2093 2094 needWake = enqueueInboundEventLocked(newEntry); 2095 } // release lock 2096 2097 if (needWake) { 2098 mLooper->wake(); 2099 } 2100 } 2101 2102 void InputDispatcher::notifyMotion(nsecs_t eventTime, int32_t deviceId, int32_t source, 2103 uint32_t policyFlags, int32_t action, int32_t flags, int32_t metaState, int32_t edgeFlags, 2104 uint32_t pointerCount, const int32_t* pointerIds, const PointerCoords* pointerCoords, 2105 float xPrecision, float yPrecision, nsecs_t downTime) { 2106 #if DEBUG_INBOUND_EVENT_DETAILS 2107 LOGD("notifyMotion - eventTime=%lld, deviceId=0x%x, source=0x%x, policyFlags=0x%x, " 2108 "action=0x%x, flags=0x%x, metaState=0x%x, edgeFlags=0x%x, " 2109 "xPrecision=%f, yPrecision=%f, downTime=%lld", 2110 eventTime, deviceId, source, policyFlags, action, flags, metaState, edgeFlags, 2111 xPrecision, yPrecision, downTime); 2112 for (uint32_t i = 0; i < pointerCount; i++) { 2113 LOGD(" Pointer %d: id=%d, x=%f, y=%f, pressure=%f, size=%f, " 2114 "touchMajor=%f, touchMinor=%f, toolMajor=%f, toolMinor=%f, " 2115 "orientation=%f", 2116 i, pointerIds[i], pointerCoords[i].x, pointerCoords[i].y, 2117 pointerCoords[i].pressure, pointerCoords[i].size, 2118 pointerCoords[i].touchMajor, pointerCoords[i].touchMinor, 2119 pointerCoords[i].toolMajor, pointerCoords[i].toolMinor, 2120 pointerCoords[i].orientation); 2121 } 2122 #endif 2123 if (! validateMotionEvent(action, pointerCount, pointerIds)) { 2124 return; 2125 } 2126 2127 policyFlags |= POLICY_FLAG_TRUSTED; 2128 mPolicy->interceptGenericBeforeQueueing(eventTime, /*byref*/ policyFlags); 2129 2130 bool needWake; 2131 { // acquire lock 2132 AutoMutex _l(mLock); 2133 2134 // Attempt batching and streaming of move events. 2135 if (action == AMOTION_EVENT_ACTION_MOVE) { 2136 // BATCHING CASE 2137 // 2138 // Try to append a move sample to the tail of the inbound queue for this device. 2139 // Give up if we encounter a non-move motion event for this device since that 2140 // means we cannot append any new samples until a new motion event has started. 2141 for (EventEntry* entry = mInboundQueue.tailSentinel.prev; 2142 entry != & mInboundQueue.headSentinel; entry = entry->prev) { 2143 if (entry->type != EventEntry::TYPE_MOTION) { 2144 // Keep looking for motion events. 2145 continue; 2146 } 2147 2148 MotionEntry* motionEntry = static_cast<MotionEntry*>(entry); 2149 if (motionEntry->deviceId != deviceId) { 2150 // Keep looking for this device. 2151 continue; 2152 } 2153 2154 if (motionEntry->action != AMOTION_EVENT_ACTION_MOVE 2155 || motionEntry->pointerCount != pointerCount 2156 || motionEntry->isInjected()) { 2157 // Last motion event in the queue for this device is not compatible for 2158 // appending new samples. Stop here. 2159 goto NoBatchingOrStreaming; 2160 } 2161 2162 // The last motion event is a move and is compatible for appending. 2163 // Do the batching magic. 2164 mAllocator.appendMotionSample(motionEntry, eventTime, pointerCoords); 2165 #if DEBUG_BATCHING 2166 LOGD("Appended motion sample onto batch for most recent " 2167 "motion event for this device in the inbound queue."); 2168 #endif 2169 return; // done! 2170 } 2171 2172 // STREAMING CASE 2173 // 2174 // There is no pending motion event (of any kind) for this device in the inbound queue. 2175 // Search the outbound queue for the current foreground targets to find a dispatched 2176 // motion event that is still in progress. If found, then, appen the new sample to 2177 // that event and push it out to all current targets. The logic in 2178 // prepareDispatchCycleLocked takes care of the case where some targets may 2179 // already have consumed the motion event by starting a new dispatch cycle if needed. 2180 if (mCurrentInputTargetsValid) { 2181 for (size_t i = 0; i < mCurrentInputTargets.size(); i++) { 2182 const InputTarget& inputTarget = mCurrentInputTargets[i]; 2183 if ((inputTarget.flags & InputTarget::FLAG_FOREGROUND) == 0) { 2184 // Skip non-foreground targets. We only want to stream if there is at 2185 // least one foreground target whose dispatch is still in progress. 2186 continue; 2187 } 2188 2189 ssize_t connectionIndex = getConnectionIndexLocked(inputTarget.inputChannel); 2190 if (connectionIndex < 0) { 2191 // Connection must no longer be valid. 2192 continue; 2193 } 2194 2195 sp<Connection> connection = mConnectionsByReceiveFd.valueAt(connectionIndex); 2196 if (connection->outboundQueue.isEmpty()) { 2197 // This foreground target has an empty outbound queue. 2198 continue; 2199 } 2200 2201 DispatchEntry* dispatchEntry = connection->outboundQueue.headSentinel.next; 2202 if (! dispatchEntry->inProgress 2203 || dispatchEntry->eventEntry->type != EventEntry::TYPE_MOTION 2204 || dispatchEntry->isSplit()) { 2205 // No motion event is being dispatched, or it is being split across 2206 // windows in which case we cannot stream. 2207 continue; 2208 } 2209 2210 MotionEntry* motionEntry = static_cast<MotionEntry*>( 2211 dispatchEntry->eventEntry); 2212 if (motionEntry->action != AMOTION_EVENT_ACTION_MOVE 2213 || motionEntry->deviceId != deviceId 2214 || motionEntry->pointerCount != pointerCount 2215 || motionEntry->isInjected()) { 2216 // The motion event is not compatible with this move. 2217 continue; 2218 } 2219 2220 // Hurray! This foreground target is currently dispatching a move event 2221 // that we can stream onto. Append the motion sample and resume dispatch. 2222 mAllocator.appendMotionSample(motionEntry, eventTime, pointerCoords); 2223 #if DEBUG_BATCHING 2224 LOGD("Appended motion sample onto batch for most recently dispatched " 2225 "motion event for this device in the outbound queues. " 2226 "Attempting to stream the motion sample."); 2227 #endif 2228 nsecs_t currentTime = now(); 2229 dispatchEventToCurrentInputTargetsLocked(currentTime, motionEntry, 2230 true /*resumeWithAppendedMotionSample*/); 2231 2232 runCommandsLockedInterruptible(); 2233 return; // done! 2234 } 2235 } 2236 2237 NoBatchingOrStreaming:; 2238 } 2239 2240 // Just enqueue a new motion event. 2241 MotionEntry* newEntry = mAllocator.obtainMotionEntry(eventTime, 2242 deviceId, source, policyFlags, action, flags, metaState, edgeFlags, 2243 xPrecision, yPrecision, downTime, 2244 pointerCount, pointerIds, pointerCoords); 2245 2246 needWake = enqueueInboundEventLocked(newEntry); 2247 } // release lock 2248 2249 if (needWake) { 2250 mLooper->wake(); 2251 } 2252 } 2253 2254 void InputDispatcher::notifySwitch(nsecs_t when, int32_t switchCode, int32_t switchValue, 2255 uint32_t policyFlags) { 2256 #if DEBUG_INBOUND_EVENT_DETAILS 2257 LOGD("notifySwitch - switchCode=%d, switchValue=%d, policyFlags=0x%x", 2258 switchCode, switchValue, policyFlags); 2259 #endif 2260 2261 policyFlags |= POLICY_FLAG_TRUSTED; 2262 mPolicy->notifySwitch(when, switchCode, switchValue, policyFlags); 2263 } 2264 2265 int32_t InputDispatcher::injectInputEvent(const InputEvent* event, 2266 int32_t injectorPid, int32_t injectorUid, int32_t syncMode, int32_t timeoutMillis) { 2267 #if DEBUG_INBOUND_EVENT_DETAILS 2268 LOGD("injectInputEvent - eventType=%d, injectorPid=%d, injectorUid=%d, " 2269 "syncMode=%d, timeoutMillis=%d", 2270 event->getType(), injectorPid, injectorUid, syncMode, timeoutMillis); 2271 #endif 2272 2273 nsecs_t endTime = now() + milliseconds_to_nanoseconds(timeoutMillis); 2274 2275 uint32_t policyFlags = POLICY_FLAG_INJECTED; 2276 if (hasInjectionPermission(injectorPid, injectorUid)) { 2277 policyFlags |= POLICY_FLAG_TRUSTED; 2278 } 2279 2280 EventEntry* injectedEntry; 2281 switch (event->getType()) { 2282 case AINPUT_EVENT_TYPE_KEY: { 2283 const KeyEvent* keyEvent = static_cast<const KeyEvent*>(event); 2284 int32_t action = keyEvent->getAction(); 2285 if (! validateKeyEvent(action)) { 2286 return INPUT_EVENT_INJECTION_FAILED; 2287 } 2288 2289 nsecs_t eventTime = keyEvent->getEventTime(); 2290 int32_t deviceId = keyEvent->getDeviceId(); 2291 int32_t flags = keyEvent->getFlags(); 2292 int32_t keyCode = keyEvent->getKeyCode(); 2293 int32_t scanCode = keyEvent->getScanCode(); 2294 mPolicy->interceptKeyBeforeQueueing(eventTime, deviceId, action, /*byref*/ flags, 2295 keyCode, scanCode, /*byref*/ policyFlags); 2296 2297 mLock.lock(); 2298 injectedEntry = mAllocator.obtainKeyEntry(eventTime, deviceId, keyEvent->getSource(), 2299 policyFlags, action, flags, keyCode, scanCode, keyEvent->getMetaState(), 2300 keyEvent->getRepeatCount(), keyEvent->getDownTime()); 2301 break; 2302 } 2303 2304 case AINPUT_EVENT_TYPE_MOTION: { 2305 const MotionEvent* motionEvent = static_cast<const MotionEvent*>(event); 2306 int32_t action = motionEvent->getAction(); 2307 size_t pointerCount = motionEvent->getPointerCount(); 2308 const int32_t* pointerIds = motionEvent->getPointerIds(); 2309 if (! validateMotionEvent(action, pointerCount, pointerIds)) { 2310 return INPUT_EVENT_INJECTION_FAILED; 2311 } 2312 2313 nsecs_t eventTime = motionEvent->getEventTime(); 2314 mPolicy->interceptGenericBeforeQueueing(eventTime, /*byref*/ policyFlags); 2315 2316 mLock.lock(); 2317 const nsecs_t* sampleEventTimes = motionEvent->getSampleEventTimes(); 2318 const PointerCoords* samplePointerCoords = motionEvent->getSamplePointerCoords(); 2319 MotionEntry* motionEntry = mAllocator.obtainMotionEntry(*sampleEventTimes, 2320 motionEvent->getDeviceId(), motionEvent->getSource(), policyFlags, 2321 action, motionEvent->getFlags(), 2322 motionEvent->getMetaState(), motionEvent->getEdgeFlags(), 2323 motionEvent->getXPrecision(), motionEvent->getYPrecision(), 2324 motionEvent->getDownTime(), uint32_t(pointerCount), 2325 pointerIds, samplePointerCoords); 2326 for (size_t i = motionEvent->getHistorySize(); i > 0; i--) { 2327 sampleEventTimes += 1; 2328 samplePointerCoords += pointerCount; 2329 mAllocator.appendMotionSample(motionEntry, *sampleEventTimes, samplePointerCoords); 2330 } 2331 injectedEntry = motionEntry; 2332 break; 2333 } 2334 2335 default: 2336 LOGW("Cannot inject event of type %d", event->getType()); 2337 return INPUT_EVENT_INJECTION_FAILED; 2338 } 2339 2340 InjectionState* injectionState = mAllocator.obtainInjectionState(injectorPid, injectorUid); 2341 if (syncMode == INPUT_EVENT_INJECTION_SYNC_NONE) { 2342 injectionState->injectionIsAsync = true; 2343 } 2344 2345 injectionState->refCount += 1; 2346 injectedEntry->injectionState = injectionState; 2347 2348 bool needWake = enqueueInboundEventLocked(injectedEntry); 2349 mLock.unlock(); 2350 2351 if (needWake) { 2352 mLooper->wake(); 2353 } 2354 2355 int32_t injectionResult; 2356 { // acquire lock 2357 AutoMutex _l(mLock); 2358 2359 if (syncMode == INPUT_EVENT_INJECTION_SYNC_NONE) { 2360 injectionResult = INPUT_EVENT_INJECTION_SUCCEEDED; 2361 } else { 2362 for (;;) { 2363 injectionResult = injectionState->injectionResult; 2364 if (injectionResult != INPUT_EVENT_INJECTION_PENDING) { 2365 break; 2366 } 2367 2368 nsecs_t remainingTimeout = endTime - now(); 2369 if (remainingTimeout <= 0) { 2370 #if DEBUG_INJECTION 2371 LOGD("injectInputEvent - Timed out waiting for injection result " 2372 "to become available."); 2373 #endif 2374 injectionResult = INPUT_EVENT_INJECTION_TIMED_OUT; 2375 break; 2376 } 2377 2378 mInjectionResultAvailableCondition.waitRelative(mLock, remainingTimeout); 2379 } 2380 2381 if (injectionResult == INPUT_EVENT_INJECTION_SUCCEEDED 2382 && syncMode == INPUT_EVENT_INJECTION_SYNC_WAIT_FOR_FINISHED) { 2383 while (injectionState->pendingForegroundDispatches != 0) { 2384 #if DEBUG_INJECTION 2385 LOGD("injectInputEvent - Waiting for %d pending foreground dispatches.", 2386 injectionState->pendingForegroundDispatches); 2387 #endif 2388 nsecs_t remainingTimeout = endTime - now(); 2389 if (remainingTimeout <= 0) { 2390 #if DEBUG_INJECTION 2391 LOGD("injectInputEvent - Timed out waiting for pending foreground " 2392 "dispatches to finish."); 2393 #endif 2394 injectionResult = INPUT_EVENT_INJECTION_TIMED_OUT; 2395 break; 2396 } 2397 2398 mInjectionSyncFinishedCondition.waitRelative(mLock, remainingTimeout); 2399 } 2400 } 2401 } 2402 2403 mAllocator.releaseInjectionState(injectionState); 2404 } // release lock 2405 2406 #if DEBUG_INJECTION 2407 LOGD("injectInputEvent - Finished with result %d. " 2408 "injectorPid=%d, injectorUid=%d", 2409 injectionResult, injectorPid, injectorUid); 2410 #endif 2411 2412 return injectionResult; 2413 } 2414 2415 bool InputDispatcher::hasInjectionPermission(int32_t injectorPid, int32_t injectorUid) { 2416 return injectorUid == 0 2417 || mPolicy->checkInjectEventsPermissionNonReentrant(injectorPid, injectorUid); 2418 } 2419 2420 void InputDispatcher::setInjectionResultLocked(EventEntry* entry, int32_t injectionResult) { 2421 InjectionState* injectionState = entry->injectionState; 2422 if (injectionState) { 2423 #if DEBUG_INJECTION 2424 LOGD("Setting input event injection result to %d. " 2425 "injectorPid=%d, injectorUid=%d", 2426 injectionResult, injectionState->injectorPid, injectionState->injectorUid); 2427 #endif 2428 2429 if (injectionState->injectionIsAsync) { 2430 // Log the outcome since the injector did not wait for the injection result. 2431 switch (injectionResult) { 2432 case INPUT_EVENT_INJECTION_SUCCEEDED: 2433 LOGV("Asynchronous input event injection succeeded."); 2434 break; 2435 case INPUT_EVENT_INJECTION_FAILED: 2436 LOGW("Asynchronous input event injection failed."); 2437 break; 2438 case INPUT_EVENT_INJECTION_PERMISSION_DENIED: 2439 LOGW("Asynchronous input event injection permission denied."); 2440 break; 2441 case INPUT_EVENT_INJECTION_TIMED_OUT: 2442 LOGW("Asynchronous input event injection timed out."); 2443 break; 2444 } 2445 } 2446 2447 injectionState->injectionResult = injectionResult; 2448 mInjectionResultAvailableCondition.broadcast(); 2449 } 2450 } 2451 2452 void InputDispatcher::incrementPendingForegroundDispatchesLocked(EventEntry* entry) { 2453 InjectionState* injectionState = entry->injectionState; 2454 if (injectionState) { 2455 injectionState->pendingForegroundDispatches += 1; 2456 } 2457 } 2458 2459 void InputDispatcher::decrementPendingForegroundDispatchesLocked(EventEntry* entry) { 2460 InjectionState* injectionState = entry->injectionState; 2461 if (injectionState) { 2462 injectionState->pendingForegroundDispatches -= 1; 2463 2464 if (injectionState->pendingForegroundDispatches == 0) { 2465 mInjectionSyncFinishedCondition.broadcast(); 2466 } 2467 } 2468 } 2469 2470 const InputWindow* InputDispatcher::getWindowLocked(const sp<InputChannel>& inputChannel) { 2471 for (size_t i = 0; i < mWindows.size(); i++) { 2472 const InputWindow* window = & mWindows[i]; 2473 if (window->inputChannel == inputChannel) { 2474 return window; 2475 } 2476 } 2477 return NULL; 2478 } 2479 2480 void InputDispatcher::setInputWindows(const Vector<InputWindow>& inputWindows) { 2481 #if DEBUG_FOCUS 2482 LOGD("setInputWindows"); 2483 #endif 2484 { // acquire lock 2485 AutoMutex _l(mLock); 2486 2487 // Clear old window pointers. 2488 sp<InputChannel> oldFocusedWindowChannel; 2489 if (mFocusedWindow) { 2490 oldFocusedWindowChannel = mFocusedWindow->inputChannel; 2491 mFocusedWindow = NULL; 2492 } 2493 2494 mWindows.clear(); 2495 2496 // Loop over new windows and rebuild the necessary window pointers for 2497 // tracking focus and touch. 2498 mWindows.appendVector(inputWindows); 2499 2500 size_t numWindows = mWindows.size(); 2501 for (size_t i = 0; i < numWindows; i++) { 2502 const InputWindow* window = & mWindows.itemAt(i); 2503 if (window->hasFocus) { 2504 mFocusedWindow = window; 2505 break; 2506 } 2507 } 2508 2509 if (oldFocusedWindowChannel != NULL) { 2510 if (!mFocusedWindow || oldFocusedWindowChannel != mFocusedWindow->inputChannel) { 2511 #if DEBUG_FOCUS 2512 LOGD("Focus left window: %s", 2513 oldFocusedWindowChannel->getName().string()); 2514 #endif 2515 synthesizeCancelationEventsForInputChannelLocked(oldFocusedWindowChannel, 2516 InputState::CANCEL_NON_POINTER_EVENTS, "focus left window"); 2517 oldFocusedWindowChannel.clear(); 2518 } 2519 } 2520 if (mFocusedWindow && oldFocusedWindowChannel == NULL) { 2521 #if DEBUG_FOCUS 2522 LOGD("Focus entered window: %s", 2523 mFocusedWindow->inputChannel->getName().string()); 2524 #endif 2525 } 2526 2527 for (size_t i = 0; i < mTouchState.windows.size(); ) { 2528 TouchedWindow& touchedWindow = mTouchState.windows.editItemAt(i); 2529 const InputWindow* window = getWindowLocked(touchedWindow.channel); 2530 if (window) { 2531 touchedWindow.window = window; 2532 i += 1; 2533 } else { 2534 #if DEBUG_FOCUS 2535 LOGD("Touched window was removed: %s", touchedWindow.channel->getName().string()); 2536 #endif 2537 synthesizeCancelationEventsForInputChannelLocked(touchedWindow.channel, 2538 InputState::CANCEL_POINTER_EVENTS, "touched window was removed"); 2539 mTouchState.windows.removeAt(i); 2540 } 2541 } 2542 2543 #if DEBUG_FOCUS 2544 //logDispatchStateLocked(); 2545 #endif 2546 } // release lock 2547 2548 // Wake up poll loop since it may need to make new input dispatching choices. 2549 mLooper->wake(); 2550 } 2551 2552 void InputDispatcher::setFocusedApplication(const InputApplication* inputApplication) { 2553 #if DEBUG_FOCUS 2554 LOGD("setFocusedApplication"); 2555 #endif 2556 { // acquire lock 2557 AutoMutex _l(mLock); 2558 2559 releaseFocusedApplicationLocked(); 2560 2561 if (inputApplication) { 2562 mFocusedApplicationStorage = *inputApplication; 2563 mFocusedApplication = & mFocusedApplicationStorage; 2564 } 2565 2566 #if DEBUG_FOCUS 2567 //logDispatchStateLocked(); 2568 #endif 2569 } // release lock 2570 2571 // Wake up poll loop since it may need to make new input dispatching choices. 2572 mLooper->wake(); 2573 } 2574 2575 void InputDispatcher::releaseFocusedApplicationLocked() { 2576 if (mFocusedApplication) { 2577 mFocusedApplication = NULL; 2578 mFocusedApplicationStorage.handle.clear(); 2579 } 2580 } 2581 2582 void InputDispatcher::setInputDispatchMode(bool enabled, bool frozen) { 2583 #if DEBUG_FOCUS 2584 LOGD("setInputDispatchMode: enabled=%d, frozen=%d", enabled, frozen); 2585 #endif 2586 2587 bool changed; 2588 { // acquire lock 2589 AutoMutex _l(mLock); 2590 2591 if (mDispatchEnabled != enabled || mDispatchFrozen != frozen) { 2592 if (mDispatchFrozen && !frozen) { 2593 resetANRTimeoutsLocked(); 2594 } 2595 2596 if (mDispatchEnabled && !enabled) { 2597 resetAndDropEverythingLocked("dispatcher is being disabled"); 2598 } 2599 2600 mDispatchEnabled = enabled; 2601 mDispatchFrozen = frozen; 2602 changed = true; 2603 } else { 2604 changed = false; 2605 } 2606 2607 #if DEBUG_FOCUS 2608 //logDispatchStateLocked(); 2609 #endif 2610 } // release lock 2611 2612 if (changed) { 2613 // Wake up poll loop since it may need to make new input dispatching choices. 2614 mLooper->wake(); 2615 } 2616 } 2617 2618 void InputDispatcher::resetAndDropEverythingLocked(const char* reason) { 2619 #if DEBUG_FOCUS 2620 LOGD("Resetting and dropping all events (%s).", reason); 2621 #endif 2622 2623 synthesizeCancelationEventsForAllConnectionsLocked(InputState::CANCEL_ALL_EVENTS, reason); 2624 2625 resetKeyRepeatLocked(); 2626 releasePendingEventLocked(); 2627 drainInboundQueueLocked(); 2628 resetTargetsLocked(); 2629 2630 mTouchState.reset(); 2631 } 2632 2633 void InputDispatcher::logDispatchStateLocked() { 2634 String8 dump; 2635 dumpDispatchStateLocked(dump); 2636 2637 char* text = dump.lockBuffer(dump.size()); 2638 char* start = text; 2639 while (*start != '\0') { 2640 char* end = strchr(start, '\n'); 2641 if (*end == '\n') { 2642 *(end++) = '\0'; 2643 } 2644 LOGD("%s", start); 2645 start = end; 2646 } 2647 } 2648 2649 void InputDispatcher::dumpDispatchStateLocked(String8& dump) { 2650 dump.appendFormat(INDENT "DispatchEnabled: %d\n", mDispatchEnabled); 2651 dump.appendFormat(INDENT "DispatchFrozen: %d\n", mDispatchFrozen); 2652 2653 if (mFocusedApplication) { 2654 dump.appendFormat(INDENT "FocusedApplication: name='%s', dispatchingTimeout=%0.3fms\n", 2655 mFocusedApplication->name.string(), 2656 mFocusedApplication->dispatchingTimeout / 1000000.0); 2657 } else { 2658 dump.append(INDENT "FocusedApplication: <null>\n"); 2659 } 2660 dump.appendFormat(INDENT "FocusedWindow: name='%s'\n", 2661 mFocusedWindow != NULL ? mFocusedWindow->name.string() : "<null>"); 2662 2663 dump.appendFormat(INDENT "TouchDown: %s\n", toString(mTouchState.down)); 2664 dump.appendFormat(INDENT "TouchSplit: %s\n", toString(mTouchState.split)); 2665 if (!mTouchState.windows.isEmpty()) { 2666 dump.append(INDENT "TouchedWindows:\n"); 2667 for (size_t i = 0; i < mTouchState.windows.size(); i++) { 2668 const TouchedWindow& touchedWindow = mTouchState.windows[i]; 2669 dump.appendFormat(INDENT2 "%d: name='%s', pointerIds=0x%0x, targetFlags=0x%x\n", 2670 i, touchedWindow.window->name.string(), touchedWindow.pointerIds.value, 2671 touchedWindow.targetFlags); 2672 } 2673 } else { 2674 dump.append(INDENT "TouchedWindows: <none>\n"); 2675 } 2676 2677 if (!mWindows.isEmpty()) { 2678 dump.append(INDENT "Windows:\n"); 2679 for (size_t i = 0; i < mWindows.size(); i++) { 2680 const InputWindow& window = mWindows[i]; 2681 dump.appendFormat(INDENT2 "%d: name='%s', paused=%s, hasFocus=%s, hasWallpaper=%s, " 2682 "visible=%s, canReceiveKeys=%s, flags=0x%08x, type=0x%08x, layer=%d, " 2683 "frame=[%d,%d][%d,%d], " 2684 "visibleFrame=[%d,%d][%d,%d], " 2685 "touchableArea=[%d,%d][%d,%d], " 2686 "ownerPid=%d, ownerUid=%d, dispatchingTimeout=%0.3fms\n", 2687 i, window.name.string(), 2688 toString(window.paused), 2689 toString(window.hasFocus), 2690 toString(window.hasWallpaper), 2691 toString(window.visible), 2692 toString(window.canReceiveKeys), 2693 window.layoutParamsFlags, window.layoutParamsType, 2694 window.layer, 2695 window.frameLeft, window.frameTop, 2696 window.frameRight, window.frameBottom, 2697 window.visibleFrameLeft, window.visibleFrameTop, 2698 window.visibleFrameRight, window.visibleFrameBottom, 2699 window.touchableAreaLeft, window.touchableAreaTop, 2700 window.touchableAreaRight, window.touchableAreaBottom, 2701 window.ownerPid, window.ownerUid, 2702 window.dispatchingTimeout / 1000000.0); 2703 } 2704 } else { 2705 dump.append(INDENT "Windows: <none>\n"); 2706 } 2707 2708 if (!mMonitoringChannels.isEmpty()) { 2709 dump.append(INDENT "MonitoringChannels:\n"); 2710 for (size_t i = 0; i < mMonitoringChannels.size(); i++) { 2711 const sp<InputChannel>& channel = mMonitoringChannels[i]; 2712 dump.appendFormat(INDENT2 "%d: '%s'\n", i, channel->getName().string()); 2713 } 2714 } else { 2715 dump.append(INDENT "MonitoringChannels: <none>\n"); 2716 } 2717 2718 dump.appendFormat(INDENT "InboundQueue: length=%u\n", mInboundQueue.count()); 2719 2720 if (!mActiveConnections.isEmpty()) { 2721 dump.append(INDENT "ActiveConnections:\n"); 2722 for (size_t i = 0; i < mActiveConnections.size(); i++) { 2723 const Connection* connection = mActiveConnections[i]; 2724 dump.appendFormat(INDENT2 "%d: '%s', status=%s, outboundQueueLength=%u" 2725 "inputState.isNeutral=%s\n", 2726 i, connection->getInputChannelName(), connection->getStatusLabel(), 2727 connection->outboundQueue.count(), 2728 toString(connection->inputState.isNeutral())); 2729 } 2730 } else { 2731 dump.append(INDENT "ActiveConnections: <none>\n"); 2732 } 2733 2734 if (isAppSwitchPendingLocked()) { 2735 dump.appendFormat(INDENT "AppSwitch: pending, due in %01.1fms\n", 2736 (mAppSwitchDueTime - now()) / 1000000.0); 2737 } else { 2738 dump.append(INDENT "AppSwitch: not pending\n"); 2739 } 2740 } 2741 2742 status_t InputDispatcher::registerInputChannel(const sp<InputChannel>& inputChannel, bool monitor) { 2743 #if DEBUG_REGISTRATION 2744 LOGD("channel '%s' ~ registerInputChannel - monitor=%s", inputChannel->getName().string(), 2745 toString(monitor)); 2746 #endif 2747 2748 { // acquire lock 2749 AutoMutex _l(mLock); 2750 2751 if (getConnectionIndexLocked(inputChannel) >= 0) { 2752 LOGW("Attempted to register already registered input channel '%s'", 2753 inputChannel->getName().string()); 2754 return BAD_VALUE; 2755 } 2756 2757 sp<Connection> connection = new Connection(inputChannel); 2758 status_t status = connection->initialize(); 2759 if (status) { 2760 LOGE("Failed to initialize input publisher for input channel '%s', status=%d", 2761 inputChannel->getName().string(), status); 2762 return status; 2763 } 2764 2765 int32_t receiveFd = inputChannel->getReceivePipeFd(); 2766 mConnectionsByReceiveFd.add(receiveFd, connection); 2767 2768 if (monitor) { 2769 mMonitoringChannels.push(inputChannel); 2770 } 2771 2772 mLooper->addFd(receiveFd, 0, ALOOPER_EVENT_INPUT, handleReceiveCallback, this); 2773 2774 runCommandsLockedInterruptible(); 2775 } // release lock 2776 return OK; 2777 } 2778 2779 status_t InputDispatcher::unregisterInputChannel(const sp<InputChannel>& inputChannel) { 2780 #if DEBUG_REGISTRATION 2781 LOGD("channel '%s' ~ unregisterInputChannel", inputChannel->getName().string()); 2782 #endif 2783 2784 { // acquire lock 2785 AutoMutex _l(mLock); 2786 2787 ssize_t connectionIndex = getConnectionIndexLocked(inputChannel); 2788 if (connectionIndex < 0) { 2789 LOGW("Attempted to unregister already unregistered input channel '%s'", 2790 inputChannel->getName().string()); 2791 return BAD_VALUE; 2792 } 2793 2794 sp<Connection> connection = mConnectionsByReceiveFd.valueAt(connectionIndex); 2795 mConnectionsByReceiveFd.removeItemsAt(connectionIndex); 2796 2797 connection->status = Connection::STATUS_ZOMBIE; 2798 2799 for (size_t i = 0; i < mMonitoringChannels.size(); i++) { 2800 if (mMonitoringChannels[i] == inputChannel) { 2801 mMonitoringChannels.removeAt(i); 2802 break; 2803 } 2804 } 2805 2806 mLooper->removeFd(inputChannel->getReceivePipeFd()); 2807 2808 nsecs_t currentTime = now(); 2809 abortBrokenDispatchCycleLocked(currentTime, connection); 2810 2811 runCommandsLockedInterruptible(); 2812 } // release lock 2813 2814 // Wake the poll loop because removing the connection may have changed the current 2815 // synchronization state. 2816 mLooper->wake(); 2817 return OK; 2818 } 2819 2820 ssize_t InputDispatcher::getConnectionIndexLocked(const sp<InputChannel>& inputChannel) { 2821 ssize_t connectionIndex = mConnectionsByReceiveFd.indexOfKey(inputChannel->getReceivePipeFd()); 2822 if (connectionIndex >= 0) { 2823 sp<Connection> connection = mConnectionsByReceiveFd.valueAt(connectionIndex); 2824 if (connection->inputChannel.get() == inputChannel.get()) { 2825 return connectionIndex; 2826 } 2827 } 2828 2829 return -1; 2830 } 2831 2832 void InputDispatcher::activateConnectionLocked(Connection* connection) { 2833 for (size_t i = 0; i < mActiveConnections.size(); i++) { 2834 if (mActiveConnections.itemAt(i) == connection) { 2835 return; 2836 } 2837 } 2838 mActiveConnections.add(connection); 2839 } 2840 2841 void InputDispatcher::deactivateConnectionLocked(Connection* connection) { 2842 for (size_t i = 0; i < mActiveConnections.size(); i++) { 2843 if (mActiveConnections.itemAt(i) == connection) { 2844 mActiveConnections.removeAt(i); 2845 return; 2846 } 2847 } 2848 } 2849 2850 void InputDispatcher::onDispatchCycleStartedLocked( 2851 nsecs_t currentTime, const sp<Connection>& connection) { 2852 } 2853 2854 void InputDispatcher::onDispatchCycleFinishedLocked( 2855 nsecs_t currentTime, const sp<Connection>& connection) { 2856 } 2857 2858 void InputDispatcher::onDispatchCycleBrokenLocked( 2859 nsecs_t currentTime, const sp<Connection>& connection) { 2860 LOGE("channel '%s' ~ Channel is unrecoverably broken and will be disposed!", 2861 connection->getInputChannelName()); 2862 2863 CommandEntry* commandEntry = postCommandLocked( 2864 & InputDispatcher::doNotifyInputChannelBrokenLockedInterruptible); 2865 commandEntry->connection = connection; 2866 } 2867 2868 void InputDispatcher::onANRLocked( 2869 nsecs_t currentTime, const InputApplication* application, const InputWindow* window, 2870 nsecs_t eventTime, nsecs_t waitStartTime) { 2871 LOGI("Application is not responding: %s. " 2872 "%01.1fms since event, %01.1fms since wait started", 2873 getApplicationWindowLabelLocked(application, window).string(), 2874 (currentTime - eventTime) / 1000000.0, 2875 (currentTime - waitStartTime) / 1000000.0); 2876 2877 CommandEntry* commandEntry = postCommandLocked( 2878 & InputDispatcher::doNotifyANRLockedInterruptible); 2879 if (application) { 2880 commandEntry->inputApplicationHandle = application->handle; 2881 } 2882 if (window) { 2883 commandEntry->inputChannel = window->inputChannel; 2884 } 2885 } 2886 2887 void InputDispatcher::doNotifyConfigurationChangedInterruptible( 2888 CommandEntry* commandEntry) { 2889 mLock.unlock(); 2890 2891 mPolicy->notifyConfigurationChanged(commandEntry->eventTime); 2892 2893 mLock.lock(); 2894 } 2895 2896 void InputDispatcher::doNotifyInputChannelBrokenLockedInterruptible( 2897 CommandEntry* commandEntry) { 2898 sp<Connection> connection = commandEntry->connection; 2899 2900 if (connection->status != Connection::STATUS_ZOMBIE) { 2901 mLock.unlock(); 2902 2903 mPolicy->notifyInputChannelBroken(connection->inputChannel); 2904 2905 mLock.lock(); 2906 } 2907 } 2908 2909 void InputDispatcher::doNotifyANRLockedInterruptible( 2910 CommandEntry* commandEntry) { 2911 mLock.unlock(); 2912 2913 nsecs_t newTimeout = mPolicy->notifyANR( 2914 commandEntry->inputApplicationHandle, commandEntry->inputChannel); 2915 2916 mLock.lock(); 2917 2918 resumeAfterTargetsNotReadyTimeoutLocked(newTimeout, commandEntry->inputChannel); 2919 } 2920 2921 void InputDispatcher::doInterceptKeyBeforeDispatchingLockedInterruptible( 2922 CommandEntry* commandEntry) { 2923 KeyEntry* entry = commandEntry->keyEntry; 2924 mReusableKeyEvent.initialize(entry->deviceId, entry->source, entry->action, entry->flags, 2925 entry->keyCode, entry->scanCode, entry->metaState, entry->repeatCount, 2926 entry->downTime, entry->eventTime); 2927 2928 mLock.unlock(); 2929 2930 bool consumed = mPolicy->interceptKeyBeforeDispatching(commandEntry->inputChannel, 2931 & mReusableKeyEvent, entry->policyFlags); 2932 2933 mLock.lock(); 2934 2935 entry->interceptKeyResult = consumed 2936 ? KeyEntry::INTERCEPT_KEY_RESULT_SKIP 2937 : KeyEntry::INTERCEPT_KEY_RESULT_CONTINUE; 2938 mAllocator.releaseKeyEntry(entry); 2939 } 2940 2941 void InputDispatcher::doPokeUserActivityLockedInterruptible(CommandEntry* commandEntry) { 2942 mLock.unlock(); 2943 2944 mPolicy->pokeUserActivity(commandEntry->eventTime, commandEntry->userActivityEventType); 2945 2946 mLock.lock(); 2947 } 2948 2949 void InputDispatcher::updateDispatchStatisticsLocked(nsecs_t currentTime, const EventEntry* entry, 2950 int32_t injectionResult, nsecs_t timeSpentWaitingForApplication) { 2951 // TODO Write some statistics about how long we spend waiting. 2952 } 2953 2954 void InputDispatcher::dump(String8& dump) { 2955 dump.append("Input Dispatcher State:\n"); 2956 dumpDispatchStateLocked(dump); 2957 } 2958 2959 2960 // --- InputDispatcher::Queue --- 2961 2962 template <typename T> 2963 uint32_t InputDispatcher::Queue<T>::count() const { 2964 uint32_t result = 0; 2965 for (const T* entry = headSentinel.next; entry != & tailSentinel; entry = entry->next) { 2966 result += 1; 2967 } 2968 return result; 2969 } 2970 2971 2972 // --- InputDispatcher::Allocator --- 2973 2974 InputDispatcher::Allocator::Allocator() { 2975 } 2976 2977 InputDispatcher::InjectionState* 2978 InputDispatcher::Allocator::obtainInjectionState(int32_t injectorPid, int32_t injectorUid) { 2979 InjectionState* injectionState = mInjectionStatePool.alloc(); 2980 injectionState->refCount = 1; 2981 injectionState->injectorPid = injectorPid; 2982 injectionState->injectorUid = injectorUid; 2983 injectionState->injectionIsAsync = false; 2984 injectionState->injectionResult = INPUT_EVENT_INJECTION_PENDING; 2985 injectionState->pendingForegroundDispatches = 0; 2986 return injectionState; 2987 } 2988 2989 void InputDispatcher::Allocator::initializeEventEntry(EventEntry* entry, int32_t type, 2990 nsecs_t eventTime, uint32_t policyFlags) { 2991 entry->type = type; 2992 entry->refCount = 1; 2993 entry->dispatchInProgress = false; 2994 entry->eventTime = eventTime; 2995 entry->policyFlags = policyFlags; 2996 entry->injectionState = NULL; 2997 } 2998 2999 void InputDispatcher::Allocator::releaseEventEntryInjectionState(EventEntry* entry) { 3000 if (entry->injectionState) { 3001 releaseInjectionState(entry->injectionState); 3002 entry->injectionState = NULL; 3003 } 3004 } 3005 3006 InputDispatcher::ConfigurationChangedEntry* 3007 InputDispatcher::Allocator::obtainConfigurationChangedEntry(nsecs_t eventTime) { 3008 ConfigurationChangedEntry* entry = mConfigurationChangeEntryPool.alloc(); 3009 initializeEventEntry(entry, EventEntry::TYPE_CONFIGURATION_CHANGED, eventTime, 0); 3010 return entry; 3011 } 3012 3013 InputDispatcher::KeyEntry* InputDispatcher::Allocator::obtainKeyEntry(nsecs_t eventTime, 3014 int32_t deviceId, int32_t source, uint32_t policyFlags, int32_t action, 3015 int32_t flags, int32_t keyCode, int32_t scanCode, int32_t metaState, 3016 int32_t repeatCount, nsecs_t downTime) { 3017 KeyEntry* entry = mKeyEntryPool.alloc(); 3018 initializeEventEntry(entry, EventEntry::TYPE_KEY, eventTime, policyFlags); 3019 3020 entry->deviceId = deviceId; 3021 entry->source = source; 3022 entry->action = action; 3023 entry->flags = flags; 3024 entry->keyCode = keyCode; 3025 entry->scanCode = scanCode; 3026 entry->metaState = metaState; 3027 entry->repeatCount = repeatCount; 3028 entry->downTime = downTime; 3029 entry->syntheticRepeat = false; 3030 entry->interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_UNKNOWN; 3031 return entry; 3032 } 3033 3034 InputDispatcher::MotionEntry* InputDispatcher::Allocator::obtainMotionEntry(nsecs_t eventTime, 3035 int32_t deviceId, int32_t source, uint32_t policyFlags, int32_t action, int32_t flags, 3036 int32_t metaState, int32_t edgeFlags, float xPrecision, float yPrecision, 3037 nsecs_t downTime, uint32_t pointerCount, 3038 const int32_t* pointerIds, const PointerCoords* pointerCoords) { 3039 MotionEntry* entry = mMotionEntryPool.alloc(); 3040 initializeEventEntry(entry, EventEntry::TYPE_MOTION, eventTime, policyFlags); 3041 3042 entry->eventTime = eventTime; 3043 entry->deviceId = deviceId; 3044 entry->source = source; 3045 entry->action = action; 3046 entry->flags = flags; 3047 entry->metaState = metaState; 3048 entry->edgeFlags = edgeFlags; 3049 entry->xPrecision = xPrecision; 3050 entry->yPrecision = yPrecision; 3051 entry->downTime = downTime; 3052 entry->pointerCount = pointerCount; 3053 entry->firstSample.eventTime = eventTime; 3054 entry->firstSample.next = NULL; 3055 entry->lastSample = & entry->firstSample; 3056 for (uint32_t i = 0; i < pointerCount; i++) { 3057 entry->pointerIds[i] = pointerIds[i]; 3058 entry->firstSample.pointerCoords[i] = pointerCoords[i]; 3059 } 3060 return entry; 3061 } 3062 3063 InputDispatcher::DispatchEntry* InputDispatcher::Allocator::obtainDispatchEntry( 3064 EventEntry* eventEntry, 3065 int32_t targetFlags, float xOffset, float yOffset) { 3066 DispatchEntry* entry = mDispatchEntryPool.alloc(); 3067 entry->eventEntry = eventEntry; 3068 eventEntry->refCount += 1; 3069 entry->targetFlags = targetFlags; 3070 entry->xOffset = xOffset; 3071 entry->yOffset = yOffset; 3072 entry->inProgress = false; 3073 entry->headMotionSample = NULL; 3074 entry->tailMotionSample = NULL; 3075 return entry; 3076 } 3077 3078 InputDispatcher::CommandEntry* InputDispatcher::Allocator::obtainCommandEntry(Command command) { 3079 CommandEntry* entry = mCommandEntryPool.alloc(); 3080 entry->command = command; 3081 return entry; 3082 } 3083 3084 void InputDispatcher::Allocator::releaseInjectionState(InjectionState* injectionState) { 3085 injectionState->refCount -= 1; 3086 if (injectionState->refCount == 0) { 3087 mInjectionStatePool.free(injectionState); 3088 } else { 3089 assert(injectionState->refCount > 0); 3090 } 3091 } 3092 3093 void InputDispatcher::Allocator::releaseEventEntry(EventEntry* entry) { 3094 switch (entry->type) { 3095 case EventEntry::TYPE_CONFIGURATION_CHANGED: 3096 releaseConfigurationChangedEntry(static_cast<ConfigurationChangedEntry*>(entry)); 3097 break; 3098 case EventEntry::TYPE_KEY: 3099 releaseKeyEntry(static_cast<KeyEntry*>(entry)); 3100 break; 3101 case EventEntry::TYPE_MOTION: 3102 releaseMotionEntry(static_cast<MotionEntry*>(entry)); 3103 break; 3104 default: 3105 assert(false); 3106 break; 3107 } 3108 } 3109 3110 void InputDispatcher::Allocator::releaseConfigurationChangedEntry( 3111 ConfigurationChangedEntry* entry) { 3112 entry->refCount -= 1; 3113 if (entry->refCount == 0) { 3114 releaseEventEntryInjectionState(entry); 3115 mConfigurationChangeEntryPool.free(entry); 3116 } else { 3117 assert(entry->refCount > 0); 3118 } 3119 } 3120 3121 void InputDispatcher::Allocator::releaseKeyEntry(KeyEntry* entry) { 3122 entry->refCount -= 1; 3123 if (entry->refCount == 0) { 3124 releaseEventEntryInjectionState(entry); 3125 mKeyEntryPool.free(entry); 3126 } else { 3127 assert(entry->refCount > 0); 3128 } 3129 } 3130 3131 void InputDispatcher::Allocator::releaseMotionEntry(MotionEntry* entry) { 3132 entry->refCount -= 1; 3133 if (entry->refCount == 0) { 3134 releaseEventEntryInjectionState(entry); 3135 for (MotionSample* sample = entry->firstSample.next; sample != NULL; ) { 3136 MotionSample* next = sample->next; 3137 mMotionSamplePool.free(sample); 3138 sample = next; 3139 } 3140 mMotionEntryPool.free(entry); 3141 } else { 3142 assert(entry->refCount > 0); 3143 } 3144 } 3145 3146 void InputDispatcher::Allocator::releaseDispatchEntry(DispatchEntry* entry) { 3147 releaseEventEntry(entry->eventEntry); 3148 mDispatchEntryPool.free(entry); 3149 } 3150 3151 void InputDispatcher::Allocator::releaseCommandEntry(CommandEntry* entry) { 3152 mCommandEntryPool.free(entry); 3153 } 3154 3155 void InputDispatcher::Allocator::appendMotionSample(MotionEntry* motionEntry, 3156 nsecs_t eventTime, const PointerCoords* pointerCoords) { 3157 MotionSample* sample = mMotionSamplePool.alloc(); 3158 sample->eventTime = eventTime; 3159 uint32_t pointerCount = motionEntry->pointerCount; 3160 for (uint32_t i = 0; i < pointerCount; i++) { 3161 sample->pointerCoords[i] = pointerCoords[i]; 3162 } 3163 3164 sample->next = NULL; 3165 motionEntry->lastSample->next = sample; 3166 motionEntry->lastSample = sample; 3167 } 3168 3169 void InputDispatcher::Allocator::recycleKeyEntry(KeyEntry* keyEntry) { 3170 releaseEventEntryInjectionState(keyEntry); 3171 3172 keyEntry->dispatchInProgress = false; 3173 keyEntry->syntheticRepeat = false; 3174 keyEntry->interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_UNKNOWN; 3175 } 3176 3177 3178 // --- InputDispatcher::MotionEntry --- 3179 3180 uint32_t InputDispatcher::MotionEntry::countSamples() const { 3181 uint32_t count = 1; 3182 for (MotionSample* sample = firstSample.next; sample != NULL; sample = sample->next) { 3183 count += 1; 3184 } 3185 return count; 3186 } 3187 3188 3189 // --- InputDispatcher::InputState --- 3190 3191 InputDispatcher::InputState::InputState() { 3192 } 3193 3194 InputDispatcher::InputState::~InputState() { 3195 } 3196 3197 bool InputDispatcher::InputState::isNeutral() const { 3198 return mKeyMementos.isEmpty() && mMotionMementos.isEmpty(); 3199 } 3200 3201 InputDispatcher::InputState::Consistency InputDispatcher::InputState::trackEvent( 3202 const EventEntry* entry) { 3203 switch (entry->type) { 3204 case EventEntry::TYPE_KEY: 3205 return trackKey(static_cast<const KeyEntry*>(entry)); 3206 3207 case EventEntry::TYPE_MOTION: 3208 return trackMotion(static_cast<const MotionEntry*>(entry)); 3209 3210 default: 3211 return CONSISTENT; 3212 } 3213 } 3214 3215 InputDispatcher::InputState::Consistency InputDispatcher::InputState::trackKey( 3216 const KeyEntry* entry) { 3217 int32_t action = entry->action; 3218 for (size_t i = 0; i < mKeyMementos.size(); i++) { 3219 KeyMemento& memento = mKeyMementos.editItemAt(i); 3220 if (memento.deviceId == entry->deviceId 3221 && memento.source == entry->source 3222 && memento.keyCode == entry->keyCode 3223 && memento.scanCode == entry->scanCode) { 3224 switch (action) { 3225 case AKEY_EVENT_ACTION_UP: 3226 mKeyMementos.removeAt(i); 3227 return CONSISTENT; 3228 3229 case AKEY_EVENT_ACTION_DOWN: 3230 return TOLERABLE; 3231 3232 default: 3233 return BROKEN; 3234 } 3235 } 3236 } 3237 3238 switch (action) { 3239 case AKEY_EVENT_ACTION_DOWN: { 3240 mKeyMementos.push(); 3241 KeyMemento& memento = mKeyMementos.editTop(); 3242 memento.deviceId = entry->deviceId; 3243 memento.source = entry->source; 3244 memento.keyCode = entry->keyCode; 3245 memento.scanCode = entry->scanCode; 3246 memento.downTime = entry->downTime; 3247 return CONSISTENT; 3248 } 3249 3250 default: 3251 return BROKEN; 3252 } 3253 } 3254 3255 InputDispatcher::InputState::Consistency InputDispatcher::InputState::trackMotion( 3256 const MotionEntry* entry) { 3257 int32_t action = entry->action & AMOTION_EVENT_ACTION_MASK; 3258 for (size_t i = 0; i < mMotionMementos.size(); i++) { 3259 MotionMemento& memento = mMotionMementos.editItemAt(i); 3260 if (memento.deviceId == entry->deviceId 3261 && memento.source == entry->source) { 3262 switch (action) { 3263 case AMOTION_EVENT_ACTION_UP: 3264 case AMOTION_EVENT_ACTION_CANCEL: 3265 mMotionMementos.removeAt(i); 3266 return CONSISTENT; 3267 3268 case AMOTION_EVENT_ACTION_DOWN: 3269 return TOLERABLE; 3270 3271 case AMOTION_EVENT_ACTION_POINTER_DOWN: 3272 if (entry->pointerCount == memento.pointerCount + 1) { 3273 memento.setPointers(entry); 3274 return CONSISTENT; 3275 } 3276 return BROKEN; 3277 3278 case AMOTION_EVENT_ACTION_POINTER_UP: 3279 if (entry->pointerCount == memento.pointerCount - 1) { 3280 memento.setPointers(entry); 3281 return CONSISTENT; 3282 } 3283 return BROKEN; 3284 3285 case AMOTION_EVENT_ACTION_MOVE: 3286 if (entry->pointerCount == memento.pointerCount) { 3287 return CONSISTENT; 3288 } 3289 return BROKEN; 3290 3291 default: 3292 return BROKEN; 3293 } 3294 } 3295 } 3296 3297 switch (action) { 3298 case AMOTION_EVENT_ACTION_DOWN: { 3299 mMotionMementos.push(); 3300 MotionMemento& memento = mMotionMementos.editTop(); 3301 memento.deviceId = entry->deviceId; 3302 memento.source = entry->source; 3303 memento.xPrecision = entry->xPrecision; 3304 memento.yPrecision = entry->yPrecision; 3305 memento.downTime = entry->downTime; 3306 memento.setPointers(entry); 3307 return CONSISTENT; 3308 } 3309 3310 default: 3311 return BROKEN; 3312 } 3313 } 3314 3315 void InputDispatcher::InputState::MotionMemento::setPointers(const MotionEntry* entry) { 3316 pointerCount = entry->pointerCount; 3317 for (uint32_t i = 0; i < entry->pointerCount; i++) { 3318 pointerIds[i] = entry->pointerIds[i]; 3319 pointerCoords[i] = entry->lastSample->pointerCoords[i]; 3320 } 3321 } 3322 3323 void InputDispatcher::InputState::synthesizeCancelationEvents(nsecs_t currentTime, 3324 Allocator* allocator, Vector<EventEntry*>& outEvents, 3325 CancelationOptions options) { 3326 for (size_t i = 0; i < mKeyMementos.size(); ) { 3327 const KeyMemento& memento = mKeyMementos.itemAt(i); 3328 if (shouldCancelEvent(memento.source, options)) { 3329 outEvents.push(allocator->obtainKeyEntry(currentTime, 3330 memento.deviceId, memento.source, 0, 3331 AKEY_EVENT_ACTION_UP, AKEY_EVENT_FLAG_CANCELED, 3332 memento.keyCode, memento.scanCode, 0, 0, memento.downTime)); 3333 mKeyMementos.removeAt(i); 3334 } else { 3335 i += 1; 3336 } 3337 } 3338 3339 for (size_t i = 0; i < mMotionMementos.size(); ) { 3340 const MotionMemento& memento = mMotionMementos.itemAt(i); 3341 if (shouldCancelEvent(memento.source, options)) { 3342 outEvents.push(allocator->obtainMotionEntry(currentTime, 3343 memento.deviceId, memento.source, 0, 3344 AMOTION_EVENT_ACTION_CANCEL, 0, 0, 0, 3345 memento.xPrecision, memento.yPrecision, memento.downTime, 3346 memento.pointerCount, memento.pointerIds, memento.pointerCoords)); 3347 mMotionMementos.removeAt(i); 3348 } else { 3349 i += 1; 3350 } 3351 } 3352 } 3353 3354 void InputDispatcher::InputState::clear() { 3355 mKeyMementos.clear(); 3356 mMotionMementos.clear(); 3357 } 3358 3359 bool InputDispatcher::InputState::shouldCancelEvent(int32_t eventSource, 3360 CancelationOptions options) { 3361 switch (options) { 3362 case CANCEL_POINTER_EVENTS: 3363 return eventSource & AINPUT_SOURCE_CLASS_POINTER; 3364 case CANCEL_NON_POINTER_EVENTS: 3365 return !(eventSource & AINPUT_SOURCE_CLASS_POINTER); 3366 default: 3367 return true; 3368 } 3369 } 3370 3371 3372 // --- InputDispatcher::Connection --- 3373 3374 InputDispatcher::Connection::Connection(const sp<InputChannel>& inputChannel) : 3375 status(STATUS_NORMAL), inputChannel(inputChannel), inputPublisher(inputChannel), 3376 lastEventTime(LONG_LONG_MAX), lastDispatchTime(LONG_LONG_MAX) { 3377 } 3378 3379 InputDispatcher::Connection::~Connection() { 3380 } 3381 3382 status_t InputDispatcher::Connection::initialize() { 3383 return inputPublisher.initialize(); 3384 } 3385 3386 const char* InputDispatcher::Connection::getStatusLabel() const { 3387 switch (status) { 3388 case STATUS_NORMAL: 3389 return "NORMAL"; 3390 3391 case STATUS_BROKEN: 3392 return "BROKEN"; 3393 3394 case STATUS_ZOMBIE: 3395 return "ZOMBIE"; 3396 3397 default: 3398 return "UNKNOWN"; 3399 } 3400 } 3401 3402 InputDispatcher::DispatchEntry* InputDispatcher::Connection::findQueuedDispatchEntryForEvent( 3403 const EventEntry* eventEntry) const { 3404 for (DispatchEntry* dispatchEntry = outboundQueue.tailSentinel.prev; 3405 dispatchEntry != & outboundQueue.headSentinel; dispatchEntry = dispatchEntry->prev) { 3406 if (dispatchEntry->eventEntry == eventEntry) { 3407 return dispatchEntry; 3408 } 3409 } 3410 return NULL; 3411 } 3412 3413 3414 // --- InputDispatcher::CommandEntry --- 3415 3416 InputDispatcher::CommandEntry::CommandEntry() : 3417 keyEntry(NULL) { 3418 } 3419 3420 InputDispatcher::CommandEntry::~CommandEntry() { 3421 } 3422 3423 3424 // --- InputDispatcher::TouchState --- 3425 3426 InputDispatcher::TouchState::TouchState() : 3427 down(false), split(false) { 3428 } 3429 3430 InputDispatcher::TouchState::~TouchState() { 3431 } 3432 3433 void InputDispatcher::TouchState::reset() { 3434 down = false; 3435 split = false; 3436 windows.clear(); 3437 } 3438 3439 void InputDispatcher::TouchState::copyFrom(const TouchState& other) { 3440 down = other.down; 3441 split = other.split; 3442 windows.clear(); 3443 windows.appendVector(other.windows); 3444 } 3445 3446 void InputDispatcher::TouchState::addOrUpdateWindow(const InputWindow* window, 3447 int32_t targetFlags, BitSet32 pointerIds) { 3448 if (targetFlags & InputTarget::FLAG_SPLIT) { 3449 split = true; 3450 } 3451 3452 for (size_t i = 0; i < windows.size(); i++) { 3453 TouchedWindow& touchedWindow = windows.editItemAt(i); 3454 if (touchedWindow.window == window) { 3455 touchedWindow.targetFlags |= targetFlags; 3456 touchedWindow.pointerIds.value |= pointerIds.value; 3457 return; 3458 } 3459 } 3460 3461 windows.push(); 3462 3463 TouchedWindow& touchedWindow = windows.editTop(); 3464 touchedWindow.window = window; 3465 touchedWindow.targetFlags = targetFlags; 3466 touchedWindow.pointerIds = pointerIds; 3467 touchedWindow.channel = window->inputChannel; 3468 } 3469 3470 void InputDispatcher::TouchState::removeOutsideTouchWindows() { 3471 for (size_t i = 0 ; i < windows.size(); ) { 3472 if (windows[i].targetFlags & InputTarget::FLAG_OUTSIDE) { 3473 windows.removeAt(i); 3474 } else { 3475 i += 1; 3476 } 3477 } 3478 } 3479 3480 const InputWindow* InputDispatcher::TouchState::getFirstForegroundWindow() { 3481 for (size_t i = 0; i < windows.size(); i++) { 3482 if (windows[i].targetFlags & InputTarget::FLAG_FOREGROUND) { 3483 return windows[i].window; 3484 } 3485 } 3486 return NULL; 3487 } 3488 3489 3490 // --- InputDispatcherThread --- 3491 3492 InputDispatcherThread::InputDispatcherThread(const sp<InputDispatcherInterface>& dispatcher) : 3493 Thread(/*canCallJava*/ true), mDispatcher(dispatcher) { 3494 } 3495 3496 InputDispatcherThread::~InputDispatcherThread() { 3497 } 3498 3499 bool InputDispatcherThread::threadLoop() { 3500 mDispatcher->dispatchOnce(); 3501 return true; 3502 } 3503 3504 } // namespace android 3505