Merge "Refactor interceptKeyBeforeQueueing tests in FakeInputDispatcherPolicy" into main (6925c952) · Commits · e / os / android_frameworks_native

services/inputflinger/tests/FakeInputDispatcherPolicy.cpp

+13 −11

Original line number	Diff line number	Diff line
		@@ -198,10 +198,6 @@ void FakeInputDispatcherPolicy::assertNotifyInputChannelBrokenWasCalled(const sp
		ASSERT_EQ(token, *receivedToken);
		}

		void FakeInputDispatcherPolicy::setInterceptKeyTimeout(std::chrono::milliseconds timeout) {
		mInterceptKeyTimeout = timeout;
		}

		std::chrono::nanoseconds FakeInputDispatcherPolicy::getKeyWaitingForEventsTimeout() {
		return 500ms;
		}
		@@ -210,8 +206,9 @@ void FakeInputDispatcherPolicy::setStaleEventTimeout(std::chrono::nanoseconds ti
		mStaleEventTimeout = timeout;
		}

		void FakeInputDispatcherPolicy::setConsumeKeyBeforeDispatching(bool consumeKeyBeforeDispatching) {
		mConsumeKeyBeforeDispatching = consumeKeyBeforeDispatching;
		void FakeInputDispatcherPolicy::setInterceptKeyBeforeDispatchingResult(
		std::variant<nsecs_t, inputdispatcher::KeyEntry::InterceptKeyResult> result) {
		mInterceptKeyBeforeDispatchingResult = result;
		}

		void FakeInputDispatcherPolicy::assertFocusedDisplayNotified(ui::LogicalDisplayId expectedDisplay) {
		@@ -404,7 +401,9 @@ bool FakeInputDispatcherPolicy::filterInputEvent(const InputEvent& inputEvent,
		void FakeInputDispatcherPolicy::interceptKeyBeforeQueueing(const KeyEvent& inputEvent, uint32_t&) {
		if (inputEvent.getAction() == AKEY_EVENT_ACTION_UP) {
		// Clear intercept state when we handled the event.
		mInterceptKeyTimeout = 0ms;
		if (std::holds_alternative<nsecs_t>(mInterceptKeyBeforeDispatchingResult)) {
		mInterceptKeyBeforeDispatchingResult = nsecs_t(0);
		}
		}
		}

		@@ -414,17 +413,20 @@ void FakeInputDispatcherPolicy::interceptMotionBeforeQueueing(ui::LogicalDisplay
		std::variant<nsecs_t, inputdispatcher::KeyEntry::InterceptKeyResult>
		FakeInputDispatcherPolicy::interceptKeyBeforeDispatching(const sp<IBinder>&, const KeyEvent&,
		uint32_t) {
		if (mConsumeKeyBeforeDispatching) {
		return inputdispatcher::KeyEntry::InterceptKeyResult::SKIP;
		if (std::holds_alternative<inputdispatcher::KeyEntry::InterceptKeyResult>(
		mInterceptKeyBeforeDispatchingResult)) {
		return mInterceptKeyBeforeDispatchingResult;
		}

		nsecs_t delay = std::chrono::nanoseconds(mInterceptKeyTimeout).count();
		nsecs_t delay =
		std::chrono::nanoseconds(std::get<nsecs_t>(mInterceptKeyBeforeDispatchingResult))
		.count();
		if (delay == 0) {
		return inputdispatcher::KeyEntry::InterceptKeyResult::CONTINUE;
		}

		// Clear intercept state so we could dispatch the event in next wake.
		mInterceptKeyTimeout = 0ms;
		mInterceptKeyBeforeDispatchingResult = nsecs_t(0);
		return delay;
		}

services/inputflinger/tests/FakeInputDispatcherPolicy.h

+8 −8

Original line number	Diff line number	Diff line
		@@ -96,10 +96,6 @@ public:
		void assertDropTargetEquals(const InputDispatcherInterface& dispatcher,
		const sp<IBinder>& targetToken);
		void assertNotifyInputChannelBrokenWasCalled(const sp<IBinder>& token);
		/**
		* Set policy timeout. A value of zero means next key will not be intercepted.
		*/
		void setInterceptKeyTimeout(std::chrono::milliseconds timeout);
		std::chrono::nanoseconds getKeyWaitingForEventsTimeout() override;
		void setStaleEventTimeout(std::chrono::nanoseconds timeout);
		void assertUserActivityNotPoked();
		@@ -116,7 +112,12 @@ public:
		void setUnhandledKeyHandler(std::function<std::optional<KeyEvent>(const KeyEvent&)> handler);
		void assertUnhandledKeyReported(int32_t keycode);
		void assertUnhandledKeyNotReported();
		void setConsumeKeyBeforeDispatching(bool consumeKeyBeforeDispatching);
		/**
		* Set policy timeout or the interception result.
		* A timeout value of zero means next key will not be intercepted.
		*/
		void setInterceptKeyBeforeDispatchingResult(
		std::variant<nsecs_t, inputdispatcher::KeyEntry::InterceptKeyResult> result);
		void assertFocusedDisplayNotified(ui::LogicalDisplayId expectedDisplay);

		private:
		@@ -145,11 +146,10 @@ private:
		std::condition_variable mNotifyUserActivity;
		std::queue<UserActivityPokeEvent> mUserActivityPokeEvents;

		std::chrono::milliseconds mInterceptKeyTimeout = 0ms;

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

		bool mConsumeKeyBeforeDispatching = false;
		std::variant<nsecs_t, inputdispatcher::KeyEntry::InterceptKeyResult>
		mInterceptKeyBeforeDispatchingResult;

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

services/inputflinger/tests/InputDispatcher_test.cpp

+7 −4

Original line number	Diff line number	Diff line
		@@ -5491,7 +5491,8 @@ TEST_F(InputDispatcherTest, InterceptKeyByPolicy) {
		generateKeyArgs(AKEY_EVENT_ACTION_DOWN, ui::LogicalDisplayId::DEFAULT);
		const std::chrono::milliseconds interceptKeyTimeout = 50ms;
		const nsecs_t injectTime = keyArgs.eventTime;
		mFakePolicy->setInterceptKeyTimeout(interceptKeyTimeout);
		mFakePolicy->setInterceptKeyBeforeDispatchingResult(
		std::chrono::nanoseconds(interceptKeyTimeout).count());
		mDispatcher->notifyKey(keyArgs);
		// The dispatching time should be always greater than or equal to intercept key timeout.
		window->consumeKeyDown(ui::LogicalDisplayId::DEFAULT);
		@@ -5519,7 +5520,7 @@ TEST_F(InputDispatcherTest, InterceptKeyIfKeyUp) {

		// Set a value that's significantly larger than the default consumption timeout. If the
		// implementation is correct, the actual value doesn't matter; it won't slow down the test.
		mFakePolicy->setInterceptKeyTimeout(600ms);
		mFakePolicy->setInterceptKeyBeforeDispatchingResult(std::chrono::nanoseconds(600ms).count());
		mDispatcher->notifyKey(generateKeyArgs(AKEY_EVENT_ACTION_UP, ui::LogicalDisplayId::DEFAULT));
		// Window should receive key event immediately when same key up.
		window->consumeKeyUp(ui::LogicalDisplayId::DEFAULT);
		@@ -7438,7 +7439,8 @@ TEST_F(InputDispatcherTest, FocusedWindow_DoesNotReceivePolicyConsumedKey) {

		window->consumeFocusEvent(true);

		mFakePolicy->setConsumeKeyBeforeDispatching(true);
		mFakePolicy->setInterceptKeyBeforeDispatchingResult(
		inputdispatcher::KeyEntry::InterceptKeyResult::SKIP);

		mDispatcher->notifyKey(
		KeyArgsBuilder(ACTION_DOWN, AINPUT_SOURCE_KEYBOARD).keyCode(AKEYCODE_A).build());
		@@ -7464,7 +7466,8 @@ TEST_F(InputDispatcherTest, FocusedWindow_PolicyConsumedKeyIgnoresDisableUserAct

		window->consumeFocusEvent(true);

		mFakePolicy->setConsumeKeyBeforeDispatching(true);
		mFakePolicy->setInterceptKeyBeforeDispatchingResult(
		inputdispatcher::KeyEntry::InterceptKeyResult::SKIP);

		mDispatcher->notifyKey(
		KeyArgsBuilder(ACTION_DOWN, AINPUT_SOURCE_KEYBOARD).keyCode(AKEYCODE_A).build());