am 03aa28fb: Merge "Improve the input policy handling a bit." into gingerbread (4b255a23) · Commits · e / os / android_frameworks_base

libs/ui/InputDispatcher.cpp

+6 −8

Original line number	Diff line number	Diff line
		@@ -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;
		}

policy/src/com/android/internal/policy/impl/PhoneWindowManager.java

+17 −15

Original line number	Diff line number	Diff line
		@@ -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;
		}
		}

services/jni/com_android_server_InputManager.cpp

+64 −44

Original line number	Diff line number	Diff line
		@@ -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 (!(flags & POLICY_FLAG_INJECTED)) {
		if (!isScreenOn) {
		// Key presses and releases wake the device.
		policyFlags \|= POLICY_FLAG_WOKE_HERE;
		flags \|= AKEY_EVENT_FLAG_WOKE_HERE;
		}

		if (!isScreenBright) {
		// Key presses and releases brighten the screen if dimmed.
		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) {