Merge "Increase timeouts in FakeInputDispatcherPolicy" into main (749497e7) · Commits · e / os / android_frameworks_native

services/inputflinger/dispatcher/InputDispatcher.cpp

+10 −11

Original line number	Diff line number	Diff line
		@@ -3251,7 +3251,7 @@ void InputDispatcher::pokeUserActivityLocked(const EventEntry& eventEntry) {
		}

		const int32_t eventType = getUserActivityEventType(eventEntry);
		if (input_flags::rate_limit_user_activity_poke_in_dispatcher()) {

		// Note that we're directly getting the time diff between the current event and the previous
		// event. This is assuming that the first user event always happens at a timestamp that is
		// greater than `mMinTimeBetweenUserActivityPokes` (otherwise, the first user event will
		@@ -3262,7 +3262,6 @@ void InputDispatcher::pokeUserActivityLocked(const EventEntry& eventEntry) {
		if (timeSinceLastEvent < mMinTimeBetweenUserActivityPokes) {
		return;
		}
		}

		ui::LogicalDisplayId displayId = getTargetDisplayId(eventEntry);
		sp<WindowInfoHandle> focusedWindowHandle = getFocusedWindowHandleLocked(displayId);

services/inputflinger/tests/FakeInputDispatcherPolicy.cpp

+33 −19

Original line number	Diff line number	Diff line
		@@ -22,6 +22,13 @@

		namespace android {

		// How long to wait when we are expecting an event to occur.
		// This should be long, so that tests are not flaky when the device is slow.
		static constexpr std::chrono::nanoseconds EVENT_SHOULD_OCCUR_TIMEOUT = 5s;
		// How long to wait when we are expecting an event to not occur.
		// This should be short, so that the tests are fast.
		static constexpr std::chrono::nanoseconds EVENT_SHOULD_NOT_OCCUR_TIMEOUT = 10ms;

		// --- FakeInputDispatcherPolicy ---

		void FakeInputDispatcherPolicy::assertFilterInputEventWasCalled(const NotifyKeyArgs& args) {
		@@ -150,7 +157,8 @@ PointerCaptureRequest FakeInputDispatcherPolicy::assertSetPointerCaptureCalled(
		base::ScopedLockAssertion assumeLocked(mLock);

		if (!mPointerCaptureChangedCondition
		.wait_for(lock, 100ms, [this, enabled, window]() REQUIRES(mLock) {
		.wait_for(lock, EVENT_SHOULD_OCCUR_TIMEOUT,
		[this, enabled, window]() REQUIRES(mLock) {
		if (enabled) {
		return mPointerCaptureRequest->isEnable() &&
		mPointerCaptureRequest->window == window->getToken();
		@@ -171,7 +179,8 @@ void FakeInputDispatcherPolicy::assertSetPointerCaptureNotCalled() {
		std::unique_lock lock(mLock);
		base::ScopedLockAssertion assumeLocked(mLock);

		if (mPointerCaptureChangedCondition.wait_for(lock, 100ms) != std::cv_status::timeout) {
		if (mPointerCaptureChangedCondition.wait_for(lock, EVENT_SHOULD_NOT_OCCUR_TIMEOUT) !=
		std::cv_status::timeout) {
		FAIL() << "Expected setPointerCapture(request) to not be called, but was called. "
		"enabled = "
		<< std::to_string(mPointerCaptureRequest->isEnable());
		@@ -192,8 +201,8 @@ void FakeInputDispatcherPolicy::assertNotifyInputChannelBrokenWasCalled(const sp
		std::unique_lock lock(mLock);
		base::ScopedLockAssertion assumeLocked(mLock);
		std::optional<sp<IBinder>> receivedToken =
		getItemFromStorageLockedInterruptible(100ms, mBrokenInputChannels, lock,
		mNotifyInputChannelBroken);
		getItemFromStorageLockedInterruptible(EVENT_SHOULD_OCCUR_TIMEOUT, mBrokenInputChannels,
		lock, mNotifyInputChannelBroken);
		ASSERT_TRUE(receivedToken.has_value()) << "Did not receive the broken channel token";
		ASSERT_EQ(token, *receivedToken);
		}
		@@ -215,7 +224,7 @@ void FakeInputDispatcherPolicy::assertFocusedDisplayNotified(ui::LogicalDisplayI
		std::unique_lock lock(mLock);
		base::ScopedLockAssertion assumeLocked(mLock);

		if (!mFocusedDisplayNotifiedCondition.wait_for(lock, 100ms,
		if (!mFocusedDisplayNotifiedCondition.wait_for(lock, EVENT_SHOULD_OCCUR_TIMEOUT,
		[this, expectedDisplay]() REQUIRES(mLock) {
		if (!mNotifiedFocusedDisplay.has_value() \|\|
		mNotifiedFocusedDisplay.value() !=
		@@ -234,7 +243,8 @@ void FakeInputDispatcherPolicy::assertUserActivityNotPoked() {
		base::ScopedLockAssertion assumeLocked(mLock);

		std::optional<UserActivityPokeEvent> pokeEvent =
		getItemFromStorageLockedInterruptible(500ms, mUserActivityPokeEvents, lock,
		getItemFromStorageLockedInterruptible(EVENT_SHOULD_NOT_OCCUR_TIMEOUT,
		mUserActivityPokeEvents, lock,
		mNotifyUserActivity);

		ASSERT_FALSE(pokeEvent) << "Expected user activity not to have been poked";
		@@ -246,7 +256,8 @@ void FakeInputDispatcherPolicy::assertUserActivityPoked(
		base::ScopedLockAssertion assumeLocked(mLock);

		std::optional<UserActivityPokeEvent> pokeEvent =
		getItemFromStorageLockedInterruptible(500ms, mUserActivityPokeEvents, lock,
		getItemFromStorageLockedInterruptible(EVENT_SHOULD_OCCUR_TIMEOUT,
		mUserActivityPokeEvents, lock,
		mNotifyUserActivity);
		ASSERT_TRUE(pokeEvent) << "Expected a user poke event";

		@@ -257,11 +268,12 @@ void FakeInputDispatcherPolicy::assertUserActivityPoked(

		void FakeInputDispatcherPolicy::assertNotifyDeviceInteractionWasCalled(int32_t deviceId,
		std::set<gui::Uid> uids) {
		ASSERT_EQ(std::make_pair(deviceId, uids), mNotifiedInteractions.popWithTimeout(100ms));
		ASSERT_EQ(std::make_pair(deviceId, uids),
		mNotifiedInteractions.popWithTimeout(EVENT_SHOULD_OCCUR_TIMEOUT));
		}

		void FakeInputDispatcherPolicy::assertNotifyDeviceInteractionWasNotCalled() {
		ASSERT_FALSE(mNotifiedInteractions.popWithTimeout(10ms));
		ASSERT_FALSE(mNotifiedInteractions.popWithTimeout(EVENT_SHOULD_NOT_OCCUR_TIMEOUT));
		}

		void FakeInputDispatcherPolicy::setUnhandledKeyHandler(
		@@ -274,7 +286,8 @@ void FakeInputDispatcherPolicy::assertUnhandledKeyReported(int32_t keycode) {
		std::unique_lock lock(mLock);
		base::ScopedLockAssertion assumeLocked(mLock);
		std::optional<int32_t> unhandledKeycode =
		getItemFromStorageLockedInterruptible(100ms, mReportedUnhandledKeycodes, lock,
		getItemFromStorageLockedInterruptible(EVENT_SHOULD_OCCUR_TIMEOUT,
		mReportedUnhandledKeycodes, lock,
		mNotifyUnhandledKey);
		ASSERT_TRUE(unhandledKeycode) << "Expected unhandled key to be reported";
		ASSERT_EQ(unhandledKeycode, keycode);
		@@ -284,7 +297,8 @@ void FakeInputDispatcherPolicy::assertUnhandledKeyNotReported() {
		std::unique_lock lock(mLock);
		base::ScopedLockAssertion assumeLocked(mLock);
		std::optional<int32_t> unhandledKeycode =
		getItemFromStorageLockedInterruptible(10ms, mReportedUnhandledKeycodes, lock,
		getItemFromStorageLockedInterruptible(EVENT_SHOULD_NOT_OCCUR_TIMEOUT,
		mReportedUnhandledKeycodes, lock,
		mNotifyUnhandledKey);
		ASSERT_FALSE(unhandledKeycode) << "Expected unhandled key NOT to be reported";
		}
		@@ -436,7 +450,7 @@ FakeInputDispatcherPolicy::interceptKeyBeforeDispatching(const sp<IBinder>&, con

		void FakeInputDispatcherPolicy::assertKeyConsumedByPolicy(
		const ::testing::Matcher<KeyEvent>& matcher) {
		ASSERT_THAT(*mKeysConsumedByPolicy.popWithTimeout(100ms), matcher);
		ASSERT_THAT(*mKeysConsumedByPolicy.popWithTimeout(EVENT_SHOULD_OCCUR_TIMEOUT), matcher);
		}

		void FakeInputDispatcherPolicy::assertNoKeysConsumedByPolicy() {

services/inputflinger/tests/InputDispatcher_test.cpp

+17 −45

Original line number	Diff line number	Diff line
		@@ -9833,11 +9833,8 @@ private:
		std::chrono::nanoseconds mGestureStartTime;
		};

		TEST_F_WITH_FLAGS(
		InputDispatcherUserActivityPokeTests, MinPokeTimeObserved,
		REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(com::android::input::flags,
		rate_limit_user_activity_poke_in_dispatcher))) {
		mDispatcher->setMinTimeBetweenUserActivityPokes(50ms);
		TEST_F(InputDispatcherUserActivityPokeTests, MinPokeTimeObserved) {
		mDispatcher->setMinTimeBetweenUserActivityPokes(10ms);

		// First event of type TOUCH. Should poke.
		NotifyMotionArgs motionArgs =
		@@ -9846,88 +9843,63 @@ TEST_F_WITH_FLAGS(
		mFakePolicy->assertUserActivityPoked(
		{{motionArgs.eventTime, USER_ACTIVITY_EVENT_TOUCH, ui::LogicalDisplayId::DEFAULT}});

		// 80ns > 50ns has passed since previous TOUCH event. Should poke.
		// 80ms > 10ms has passed since previous TOUCH event. Should poke.
		motionArgs =
		notifyAndConsumeMotion(ACTION_MOVE, AINPUT_SOURCE_TOUCHSCREEN,
		ui::LogicalDisplayId::DEFAULT, std::chrono::milliseconds(130));
		mFakePolicy->assertUserActivityPoked(
		{{motionArgs.eventTime, USER_ACTIVITY_EVENT_TOUCH, ui::LogicalDisplayId::DEFAULT}});

		// First event of type OTHER. Should poke (despite being within 50ns of previous TOUCH event).
		// First event of type OTHER. Should poke (despite being within 10ms of previous TOUCH event).
		motionArgs =
		notifyAndConsumeMotion(ACTION_SCROLL, AINPUT_SOURCE_ROTARY_ENCODER,
		ui::LogicalDisplayId::DEFAULT, std::chrono::milliseconds(135));
		mFakePolicy->assertUserActivityPoked(
		{{motionArgs.eventTime, USER_ACTIVITY_EVENT_OTHER, ui::LogicalDisplayId::DEFAULT}});

		// Within 50ns of previous TOUCH event. Should NOT poke.
		// Within 10ms of previous TOUCH event. Should NOT poke.
		notifyAndConsumeMotion(ACTION_UP, AINPUT_SOURCE_TOUCHSCREEN, ui::LogicalDisplayId::DEFAULT,
		std::chrono::milliseconds(140));
		std::chrono::milliseconds(138));
		mFakePolicy->assertUserActivityNotPoked();

		// Within 50ns of previous OTHER event. Should NOT poke.
		// Within 10ms of previous OTHER event. Should NOT poke.
		notifyAndConsumeMotion(ACTION_SCROLL, AINPUT_SOURCE_ROTARY_ENCODER,
		ui::LogicalDisplayId::DEFAULT, std::chrono::milliseconds(150));
		ui::LogicalDisplayId::DEFAULT, std::chrono::milliseconds(142));
		mFakePolicy->assertUserActivityNotPoked();

		// Within 50ns of previous TOUCH event (which was at time 130). Should NOT poke.
		// Within 10ms of previous TOUCH event (which was at time 130). Should NOT poke.
		// Note that STYLUS is mapped to TOUCH user activity, since it's a pointer-type source.
		notifyAndConsumeMotion(ACTION_DOWN, AINPUT_SOURCE_STYLUS, ui::LogicalDisplayId::DEFAULT,
		std::chrono::milliseconds(160));
		std::chrono::milliseconds(139));
		mFakePolicy->assertUserActivityNotPoked();

		// 65ns > 50ns has passed since previous OTHER event. Should poke.
		// 50ms > 10ms has passed since previous OTHER event at 135ms. Should poke.
		motionArgs =
		notifyAndConsumeMotion(ACTION_SCROLL, AINPUT_SOURCE_ROTARY_ENCODER,
		ui::LogicalDisplayId::DEFAULT, std::chrono::milliseconds(200));
		ui::LogicalDisplayId::DEFAULT, std::chrono::milliseconds(185));
		mFakePolicy->assertUserActivityPoked(
		{{motionArgs.eventTime, USER_ACTIVITY_EVENT_OTHER, ui::LogicalDisplayId::DEFAULT}});

		// 170ns > 50ns has passed since previous TOUCH event. Should poke.
		// 160ms > 10ms has passed since previous TOUCH event. Should poke.
		motionArgs =
		notifyAndConsumeMotion(ACTION_UP, AINPUT_SOURCE_STYLUS, ui::LogicalDisplayId::DEFAULT,
		std::chrono::milliseconds(300));
		std::chrono::milliseconds(290));
		mFakePolicy->assertUserActivityPoked(
		{{motionArgs.eventTime, USER_ACTIVITY_EVENT_TOUCH, ui::LogicalDisplayId::DEFAULT}});

		// Assert that there's no more user activity poke event.
		// No other pokes
		mFakePolicy->assertUserActivityNotPoked();
		}

		TEST_F_WITH_FLAGS(
		InputDispatcherUserActivityPokeTests, DefaultMinPokeTimeOf100MsUsed,
		REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(com::android::input::flags,
		rate_limit_user_activity_poke_in_dispatcher))) {
		NotifyMotionArgs motionArgs =
		notifyAndConsumeMotion(ACTION_DOWN, AINPUT_SOURCE_TOUCHSCREEN,
		ui::LogicalDisplayId::DEFAULT, std::chrono::milliseconds(200));
		mFakePolicy->assertUserActivityPoked(
		{{motionArgs.eventTime, USER_ACTIVITY_EVENT_TOUCH, ui::LogicalDisplayId::DEFAULT}});

		notifyAndConsumeMotion(ACTION_MOVE, AINPUT_SOURCE_TOUCHSCREEN, ui::LogicalDisplayId::DEFAULT,
		std::chrono::milliseconds(280));
		mFakePolicy->assertUserActivityNotPoked();

		motionArgs =
		notifyAndConsumeMotion(ACTION_UP, AINPUT_SOURCE_TOUCHSCREEN,
		ui::LogicalDisplayId::DEFAULT, std::chrono::milliseconds(340));
		mFakePolicy->assertUserActivityPoked(
		{{motionArgs.eventTime, USER_ACTIVITY_EVENT_TOUCH, ui::LogicalDisplayId::DEFAULT}});
		}

		TEST_F_WITH_FLAGS(
		InputDispatcherUserActivityPokeTests, ZeroMinPokeTimeDisablesRateLimiting,
		REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(com::android::input::flags,
		rate_limit_user_activity_poke_in_dispatcher))) {
		TEST_F(InputDispatcherUserActivityPokeTests, ZeroMinPokeTimeDisablesRateLimiting) {
		mDispatcher->setMinTimeBetweenUserActivityPokes(0ms);

		notifyAndConsumeMotion(ACTION_DOWN, AINPUT_SOURCE_TOUCHSCREEN, ui::LogicalDisplayId::DEFAULT,
		std::chrono::milliseconds(20));
		mFakePolicy->assertUserActivityPoked();

		notifyAndConsumeMotion(ACTION_MOVE, AINPUT_SOURCE_TOUCHSCREEN, ui::LogicalDisplayId::DEFAULT,
		std::chrono::milliseconds(30));
		mFakePolicy->assertUserActivityPoked();
		mFakePolicy->assertUserActivityPoked();
		}

		class InputDispatcherOnPointerDownOutsideFocus : public InputDispatcherTest {