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