Merge "Prevent display brightness flicker on power button" into main (e2bcb0ae) · Commits · e / os / android_frameworks_native

services/inputflinger/dispatcher/InputDispatcher.cpp

+7 −11

Original line number	Original line	Diff line number	Diff line
	@@ -1894,8 +1894,6 @@ bool InputDispatcher::dispatchKeyLocked(nsecs_t currentTime, std::shared_ptr<con
	doInterceptKeyBeforeDispatchingCommand(focusedWindowToken, *entry);		doInterceptKeyBeforeDispatchingCommand(focusedWindowToken, *entry);
	};		};
	postCommandLocked(std::move(command));		postCommandLocked(std::move(command));
	// Poke user activity for keys not passed to user
	pokeUserActivityLocked(*entry);
	return false; // wait for the command to run		return false; // wait for the command to run
	} else {		} else {
	entry->interceptKeyResult = KeyEntry::InterceptKeyResult::CONTINUE;		entry->interceptKeyResult = KeyEntry::InterceptKeyResult::CONTINUE;
	@@ -1912,8 +1910,12 @@ bool InputDispatcher::dispatchKeyLocked(nsecs_t currentTime, std::shared_ptr<con
	*dropReason == DropReason::POLICY ? InputEventInjectionResult::SUCCEEDED		*dropReason == DropReason::POLICY ? InputEventInjectionResult::SUCCEEDED
	: InputEventInjectionResult::FAILED);		: InputEventInjectionResult::FAILED);
	mReporter->reportDroppedKey(entry->id);		mReporter->reportDroppedKey(entry->id);
	// Poke user activity for undispatched keys		// Poke user activity for consumed keys, as it may have not been reported due to
			// the focused window requesting user activity to be disabled
			if (*dropReason == DropReason::POLICY &&
			mPendingEvent->policyFlags & POLICY_FLAG_PASS_TO_USER) {
	pokeUserActivityLocked(*entry);		pokeUserActivityLocked(*entry);
			}
	return true;		return true;
	}		}

	@@ -3313,22 +3315,16 @@ void InputDispatcher::pokeUserActivityLocked(const EventEntry& eventEntry) {
	if (keyEntry.flags & AKEY_EVENT_FLAG_CANCELED) {		if (keyEntry.flags & AKEY_EVENT_FLAG_CANCELED) {
	return;		return;
	}		}
	// If the key code is unknown, we don't consider it user activity
	if (keyEntry.keyCode == AKEYCODE_UNKNOWN) {
	return;
	}
	// Don't inhibit events that were intercepted or are not passed to		// Don't inhibit events that were intercepted or are not passed to
	// the apps, like system shortcuts		// the apps, like system shortcuts
	if (windowDisablingUserActivityInfo != nullptr &&		if (windowDisablingUserActivityInfo != nullptr &&
	keyEntry.interceptKeyResult != KeyEntry::InterceptKeyResult::SKIP &&		keyEntry.interceptKeyResult != KeyEntry::InterceptKeyResult::SKIP) {
	keyEntry.policyFlags & POLICY_FLAG_PASS_TO_USER) {
	if (DEBUG_DISPATCH_CYCLE) {		if (DEBUG_DISPATCH_CYCLE) {
	ALOGD("Not poking user activity: disabled by window '%s'.",		ALOGD("Not poking user activity: disabled by window '%s'.",
	windowDisablingUserActivityInfo->name.c_str());		windowDisablingUserActivityInfo->name.c_str());
	}		}
	return;		return;
	}		}

	break;		break;
	}		}
	default: {		default: {

services/inputflinger/tests/FakeInputDispatcherPolicy.cpp

+7 −0

Original line number	Original line	Diff line number	Diff line
	@@ -215,6 +215,10 @@ void FakeInputDispatcherPolicy::setStaleEventTimeout(std::chrono::nanoseconds ti
	mStaleEventTimeout = timeout;		mStaleEventTimeout = timeout;
	}		}

			void FakeInputDispatcherPolicy::setConsumeKeyBeforeDispatching(bool consumeKeyBeforeDispatching) {
			mConsumeKeyBeforeDispatching = consumeKeyBeforeDispatching;
			}

	void FakeInputDispatcherPolicy::assertUserActivityNotPoked() {		void FakeInputDispatcherPolicy::assertUserActivityNotPoked() {
	std::unique_lock lock(mLock);		std::unique_lock lock(mLock);
	base::ScopedLockAssertion assumeLocked(mLock);		base::ScopedLockAssertion assumeLocked(mLock);
	@@ -401,6 +405,9 @@ void FakeInputDispatcherPolicy::interceptMotionBeforeQueueing(ui::LogicalDisplay

	nsecs_t FakeInputDispatcherPolicy::interceptKeyBeforeDispatching(const sp<IBinder>&,		nsecs_t FakeInputDispatcherPolicy::interceptKeyBeforeDispatching(const sp<IBinder>&,
	const KeyEvent&, uint32_t) {		const KeyEvent&, uint32_t) {
			if (mConsumeKeyBeforeDispatching) {
			return -1;
			}
	nsecs_t delay = std::chrono::nanoseconds(mInterceptKeyTimeout).count();		nsecs_t delay = std::chrono::nanoseconds(mInterceptKeyTimeout).count();
	// Clear intercept state so we could dispatch the event in next wake.		// Clear intercept state so we could dispatch the event in next wake.
	mInterceptKeyTimeout = 0ms;		mInterceptKeyTimeout = 0ms;

services/inputflinger/tests/FakeInputDispatcherPolicy.h

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -115,6 +115,7 @@ public:
	void setUnhandledKeyHandler(std::function<std::optional<KeyEvent>(const KeyEvent&)> handler);		void setUnhandledKeyHandler(std::function<std::optional<KeyEvent>(const KeyEvent&)> handler);
	void assertUnhandledKeyReported(int32_t keycode);		void assertUnhandledKeyReported(int32_t keycode);
	void assertUnhandledKeyNotReported();		void assertUnhandledKeyNotReported();
			void setConsumeKeyBeforeDispatching(bool consumeKeyBeforeDispatching);

	private:		private:
	std::mutex mLock;		std::mutex mLock;
	@@ -144,6 +145,8 @@ private:

	std::chrono::nanoseconds mStaleEventTimeout = 1000ms;		std::chrono::nanoseconds mStaleEventTimeout = 1000ms;

			bool mConsumeKeyBeforeDispatching = false;

	BlockingQueue<std::pair<int32_t /deviceId/, std::set<gui::Uid>>> mNotifiedInteractions;		BlockingQueue<std::pair<int32_t /deviceId/, std::set<gui::Uid>>> mNotifiedInteractions;

	std::condition_variable mNotifyUnhandledKey;		std::condition_variable mNotifyUnhandledKey;

services/inputflinger/tests/InputDispatcher_test.cpp

+29 −36

Original line number	Original line	Diff line number	Diff line
	@@ -610,28 +610,6 @@ static NotifyKeyArgs generateKeyArgs(
	return args;		return args;
	}		}

	static NotifyKeyArgs generateSystemShortcutArgs(
	int32_t action, ui::LogicalDisplayId displayId = ui::LogicalDisplayId::INVALID) {
	nsecs_t currentTime = systemTime(SYSTEM_TIME_MONOTONIC);
	// Define a valid key event.
	NotifyKeyArgs args(InputEvent::nextId(), currentTime, /readTime=/0, DEVICE_ID,
	AINPUT_SOURCE_KEYBOARD, displayId, 0, action, /flags=/0, AKEYCODE_C, KEY_C,
	AMETA_META_ON, currentTime);

	return args;
	}

	static NotifyKeyArgs generateAssistantKeyArgs(
	int32_t action, ui::LogicalDisplayId displayId = ui::LogicalDisplayId::INVALID) {
	nsecs_t currentTime = systemTime(SYSTEM_TIME_MONOTONIC);
	// Define a valid key event.
	NotifyKeyArgs args(InputEvent::nextId(), currentTime, /readTime=/0, DEVICE_ID,
	AINPUT_SOURCE_KEYBOARD, displayId, 0, action, /flags=/0, AKEYCODE_ASSIST,
	KEY_ASSISTANT, AMETA_NONE, currentTime);

	return args;
	}

	[[nodiscard]] static NotifyMotionArgs generateMotionArgs(int32_t action, int32_t source,		[[nodiscard]] static NotifyMotionArgs generateMotionArgs(int32_t action, int32_t source,
	ui::LogicalDisplayId displayId,		ui::LogicalDisplayId displayId,
	const std::vector<PointF>& points) {		const std::vector<PointF>& points) {
	@@ -6628,17 +6606,18 @@ TEST_F(InputDispatcherTest, FocusedWindow_DisableUserActivity) {

	window->consumeFocusEvent(true);		window->consumeFocusEvent(true);

	mDispatcher->notifyKey(generateKeyArgs(AKEY_EVENT_ACTION_DOWN, ui::LogicalDisplayId::DEFAULT));		mDispatcher->notifyKey(
			KeyArgsBuilder(ACTION_DOWN, AINPUT_SOURCE_KEYBOARD).keyCode(AKEYCODE_A).build());

	// Window should receive key down event.		// Window should receive key down event.
	window->consumeKeyDown(ui::LogicalDisplayId::DEFAULT);		window->consumeKeyDown(ui::LogicalDisplayId::DEFAULT);

	// Should have poked user activity		// Should have not poked user activity
	mDispatcher->waitForIdle();		mDispatcher->waitForIdle();
	mFakePolicy->assertUserActivityNotPoked();		mFakePolicy->assertUserActivityNotPoked();
	}		}

	TEST_F(InputDispatcherTest, FocusedWindow_DoesNotReceiveSystemShortcut) {		TEST_F(InputDispatcherTest, FocusedWindow_DoesNotReceivePolicyConsumedKey) {
	std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();		std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
	sp<FakeWindowHandle> window =		sp<FakeWindowHandle> window =
	sp<FakeWindowHandle>::make(application, mDispatcher, "Fake Window",		sp<FakeWindowHandle>::make(application, mDispatcher, "Fake Window",
	@@ -6650,31 +6629,36 @@ TEST_F(InputDispatcherTest, FocusedWindow_DoesNotReceiveSystemShortcut) {

	window->consumeFocusEvent(true);		window->consumeFocusEvent(true);

			mFakePolicy->setConsumeKeyBeforeDispatching(true);

	mDispatcher->notifyKey(		mDispatcher->notifyKey(
	generateSystemShortcutArgs(AKEY_EVENT_ACTION_DOWN, ui::LogicalDisplayId::DEFAULT));		KeyArgsBuilder(ACTION_DOWN, AINPUT_SOURCE_KEYBOARD).keyCode(AKEYCODE_A).build());
	mDispatcher->waitForIdle();		mDispatcher->waitForIdle();

	// System key is not passed down		// Key is not passed down
	window->assertNoEvents();		window->assertNoEvents();

	// Should have poked user activity		// Should have poked user activity
	mFakePolicy->assertUserActivityPoked();		mFakePolicy->assertUserActivityPoked();
	}		}

	TEST_F(InputDispatcherTest, FocusedWindow_DoesNotReceiveAssistantKey) {		TEST_F(InputDispatcherTest, FocusedWindow_PolicyConsumedKeyIgnoresDisableUserActivity) {
	std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();		std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
	sp<FakeWindowHandle> window =		sp<FakeWindowHandle> window =
	sp<FakeWindowHandle>::make(application, mDispatcher, "Fake Window",		sp<FakeWindowHandle>::make(application, mDispatcher, "Fake Window",
	ui::LogicalDisplayId::DEFAULT);		ui::LogicalDisplayId::DEFAULT);

			window->setDisableUserActivity(true);
	window->setFocusable(true);		window->setFocusable(true);
	mDispatcher->onWindowInfosChanged({{*window->getInfo()}, {}, 0, 0});		mDispatcher->onWindowInfosChanged({{*window->getInfo()}, {}, 0, 0});
	setFocusedWindow(window);		setFocusedWindow(window);

	window->consumeFocusEvent(true);		window->consumeFocusEvent(true);

			mFakePolicy->setConsumeKeyBeforeDispatching(true);

	mDispatcher->notifyKey(		mDispatcher->notifyKey(
	generateAssistantKeyArgs(AKEY_EVENT_ACTION_DOWN, ui::LogicalDisplayId::DEFAULT));		KeyArgsBuilder(ACTION_DOWN, AINPUT_SOURCE_KEYBOARD).keyCode(AKEYCODE_A).build());
	mDispatcher->waitForIdle();		mDispatcher->waitForIdle();

	// System key is not passed down		// System key is not passed down
	@@ -6684,30 +6668,39 @@ TEST_F(InputDispatcherTest, FocusedWindow_DoesNotReceiveAssistantKey) {
	mFakePolicy->assertUserActivityPoked();		mFakePolicy->assertUserActivityPoked();
	}		}

	TEST_F(InputDispatcherTest, FocusedWindow_SystemKeyIgnoresDisableUserActivity) {		class DisableUserActivityInputDispatcherTest : public InputDispatcherTest,
			public ::testing::WithParamInterface<bool> {};

			TEST_P(DisableUserActivityInputDispatcherTest, NotPassedToUserUserActivity) {
	std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();		std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
	sp<FakeWindowHandle> window =		sp<FakeWindowHandle> window =
	sp<FakeWindowHandle>::make(application, mDispatcher, "Fake Window",		sp<FakeWindowHandle>::make(application, mDispatcher, "Fake Window",
	ui::LogicalDisplayId::DEFAULT);		ui::LogicalDisplayId::DEFAULT);

	window->setDisableUserActivity(true);		window->setDisableUserActivity(GetParam());

	window->setFocusable(true);		window->setFocusable(true);
	mDispatcher->onWindowInfosChanged({{*window->getInfo()}, {}, 0, 0});		mDispatcher->onWindowInfosChanged({{*window->getInfo()}, {}, 0, 0});
	setFocusedWindow(window);		setFocusedWindow(window);

	window->consumeFocusEvent(true);		window->consumeFocusEvent(true);

	mDispatcher->notifyKey(		mDispatcher->notifyKey(KeyArgsBuilder(ACTION_DOWN, AINPUT_SOURCE_KEYBOARD)
	generateSystemShortcutArgs(AKEY_EVENT_ACTION_DOWN, ui::LogicalDisplayId::DEFAULT));		.keyCode(AKEYCODE_A)
			.policyFlags(0)
			.build());
	mDispatcher->waitForIdle();		mDispatcher->waitForIdle();

	// System key is not passed down		// Key is not passed down
	window->assertNoEvents();		window->assertNoEvents();

	// Should have poked user activity		// Should not have poked user activity
	mFakePolicy->assertUserActivityPoked();		mFakePolicy->assertUserActivityNotPoked();
	}		}

			INSTANTIATE_TEST_CASE_P(DisableUserActivity, DisableUserActivityInputDispatcherTest,
			::testing::Bool());

	TEST_F(InputDispatcherTest, InjectedTouchesPokeUserActivity) {		TEST_F(InputDispatcherTest, InjectedTouchesPokeUserActivity) {
	std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();		std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
	sp<FakeWindowHandle> window =		sp<FakeWindowHandle> window =