am 03aa28fb: Merge "Improve the input policy handling a bit." into gingerbread

Merge commit '03aa28fb36589a3d601be08e75c08a24c4344d6f' into gingerbread-plus-aosp * commit '03aa28fb36589a3d601be08e75c08a24c4344d6f': Improve the input policy handling a bit.
2010-10-12 01:04:16 -07:00
parent b99db0c70e 03aa28fb36
commit 4b255a2304
3 changed files with 84 additions and 64 deletions
--- a/libs/ui/InputDispatcher.cpp
+++ b/libs/ui/InputDispatcher.cpp
@ -432,10 +432,9 @@ void InputDispatcher::dropInboundEventLocked(EventEntry* entry, DropReason dropR
    switch (dropReason) {
    case DROP_REASON_POLICY:
 #if DEBUG_INBOUND_EVENT_DETAILS
-        LOGD("Dropped event because policy requested that it not be delivered to the application.");
+        LOGD("Dropped event because policy consumed it.");
 #endif
-        reason = "inbound event was dropped because the policy requested that it not be "
-                "delivered to the application";
+        reason = "inbound event was dropped because the policy consumed it";
        break;
    case DROP_REASON_DISABLED:
        LOGI("Dropped event because input dispatch is disabled.");
@ -625,15 +624,13 @@ bool InputDispatcher::dispatchKeyLocked(
        if (*dropReason == DROP_REASON_NOT_DROPPED) {
            *dropReason = DROP_REASON_POLICY;
        }
-        resetTargetsLocked();
-        setInjectionResultLocked(entry, INPUT_EVENT_INJECTION_SUCCEEDED);
-        return true;
    }

    // Clean up if dropping the event.
    if (*dropReason != DROP_REASON_NOT_DROPPED) {
        resetTargetsLocked();
-        setInjectionResultLocked(entry, INPUT_EVENT_INJECTION_FAILED);
+        setInjectionResultLocked(entry, *dropReason == DROP_REASON_POLICY
+                ? INPUT_EVENT_INJECTION_SUCCEEDED : INPUT_EVENT_INJECTION_FAILED);
        return true;
    }

@ -713,7 +710,8 @@ bool InputDispatcher::dispatchMotionLocked(
    // Clean up if dropping the event.
    if (*dropReason != DROP_REASON_NOT_DROPPED) {
        resetTargetsLocked();
-        setInjectionResultLocked(entry, INPUT_EVENT_INJECTION_FAILED);
+        setInjectionResultLocked(entry, *dropReason == DROP_REASON_POLICY
+                ? INPUT_EVENT_INJECTION_SUCCEEDED : INPUT_EVENT_INJECTION_FAILED);
        return true;
    }

--- a/policy/src/com/android/internal/policy/impl/PhoneWindowManager.java
+++ b/policy/src/com/android/internal/policy/impl/PhoneWindowManager.java
@ -1057,10 +1057,6 @@ public class PhoneWindowManager implements WindowManagerPolicy {
    @Override
    public boolean interceptKeyBeforeDispatching(WindowState win, int action, int flags,
            int keyCode, int metaState, int repeatCount, int policyFlags) {
-        if ((policyFlags & WindowManagerPolicy.FLAG_TRUSTED) == 0) {
-            return false;
-        }
-
        final boolean keyguardOn = keyguardOn();
        final boolean down = (action == KeyEvent.ACTION_DOWN);
        final boolean canceled = ((flags & KeyEvent.FLAG_CANCELED) != 0);
@ -1739,9 +1735,6 @@ public class PhoneWindowManager implements WindowManagerPolicy {
    public int interceptKeyBeforeQueueing(long whenNanos, int keyCode, boolean down,
            int policyFlags, boolean isScreenOn) {
        int result = ACTION_PASS_TO_USER;
-        if ((policyFlags & WindowManagerPolicy.FLAG_TRUSTED) == 0) {
-            return result;
-        }

        if (down && (policyFlags & WindowManagerPolicy.FLAG_VIRTUAL) != 0) {
            performHapticFeedbackLw(null, HapticFeedbackConstants.VIRTUAL_KEY, false);
@ -1750,6 +1743,13 @@ public class PhoneWindowManager implements WindowManagerPolicy {
        final boolean isWakeKey = (policyFlags
                & (WindowManagerPolicy.FLAG_WAKE | WindowManagerPolicy.FLAG_WAKE_DROPPED)) != 0;

+        // If the key is injected, pretend that the screen is on and don't let the
+        // device go to sleep.  This feature is mainly used for testing purposes.
+        final boolean isInjected = (policyFlags & WindowManagerPolicy.FLAG_INJECTED) != 0;
+        if (isInjected) {
+            isScreenOn = true;
+        }
+
        // If screen is off then we treat the case where the keyguard is open but hidden
        // the same as if it were open and in front.
        // This will prevent any keys other than the power button from waking the screen
@ -1848,7 +1848,7 @@ public class PhoneWindowManager implements WindowManagerPolicy {
                        || (handled && hungUp && keyCode == KeyEvent.KEYCODE_POWER)) {
                    mShouldTurnOffOnKeyUp = false;
                } else {
-                    // only try to turn off the screen if we didn't already hang up
+                    // Only try to turn off the screen if we didn't already hang up.
                    mShouldTurnOffOnKeyUp = true;
                    mHandler.postDelayed(mPowerLongPress,
                            ViewConfiguration.getGlobalActionKeyTimeout());
@ -1871,13 +1871,15 @@ public class PhoneWindowManager implements WindowManagerPolicy {
                    if (keyguardActive
                            || (sleeps && !gohome)
                            || (gohome && !goHome() && sleeps)) {
-                        // they must already be on the keyguad or home screen,
-                        // go to sleep instead
+                        // They must already be on the keyguard or home screen,
+                        // go to sleep instead unless the event was injected.
+                        if (!isInjected) {
                            Log.d(TAG, "I'm tired mEndcallBehavior=0x"
                                    + Integer.toHexString(mEndcallBehavior));
                            result &= ~ACTION_POKE_USER_ACTIVITY;
                            result |= ACTION_GO_TO_SLEEP;
                        }
+                    }
                    result &= ~ACTION_PASS_TO_USER;
                }
            }
--- a/services/jni/com_android_server_InputManager.cpp
+++ b/services/jni/com_android_server_InputManager.cpp
@ -842,6 +842,11 @@ void NativeInputManager::interceptKeyBeforeQueueing(nsecs_t when,
        flags |= AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY;
    }

+    // Policy:
+    // - Ignore untrusted events and pass them along.
+    // - Ask the window manager what to do with normal events and trusted injected events.
+    // - For normal events wake and brighten the screen if currently off or dim.
+    if ((policyFlags & POLICY_FLAG_TRUSTED)) {
        const int32_t WM_ACTION_PASS_TO_USER = 1;
        const int32_t WM_ACTION_POKE_USER_ACTIVITY = 2;
        const int32_t WM_ACTION_GO_TO_SLEEP = 4;
@ -857,17 +862,16 @@ void NativeInputManager::interceptKeyBeforeQueueing(nsecs_t when,
            wmActions = 0;
        }

-    if (policyFlags & POLICY_FLAG_TRUSTED) {
-        if (! isScreenOn) {
-            // Key presses and releases wake the device.
+        if (!(flags & POLICY_FLAG_INJECTED)) {
+            if (!isScreenOn) {
                policyFlags |= POLICY_FLAG_WOKE_HERE;
                flags |= AKEY_EVENT_FLAG_WOKE_HERE;
            }

-        if (! isScreenBright) {
-            // Key presses and releases brighten the screen if dimmed.
+            if (!isScreenBright) {
                policyFlags |= POLICY_FLAG_BRIGHT_HERE;
            }
+        }

        if (wmActions & WM_ACTION_GO_TO_SLEEP) {
            android_server_PowerManagerService_goToSleep(when);
@ -876,11 +880,13 @@ void NativeInputManager::interceptKeyBeforeQueueing(nsecs_t when,
        if (wmActions & WM_ACTION_POKE_USER_ACTIVITY) {
            android_server_PowerManagerService_userActivity(when, POWER_MANAGER_BUTTON_EVENT);
        }
-    }

        if (wmActions & WM_ACTION_PASS_TO_USER) {
            policyFlags |= POLICY_FLAG_PASS_TO_USER;
        }
+    } else {
+        policyFlags |= POLICY_FLAG_PASS_TO_USER;
+    }
 }

 void NativeInputManager::interceptGenericBeforeQueueing(nsecs_t when, uint32_t& policyFlags) {
@ -888,20 +894,31 @@ void NativeInputManager::interceptGenericBeforeQueueing(nsecs_t when, uint32_t&
    LOGD("interceptGenericBeforeQueueing - when=%lld, policyFlags=0x%x", when, policyFlags);
 #endif

+    // Policy:
+    // - Ignore untrusted events and pass them along.
+    // - No special filtering for injected events required at this time.
+    // - Filter normal events based on screen state.
+    // - For normal events brighten (but do not wake) the screen if currently dim.
+    if ((policyFlags & POLICY_FLAG_TRUSTED) && !(policyFlags & POLICY_FLAG_INJECTED)) {
        if (isScreenOn()) {
-        // Only dispatch events when the device is awake.
-        // Do not wake the device.
            policyFlags |= POLICY_FLAG_PASS_TO_USER;

-        if ((policyFlags & POLICY_FLAG_TRUSTED) && !isScreenBright()) {
-            // Brighten the screen if dimmed.
+            if (!isScreenBright()) {
                policyFlags |= POLICY_FLAG_BRIGHT_HERE;
            }
        }
+    } else {
+        policyFlags |= POLICY_FLAG_PASS_TO_USER;
+    }
 }

 bool NativeInputManager::interceptKeyBeforeDispatching(const sp<InputChannel>& inputChannel,
        const KeyEvent* keyEvent, uint32_t policyFlags) {
+    // Policy:
+    // - Ignore untrusted events and pass them along.
+    // - Filter normal events and trusted injected events through the window manager policy to
+    //   handle the HOME key and the like.
+    if (policyFlags & POLICY_FLAG_TRUSTED) {
        JNIEnv* env = jniEnv();

        // Note: inputChannel may be null.
@ -915,6 +932,9 @@ bool NativeInputManager::interceptKeyBeforeDispatching(const sp<InputChannel>& i

        env->DeleteLocalRef(inputChannelObj);
        return consumed && ! error;
+    } else {
+        return false;
+    }
 }

 void NativeInputManager::pokeUserActivity(nsecs_t eventTime, int32_t eventType) {