From ef3a8234824cc9f7c3464dd05f9aeca8ea77ebd9 Mon Sep 17 00:00:00 2001 From: Jeff Brown Date: Mon, 18 Oct 2010 13:21:23 -0700 Subject: [PATCH] Fix bug where home presses were not poking user activity. We now poke user activity twice: once upon dequeueing an event for dispatch and then again just before we dispatch it. The second poke is to compensate for the fact that it can take a few seconds to identify the dispatch target (if the application is responding slowly) but we want to keep the display from going to sleep for X amount of time after the app gets a chance to actually receive the event. This mirrors pre-Gingerbread behavior. Removed some unnecessary code that filters user activity pokes when sending events to KeyGuard. We don't need this because KeyGuard already tells the power manager to disable user activity. Bug: 3101397 Change-Id: I8c3a77601fdef8f584e84cfdd11aa79da0ff51db --- include/ui/InputDispatcher.h | 6 +--- libs/ui/InputDispatcher.cpp | 68 +++++++++++++++--------------------- 2 files changed, 29 insertions(+), 45 deletions(-) diff --git a/include/ui/InputDispatcher.h b/include/ui/InputDispatcher.h index 4955d473f..b0b855edb 100644 --- a/include/ui/InputDispatcher.h +++ b/include/ui/InputDispatcher.h @@ -109,9 +109,6 @@ struct InputTarget { // (ignored for KeyEvents) float xOffset, yOffset; - // The window type of the input target. - int32_t windowType; - // The subset of pointer ids to include in motion events dispatched to this input target // if FLAG_SPLIT is set. BitSet32 pointerIds; @@ -1004,8 +1001,7 @@ private: void addWindowTargetLocked(const InputWindow* window, int32_t targetFlags, BitSet32 pointerIds); void addMonitoringTargetsLocked(); - bool shouldPokeUserActivityForCurrentInputTargetsLocked(); - void pokeUserActivityLocked(nsecs_t eventTime, int32_t eventType); + void pokeUserActivityLocked(const EventEntry* eventEntry); bool checkInjectionPermission(const InputWindow* window, const InjectionState* injectionState); bool isWindowObscuredAtPointLocked(const InputWindow* window, int32_t x, int32_t y) const; bool isWindowFinishedWithPreviousInputLocked(const InputWindow* window); diff --git a/libs/ui/InputDispatcher.cpp b/libs/ui/InputDispatcher.cpp index 92daee19e..303075f1b 100644 --- a/libs/ui/InputDispatcher.cpp +++ b/libs/ui/InputDispatcher.cpp @@ -340,6 +340,11 @@ void InputDispatcher::dispatchOnceInnerLocked(nsecs_t keyRepeatTimeout, mInboundQueue.dequeue(entry); mPendingEvent = entry; } + + // Poke user activity for this event. + if (mPendingEvent->policyFlags & POLICY_FLAG_PASS_TO_USER) { + pokeUserActivityLocked(mPendingEvent); + } } // Now we have an event to dispatch. @@ -686,11 +691,6 @@ bool InputDispatcher::dispatchKeyLocked( // Dispatch the key. dispatchEventToCurrentInputTargetsLocked(currentTime, entry, false); - - // Poke user activity. - if (shouldPokeUserActivityForCurrentInputTargetsLocked()) { - pokeUserActivityLocked(entry->eventTime, POWER_MANAGER_BUTTON_EVENT); - } return true; } @@ -753,31 +753,6 @@ bool InputDispatcher::dispatchMotionLocked( // Dispatch the motion. dispatchEventToCurrentInputTargetsLocked(currentTime, entry, false); - - // Poke user activity. - if (shouldPokeUserActivityForCurrentInputTargetsLocked()) { - int32_t eventType; - if (isPointerEvent) { - switch (entry->action) { - case AMOTION_EVENT_ACTION_DOWN: - eventType = POWER_MANAGER_TOUCH_EVENT; - break; - case AMOTION_EVENT_ACTION_UP: - eventType = POWER_MANAGER_TOUCH_UP_EVENT; - break; - default: - if (entry->eventTime - entry->downTime >= EVENT_IGNORE_DURATION) { - eventType = POWER_MANAGER_TOUCH_EVENT; - } else { - eventType = POWER_MANAGER_LONG_TOUCH_EVENT; - } - break; - } - } else { - eventType = POWER_MANAGER_BUTTON_EVENT; - } - pokeUserActivityLocked(entry->eventTime, eventType); - } return true; } @@ -829,6 +804,8 @@ void InputDispatcher::dispatchEventToCurrentInputTargetsLocked(nsecs_t currentTi assert(eventEntry->dispatchInProgress); // should already have been set to true + pokeUserActivityLocked(eventEntry); + for (size_t i = 0; i < mCurrentInputTargets.size(); i++) { const InputTarget& inputTarget = mCurrentInputTargets.itemAt(i); @@ -1338,7 +1315,6 @@ void InputDispatcher::addWindowTargetLocked(const InputWindow* window, int32_t t target.flags = targetFlags; target.xOffset = - window->frameLeft; target.yOffset = - window->frameTop; - target.windowType = window->layoutParamsType; target.pointerIds = pointerIds; } @@ -1351,7 +1327,6 @@ void InputDispatcher::addMonitoringTargetsLocked() { target.flags = 0; target.xOffset = 0; target.yOffset = 0; - target.windowType = -1; } } @@ -1418,19 +1393,32 @@ String8 InputDispatcher::getApplicationWindowLabelLocked(const InputApplication* } } -bool InputDispatcher::shouldPokeUserActivityForCurrentInputTargetsLocked() { - for (size_t i = 0; i < mCurrentInputTargets.size(); i++) { - if (mCurrentInputTargets[i].windowType == InputWindow::TYPE_KEYGUARD) { - return false; +void InputDispatcher::pokeUserActivityLocked(const EventEntry* eventEntry) { + int32_t eventType = POWER_MANAGER_BUTTON_EVENT; + if (eventEntry->type == EventEntry::TYPE_MOTION) { + const MotionEntry* motionEntry = static_cast(eventEntry); + if (motionEntry->source & AINPUT_SOURCE_CLASS_POINTER) { + switch (motionEntry->action) { + case AMOTION_EVENT_ACTION_DOWN: + eventType = POWER_MANAGER_TOUCH_EVENT; + break; + case AMOTION_EVENT_ACTION_UP: + eventType = POWER_MANAGER_TOUCH_UP_EVENT; + break; + default: + if (motionEntry->eventTime - motionEntry->downTime >= EVENT_IGNORE_DURATION) { + eventType = POWER_MANAGER_TOUCH_EVENT; + } else { + eventType = POWER_MANAGER_LONG_TOUCH_EVENT; + } + break; + } } } - return true; -} -void InputDispatcher::pokeUserActivityLocked(nsecs_t eventTime, int32_t eventType) { CommandEntry* commandEntry = postCommandLocked( & InputDispatcher::doPokeUserActivityLockedInterruptible); - commandEntry->eventTime = eventTime; + commandEntry->eventTime = eventEntry->eventTime; commandEntry->userActivityEventType = eventType; }