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