The Tor Browser / file revision

 /*

  * Copyright (C) 2010 The Android Open Source Project

  *

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  *

  *      http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 #define LOG_TAG "InputDispatcher"

 #define ATRACE_TAG ATRACE_TAG_INPUT

 //#define LOG_NDEBUG 0

 #include "cutils_log.h"

 // Log detailed debug messages about each inbound event notification to the dispatcher.

 #define DEBUG_INBOUND_EVENT_DETAILS 0

 // Log detailed debug messages about each outbound event processed by the dispatcher.

 #define DEBUG_OUTBOUND_EVENT_DETAILS 0

 // Log debug messages about the dispatch cycle.

 #define DEBUG_DISPATCH_CYCLE 0

 // Log debug messages about registrations.

 #define DEBUG_REGISTRATION 0

 // Log debug messages about input event injection.

 #define DEBUG_INJECTION 0

 // Log debug messages about input focus tracking.

 #define DEBUG_FOCUS 0

 // Log debug messages about the app switch latency optimization.

 #define DEBUG_APP_SWITCH 0

 // Log debug messages about hover events.

 #define DEBUG_HOVER 0

 #include "InputDispatcher.h"

 #include "Trace.h"

 #include "PowerManager.h"

 #include <stddef.h>

 #include <unistd.h>

 #include <errno.h>

 #include <limits.h>

 #include <time.h>

 #define INDENT "  "

 #define INDENT2 "    "

 #define INDENT3 "      "

 #define INDENT4 "        "

 namespace android {

 // Default input dispatching timeout if there is no focused application or paused window

 // from which to determine an appropriate dispatching timeout.

 const nsecs_t DEFAULT_INPUT_DISPATCHING_TIMEOUT = 5000 * 1000000LL; // 5 sec

 // Amount of time to allow for all pending events to be processed when an app switch

 // key is on the way.  This is used to preempt input dispatch and drop input events

 // when an application takes too long to respond and the user has pressed an app switch key.

 const nsecs_t APP_SWITCH_TIMEOUT = 500 * 1000000LL; // 0.5sec

 // Amount of time to allow for an event to be dispatched (measured since its eventTime)

 // before considering it stale and dropping it.

 const nsecs_t STALE_EVENT_TIMEOUT = 10000 * 1000000LL; // 10sec

 // Amount of time to allow touch events to be streamed out to a connection before requiring

 // that the first event be finished.  This value extends the ANR timeout by the specified

 // amount.  For example, if streaming is allowed to get ahead by one second relative to the

 // queue of waiting unfinished events, then ANRs will similarly be delayed by one second.

 const nsecs_t STREAM_AHEAD_EVENT_TIMEOUT = 500 * 1000000LL; // 0.5sec

 // Log a warning when an event takes longer than this to process, even if an ANR does not occur.

 const nsecs_t SLOW_EVENT_PROCESSING_WARNING_TIMEOUT = 2000 * 1000000LL; // 2sec

 static inline nsecs_t now() {

     return systemTime(SYSTEM_TIME_MONOTONIC);

 }

 static inline const char* toString(bool value) {

     return value ? "true" : "false";

 }

 static inline int32_t getMotionEventActionPointerIndex(int32_t action) {

     return (action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK)

             >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;

 }

 static bool isValidKeyAction(int32_t action) {

     switch (action) {

     case AKEY_EVENT_ACTION_DOWN:

     case AKEY_EVENT_ACTION_UP:

         return true;

     default:

         return false;

     }

 }

 static bool validateKeyEvent(int32_t action) {

     if (! isValidKeyAction(action)) {

         ALOGE("Key event has invalid action code 0x%x", action);

         return false;

     }

     return true;

 }

 static bool isValidMotionAction(int32_t action, size_t pointerCount) {

     switch (action & AMOTION_EVENT_ACTION_MASK) {

     case AMOTION_EVENT_ACTION_DOWN:

     case AMOTION_EVENT_ACTION_UP:

     case AMOTION_EVENT_ACTION_CANCEL:

     case AMOTION_EVENT_ACTION_MOVE:

     case AMOTION_EVENT_ACTION_OUTSIDE:

     case AMOTION_EVENT_ACTION_HOVER_ENTER:

     case AMOTION_EVENT_ACTION_HOVER_MOVE:

     case AMOTION_EVENT_ACTION_HOVER_EXIT:

     case AMOTION_EVENT_ACTION_SCROLL:

         return true;

     case AMOTION_EVENT_ACTION_POINTER_DOWN:

     case AMOTION_EVENT_ACTION_POINTER_UP: {

         int32_t index = getMotionEventActionPointerIndex(action);

         return index >= 0 && size_t(index) < pointerCount;

     }

     default:

         return false;

     }

 }

 static bool validateMotionEvent(int32_t action, size_t pointerCount,

         const PointerProperties* pointerProperties) {

     if (! isValidMotionAction(action, pointerCount)) {

         ALOGE("Motion event has invalid action code 0x%x", action);

         return false;

     }

     if (pointerCount < 1 || pointerCount > MAX_POINTERS) {

         ALOGE("Motion event has invalid pointer count %d; value must be between 1 and %d.",

                 pointerCount, MAX_POINTERS);

         return false;

     }

     BitSet32 pointerIdBits;

     for (size_t i = 0; i < pointerCount; i++) {

         int32_t id = pointerProperties[i].id;

         if (id < 0 || id > MAX_POINTER_ID) {

             ALOGE("Motion event has invalid pointer id %d; value must be between 0 and %d",

                     id, MAX_POINTER_ID);

             return false;

         }

         if (pointerIdBits.hasBit(id)) {

             ALOGE("Motion event has duplicate pointer id %d", id);

             return false;

         }

         pointerIdBits.markBit(id);

     }

     return true;

 }

 static bool isMainDisplay(int32_t displayId) {

     return displayId == ADISPLAY_ID_DEFAULT || displayId == ADISPLAY_ID_NONE;

 }

 static void dumpRegion(String8& dump, const SkRegion& region) {

     if (region.isEmpty()) {

         dump.append("<empty>");

         return;

     }

     bool first = true;

     for (SkRegion::Iterator it(region); !it.done(); it.next()) {

         if (first) {

             first = false;

         } else {

             dump.append("|");

         }

         const SkIRect& rect = it.rect();

         dump.appendFormat("[%d,%d][%d,%d]", rect.fLeft, rect.fTop, rect.fRight, rect.fBottom);

     }

 }

 // --- InputDispatcher ---

 InputDispatcher::InputDispatcher(const sp<InputDispatcherPolicyInterface>& policy) :

     mPolicy(policy),

     mPendingEvent(NULL), mAppSwitchSawKeyDown(false), mAppSwitchDueTime(LONG_LONG_MAX),

     mNextUnblockedEvent(NULL),

     mDispatchEnabled(false), mDispatchFrozen(false), mInputFilterEnabled(false),

     mInputTargetWaitCause(INPUT_TARGET_WAIT_CAUSE_NONE) {

     mLooper = new Looper(false);

     mKeyRepeatState.lastKeyEntry = NULL;

     policy->getDispatcherConfiguration(&mConfig);

 }

 InputDispatcher::~InputDispatcher() {

     { // acquire lock

         AutoMutex _l(mLock);

         resetKeyRepeatLocked();

         releasePendingEventLocked();

         drainInboundQueueLocked();

     }

     while (mConnectionsByFd.size() != 0) {

         unregisterInputChannel(mConnectionsByFd.valueAt(0)->inputChannel);

     }

 }

 void InputDispatcher::dispatchOnce() {

     nsecs_t nextWakeupTime = LONG_LONG_MAX;

     { // acquire lock

         AutoMutex _l(mLock);

         mDispatcherIsAliveCondition.broadcast();

         // Run a dispatch loop if there are no pending commands.

         // The dispatch loop might enqueue commands to run afterwards.

         if (!haveCommandsLocked()) {

             dispatchOnceInnerLocked(&nextWakeupTime);

         }

         // Run all pending commands if there are any.

         // If any commands were run then force the next poll to wake up immediately.

         if (runCommandsLockedInterruptible()) {

             nextWakeupTime = LONG_LONG_MIN;

         }

     } // release lock

     // Wait for callback or timeout or wake.  (make sure we round up, not down)

     nsecs_t currentTime = now();

     int timeoutMillis = toMillisecondTimeoutDelay(currentTime, nextWakeupTime);

     mLooper->pollOnce(timeoutMillis);

 }

 void InputDispatcher::dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) {

     nsecs_t currentTime = now();

     // Reset the key repeat timer whenever we disallow key events, even if the next event

     // is not a key.  This is to ensure that we abort a key repeat if the device is just coming

     // out of sleep.

     if (!mPolicy->isKeyRepeatEnabled()) {

         resetKeyRepeatLocked();

     }

     // If dispatching is frozen, do not process timeouts or try to deliver any new events.

     if (mDispatchFrozen) {

 #if DEBUG_FOCUS

         ALOGD("Dispatch frozen.  Waiting some more.");

 #endif

         return;

     }

     // Optimize latency of app switches.

     // Essentially we start a short timeout when an app switch key (HOME / ENDCALL) has

     // been pressed.  When it expires, we preempt dispatch and drop all other pending events.

     bool isAppSwitchDue = mAppSwitchDueTime <= currentTime;

     if (mAppSwitchDueTime < *nextWakeupTime) {

         *nextWakeupTime = mAppSwitchDueTime;

     }

     // Ready to start a new event.

     // If we don't already have a pending event, go grab one.

     if (! mPendingEvent) {

         if (mInboundQueue.isEmpty()) {

             if (isAppSwitchDue) {

                 // The inbound queue is empty so the app switch key we were waiting

                 // for will never arrive.  Stop waiting for it.

                 resetPendingAppSwitchLocked(false);

                 isAppSwitchDue = false;

             }

             // Synthesize a key repeat if appropriate.

             if (mKeyRepeatState.lastKeyEntry) {

                 if (currentTime >= mKeyRepeatState.nextRepeatTime) {

                     mPendingEvent = synthesizeKeyRepeatLocked(currentTime);

                 } else {

                     if (mKeyRepeatState.nextRepeatTime < *nextWakeupTime) {

                         *nextWakeupTime = mKeyRepeatState.nextRepeatTime;

                     }

                 }

             }

             // Nothing to do if there is no pending event.

             if (!mPendingEvent) {

                 return;

             }

         } else {

             // Inbound queue has at least one entry.

             mPendingEvent = mInboundQueue.dequeueAtHead();

             traceInboundQueueLengthLocked();

         }

         // Poke user activity for this event.

         if (mPendingEvent->policyFlags & POLICY_FLAG_PASS_TO_USER) {

             pokeUserActivityLocked(mPendingEvent);

         }

         // Get ready to dispatch the event.

         resetANRTimeoutsLocked();

     }

     // Now we have an event to dispatch.

     // All events are eventually dequeued and processed this way, even if we intend to drop them.

     ALOG_ASSERT(mPendingEvent != NULL);

     bool done = false;

     DropReason dropReason = DROP_REASON_NOT_DROPPED;

     if (!(mPendingEvent->policyFlags & POLICY_FLAG_PASS_TO_USER)) {

         dropReason = DROP_REASON_POLICY;

     } else if (!mDispatchEnabled) {

         dropReason = DROP_REASON_DISABLED;

     }

     if (mNextUnblockedEvent == mPendingEvent) {

         mNextUnblockedEvent = NULL;

     }

     switch (mPendingEvent->type) {

     case EventEntry::TYPE_CONFIGURATION_CHANGED: {

         ConfigurationChangedEntry* typedEntry =

                 static_cast<ConfigurationChangedEntry*>(mPendingEvent);

         done = dispatchConfigurationChangedLocked(currentTime, typedEntry);

         dropReason = DROP_REASON_NOT_DROPPED; // configuration changes are never dropped

         break;

     }

     case EventEntry::TYPE_DEVICE_RESET: {

         DeviceResetEntry* typedEntry =

                 static_cast<DeviceResetEntry*>(mPendingEvent);

         done = dispatchDeviceResetLocked(currentTime, typedEntry);

         dropReason = DROP_REASON_NOT_DROPPED; // device resets are never dropped

         break;

     }

     case EventEntry::TYPE_KEY: {

         KeyEntry* typedEntry = static_cast<KeyEntry*>(mPendingEvent);

         if (isAppSwitchDue) {

             if (isAppSwitchKeyEventLocked(typedEntry)) {

                 resetPendingAppSwitchLocked(true);

                 isAppSwitchDue = false;

             } else if (dropReason == DROP_REASON_NOT_DROPPED) {

                 dropReason = DROP_REASON_APP_SWITCH;

             }

         }

         if (dropReason == DROP_REASON_NOT_DROPPED

                 && isStaleEventLocked(currentTime, typedEntry)) {

             dropReason = DROP_REASON_STALE;

         }

         if (dropReason == DROP_REASON_NOT_DROPPED && mNextUnblockedEvent) {

             dropReason = DROP_REASON_BLOCKED;

         }

         done = dispatchKeyLocked(currentTime, typedEntry, &dropReason, nextWakeupTime);

         break;

     }

     case EventEntry::TYPE_MOTION: {

         MotionEntry* typedEntry = static_cast<MotionEntry*>(mPendingEvent);

         if (dropReason == DROP_REASON_NOT_DROPPED && isAppSwitchDue) {

             dropReason = DROP_REASON_APP_SWITCH;

         }

         if (dropReason == DROP_REASON_NOT_DROPPED

                 && isStaleEventLocked(currentTime, typedEntry)) {

             dropReason = DROP_REASON_STALE;

         }

         if (dropReason == DROP_REASON_NOT_DROPPED && mNextUnblockedEvent) {

             dropReason = DROP_REASON_BLOCKED;

         }

         done = dispatchMotionLocked(currentTime, typedEntry,

                 &dropReason, nextWakeupTime);

         break;

     }

     default:

         ALOG_ASSERT(false);

         break;

     }

     if (done) {

         if (dropReason != DROP_REASON_NOT_DROPPED) {

             dropInboundEventLocked(mPendingEvent, dropReason);

         }

         releasePendingEventLocked();

         *nextWakeupTime = LONG_LONG_MIN;  // force next poll to wake up immediately

     }

 }

 bool InputDispatcher::enqueueInboundEventLocked(EventEntry* entry) {

     bool needWake = mInboundQueue.isEmpty();

     mInboundQueue.enqueueAtTail(entry);

     traceInboundQueueLengthLocked();

     switch (entry->type) {

     case EventEntry::TYPE_KEY: {

         // Optimize app switch latency.

         // If the application takes too long to catch up then we drop all events preceding

         // the app switch key.

         KeyEntry* keyEntry = static_cast<KeyEntry*>(entry);

         if (isAppSwitchKeyEventLocked(keyEntry)) {

             if (keyEntry->action == AKEY_EVENT_ACTION_DOWN) {

                 mAppSwitchSawKeyDown = true;

             } else if (keyEntry->action == AKEY_EVENT_ACTION_UP) {

                 if (mAppSwitchSawKeyDown) {

 #if DEBUG_APP_SWITCH

                     ALOGD("App switch is pending!");

 #endif

                     mAppSwitchDueTime = keyEntry->eventTime + APP_SWITCH_TIMEOUT;

                     mAppSwitchSawKeyDown = false;

                     needWake = true;

                 }

             }

         }

         break;

     }

     case EventEntry::TYPE_MOTION: {

         // Optimize case where the current application is unresponsive and the user

         // decides to touch a window in a different application.

         // If the application takes too long to catch up then we drop all events preceding

         // the touch into the other window.

         MotionEntry* motionEntry = static_cast<MotionEntry*>(entry);

         if (motionEntry->action == AMOTION_EVENT_ACTION_DOWN

                 && (motionEntry->source & AINPUT_SOURCE_CLASS_POINTER)

                 && mInputTargetWaitCause == INPUT_TARGET_WAIT_CAUSE_APPLICATION_NOT_READY

                 && mInputTargetWaitApplicationHandle != NULL) {

             int32_t displayId = motionEntry->displayId;

             int32_t x = int32_t(motionEntry->pointerCoords[0].

                     getAxisValue(AMOTION_EVENT_AXIS_X));

             int32_t y = int32_t(motionEntry->pointerCoords[0].

                     getAxisValue(AMOTION_EVENT_AXIS_Y));

             sp<InputWindowHandle> touchedWindowHandle = findTouchedWindowAtLocked(displayId, x, y);

             if (touchedWindowHandle != NULL

                     && touchedWindowHandle->inputApplicationHandle

                             != mInputTargetWaitApplicationHandle) {

                 // User touched a different application than the one we are waiting on.

                 // Flag the event, and start pruning the input queue.

                 mNextUnblockedEvent = motionEntry;

                 needWake = true;

             }

         }

         break;

     }

     }

     return needWake;

 }

 sp<InputWindowHandle> InputDispatcher::findTouchedWindowAtLocked(int32_t displayId,

         int32_t x, int32_t y) {

     // Traverse windows from front to back to find touched window.

     size_t numWindows = mWindowHandles.size();

     for (size_t i = 0; i < numWindows; i++) {

         sp<InputWindowHandle> windowHandle = mWindowHandles.itemAt(i);

         const InputWindowInfo* windowInfo = windowHandle->getInfo();

         if (windowInfo->displayId == displayId) {

             int32_t flags = windowInfo->layoutParamsFlags;

             if (windowInfo->visible) {

                 if (!(flags & InputWindowInfo::FLAG_NOT_TOUCHABLE)) {

                     bool isTouchModal = (flags & (InputWindowInfo::FLAG_NOT_FOCUSABLE

                             | InputWindowInfo::FLAG_NOT_TOUCH_MODAL)) == 0;

                     if (isTouchModal || windowInfo->touchableRegionContainsPoint(x, y)) {

                         // Found window.

                         return windowHandle;

                     }

                 }

             }

             if (flags & InputWindowInfo::FLAG_SYSTEM_ERROR) {

                 // Error window is on top but not visible, so touch is dropped.

                 return NULL;

             }

         }

     }

     return NULL;

 }

 void InputDispatcher::dropInboundEventLocked(EventEntry* entry, DropReason dropReason) {

     const char* reason;

     switch (dropReason) {

     case DROP_REASON_POLICY:

 #if DEBUG_INBOUND_EVENT_DETAILS

         ALOGD("Dropped event because policy consumed it.");

 #endif

         reason = "inbound event was dropped because the policy consumed it";

         break;

     case DROP_REASON_DISABLED:

         ALOGI("Dropped event because input dispatch is disabled.");

         reason = "inbound event was dropped because input dispatch is disabled";

         break;

     case DROP_REASON_APP_SWITCH:

         ALOGI("Dropped event because of pending overdue app switch.");

         reason = "inbound event was dropped because of pending overdue app switch";

         break;

     case DROP_REASON_BLOCKED:

         ALOGI("Dropped event because the current application is not responding and the user "

                 "has started interacting with a different application.");

         reason = "inbound event was dropped because the current application is not responding "

                 "and the user has started interacting with a different application";

         break;

     case DROP_REASON_STALE:

         ALOGI("Dropped event because it is stale.");

         reason = "inbound event was dropped because it is stale";

         break;

     default:

         ALOG_ASSERT(false);

         return;

     }

     switch (entry->type) {

     case EventEntry::TYPE_KEY: {

         CancelationOptions options(CancelationOptions::CANCEL_NON_POINTER_EVENTS, reason);

         synthesizeCancelationEventsForAllConnectionsLocked(options);

         break;

     }

     case EventEntry::TYPE_MOTION: {

         MotionEntry* motionEntry = static_cast<MotionEntry*>(entry);

         if (motionEntry->source & AINPUT_SOURCE_CLASS_POINTER) {

             CancelationOptions options(CancelationOptions::CANCEL_POINTER_EVENTS, reason);

             synthesizeCancelationEventsForAllConnectionsLocked(options);

         } else {

             CancelationOptions options(CancelationOptions::CANCEL_NON_POINTER_EVENTS, reason);

             synthesizeCancelationEventsForAllConnectionsLocked(options);

         }

         break;

     }

     }

 }

 bool InputDispatcher::isAppSwitchKeyCode(int32_t keyCode) {

     return keyCode == AKEYCODE_HOME

             || keyCode == AKEYCODE_ENDCALL

             || keyCode == AKEYCODE_APP_SWITCH;

 }

 bool InputDispatcher::isAppSwitchKeyEventLocked(KeyEntry* keyEntry) {

     return ! (keyEntry->flags & AKEY_EVENT_FLAG_CANCELED)

             && isAppSwitchKeyCode(keyEntry->keyCode)

             && (keyEntry->policyFlags & POLICY_FLAG_TRUSTED)

             && (keyEntry->policyFlags & POLICY_FLAG_PASS_TO_USER);

 }

 bool InputDispatcher::isAppSwitchPendingLocked() {

     return mAppSwitchDueTime != LONG_LONG_MAX;

 }

 void InputDispatcher::resetPendingAppSwitchLocked(bool handled) {

     mAppSwitchDueTime = LONG_LONG_MAX;

 #if DEBUG_APP_SWITCH

     if (handled) {

         ALOGD("App switch has arrived.");

     } else {

         ALOGD("App switch was abandoned.");

     }

 #endif

 }

 bool InputDispatcher::isStaleEventLocked(nsecs_t currentTime, EventEntry* entry) {

     return currentTime - entry->eventTime >= STALE_EVENT_TIMEOUT;

 }

 bool InputDispatcher::haveCommandsLocked() const {

     return !mCommandQueue.isEmpty();

 }

 bool InputDispatcher::runCommandsLockedInterruptible() {

     if (mCommandQueue.isEmpty()) {

         return false;

     }

     do {

         CommandEntry* commandEntry = mCommandQueue.dequeueAtHead();

         Command command = commandEntry->command;

         (this->*command)(commandEntry); // commands are implicitly 'LockedInterruptible'

         commandEntry->connection.clear();

         delete commandEntry;

     } while (! mCommandQueue.isEmpty());

     return true;

 }

 InputDispatcher::CommandEntry* InputDispatcher::postCommandLocked(Command command) {

     CommandEntry* commandEntry = new CommandEntry(command);

     mCommandQueue.enqueueAtTail(commandEntry);

     return commandEntry;

 }

 void InputDispatcher::drainInboundQueueLocked() {

     while (! mInboundQueue.isEmpty()) {

         EventEntry* entry = mInboundQueue.dequeueAtHead();

         releaseInboundEventLocked(entry);

     }

     traceInboundQueueLengthLocked();

 }

 void InputDispatcher::releasePendingEventLocked() {

     if (mPendingEvent) {

         resetANRTimeoutsLocked();

         releaseInboundEventLocked(mPendingEvent);

         mPendingEvent = NULL;

     }

 }

 void InputDispatcher::releaseInboundEventLocked(EventEntry* entry) {

     InjectionState* injectionState = entry->injectionState;

     if (injectionState && injectionState->injectionResult == INPUT_EVENT_INJECTION_PENDING) {

 #if DEBUG_DISPATCH_CYCLE

         ALOGD("Injected inbound event was dropped.");

 #endif

         setInjectionResultLocked(entry, INPUT_EVENT_INJECTION_FAILED);

     }

     if (entry == mNextUnblockedEvent) {

         mNextUnblockedEvent = NULL;

     }

     entry->release();

 }

 void InputDispatcher::resetKeyRepeatLocked() {

     if (mKeyRepeatState.lastKeyEntry) {

         mKeyRepeatState.lastKeyEntry->release();

         mKeyRepeatState.lastKeyEntry = NULL;

     }

 }

 InputDispatcher::KeyEntry* InputDispatcher::synthesizeKeyRepeatLocked(nsecs_t currentTime) {

     KeyEntry* entry = mKeyRepeatState.lastKeyEntry;

     // Reuse the repeated key entry if it is otherwise unreferenced.

     uint32_t policyFlags = (entry->policyFlags & POLICY_FLAG_RAW_MASK)

             | POLICY_FLAG_PASS_TO_USER | POLICY_FLAG_TRUSTED;

     if (entry->refCount == 1) {

         entry->recycle();

         entry->eventTime = currentTime;

         entry->policyFlags = policyFlags;

         entry->repeatCount += 1;

     } else {

         KeyEntry* newEntry = new KeyEntry(currentTime,

                 entry->deviceId, entry->source, policyFlags,

                 entry->action, entry->flags, entry->keyCode, entry->scanCode,

                 entry->metaState, entry->repeatCount + 1, entry->downTime);

         mKeyRepeatState.lastKeyEntry = newEntry;

         entry->release();

         entry = newEntry;

     }

     entry->syntheticRepeat = true;

     // Increment reference count since we keep a reference to the event in

     // mKeyRepeatState.lastKeyEntry in addition to the one we return.

     entry->refCount += 1;

     mKeyRepeatState.nextRepeatTime = currentTime + mConfig.keyRepeatDelay;

     return entry;

 }

 bool InputDispatcher::dispatchConfigurationChangedLocked(

         nsecs_t currentTime, ConfigurationChangedEntry* entry) {

 #if DEBUG_OUTBOUND_EVENT_DETAILS

     ALOGD("dispatchConfigurationChanged - eventTime=%lld", entry->eventTime);

 #endif

     // Reset key repeating in case a keyboard device was added or removed or something.

     resetKeyRepeatLocked();

     // Enqueue a command to run outside the lock to tell the policy that the configuration changed.

     CommandEntry* commandEntry = postCommandLocked(

             & InputDispatcher::doNotifyConfigurationChangedInterruptible);

     commandEntry->eventTime = entry->eventTime;

     return true;

 }

 bool InputDispatcher::dispatchDeviceResetLocked(

         nsecs_t currentTime, DeviceResetEntry* entry) {

 #if DEBUG_OUTBOUND_EVENT_DETAILS

     ALOGD("dispatchDeviceReset - eventTime=%lld, deviceId=%d", entry->eventTime, entry->deviceId);

 #endif

     CancelationOptions options(CancelationOptions::CANCEL_ALL_EVENTS,

             "device was reset");

     options.deviceId = entry->deviceId;

     synthesizeCancelationEventsForAllConnectionsLocked(options);

     return true;

 }

 bool InputDispatcher::dispatchKeyLocked(nsecs_t currentTime, KeyEntry* entry,

         DropReason* dropReason, nsecs_t* nextWakeupTime) {

     // Preprocessing.

     if (! entry->dispatchInProgress) {

         if (entry->repeatCount == 0

                 && entry->action == AKEY_EVENT_ACTION_DOWN

                 && (entry->policyFlags & POLICY_FLAG_TRUSTED)

                 && (!(entry->policyFlags & POLICY_FLAG_DISABLE_KEY_REPEAT))) {

             if (mKeyRepeatState.lastKeyEntry

                     && mKeyRepeatState.lastKeyEntry->keyCode == entry->keyCode) {

                 // We have seen two identical key downs in a row which indicates that the device

                 // driver is automatically generating key repeats itself.  We take note of the

                 // repeat here, but we disable our own next key repeat timer since it is clear that

                 // we will not need to synthesize key repeats ourselves.

                 entry->repeatCount = mKeyRepeatState.lastKeyEntry->repeatCount + 1;

                 resetKeyRepeatLocked();

                 mKeyRepeatState.nextRepeatTime = LONG_LONG_MAX; // don't generate repeats ourselves

             } else {

                 // Not a repeat.  Save key down state in case we do see a repeat later.

                 resetKeyRepeatLocked();

                 mKeyRepeatState.nextRepeatTime = entry->eventTime + mConfig.keyRepeatTimeout;

             }

             mKeyRepeatState.lastKeyEntry = entry;

             entry->refCount += 1;

         } else if (! entry->syntheticRepeat) {

             resetKeyRepeatLocked();

         }

         if (entry->repeatCount == 1) {

             entry->flags |= AKEY_EVENT_FLAG_LONG_PRESS;

         } else {

             entry->flags &= ~AKEY_EVENT_FLAG_LONG_PRESS;

         }

         entry->dispatchInProgress = true;

         logOutboundKeyDetailsLocked("dispatchKey - ", entry);

     }

     // Handle case where the policy asked us to try again later last time.

     if (entry->interceptKeyResult == KeyEntry::INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER) {

         if (currentTime < entry->interceptKeyWakeupTime) {

             if (entry->interceptKeyWakeupTime < *nextWakeupTime) {

                 *nextWakeupTime = entry->interceptKeyWakeupTime;

             }

             return false; // wait until next wakeup

         }

         entry->interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_UNKNOWN;

         entry->interceptKeyWakeupTime = 0;

     }

     // Give the policy a chance to intercept the key.

     if (entry->interceptKeyResult == KeyEntry::INTERCEPT_KEY_RESULT_UNKNOWN) {

         if (entry->policyFlags & POLICY_FLAG_PASS_TO_USER) {

             CommandEntry* commandEntry = postCommandLocked(

                     & InputDispatcher::doInterceptKeyBeforeDispatchingLockedInterruptible);

             if (mFocusedWindowHandle != NULL) {

                 commandEntry->inputWindowHandle = mFocusedWindowHandle;

             }

             commandEntry->keyEntry = entry;

             entry->refCount += 1;

             return false; // wait for the command to run

         } else {

             entry->interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_CONTINUE;

         }

     } else if (entry->interceptKeyResult == KeyEntry::INTERCEPT_KEY_RESULT_SKIP) {

         if (*dropReason == DROP_REASON_NOT_DROPPED) {

             *dropReason = DROP_REASON_POLICY;

         }

     }

     // Clean up if dropping the event.

     if (*dropReason != DROP_REASON_NOT_DROPPED) {

         setInjectionResultLocked(entry, *dropReason == DROP_REASON_POLICY

                 ? INPUT_EVENT_INJECTION_SUCCEEDED : INPUT_EVENT_INJECTION_FAILED);

         return true;

     }

     // Identify targets.

     Vector<InputTarget> inputTargets;

     int32_t injectionResult = findFocusedWindowTargetsLocked(currentTime,

             entry, inputTargets, nextWakeupTime);

     if (injectionResult == INPUT_EVENT_INJECTION_PENDING) {

         return false;

     }

     setInjectionResultLocked(entry, injectionResult);

     if (injectionResult != INPUT_EVENT_INJECTION_SUCCEEDED) {

         return true;

     }

     addMonitoringTargetsLocked(inputTargets);

     // Dispatch the key.

     dispatchEventLocked(currentTime, entry, inputTargets);

     return true;

 }

 void InputDispatcher::logOutboundKeyDetailsLocked(const char* prefix, const KeyEntry* entry) {

 #if DEBUG_OUTBOUND_EVENT_DETAILS

     ALOGD("%seventTime=%lld, deviceId=%d, source=0x%x, policyFlags=0x%x, "

             "action=0x%x, flags=0x%x, keyCode=0x%x, scanCode=0x%x, metaState=0x%x, "

             "repeatCount=%d, downTime=%lld",

             prefix,

             entry->eventTime, entry->deviceId, entry->source, entry->policyFlags,

             entry->action, entry->flags, entry->keyCode, entry->scanCode, entry->metaState,

             entry->repeatCount, entry->downTime);

 #endif

 }

 bool InputDispatcher::dispatchMotionLocked(

         nsecs_t currentTime, MotionEntry* entry, DropReason* dropReason, nsecs_t* nextWakeupTime) {

     // Preprocessing.

     if (! entry->dispatchInProgress) {

         entry->dispatchInProgress = true;

         logOutboundMotionDetailsLocked("dispatchMotion - ", entry);

     }

     // Clean up if dropping the event.

     if (*dropReason != DROP_REASON_NOT_DROPPED) {

         setInjectionResultLocked(entry, *dropReason == DROP_REASON_POLICY

                 ? INPUT_EVENT_INJECTION_SUCCEEDED : INPUT_EVENT_INJECTION_FAILED);

         return true;

     }

     bool isPointerEvent = entry->source & AINPUT_SOURCE_CLASS_POINTER;

     // Identify targets.

     Vector<InputTarget> inputTargets;

     bool conflictingPointerActions = false;

     int32_t injectionResult;

     if (isPointerEvent) {

         // Pointer event.  (eg. touchscreen)

         injectionResult = findTouchedWindowTargetsLocked(currentTime,

                 entry, inputTargets, nextWakeupTime, &conflictingPointerActions);

     } else {

         // Non touch event.  (eg. trackball)

         injectionResult = findFocusedWindowTargetsLocked(currentTime,

                 entry, inputTargets, nextWakeupTime);

     }

     if (injectionResult == INPUT_EVENT_INJECTION_PENDING) {

         return false;

     }

     setInjectionResultLocked(entry, injectionResult);

     if (injectionResult != INPUT_EVENT_INJECTION_SUCCEEDED) {

         return true;

     }

     // TODO: support sending secondary display events to input monitors

     if (isMainDisplay(entry->displayId)) {

         addMonitoringTargetsLocked(inputTargets);

     }

     // Dispatch the motion.

     if (conflictingPointerActions) {

         CancelationOptions options(CancelationOptions::CANCEL_POINTER_EVENTS,

                 "conflicting pointer actions");

         synthesizeCancelationEventsForAllConnectionsLocked(options);

     }

     dispatchEventLocked(currentTime, entry, inputTargets);

     return true;

 }

 void InputDispatcher::logOutboundMotionDetailsLocked(const char* prefix, const MotionEntry* entry) {

 #if DEBUG_OUTBOUND_EVENT_DETAILS

     ALOGD("%seventTime=%lld, deviceId=%d, source=0x%x, policyFlags=0x%x, "

             "action=0x%x, flags=0x%x, "

             "metaState=0x%x, buttonState=0x%x, "

             "edgeFlags=0x%x, xPrecision=%f, yPrecision=%f, downTime=%lld",

             prefix,

             entry->eventTime, entry->deviceId, entry->source, entry->policyFlags,

             entry->action, entry->flags,

             entry->metaState, entry->buttonState,

             entry->edgeFlags, entry->xPrecision, entry->yPrecision,

             entry->downTime);

     for (uint32_t i = 0; i < entry->pointerCount; i++) {

         ALOGD("  Pointer %d: id=%d, toolType=%d, "

                 "x=%f, y=%f, pressure=%f, size=%f, "

                 "touchMajor=%f, touchMinor=%f, toolMajor=%f, toolMinor=%f, "

                 "orientation=%f",

                 i, entry->pointerProperties[i].id,

                 entry->pointerProperties[i].toolType,

                 entry->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_X),

                 entry->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_Y),

                 entry->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_PRESSURE),

                 entry->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_SIZE),

                 entry->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR),

                 entry->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR),

                 entry->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR),

                 entry->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR),

                 entry->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION));

     }

 #endif

 }

 void InputDispatcher::dispatchEventLocked(nsecs_t currentTime,

         EventEntry* eventEntry, const Vector<InputTarget>& inputTargets) {

 #if DEBUG_DISPATCH_CYCLE

     ALOGD("dispatchEventToCurrentInputTargets");

 #endif

     ALOG_ASSERT(eventEntry->dispatchInProgress); // should already have been set to true

     pokeUserActivityLocked(eventEntry);

     for (size_t i = 0; i < inputTargets.size(); i++) {

         const InputTarget& inputTarget = inputTargets.itemAt(i);

         ssize_t connectionIndex = getConnectionIndexLocked(inputTarget.inputChannel);

         if (connectionIndex >= 0) {

             sp<Connection> connection = mConnectionsByFd.valueAt(connectionIndex);

             prepareDispatchCycleLocked(currentTime, connection, eventEntry, &inputTarget);

         } else {

 #if DEBUG_FOCUS

             ALOGD("Dropping event delivery to target with channel '%s' because it "

                     "is no longer registered with the input dispatcher.",

                     inputTarget.inputChannel->getName().string());

 #endif

         }

     }

 }

 int32_t InputDispatcher::handleTargetsNotReadyLocked(nsecs_t currentTime,

         const EventEntry* entry,

         const sp<InputApplicationHandle>& applicationHandle,

         const sp<InputWindowHandle>& windowHandle,

         nsecs_t* nextWakeupTime, const char* reason) {

     if (applicationHandle == NULL && windowHandle == NULL) {

         if (mInputTargetWaitCause != INPUT_TARGET_WAIT_CAUSE_SYSTEM_NOT_READY) {

 #if DEBUG_FOCUS

             ALOGD("Waiting for system to become ready for input.  Reason: %s", reason);

 #endif

             mInputTargetWaitCause = INPUT_TARGET_WAIT_CAUSE_SYSTEM_NOT_READY;

             mInputTargetWaitStartTime = currentTime;

             mInputTargetWaitTimeoutTime = LONG_LONG_MAX;

             mInputTargetWaitTimeoutExpired = false;

             mInputTargetWaitApplicationHandle.clear();

         }

     } else {

         if (mInputTargetWaitCause != INPUT_TARGET_WAIT_CAUSE_APPLICATION_NOT_READY) {

 #if DEBUG_FOCUS

             ALOGD("Waiting for application to become ready for input: %s.  Reason: %s",

                     getApplicationWindowLabelLocked(applicationHandle, windowHandle).string(),

                     reason);

 #endif

             nsecs_t timeout;

             if (windowHandle != NULL) {

                 timeout = windowHandle->getDispatchingTimeout(DEFAULT_INPUT_DISPATCHING_TIMEOUT);

             } else if (applicationHandle != NULL) {

                 timeout = applicationHandle->getDispatchingTimeout(

                         DEFAULT_INPUT_DISPATCHING_TIMEOUT);

             } else {

                 timeout = DEFAULT_INPUT_DISPATCHING_TIMEOUT;

             }

             mInputTargetWaitCause = INPUT_TARGET_WAIT_CAUSE_APPLICATION_NOT_READY;

             mInputTargetWaitStartTime = currentTime;

             mInputTargetWaitTimeoutTime = currentTime + timeout;

             mInputTargetWaitTimeoutExpired = false;

             mInputTargetWaitApplicationHandle.clear();

             if (windowHandle != NULL) {

                 mInputTargetWaitApplicationHandle = windowHandle->inputApplicationHandle;

             }

             if (mInputTargetWaitApplicationHandle == NULL && applicationHandle != NULL) {

                 mInputTargetWaitApplicationHandle = applicationHandle;

             }

         }

     }

     if (mInputTargetWaitTimeoutExpired) {

         return INPUT_EVENT_INJECTION_TIMED_OUT;

     }

     if (currentTime >= mInputTargetWaitTimeoutTime) {

         onANRLocked(currentTime, applicationHandle, windowHandle,

                 entry->eventTime, mInputTargetWaitStartTime, reason);

         // Force poll loop to wake up immediately on next iteration once we get the

         // ANR response back from the policy.

         *nextWakeupTime = LONG_LONG_MIN;

         return INPUT_EVENT_INJECTION_PENDING;

     } else {

         // Force poll loop to wake up when timeout is due.

         if (mInputTargetWaitTimeoutTime < *nextWakeupTime) {

             *nextWakeupTime = mInputTargetWaitTimeoutTime;

         }

         return INPUT_EVENT_INJECTION_PENDING;

     }

 }

 void InputDispatcher::resumeAfterTargetsNotReadyTimeoutLocked(nsecs_t newTimeout,

         const sp<InputChannel>& inputChannel) {

     if (newTimeout > 0) {

         // Extend the timeout.

         mInputTargetWaitTimeoutTime = now() + newTimeout;

     } else {

         // Give up.

         mInputTargetWaitTimeoutExpired = true;

         // Input state will not be realistic.  Mark it out of sync.

         if (inputChannel.get()) {

             ssize_t connectionIndex = getConnectionIndexLocked(inputChannel);

             if (connectionIndex >= 0) {

                 sp<Connection> connection = mConnectionsByFd.valueAt(connectionIndex);

                 sp<InputWindowHandle> windowHandle = connection->inputWindowHandle;

                 if (windowHandle != NULL) {

                     mTouchState.removeWindow(windowHandle);

                 }

                 if (connection->status == Connection::STATUS_NORMAL) {

                     CancelationOptions options(CancelationOptions::CANCEL_ALL_EVENTS,

                             "application not responding");

                     synthesizeCancelationEventsForConnectionLocked(connection, options);

                 }

             }

         }

     }

 }

 nsecs_t InputDispatcher::getTimeSpentWaitingForApplicationLocked(

         nsecs_t currentTime) {

     if (mInputTargetWaitCause == INPUT_TARGET_WAIT_CAUSE_APPLICATION_NOT_READY) {

         return currentTime - mInputTargetWaitStartTime;

     }

     return 0;

 }

 void InputDispatcher::resetANRTimeoutsLocked() {

 #if DEBUG_FOCUS

         ALOGD("Resetting ANR timeouts.");

 #endif

     // Reset input target wait timeout.

     mInputTargetWaitCause = INPUT_TARGET_WAIT_CAUSE_NONE;

     mInputTargetWaitApplicationHandle.clear();

 }

 int32_t InputDispatcher::findFocusedWindowTargetsLocked(nsecs_t currentTime,

         const EventEntry* entry, Vector<InputTarget>& inputTargets, nsecs_t* nextWakeupTime) {

     int32_t injectionResult;

     // If there is no currently focused window and no focused application

     // then drop the event.

     if (mFocusedWindowHandle == NULL) {

         if (mFocusedApplicationHandle != NULL) {

             injectionResult = handleTargetsNotReadyLocked(currentTime, entry,

                     mFocusedApplicationHandle, NULL, nextWakeupTime,

                     "Waiting because no window has focus but there is a "

                     "focused application that may eventually add a window "

                     "when it finishes starting up.");

             goto Unresponsive;

         }

         ALOGI("Dropping event because there is no focused window or focused application.");

         injectionResult = INPUT_EVENT_INJECTION_FAILED;

         goto Failed;

     }

     // Check permissions.

     if (! checkInjectionPermission(mFocusedWindowHandle, entry->injectionState)) {

         injectionResult = INPUT_EVENT_INJECTION_PERMISSION_DENIED;

         goto Failed;

     }

     // If the currently focused window is paused then keep waiting.

     if (mFocusedWindowHandle->getInfo()->paused) {

         injectionResult = handleTargetsNotReadyLocked(currentTime, entry,

                 mFocusedApplicationHandle, mFocusedWindowHandle, nextWakeupTime,

                 "Waiting because the focused window is paused.");

         goto Unresponsive;

     }

     // If the currently focused window is still working on previous events then keep waiting.

     if (!isWindowReadyForMoreInputLocked(currentTime, mFocusedWindowHandle, entry)) {

         injectionResult = handleTargetsNotReadyLocked(currentTime, entry,

                 mFocusedApplicationHandle, mFocusedWindowHandle, nextWakeupTime,

                 "Waiting because the focused window has not finished "

                 "processing the input events that were previously delivered to it.");

         goto Unresponsive;

     }

     // Success!  Output targets.

     injectionResult = INPUT_EVENT_INJECTION_SUCCEEDED;

     addWindowTargetLocked(mFocusedWindowHandle,

             InputTarget::FLAG_FOREGROUND | InputTarget::FLAG_DISPATCH_AS_IS, BitSet32(0),

             inputTargets);

     // Done.

 Failed:

 Unresponsive:

     nsecs_t timeSpentWaitingForApplication = getTimeSpentWaitingForApplicationLocked(currentTime);

     updateDispatchStatisticsLocked(currentTime, entry,

             injectionResult, timeSpentWaitingForApplication);

 #if DEBUG_FOCUS

     ALOGD("findFocusedWindow finished: injectionResult=%d, "

             "timeSpentWaitingForApplication=%0.1fms",

             injectionResult, timeSpentWaitingForApplication / 1000000.0);

 #endif

     return injectionResult;

 }

 int32_t InputDispatcher::findTouchedWindowTargetsLocked(nsecs_t currentTime,

         const MotionEntry* entry, Vector<InputTarget>& inputTargets, nsecs_t* nextWakeupTime,

         bool* outConflictingPointerActions) {

     enum InjectionPermission {

         INJECTION_PERMISSION_UNKNOWN,

         INJECTION_PERMISSION_GRANTED,

         INJECTION_PERMISSION_DENIED

     };

     nsecs_t startTime = now();

     // For security reasons, we defer updating the touch state until we are sure that

     // event injection will be allowed.

     //

     // FIXME In the original code, screenWasOff could never be set to true.

     //       The reason is that the POLICY_FLAG_WOKE_HERE

     //       and POLICY_FLAG_BRIGHT_HERE flags were set only when preprocessing raw

     //       EV_KEY, EV_REL and EV_ABS events.  As it happens, the touch event was

     //       actually enqueued using the policyFlags that appeared in the final EV_SYN

     //       events upon which no preprocessing took place.  So policyFlags was always 0.

     //       In the new native input dispatcher we're a bit more careful about event

     //       preprocessing so the touches we receive can actually have non-zero policyFlags.

     //       Unfortunately we obtain undesirable behavior.

     //

     //       Here's what happens:

     //

     //       When the device dims in anticipation of going to sleep, touches

     //       in windows which have FLAG_TOUCHABLE_WHEN_WAKING cause

     //       the device to brighten and reset the user activity timer.

     //       Touches on other windows (such as the launcher window)

     //       are dropped.  Then after a moment, the device goes to sleep.  Oops.

     //

     //       Also notice how screenWasOff was being initialized using POLICY_FLAG_BRIGHT_HERE

     //       instead of POLICY_FLAG_WOKE_HERE...

     //

     bool screenWasOff = false; // original policy: policyFlags & POLICY_FLAG_BRIGHT_HERE;

     int32_t displayId = entry->displayId;

     int32_t action = entry->action;

     int32_t maskedAction = action & AMOTION_EVENT_ACTION_MASK;

     // Update the touch state as needed based on the properties of the touch event.

     int32_t injectionResult = INPUT_EVENT_INJECTION_PENDING;

     InjectionPermission injectionPermission = INJECTION_PERMISSION_UNKNOWN;

     sp<InputWindowHandle> newHoverWindowHandle;

     bool isSplit = mTouchState.split;

     bool switchedDevice = mTouchState.deviceId >= 0 && mTouchState.displayId >= 0

             && (mTouchState.deviceId != entry->deviceId

                     || mTouchState.source != entry->source

                     || mTouchState.displayId != displayId);

     bool isHoverAction = (maskedAction == AMOTION_EVENT_ACTION_HOVER_MOVE

             || maskedAction == AMOTION_EVENT_ACTION_HOVER_ENTER

             || maskedAction == AMOTION_EVENT_ACTION_HOVER_EXIT);

     bool newGesture = (maskedAction == AMOTION_EVENT_ACTION_DOWN

             || maskedAction == AMOTION_EVENT_ACTION_SCROLL

             || isHoverAction);

     bool wrongDevice = false;

     if (newGesture) {

         bool down = maskedAction == AMOTION_EVENT_ACTION_DOWN;

         if (switchedDevice && mTouchState.down && !down) {

 #if DEBUG_FOCUS

             ALOGD("Dropping event because a pointer for a different device is already down.");

 #endif

             mTempTouchState.copyFrom(mTouchState);

             injectionResult = INPUT_EVENT_INJECTION_FAILED;

             switchedDevice = false;

             wrongDevice = true;

             goto Failed;

         }

         mTempTouchState.reset();

         mTempTouchState.down = down;

         mTempTouchState.deviceId = entry->deviceId;

         mTempTouchState.source = entry->source;

         mTempTouchState.displayId = displayId;

         isSplit = false;

     } else {

         mTempTouchState.copyFrom(mTouchState);

     }

     if (newGesture || (isSplit && maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN)) {

         /* Case 1: New splittable pointer going down, or need target for hover or scroll. */

         int32_t pointerIndex = getMotionEventActionPointerIndex(action);

         int32_t x = int32_t(entry->pointerCoords[pointerIndex].

                 getAxisValue(AMOTION_EVENT_AXIS_X));

         int32_t y = int32_t(entry->pointerCoords[pointerIndex].

                 getAxisValue(AMOTION_EVENT_AXIS_Y));

         sp<InputWindowHandle> newTouchedWindowHandle;

         sp<InputWindowHandle> topErrorWindowHandle;

         bool isTouchModal = false;

         // Traverse windows from front to back to find touched window and outside targets.

         size_t numWindows = mWindowHandles.size();

         for (size_t i = 0; i < numWindows; i++) {

             sp<InputWindowHandle> windowHandle = mWindowHandles.itemAt(i);

             const InputWindowInfo* windowInfo = windowHandle->getInfo();

             if (windowInfo->displayId != displayId) {

                 continue; // wrong display

             }

             int32_t flags = windowInfo->layoutParamsFlags;

             if (flags & InputWindowInfo::FLAG_SYSTEM_ERROR) {

                 if (topErrorWindowHandle == NULL) {

                     topErrorWindowHandle = windowHandle;

                 }

             }

             if (windowInfo->visible) {

                 if (! (flags & InputWindowInfo::FLAG_NOT_TOUCHABLE)) {

                     isTouchModal = (flags & (InputWindowInfo::FLAG_NOT_FOCUSABLE

                             | InputWindowInfo::FLAG_NOT_TOUCH_MODAL)) == 0;

                     if (isTouchModal || windowInfo->touchableRegionContainsPoint(x, y)) {

                         if (! screenWasOff

                                 || (flags & InputWindowInfo::FLAG_TOUCHABLE_WHEN_WAKING)) {

                             newTouchedWindowHandle = windowHandle;

                         }

                         break; // found touched window, exit window loop

                     }

                 }

                 if (maskedAction == AMOTION_EVENT_ACTION_DOWN

                         && (flags & InputWindowInfo::FLAG_WATCH_OUTSIDE_TOUCH)) {

                     int32_t outsideTargetFlags = InputTarget::FLAG_DISPATCH_AS_OUTSIDE;

                     if (isWindowObscuredAtPointLocked(windowHandle, x, y)) {

                         outsideTargetFlags |= InputTarget::FLAG_WINDOW_IS_OBSCURED;

                     }

                     mTempTouchState.addOrUpdateWindow(

                             windowHandle, outsideTargetFlags, BitSet32(0));

                 }

             }

         }

         // If there is an error window but it is not taking focus (typically because

         // it is invisible) then wait for it.  Any other focused window may in

         // fact be in ANR state.

         if (topErrorWindowHandle != NULL && newTouchedWindowHandle != topErrorWindowHandle) {

             injectionResult = handleTargetsNotReadyLocked(currentTime, entry,

                     NULL, NULL, nextWakeupTime,

                     "Waiting because a system error window is about to be displayed.");

             injectionPermission = INJECTION_PERMISSION_UNKNOWN;

             goto Unresponsive;

         }

         // Figure out whether splitting will be allowed for this window.

         if (newTouchedWindowHandle != NULL

                 && newTouchedWindowHandle->getInfo()->supportsSplitTouch()) {

             // New window supports splitting.

             isSplit = true;

         } else if (isSplit) {

             // New window does not support splitting but we have already split events.

             // Ignore the new window.

             newTouchedWindowHandle = NULL;

         }

         // Handle the case where we did not find a window.

         if (newTouchedWindowHandle == NULL) {

             // Try to assign the pointer to the first foreground window we find, if there is one.

             newTouchedWindowHandle = mTempTouchState.getFirstForegroundWindowHandle();

             if (newTouchedWindowHandle == NULL) {

                 // There is no touched window.  If this is an initial down event

                 // then wait for a window to appear that will handle the touch.  This is

                 // to ensure that we report an ANR in the case where an application has started

                 // but not yet put up a window and the user is starting to get impatient.

                 if (maskedAction == AMOTION_EVENT_ACTION_DOWN

                         && mFocusedApplicationHandle != NULL) {

                     injectionResult = handleTargetsNotReadyLocked(currentTime, entry,

                             mFocusedApplicationHandle, NULL, nextWakeupTime,

                             "Waiting because there is no touchable window that can "

                             "handle the event but there is focused application that may "

                             "eventually add a new window when it finishes starting up.");

                     goto Unresponsive;

                 }

                 ALOGI("Dropping event because there is no touched window.");

                 injectionResult = INPUT_EVENT_INJECTION_FAILED;

                 goto Failed;

             }

         }

         // Set target flags.

         int32_t targetFlags = InputTarget::FLAG_FOREGROUND | InputTarget::FLAG_DISPATCH_AS_IS;

         if (isSplit) {

             targetFlags |= InputTarget::FLAG_SPLIT;

         }

         if (isWindowObscuredAtPointLocked(newTouchedWindowHandle, x, y)) {

             targetFlags |= InputTarget::FLAG_WINDOW_IS_OBSCURED;

         }

         // Update hover state.

         if (isHoverAction) {

             newHoverWindowHandle = newTouchedWindowHandle;

         } else if (maskedAction == AMOTION_EVENT_ACTION_SCROLL) {

             newHoverWindowHandle = mLastHoverWindowHandle;

         }

         // Update the temporary touch state.

         BitSet32 pointerIds;

         if (isSplit) {

             uint32_t pointerId = entry->pointerProperties[pointerIndex].id;

             pointerIds.markBit(pointerId);

         }

         mTempTouchState.addOrUpdateWindow(newTouchedWindowHandle, targetFlags, pointerIds);

     } else {

         /* Case 2: Pointer move, up, cancel or non-splittable pointer down. */

         // If the pointer is not currently down, then ignore the event.

         if (! mTempTouchState.down) {

 #if DEBUG_FOCUS

             ALOGD("Dropping event because the pointer is not down or we previously "

                     "dropped the pointer down event.");

 #endif

             injectionResult = INPUT_EVENT_INJECTION_FAILED;

             goto Failed;

         }

         // Check whether touches should slip outside of the current foreground window.

         if (maskedAction == AMOTION_EVENT_ACTION_MOVE

                 && entry->pointerCount == 1

                 && mTempTouchState.isSlippery()) {

             int32_t x = int32_t(entry->pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X));

             int32_t y = int32_t(entry->pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y));

             sp<InputWindowHandle> oldTouchedWindowHandle =

                     mTempTouchState.getFirstForegroundWindowHandle();

             sp<InputWindowHandle> newTouchedWindowHandle =

                     findTouchedWindowAtLocked(displayId, x, y);

             if (oldTouchedWindowHandle != newTouchedWindowHandle

                     && newTouchedWindowHandle != NULL) {

 #if DEBUG_FOCUS

                 ALOGD("Touch is slipping out of window %s into window %s.",

                         oldTouchedWindowHandle->getName().string(),

                         newTouchedWindowHandle->getName().string());

 #endif

                 // Make a slippery exit from the old window.

                 mTempTouchState.addOrUpdateWindow(oldTouchedWindowHandle,

                         InputTarget::FLAG_DISPATCH_AS_SLIPPERY_EXIT, BitSet32(0));

                 // Make a slippery entrance into the new window.

                 if (newTouchedWindowHandle->getInfo()->supportsSplitTouch()) {

                     isSplit = true;

                 }

                 int32_t targetFlags = InputTarget::FLAG_FOREGROUND

                         | InputTarget::FLAG_DISPATCH_AS_SLIPPERY_ENTER;

                 if (isSplit) {

                     targetFlags |= InputTarget::FLAG_SPLIT;

                 }

                 if (isWindowObscuredAtPointLocked(newTouchedWindowHandle, x, y)) {

                     targetFlags |= InputTarget::FLAG_WINDOW_IS_OBSCURED;

                 }

                 BitSet32 pointerIds;

                 if (isSplit) {

                     pointerIds.markBit(entry->pointerProperties[0].id);

                 }

                 mTempTouchState.addOrUpdateWindow(newTouchedWindowHandle, targetFlags, pointerIds);

             }

         }

     }

     if (newHoverWindowHandle != mLastHoverWindowHandle) {

         // Let the previous window know that the hover sequence is over.

         if (mLastHoverWindowHandle != NULL) {

 #if DEBUG_HOVER

             ALOGD("Sending hover exit event to window %s.",

                     mLastHoverWindowHandle->getName().string());

 #endif

             mTempTouchState.addOrUpdateWindow(mLastHoverWindowHandle,

                     InputTarget::FLAG_DISPATCH_AS_HOVER_EXIT, BitSet32(0));

         }

         // Let the new window know that the hover sequence is starting.

         if (newHoverWindowHandle != NULL) {

 #if DEBUG_HOVER

             ALOGD("Sending hover enter event to window %s.",

                     newHoverWindowHandle->getName().string());

 #endif

             mTempTouchState.addOrUpdateWindow(newHoverWindowHandle,

                     InputTarget::FLAG_DISPATCH_AS_HOVER_ENTER, BitSet32(0));

         }

     }

     // Check permission to inject into all touched foreground windows and ensure there

     // is at least one touched foreground window.

     {

         bool haveForegroundWindow = false;

         for (size_t i = 0; i < mTempTouchState.windows.size(); i++) {

             const TouchedWindow& touchedWindow = mTempTouchState.windows[i];

             if (touchedWindow.targetFlags & InputTarget::FLAG_FOREGROUND) {

                 haveForegroundWindow = true;

                 if (! checkInjectionPermission(touchedWindow.windowHandle,

                         entry->injectionState)) {

                     injectionResult = INPUT_EVENT_INJECTION_PERMISSION_DENIED;

                     injectionPermission = INJECTION_PERMISSION_DENIED;

                     goto Failed;

                 }

             }

         }

         if (! haveForegroundWindow) {

 #if DEBUG_FOCUS

             ALOGD("Dropping event because there is no touched foreground window to receive it.");

 #endif

             injectionResult = INPUT_EVENT_INJECTION_FAILED;

             goto Failed;

         }

         // Permission granted to injection into all touched foreground windows.

         injectionPermission = INJECTION_PERMISSION_GRANTED;

     }

     // Check whether windows listening for outside touches are owned by the same UID. If it is

     // set the policy flag that we will not reveal coordinate information to this window.

     if (maskedAction == AMOTION_EVENT_ACTION_DOWN) {

         sp<InputWindowHandle> foregroundWindowHandle =

                 mTempTouchState.getFirstForegroundWindowHandle();

         const int32_t foregroundWindowUid = foregroundWindowHandle->getInfo()->ownerUid;

         for (size_t i = 0; i < mTempTouchState.windows.size(); i++) {

             const TouchedWindow& touchedWindow = mTempTouchState.windows[i];

             if (touchedWindow.targetFlags & InputTarget::FLAG_DISPATCH_AS_OUTSIDE) {

                 sp<InputWindowHandle> inputWindowHandle = touchedWindow.windowHandle;

                 if (inputWindowHandle->getInfo()->ownerUid != foregroundWindowUid) {

                     mTempTouchState.addOrUpdateWindow(inputWindowHandle,

                             InputTarget::FLAG_ZERO_COORDS, BitSet32(0));

                 }

             }

         }

     }

     // Ensure all touched foreground windows are ready for new input.

     for (size_t i = 0; i < mTempTouchState.windows.size(); i++) {

         const TouchedWindow& touchedWindow = mTempTouchState.windows[i];

         if (touchedWindow.targetFlags & InputTarget::FLAG_FOREGROUND) {

             // If the touched window is paused then keep waiting.

             if (touchedWindow.windowHandle->getInfo()->paused) {

                 injectionResult = handleTargetsNotReadyLocked(currentTime, entry,

                         NULL, touchedWindow.windowHandle, nextWakeupTime,

                         "Waiting because the touched window is paused.");

                 goto Unresponsive;

             }

             // If the touched window is still working on previous events then keep waiting.

             if (!isWindowReadyForMoreInputLocked(currentTime, touchedWindow.windowHandle, entry)) {

                 injectionResult = handleTargetsNotReadyLocked(currentTime, entry,

                         NULL, touchedWindow.windowHandle, nextWakeupTime,

                         "Waiting because the touched window has not finished "

                         "processing the input events that were previously delivered to it.");

                 goto Unresponsive;

             }

         }

     }

     // If this is the first pointer going down and the touched window has a wallpaper

     // then also add the touched wallpaper windows so they are locked in for the duration

     // of the touch gesture.

     // We do not collect wallpapers during HOVER_MOVE or SCROLL because the wallpaper

     // engine only supports touch events.  We would need to add a mechanism similar

     // to View.onGenericMotionEvent to enable wallpapers to handle these events.

     if (maskedAction == AMOTION_EVENT_ACTION_DOWN) {

         sp<InputWindowHandle> foregroundWindowHandle =

                 mTempTouchState.getFirstForegroundWindowHandle();

         if (foregroundWindowHandle->getInfo()->hasWallpaper) {

             for (size_t i = 0; i < mWindowHandles.size(); i++) {

                 sp<InputWindowHandle> windowHandle = mWindowHandles.itemAt(i);

                 const InputWindowInfo* info = windowHandle->getInfo();

                 if (info->displayId == displayId

                         && windowHandle->getInfo()->layoutParamsType

                                 == InputWindowInfo::TYPE_WALLPAPER) {

                     mTempTouchState.addOrUpdateWindow(windowHandle,

                             InputTarget::FLAG_WINDOW_IS_OBSCURED

                                     | InputTarget::FLAG_DISPATCH_AS_IS,

                             BitSet32(0));

                 }

             }

         }

     }

     // Success!  Output targets.

     injectionResult = INPUT_EVENT_INJECTION_SUCCEEDED;

     for (size_t i = 0; i < mTempTouchState.windows.size(); i++) {

         const TouchedWindow& touchedWindow = mTempTouchState.windows.itemAt(i);

         addWindowTargetLocked(touchedWindow.windowHandle, touchedWindow.targetFlags,

                 touchedWindow.pointerIds, inputTargets);

     }

     // Drop the outside or hover touch windows since we will not care about them

     // in the next iteration.

     mTempTouchState.filterNonAsIsTouchWindows();

 Failed:

     // Check injection permission once and for all.

     if (injectionPermission == INJECTION_PERMISSION_UNKNOWN) {

         if (checkInjectionPermission(NULL, entry->injectionState)) {

             injectionPermission = INJECTION_PERMISSION_GRANTED;

         } else {

             injectionPermission = INJECTION_PERMISSION_DENIED;

         }

     }

     // Update final pieces of touch state if the injector had permission.

     if (injectionPermission == INJECTION_PERMISSION_GRANTED) {

         if (!wrongDevice) {

             if (switchedDevice) {

 #if DEBUG_FOCUS

                 ALOGD("Conflicting pointer actions: Switched to a different device.");

 #endif

                 *outConflictingPointerActions = true;

             }

             if (isHoverAction) {

                 // Started hovering, therefore no longer down.

                 if (mTouchState.down) {

 #if DEBUG_FOCUS

                     ALOGD("Conflicting pointer actions: Hover received while pointer was down.");

 #endif

                     *outConflictingPointerActions = true;

                 }

                 mTouchState.reset();

                 if (maskedAction == AMOTION_EVENT_ACTION_HOVER_ENTER

                         || maskedAction == AMOTION_EVENT_ACTION_HOVER_MOVE) {

                     mTouchState.deviceId = entry->deviceId;

                     mTouchState.source = entry->source;

                     mTouchState.displayId = displayId;

                 }

             } else if (maskedAction == AMOTION_EVENT_ACTION_UP

                     || maskedAction == AMOTION_EVENT_ACTION_CANCEL) {

                 // All pointers up or canceled.

                 mTouchState.reset();

             } else if (maskedAction == AMOTION_EVENT_ACTION_DOWN) {

                 // First pointer went down.

                 if (mTouchState.down) {

 #if DEBUG_FOCUS

                     ALOGD("Conflicting pointer actions: Down received while already down.");

 #endif

                     *outConflictingPointerActions = true;

                 }

                 mTouchState.copyFrom(mTempTouchState);

             } else if (maskedAction == AMOTION_EVENT_ACTION_POINTER_UP) {

                 // One pointer went up.

                 if (isSplit) {

                     int32_t pointerIndex = getMotionEventActionPointerIndex(action);

                     uint32_t pointerId = entry->pointerProperties[pointerIndex].id;

                     for (size_t i = 0; i < mTempTouchState.windows.size(); ) {

                         TouchedWindow& touchedWindow = mTempTouchState.windows.editItemAt(i);

                         if (touchedWindow.targetFlags & InputTarget::FLAG_SPLIT) {

                             touchedWindow.pointerIds.clearBit(pointerId);

                             if (touchedWindow.pointerIds.isEmpty()) {

                                 mTempTouchState.windows.removeAt(i);

                                 continue;

                             }

                         }

                         i += 1;

                     }

                 }

                 mTouchState.copyFrom(mTempTouchState);

             } else if (maskedAction == AMOTION_EVENT_ACTION_SCROLL) {

                 // Discard temporary touch state since it was only valid for this action.

             } else {

                 // Save changes to touch state as-is for all other actions.

                 mTouchState.copyFrom(mTempTouchState);

             }

             // Update hover state.

             mLastHoverWindowHandle = newHoverWindowHandle;

         }

     } else {

 #if DEBUG_FOCUS

         ALOGD("Not updating touch focus because injection was denied.");

 #endif

     }

 Unresponsive:

     // Reset temporary touch state to ensure we release unnecessary references to input channels.

     mTempTouchState.reset();

     nsecs_t timeSpentWaitingForApplication = getTimeSpentWaitingForApplicationLocked(currentTime);

     updateDispatchStatisticsLocked(currentTime, entry,

             injectionResult, timeSpentWaitingForApplication);

 #if DEBUG_FOCUS

     ALOGD("findTouchedWindow finished: injectionResult=%d, injectionPermission=%d, "

             "timeSpentWaitingForApplication=%0.1fms",

             injectionResult, injectionPermission, timeSpentWaitingForApplication / 1000000.0);

 #endif

     return injectionResult;

 }

 void InputDispatcher::addWindowTargetLocked(const sp<InputWindowHandle>& windowHandle,

         int32_t targetFlags, BitSet32 pointerIds, Vector<InputTarget>& inputTargets) {

     inputTargets.push();

     const InputWindowInfo* windowInfo = windowHandle->getInfo();

     InputTarget& target = inputTargets.editTop();

     target.inputChannel = windowInfo->inputChannel;

     target.flags = targetFlags;

     target.xOffset = - windowInfo->frameLeft;

     target.yOffset = - windowInfo->frameTop;

     target.scaleFactor = windowInfo->scaleFactor;

     target.pointerIds = pointerIds;

 }

 void InputDispatcher::addMonitoringTargetsLocked(Vector<InputTarget>& inputTargets) {

     for (size_t i = 0; i < mMonitoringChannels.size(); i++) {

         inputTargets.push();

         InputTarget& target = inputTargets.editTop();

         target.inputChannel = mMonitoringChannels[i];

         target.flags = InputTarget::FLAG_DISPATCH_AS_IS;

         target.xOffset = 0;

         target.yOffset = 0;

         target.pointerIds.clear();

         target.scaleFactor = 1.0f;

     }

 }

 bool InputDispatcher::checkInjectionPermission(const sp<InputWindowHandle>& windowHandle,

         const InjectionState* injectionState) {

     if (injectionState

             && (windowHandle == NULL

                     || windowHandle->getInfo()->ownerUid != injectionState->injectorUid)

             && !hasInjectionPermission(injectionState->injectorPid, injectionState->injectorUid)) {

         if (windowHandle != NULL) {

             ALOGW("Permission denied: injecting event from pid %d uid %d to window %s "

                     "owned by uid %d",

                     injectionState->injectorPid, injectionState->injectorUid,

                     windowHandle->getName().string(),

                     windowHandle->getInfo()->ownerUid);

         } else {

             ALOGW("Permission denied: injecting event from pid %d uid %d",

                     injectionState->injectorPid, injectionState->injectorUid);

         }

         return false;

     }

     return true;

 }

 bool InputDispatcher::isWindowObscuredAtPointLocked(

         const sp<InputWindowHandle>& windowHandle, int32_t x, int32_t y) const {

     int32_t displayId = windowHandle->getInfo()->displayId;

     size_t numWindows = mWindowHandles.size();

     for (size_t i = 0; i < numWindows; i++) {

         sp<InputWindowHandle> otherHandle = mWindowHandles.itemAt(i);

         if (otherHandle == windowHandle) {

             break;

         }

         const InputWindowInfo* otherInfo = otherHandle->getInfo();

         if (otherInfo->displayId == displayId

                 && otherInfo->visible && !otherInfo->isTrustedOverlay()

                 && otherInfo->frameContainsPoint(x, y)) {

             return true;

         }

     }

     return false;

 }

 bool InputDispatcher::isWindowReadyForMoreInputLocked(nsecs_t currentTime,

         const sp<InputWindowHandle>& windowHandle, const EventEntry* eventEntry) {

     ssize_t connectionIndex = getConnectionIndexLocked(windowHandle->getInputChannel());

     if (connectionIndex >= 0) {

         sp<Connection> connection = mConnectionsByFd.valueAt(connectionIndex);

         if (connection->inputPublisherBlocked) {

             return false;

         }

         if (eventEntry->type == EventEntry::TYPE_KEY) {

             // If the event is a key event, then we must wait for all previous events to

             // complete before delivering it because previous events may have the

             // side-effect of transferring focus to a different window and we want to

             // ensure that the following keys are sent to the new window.

             //

             // Suppose the user touches a button in a window then immediately presses "A".

             // If the button causes a pop-up window to appear then we want to ensure that

             // the "A" key is delivered to the new pop-up window.  This is because users

             // often anticipate pending UI changes when typing on a keyboard.

             // To obtain this behavior, we must serialize key events with respect to all

             // prior input events.

             return connection->outboundQueue.isEmpty()

                     && connection->waitQueue.isEmpty();

         }

         // Touch events can always be sent to a window immediately because the user intended

         // to touch whatever was visible at the time.  Even if focus changes or a new

         // window appears moments later, the touch event was meant to be delivered to

         // whatever window happened to be on screen at the time.

         //

         // Generic motion events, such as trackball or joystick events are a little trickier.

         // Like key events, generic motion events are delivered to the focused window.

         // Unlike key events, generic motion events don't tend to transfer focus to other

         // windows and it is not important for them to be serialized.  So we prefer to deliver

         // generic motion events as soon as possible to improve efficiency and reduce lag

         // through batching.

         //

         // The one case where we pause input event delivery is when the wait queue is piling

         // up with lots of events because the application is not responding.

         // This condition ensures that ANRs are detected reliably.

         if (!connection->waitQueue.isEmpty()

                 && currentTime >= connection->waitQueue.head->eventEntry->eventTime

                         + STREAM_AHEAD_EVENT_TIMEOUT) {

             return false;

         }

     }

     return true;

 }

 String8 InputDispatcher::getApplicationWindowLabelLocked(

         const sp<InputApplicationHandle>& applicationHandle,

         const sp<InputWindowHandle>& windowHandle) {

     if (applicationHandle != NULL) {

         if (windowHandle != NULL) {

             String8 label(applicationHandle->getName());

             label.append(" - ");

             label.append(windowHandle->getName());

             return label;

         } else {

             return applicationHandle->getName();

         }

     } else if (windowHandle != NULL) {

         return windowHandle->getName();

     } else {

         return String8("<unknown application or window>");

     }

 }

 void InputDispatcher::pokeUserActivityLocked(const EventEntry* eventEntry) {

     if (mFocusedWindowHandle != NULL) {

         const InputWindowInfo* info = mFocusedWindowHandle->getInfo();

         if (info->inputFeatures & InputWindowInfo::INPUT_FEATURE_DISABLE_USER_ACTIVITY) {

 #if DEBUG_DISPATCH_CYCLE

             ALOGD("Not poking user activity: disabled by window '%s'.", info->name.string());

 #endif

             return;

         }

     }

     int32_t eventType = USER_ACTIVITY_EVENT_OTHER;

     switch (eventEntry->type) {

     case EventEntry::TYPE_MOTION: {

         const MotionEntry* motionEntry = static_cast<const MotionEntry*>(eventEntry);

         if (motionEntry->action == AMOTION_EVENT_ACTION_CANCEL) {

             return;

         }

         if (MotionEvent::isTouchEvent(motionEntry->source, motionEntry->action)) {

             eventType = USER_ACTIVITY_EVENT_TOUCH;

         }

         break;

     }

     case EventEntry::TYPE_KEY: {

         const KeyEntry* keyEntry = static_cast<const KeyEntry*>(eventEntry);

         if (keyEntry->flags & AKEY_EVENT_FLAG_CANCELED) {

             return;

         }

         eventType = USER_ACTIVITY_EVENT_BUTTON;

         break;

     }

     }

     CommandEntry* commandEntry = postCommandLocked(

             & InputDispatcher::doPokeUserActivityLockedInterruptible);

     commandEntry->eventTime = eventEntry->eventTime;

     commandEntry->userActivityEventType = eventType;

 }

 void InputDispatcher::prepareDispatchCycleLocked(nsecs_t currentTime,

         const sp<Connection>& connection, EventEntry* eventEntry, const InputTarget* inputTarget) {

 #if DEBUG_DISPATCH_CYCLE

     ALOGD("channel '%s' ~ prepareDispatchCycle - flags=0x%08x, "

             "xOffset=%f, yOffset=%f, scaleFactor=%f, "

             "pointerIds=0x%x",

             connection->getInputChannelName(), inputTarget->flags,

             inputTarget->xOffset, inputTarget->yOffset,

             inputTarget->scaleFactor, inputTarget->pointerIds.value);

 #endif

     // Skip this event if the connection status is not normal.

     // We don't want to enqueue additional outbound events if the connection is broken.

     if (connection->status != Connection::STATUS_NORMAL) {

 #if DEBUG_DISPATCH_CYCLE

         ALOGD("channel '%s' ~ Dropping event because the channel status is %s",

                 connection->getInputChannelName(), connection->getStatusLabel());

 #endif

         return;

     }

     // Split a motion event if needed.

     if (inputTarget->flags & InputTarget::FLAG_SPLIT) {

         ALOG_ASSERT(eventEntry->type == EventEntry::TYPE_MOTION);

         MotionEntry* originalMotionEntry = static_cast<MotionEntry*>(eventEntry);

         if (inputTarget->pointerIds.count() != originalMotionEntry->pointerCount) {

             MotionEntry* splitMotionEntry = splitMotionEvent(

                     originalMotionEntry, inputTarget->pointerIds);

             if (!splitMotionEntry) {

                 return; // split event was dropped

             }

 #if DEBUG_FOCUS

             ALOGD("channel '%s' ~ Split motion event.",

                     connection->getInputChannelName());

             logOutboundMotionDetailsLocked("  ", splitMotionEntry);

 #endif

             enqueueDispatchEntriesLocked(currentTime, connection,

                     splitMotionEntry, inputTarget);

             splitMotionEntry->release();

             return;

         }

     }

     // Not splitting.  Enqueue dispatch entries for the event as is.

     enqueueDispatchEntriesLocked(currentTime, connection, eventEntry, inputTarget);

 }

 void InputDispatcher::enqueueDispatchEntriesLocked(nsecs_t currentTime,

         const sp<Connection>& connection, EventEntry* eventEntry, const InputTarget* inputTarget) {

     bool wasEmpty = connection->outboundQueue.isEmpty();

     // Enqueue dispatch entries for the requested modes.

     enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,

             InputTarget::FLAG_DISPATCH_AS_HOVER_EXIT);

     enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,

             InputTarget::FLAG_DISPATCH_AS_OUTSIDE);

     enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,

             InputTarget::FLAG_DISPATCH_AS_HOVER_ENTER);

     enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,

             InputTarget::FLAG_DISPATCH_AS_IS);

     enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,

             InputTarget::FLAG_DISPATCH_AS_SLIPPERY_EXIT);

     enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,

             InputTarget::FLAG_DISPATCH_AS_SLIPPERY_ENTER);

     // If the outbound queue was previously empty, start the dispatch cycle going.

     if (wasEmpty && !connection->outboundQueue.isEmpty()) {

         startDispatchCycleLocked(currentTime, connection);

     }

 }

 void InputDispatcher::enqueueDispatchEntryLocked(

         const sp<Connection>& connection, EventEntry* eventEntry, const InputTarget* inputTarget,

         int32_t dispatchMode) {

     int32_t inputTargetFlags = inputTarget->flags;

     if (!(inputTargetFlags & dispatchMode)) {

         return;

     }

     inputTargetFlags = (inputTargetFlags & ~InputTarget::FLAG_DISPATCH_MASK) | dispatchMode;

     // This is a new event.

     // Enqueue a new dispatch entry onto the outbound queue for this connection.

     DispatchEntry* dispatchEntry = new DispatchEntry(eventEntry, // increments ref

             inputTargetFlags, inputTarget->xOffset, inputTarget->yOffset,

             inputTarget->scaleFactor);

     // Apply target flags and update the connection's input state.

     switch (eventEntry->type) {

     case EventEntry::TYPE_KEY: {

         KeyEntry* keyEntry = static_cast<KeyEntry*>(eventEntry);

         dispatchEntry->resolvedAction = keyEntry->action;

         dispatchEntry->resolvedFlags = keyEntry->flags;

         if (!connection->inputState.trackKey(keyEntry,

                 dispatchEntry->resolvedAction, dispatchEntry->resolvedFlags)) {

 #if DEBUG_DISPATCH_CYCLE

             ALOGD("channel '%s' ~ enqueueDispatchEntryLocked: skipping inconsistent key event",

                     connection->getInputChannelName());

 #endif

             delete dispatchEntry;

             return; // skip the inconsistent event

         }

         break;

     }

     case EventEntry::TYPE_MOTION: {

         MotionEntry* motionEntry = static_cast<MotionEntry*>(eventEntry);

         if (dispatchMode & InputTarget::FLAG_DISPATCH_AS_OUTSIDE) {

             dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_OUTSIDE;

         } else if (dispatchMode & InputTarget::FLAG_DISPATCH_AS_HOVER_EXIT) {

             dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_HOVER_EXIT;

         } else if (dispatchMode & InputTarget::FLAG_DISPATCH_AS_HOVER_ENTER) {

             dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_HOVER_ENTER;

         } else if (dispatchMode & InputTarget::FLAG_DISPATCH_AS_SLIPPERY_EXIT) {

             dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_CANCEL;

         } else if (dispatchMode & InputTarget::FLAG_DISPATCH_AS_SLIPPERY_ENTER) {

             dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_DOWN;

         } else {

             dispatchEntry->resolvedAction = motionEntry->action;

         }

         if (dispatchEntry->resolvedAction == AMOTION_EVENT_ACTION_HOVER_MOVE

                 && !connection->inputState.isHovering(

                         motionEntry->deviceId, motionEntry->source, motionEntry->displayId)) {

 #if DEBUG_DISPATCH_CYCLE

         ALOGD("channel '%s' ~ enqueueDispatchEntryLocked: filling in missing hover enter event",

                 connection->getInputChannelName());

 #endif

             dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_HOVER_ENTER;

         }

         dispatchEntry->resolvedFlags = motionEntry->flags;

         if (dispatchEntry->targetFlags & InputTarget::FLAG_WINDOW_IS_OBSCURED) {

             dispatchEntry->resolvedFlags |= AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED;

         }

         if (!connection->inputState.trackMotion(motionEntry,

                 dispatchEntry->resolvedAction, dispatchEntry->resolvedFlags)) {

 #if DEBUG_DISPATCH_CYCLE

             ALOGD("channel '%s' ~ enqueueDispatchEntryLocked: skipping inconsistent motion event",

                     connection->getInputChannelName());

 #endif

             delete dispatchEntry;

             return; // skip the inconsistent event

         }

         break;

     }

     }

     // Remember that we are waiting for this dispatch to complete.

     if (dispatchEntry->hasForegroundTarget()) {

         incrementPendingForegroundDispatchesLocked(eventEntry);

     }

     // Enqueue the dispatch entry.

     connection->outboundQueue.enqueueAtTail(dispatchEntry);

     traceOutboundQueueLengthLocked(connection);

 }

 void InputDispatcher::startDispatchCycleLocked(nsecs_t currentTime,

         const sp<Connection>& connection) {

 #if DEBUG_DISPATCH_CYCLE

     ALOGD("channel '%s' ~ startDispatchCycle",

             connection->getInputChannelName());

 #endif

     while (connection->status == Connection::STATUS_NORMAL

             && !connection->outboundQueue.isEmpty()) {

         DispatchEntry* dispatchEntry = connection->outboundQueue.head;

         dispatchEntry->deliveryTime = currentTime;

         // Publish the event.

         status_t status;

         EventEntry* eventEntry = dispatchEntry->eventEntry;

         switch (eventEntry->type) {

         case EventEntry::TYPE_KEY: {

             KeyEntry* keyEntry = static_cast<KeyEntry*>(eventEntry);

             // Publish the key event.

             status = connection->inputPublisher.publishKeyEvent(dispatchEntry->seq,

                     keyEntry->deviceId, keyEntry->source,

                     dispatchEntry->resolvedAction, dispatchEntry->resolvedFlags,

                     keyEntry->keyCode, keyEntry->scanCode,

                     keyEntry->metaState, keyEntry->repeatCount, keyEntry->downTime,

                     keyEntry->eventTime);

             break;

         }

         case EventEntry::TYPE_MOTION: {

             MotionEntry* motionEntry = static_cast<MotionEntry*>(eventEntry);

             PointerCoords scaledCoords[MAX_POINTERS];

             const PointerCoords* usingCoords = motionEntry->pointerCoords;

             // Set the X and Y offset depending on the input source.

             float xOffset, yOffset, scaleFactor;

             if ((motionEntry->source & AINPUT_SOURCE_CLASS_POINTER)

                     && !(dispatchEntry->targetFlags & InputTarget::FLAG_ZERO_COORDS)) {

                 scaleFactor = dispatchEntry->scaleFactor;

                 xOffset = dispatchEntry->xOffset * scaleFactor;

                 yOffset = dispatchEntry->yOffset * scaleFactor;

                 if (scaleFactor != 1.0f) {

                     for (size_t i = 0; i < motionEntry->pointerCount; i++) {

                         scaledCoords[i] = motionEntry->pointerCoords[i];

                         scaledCoords[i].scale(scaleFactor);

                     }

                     usingCoords = scaledCoords;

                 }

             } else {

                 xOffset = 0.0f;

                 yOffset = 0.0f;

                 scaleFactor = 1.0f;

                 // We don't want the dispatch target to know.

                 if (dispatchEntry->targetFlags & InputTarget::FLAG_ZERO_COORDS) {

                     for (size_t i = 0; i < motionEntry->pointerCount; i++) {

                         scaledCoords[i].clear();

                     }

                     usingCoords = scaledCoords;

                 }

             }

             // Publish the motion event.

             status = connection->inputPublisher.publishMotionEvent(dispatchEntry->seq,

                     motionEntry->deviceId, motionEntry->source,

                     dispatchEntry->resolvedAction, dispatchEntry->resolvedFlags,

                     motionEntry->edgeFlags, motionEntry->metaState, motionEntry->buttonState,

                     xOffset, yOffset,

                     motionEntry->xPrecision, motionEntry->yPrecision,

                     motionEntry->downTime, motionEntry->eventTime,

                     motionEntry->pointerCount, motionEntry->pointerProperties,

                     usingCoords);

             break;

         }

         default:

             ALOG_ASSERT(false);

             return;

         }

         // Check the result.

         if (status) {

             if (status == WOULD_BLOCK) {

                 if (connection->waitQueue.isEmpty()) {

                     ALOGE("channel '%s' ~ Could not publish event because the pipe is full. "

                             "This is unexpected because the wait queue is empty, so the pipe "

                             "should be empty and we shouldn't have any problems writing an "

                             "event to it, status=%d", connection->getInputChannelName(), status);

                     abortBrokenDispatchCycleLocked(currentTime, connection, true /*notify*/);

                 } else {

                     // Pipe is full and we are waiting for the app to finish process some events

                     // before sending more events to it.

 #if DEBUG_DISPATCH_CYCLE

                     ALOGD("channel '%s' ~ Could not publish event because the pipe is full, "

                             "waiting for the application to catch up",

                             connection->getInputChannelName());

 #endif

                     connection->inputPublisherBlocked = true;

                 }

             } else {

                 ALOGE("channel '%s' ~ Could not publish event due to an unexpected error, "

                         "status=%d", connection->getInputChannelName(), status);

                 abortBrokenDispatchCycleLocked(currentTime, connection, true /*notify*/);

             }

             return;

         }

         // Re-enqueue the event on the wait queue.

         connection->outboundQueue.dequeue(dispatchEntry);

         traceOutboundQueueLengthLocked(connection);

         connection->waitQueue.enqueueAtTail(dispatchEntry);

         traceWaitQueueLengthLocked(connection);

     }

 }

 void InputDispatcher::finishDispatchCycleLocked(nsecs_t currentTime,

         const sp<Connection>& connection, uint32_t seq, bool handled) {

 #if DEBUG_DISPATCH_CYCLE

     ALOGD("channel '%s' ~ finishDispatchCycle - seq=%u, handled=%s",

             connection->getInputChannelName(), seq, toString(handled));

 #endif

     connection->inputPublisherBlocked = false;

     if (connection->status == Connection::STATUS_BROKEN

             || connection->status == Connection::STATUS_ZOMBIE) {

         return;

     }

     // Notify other system components and prepare to start the next dispatch cycle.

     onDispatchCycleFinishedLocked(currentTime, connection, seq, handled);

 }

 void InputDispatcher::abortBrokenDispatchCycleLocked(nsecs_t currentTime,

         const sp<Connection>& connection, bool notify) {

 #if DEBUG_DISPATCH_CYCLE

     ALOGD("channel '%s' ~ abortBrokenDispatchCycle - notify=%s",

             connection->getInputChannelName(), toString(notify));

 #endif

     // Clear the dispatch queues.

     drainDispatchQueueLocked(&connection->outboundQueue);

     traceOutboundQueueLengthLocked(connection);

     drainDispatchQueueLocked(&connection->waitQueue);

     traceWaitQueueLengthLocked(connection);

     // The connection appears to be unrecoverably broken.

     // Ignore already broken or zombie connections.

     if (connection->status == Connection::STATUS_NORMAL) {

         connection->status = Connection::STATUS_BROKEN;

         if (notify) {

             // Notify other system components.

             onDispatchCycleBrokenLocked(currentTime, connection);

         }

     }

 }

 void InputDispatcher::drainDispatchQueueLocked(Queue<DispatchEntry>* queue) {

     while (!queue->isEmpty()) {

         DispatchEntry* dispatchEntry = queue->dequeueAtHead();

         releaseDispatchEntryLocked(dispatchEntry);

     }

 }

 void InputDispatcher::releaseDispatchEntryLocked(DispatchEntry* dispatchEntry) {

     if (dispatchEntry->hasForegroundTarget()) {

         decrementPendingForegroundDispatchesLocked(dispatchEntry->eventEntry);

     }

     delete dispatchEntry;

 }

 int InputDispatcher::handleReceiveCallback(int fd, int events, void* data) {

     InputDispatcher* d = static_cast<InputDispatcher*>(data);

     { // acquire lock

         AutoMutex _l(d->mLock);

         ssize_t connectionIndex = d->mConnectionsByFd.indexOfKey(fd);

         if (connectionIndex < 0) {

             ALOGE("Received spurious receive callback for unknown input channel.  "

                     "fd=%d, events=0x%x", fd, events);

             return 0; // remove the callback

         }

         bool notify;

         sp<Connection> connection = d->mConnectionsByFd.valueAt(connectionIndex);

         if (!(events & (ALOOPER_EVENT_ERROR | ALOOPER_EVENT_HANGUP))) {

             if (!(events & ALOOPER_EVENT_INPUT)) {

                 ALOGW("channel '%s' ~ Received spurious callback for unhandled poll event.  "

                         "events=0x%x", connection->getInputChannelName(), events);

                 return 1;

             }

             nsecs_t currentTime = now();

             bool gotOne = false;

             status_t status;

             for (;;) {

                 uint32_t seq;

                 bool handled;

                 status = connection->inputPublisher.receiveFinishedSignal(&seq, &handled);

                 if (status) {

                     break;

                 }

                 d->finishDispatchCycleLocked(currentTime, connection, seq, handled);

                 gotOne = true;

             }

             if (gotOne) {

                 d->runCommandsLockedInterruptible();

                 if (status == WOULD_BLOCK) {

                     return 1;

                 }

             }

             notify = status != DEAD_OBJECT || !connection->monitor;

             if (notify) {

                 ALOGE("channel '%s' ~ Failed to receive finished signal.  status=%d",

                         connection->getInputChannelName(), status);

             }

         } else {

             // Monitor channels are never explicitly unregistered.

             // We do it automatically when the remote endpoint is closed so don't warn

             // about them.

             notify = !connection->monitor;

             if (notify) {

                 ALOGW("channel '%s' ~ Consumer closed input channel or an error occurred.  "

                         "events=0x%x", connection->getInputChannelName(), events);

             }

         }

         // Unregister the channel.

         d->unregisterInputChannelLocked(connection->inputChannel, notify);

         return 0; // remove the callback

     } // release lock

 }

 void InputDispatcher::synthesizeCancelationEventsForAllConnectionsLocked(

         const CancelationOptions& options) {

     for (size_t i = 0; i < mConnectionsByFd.size(); i++) {

         synthesizeCancelationEventsForConnectionLocked(

                 mConnectionsByFd.valueAt(i), options);

     }

 }

 void InputDispatcher::synthesizeCancelationEventsForInputChannelLocked(

         const sp<InputChannel>& channel, const CancelationOptions& options) {

     ssize_t index = getConnectionIndexLocked(channel);

     if (index >= 0) {

         synthesizeCancelationEventsForConnectionLocked(

                 mConnectionsByFd.valueAt(index), options);

     }

 }

 void InputDispatcher::synthesizeCancelationEventsForConnectionLocked(

         const sp<Connection>& connection, const CancelationOptions& options) {

     if (connection->status == Connection::STATUS_BROKEN) {

         return;

     }

     nsecs_t currentTime = now();

     Vector<EventEntry*> cancelationEvents;

     connection->inputState.synthesizeCancelationEvents(currentTime,

             cancelationEvents, options);

     if (!cancelationEvents.isEmpty()) {

 #if DEBUG_OUTBOUND_EVENT_DETAILS

         ALOGD("channel '%s' ~ Synthesized %d cancelation events to bring channel back in sync "

                 "with reality: %s, mode=%d.",

                 connection->getInputChannelName(), cancelationEvents.size(),

                 options.reason, options.mode);

 #endif

         for (size_t i = 0; i < cancelationEvents.size(); i++) {

             EventEntry* cancelationEventEntry = cancelationEvents.itemAt(i);

             switch (cancelationEventEntry->type) {

             case EventEntry::TYPE_KEY:

                 logOutboundKeyDetailsLocked("cancel - ",

                         static_cast<KeyEntry*>(cancelationEventEntry));

                 break;

             case EventEntry::TYPE_MOTION:

                 logOutboundMotionDetailsLocked("cancel - ",

                         static_cast<MotionEntry*>(cancelationEventEntry));

                 break;

             }

             InputTarget target;

             sp<InputWindowHandle> windowHandle = getWindowHandleLocked(connection->inputChannel);

             if (windowHandle != NULL) {

                 const InputWindowInfo* windowInfo = windowHandle->getInfo();

                 target.xOffset = -windowInfo->frameLeft;

                 target.yOffset = -windowInfo->frameTop;

                 target.scaleFactor = windowInfo->scaleFactor;

             } else {

                 target.xOffset = 0;

                 target.yOffset = 0;

                 target.scaleFactor = 1.0f;

             }

             target.inputChannel = connection->inputChannel;

             target.flags = InputTarget::FLAG_DISPATCH_AS_IS;

             enqueueDispatchEntryLocked(connection, cancelationEventEntry, // increments ref

                     &target, InputTarget::FLAG_DISPATCH_AS_IS);

             cancelationEventEntry->release();

         }

         startDispatchCycleLocked(currentTime, connection);

     }

 }

 InputDispatcher::MotionEntry*

 InputDispatcher::splitMotionEvent(const MotionEntry* originalMotionEntry, BitSet32 pointerIds) {

     ALOG_ASSERT(pointerIds.value != 0);

     uint32_t splitPointerIndexMap[MAX_POINTERS];

     PointerProperties splitPointerProperties[MAX_POINTERS];

     PointerCoords splitPointerCoords[MAX_POINTERS];

     uint32_t originalPointerCount = originalMotionEntry->pointerCount;

     uint32_t splitPointerCount = 0;

     for (uint32_t originalPointerIndex = 0; originalPointerIndex < originalPointerCount;

             originalPointerIndex++) {

         const PointerProperties& pointerProperties =

                 originalMotionEntry->pointerProperties[originalPointerIndex];

         uint32_t pointerId = uint32_t(pointerProperties.id);

         if (pointerIds.hasBit(pointerId)) {

             splitPointerIndexMap[splitPointerCount] = originalPointerIndex;

             splitPointerProperties[splitPointerCount].copyFrom(pointerProperties);

             splitPointerCoords[splitPointerCount].copyFrom(

                     originalMotionEntry->pointerCoords[originalPointerIndex]);

             splitPointerCount += 1;

         }

     }

     if (splitPointerCount != pointerIds.count()) {

         // This is bad.  We are missing some of the pointers that we expected to deliver.

         // Most likely this indicates that we received an ACTION_MOVE events that has

         // different pointer ids than we expected based on the previous ACTION_DOWN

         // or ACTION_POINTER_DOWN events that caused us to decide to split the pointers

         // in this way.

         ALOGW("Dropping split motion event because the pointer count is %d but "

                 "we expected there to be %d pointers.  This probably means we received "

                 "a broken sequence of pointer ids from the input device.",

                 splitPointerCount, pointerIds.count());

         return NULL;

     }

     int32_t action = originalMotionEntry->action;

     int32_t maskedAction = action & AMOTION_EVENT_ACTION_MASK;

     if (maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN

             || maskedAction == AMOTION_EVENT_ACTION_POINTER_UP) {

         int32_t originalPointerIndex = getMotionEventActionPointerIndex(action);

         const PointerProperties& pointerProperties =

                 originalMotionEntry->pointerProperties[originalPointerIndex];

         uint32_t pointerId = uint32_t(pointerProperties.id);

         if (pointerIds.hasBit(pointerId)) {

             if (pointerIds.count() == 1) {

                 // The first/last pointer went down/up.

                 action = maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN

                         ? AMOTION_EVENT_ACTION_DOWN : AMOTION_EVENT_ACTION_UP;

             } else {

                 // A secondary pointer went down/up.

                 uint32_t splitPointerIndex = 0;

                 while (pointerId != uint32_t(splitPointerProperties[splitPointerIndex].id)) {

                     splitPointerIndex += 1;

                 }

                 action = maskedAction | (splitPointerIndex

                         << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);

             }

         } else {

             // An unrelated pointer changed.

             action = AMOTION_EVENT_ACTION_MOVE;

         }

     }

     MotionEntry* splitMotionEntry = new MotionEntry(

             originalMotionEntry->eventTime,

             originalMotionEntry->deviceId,

             originalMotionEntry->source,

             originalMotionEntry->policyFlags,

             action,

             originalMotionEntry->flags,

             originalMotionEntry->metaState,

             originalMotionEntry->buttonState,

             originalMotionEntry->edgeFlags,

             originalMotionEntry->xPrecision,

             originalMotionEntry->yPrecision,

             originalMotionEntry->downTime,

             originalMotionEntry->displayId,

             splitPointerCount, splitPointerProperties, splitPointerCoords);

     if (originalMotionEntry->injectionState) {

         splitMotionEntry->injectionState = originalMotionEntry->injectionState;

         splitMotionEntry->injectionState->refCount += 1;

     }

     return splitMotionEntry;

 }

 void InputDispatcher::notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args) {

 #if DEBUG_INBOUND_EVENT_DETAILS

     ALOGD("notifyConfigurationChanged - eventTime=%lld", args->eventTime);

 #endif

     bool needWake;

     { // acquire lock

         AutoMutex _l(mLock);

         ConfigurationChangedEntry* newEntry = new ConfigurationChangedEntry(args->eventTime);

         needWake = enqueueInboundEventLocked(newEntry);

     } // release lock

     if (needWake) {

         mLooper->wake();

     }

 }

 void InputDispatcher::notifyKey(const NotifyKeyArgs* args) {

 #if DEBUG_INBOUND_EVENT_DETAILS

     ALOGD("notifyKey - eventTime=%lld, deviceId=%d, source=0x%x, policyFlags=0x%x, action=0x%x, "

             "flags=0x%x, keyCode=0x%x, scanCode=0x%x, metaState=0x%x, downTime=%lld",

             args->eventTime, args->deviceId, args->source, args->policyFlags,

             args->action, args->flags, args->keyCode, args->scanCode,

             args->metaState, args->downTime);

 #endif

     if (!validateKeyEvent(args->action)) {

         return;

     }

     uint32_t policyFlags = args->policyFlags;

     int32_t flags = args->flags;

     int32_t metaState = args->metaState;

     if ((policyFlags & POLICY_FLAG_VIRTUAL) || (flags & AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY)) {

         policyFlags |= POLICY_FLAG_VIRTUAL;

         flags |= AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY;

     }

     if (policyFlags & POLICY_FLAG_ALT) {

         metaState |= AMETA_ALT_ON | AMETA_ALT_LEFT_ON;

     }

     if (policyFlags & POLICY_FLAG_ALT_GR) {

         metaState |= AMETA_ALT_ON | AMETA_ALT_RIGHT_ON;

     }

     if (policyFlags & POLICY_FLAG_SHIFT) {

         metaState |= AMETA_SHIFT_ON | AMETA_SHIFT_LEFT_ON;

     }

     if (policyFlags & POLICY_FLAG_CAPS_LOCK) {

         metaState |= AMETA_CAPS_LOCK_ON;

     }

     if (policyFlags & POLICY_FLAG_FUNCTION) {

         metaState |= AMETA_FUNCTION_ON;

     }

     policyFlags |= POLICY_FLAG_TRUSTED;

     KeyEvent event;

     event.initialize(args->deviceId, args->source, args->action,

             flags, args->keyCode, args->scanCode, metaState, 0,

             args->downTime, args->eventTime);

     mPolicy->interceptKeyBeforeQueueing(&event, /*byref*/ policyFlags);

     if (policyFlags & POLICY_FLAG_WOKE_HERE) {

         flags |= AKEY_EVENT_FLAG_WOKE_HERE;

     }

     bool needWake;

     { // acquire lock

         mLock.lock();

         if (shouldSendKeyToInputFilterLocked(args)) {

             mLock.unlock();

             policyFlags |= POLICY_FLAG_FILTERED;

             if (!mPolicy->filterInputEvent(&event, policyFlags)) {

                 return; // event was consumed by the filter

             }

             mLock.lock();

         }

         int32_t repeatCount = 0;

         KeyEntry* newEntry = new KeyEntry(args->eventTime,

                 args->deviceId, args->source, policyFlags,

                 args->action, flags, args->keyCode, args->scanCode,

                 metaState, repeatCount, args->downTime);

         needWake = enqueueInboundEventLocked(newEntry);

         mLock.unlock();

     } // release lock

     if (needWake) {

         mLooper->wake();

     }

 }

 bool InputDispatcher::shouldSendKeyToInputFilterLocked(const NotifyKeyArgs* args) {

     return mInputFilterEnabled;

 }

 void InputDispatcher::notifyMotion(const NotifyMotionArgs* args) {

 #if DEBUG_INBOUND_EVENT_DETAILS

     ALOGD("notifyMotion - eventTime=%lld, deviceId=%d, source=0x%x, policyFlags=0x%x, "

             "action=0x%x, flags=0x%x, metaState=0x%x, buttonState=0x%x, edgeFlags=0x%x, "

             "xPrecision=%f, yPrecision=%f, downTime=%lld",

             args->eventTime, args->deviceId, args->source, args->policyFlags,

             args->action, args->flags, args->metaState, args->buttonState,

             args->edgeFlags, args->xPrecision, args->yPrecision, args->downTime);

     for (uint32_t i = 0; i < args->pointerCount; i++) {

         ALOGD("  Pointer %d: id=%d, toolType=%d, "

                 "x=%f, y=%f, pressure=%f, size=%f, "

                 "touchMajor=%f, touchMinor=%f, toolMajor=%f, toolMinor=%f, "

                 "orientation=%f",

                 i, args->pointerProperties[i].id,

                 args->pointerProperties[i].toolType,

                 args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_X),

                 args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_Y),

                 args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_PRESSURE),

                 args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_SIZE),

                 args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR),

                 args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR),

                 args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR),

                 args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR),

                 args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION));

     }

 #endif

     if (!validateMotionEvent(args->action, args->pointerCount, args->pointerProperties)) {

         return;

     }

     uint32_t policyFlags = args->policyFlags;

     policyFlags |= POLICY_FLAG_TRUSTED;

     mPolicy->interceptMotionBeforeQueueing(args->eventTime, /*byref*/ policyFlags);

     bool needWake;

     { // acquire lock

         mLock.lock();

         if (shouldSendMotionToInputFilterLocked(args)) {

             mLock.unlock();

             MotionEvent event;

             event.initialize(args->deviceId, args->source, args->action, args->flags,

                     args->edgeFlags, args->metaState, args->buttonState, 0, 0,

                     args->xPrecision, args->yPrecision,

                     args->downTime, args->eventTime,

                     args->pointerCount, args->pointerProperties, args->pointerCoords);

             policyFlags |= POLICY_FLAG_FILTERED;

             if (!mPolicy->filterInputEvent(&event, policyFlags)) {

                 return; // event was consumed by the filter

             }

             mLock.lock();

         }

         // Just enqueue a new motion event.

         MotionEntry* newEntry = new MotionEntry(args->eventTime,

                 args->deviceId, args->source, policyFlags,

                 args->action, args->flags, args->metaState, args->buttonState,

                 args->edgeFlags, args->xPrecision, args->yPrecision, args->downTime,

                 args->displayId,

                 args->pointerCount, args->pointerProperties, args->pointerCoords);

         needWake = enqueueInboundEventLocked(newEntry);

         mLock.unlock();

     } // release lock

     if (needWake) {

         mLooper->wake();

     }

 }

 bool InputDispatcher::shouldSendMotionToInputFilterLocked(const NotifyMotionArgs* args) {

     // TODO: support sending secondary display events to input filter

     return mInputFilterEnabled && isMainDisplay(args->displayId);

 }

 void InputDispatcher::notifySwitch(const NotifySwitchArgs* args) {

 #if DEBUG_INBOUND_EVENT_DETAILS

     ALOGD("notifySwitch - eventTime=%lld, policyFlags=0x%x, switchValues=0x%08x, switchMask=0x%08x",

             args->eventTime, args->policyFlags,

             args->switchValues, args->switchMask);

 #endif

     uint32_t policyFlags = args->policyFlags;

     policyFlags |= POLICY_FLAG_TRUSTED;

     mPolicy->notifySwitch(args->eventTime,

             args->switchValues, args->switchMask, policyFlags);

 }

 void InputDispatcher::notifyDeviceReset(const NotifyDeviceResetArgs* args) {

 #if DEBUG_INBOUND_EVENT_DETAILS

     ALOGD("notifyDeviceReset - eventTime=%lld, deviceId=%d",

             args->eventTime, args->deviceId);

 #endif

     bool needWake;

     { // acquire lock

         AutoMutex _l(mLock);

         DeviceResetEntry* newEntry = new DeviceResetEntry(args->eventTime, args->deviceId);

         needWake = enqueueInboundEventLocked(newEntry);

     } // release lock

     if (needWake) {

         mLooper->wake();

     }

 }

 int32_t InputDispatcher::injectInputEvent(const InputEvent* event,

         int32_t injectorPid, int32_t injectorUid, int32_t syncMode, int32_t timeoutMillis,

         uint32_t policyFlags) {

 #if DEBUG_INBOUND_EVENT_DETAILS

     ALOGD("injectInputEvent - eventType=%d, injectorPid=%d, injectorUid=%d, "

             "syncMode=%d, timeoutMillis=%d, policyFlags=0x%08x",

             event->getType(), injectorPid, injectorUid, syncMode, timeoutMillis, policyFlags);

 #endif

     nsecs_t endTime = now() + milliseconds_to_nanoseconds(timeoutMillis);

     policyFlags |= POLICY_FLAG_INJECTED;

     if (hasInjectionPermission(injectorPid, injectorUid)) {

         policyFlags |= POLICY_FLAG_TRUSTED;

     }

     EventEntry* firstInjectedEntry;

     EventEntry* lastInjectedEntry;

     switch (event->getType()) {

     case AINPUT_EVENT_TYPE_KEY: {

         const KeyEvent* keyEvent = static_cast<const KeyEvent*>(event);

         int32_t action = keyEvent->getAction();

         if (! validateKeyEvent(action)) {

             return INPUT_EVENT_INJECTION_FAILED;

         }

         int32_t flags = keyEvent->getFlags();

         if (flags & AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY) {

             policyFlags |= POLICY_FLAG_VIRTUAL;

         }

         if (!(policyFlags & POLICY_FLAG_FILTERED)) {

             mPolicy->interceptKeyBeforeQueueing(keyEvent, /*byref*/ policyFlags);

         }

         if (policyFlags & POLICY_FLAG_WOKE_HERE) {

             flags |= AKEY_EVENT_FLAG_WOKE_HERE;

         }

         mLock.lock();

         firstInjectedEntry = new KeyEntry(keyEvent->getEventTime(),

                 keyEvent->getDeviceId(), keyEvent->getSource(),

                 policyFlags, action, flags,

                 keyEvent->getKeyCode(), keyEvent->getScanCode(), keyEvent->getMetaState(),

                 keyEvent->getRepeatCount(), keyEvent->getDownTime());

         lastInjectedEntry = firstInjectedEntry;

         break;

     }

     case AINPUT_EVENT_TYPE_MOTION: {

         const MotionEvent* motionEvent = static_cast<const MotionEvent*>(event);

         int32_t displayId = ADISPLAY_ID_DEFAULT;

         int32_t action = motionEvent->getAction();

         size_t pointerCount = motionEvent->getPointerCount();

         const PointerProperties* pointerProperties = motionEvent->getPointerProperties();

         if (! validateMotionEvent(action, pointerCount, pointerProperties)) {

             return INPUT_EVENT_INJECTION_FAILED;

         }

         if (!(policyFlags & POLICY_FLAG_FILTERED)) {

             nsecs_t eventTime = motionEvent->getEventTime();

             mPolicy->interceptMotionBeforeQueueing(eventTime, /*byref*/ policyFlags);

         }

         mLock.lock();

         const nsecs_t* sampleEventTimes = motionEvent->getSampleEventTimes();

         const PointerCoords* samplePointerCoords = motionEvent->getSamplePointerCoords();

         firstInjectedEntry = new MotionEntry(*sampleEventTimes,

                 motionEvent->getDeviceId(), motionEvent->getSource(), policyFlags,

                 action, motionEvent->getFlags(),

                 motionEvent->getMetaState(), motionEvent->getButtonState(),

                 motionEvent->getEdgeFlags(),

                 motionEvent->getXPrecision(), motionEvent->getYPrecision(),

                 motionEvent->getDownTime(), displayId,

                 uint32_t(pointerCount), pointerProperties, samplePointerCoords);

         lastInjectedEntry = firstInjectedEntry;

         for (size_t i = motionEvent->getHistorySize(); i > 0; i--) {

             sampleEventTimes += 1;

             samplePointerCoords += pointerCount;

             MotionEntry* nextInjectedEntry = new MotionEntry(*sampleEventTimes,

                     motionEvent->getDeviceId(), motionEvent->getSource(), policyFlags,

                     action, motionEvent->getFlags(),

                     motionEvent->getMetaState(), motionEvent->getButtonState(),

                     motionEvent->getEdgeFlags(),

                     motionEvent->getXPrecision(), motionEvent->getYPrecision(),

                     motionEvent->getDownTime(), displayId,

                     uint32_t(pointerCount), pointerProperties, samplePointerCoords);

             lastInjectedEntry->next = nextInjectedEntry;

             lastInjectedEntry = nextInjectedEntry;

         }

         break;

     }

     default:

         ALOGW("Cannot inject event of type %d", event->getType());

         return INPUT_EVENT_INJECTION_FAILED;

     }

     InjectionState* injectionState = new InjectionState(injectorPid, injectorUid);

     if (syncMode == INPUT_EVENT_INJECTION_SYNC_NONE) {

         injectionState->injectionIsAsync = true;

     }

     injectionState->refCount += 1;

     lastInjectedEntry->injectionState = injectionState;

     bool needWake = false;

     for (EventEntry* entry = firstInjectedEntry; entry != NULL; ) {