Merge "Fix dispatcher logic of handling same key pressed and released from different devices." (cbf8a329) · Commits · e / os / android_frameworks_native-old

services/inputflinger/dispatcher/InputDispatcher.cpp

+13 −1

Original line number	Diff line number	Diff line
		@@ -1108,11 +1108,17 @@ bool InputDispatcher::dispatchKeyLocked(nsecs_t currentTime, KeyEntry* entry,
		(entry->policyFlags & POLICY_FLAG_TRUSTED) &&
		(!(entry->policyFlags & POLICY_FLAG_DISABLE_KEY_REPEAT))) {
		if (mKeyRepeatState.lastKeyEntry &&
		mKeyRepeatState.lastKeyEntry->keyCode == entry->keyCode) {
		mKeyRepeatState.lastKeyEntry->keyCode == entry->keyCode &&
		// We have seen two identical key downs in a row which indicates that the device
		// driver is automatically generating key repeats itself. We take note of the
		// repeat here, but we disable our own next key repeat timer since it is clear that
		// we will not need to synthesize key repeats ourselves.
		mKeyRepeatState.lastKeyEntry->deviceId == entry->deviceId) {
		// Make sure we don't get key down from a different device. If a different
		// device Id has same key pressed down, the new device Id will replace the
		// current one to hold the key repeat with repeat count reset.
		// In the future when got a KEY_UP on the device id, drop it and do not
		// stop the key repeat on current device.
		entry->repeatCount = mKeyRepeatState.lastKeyEntry->repeatCount + 1;
		resetKeyRepeatLocked();
		mKeyRepeatState.nextRepeatTime = LONG_LONG_MAX; // don't generate repeats ourselves
		@@ -1123,6 +1129,12 @@ bool InputDispatcher::dispatchKeyLocked(nsecs_t currentTime, KeyEntry* entry,
		}
		mKeyRepeatState.lastKeyEntry = entry;
		entry->refCount += 1;
		} else if (entry->action == AKEY_EVENT_ACTION_UP && mKeyRepeatState.lastKeyEntry &&
		mKeyRepeatState.lastKeyEntry->deviceId != entry->deviceId) {
		// The stale device releases the key, reset staleDeviceId.
		#if DEBUG_INBOUND_EVENT_DETAILS
		ALOGD("deviceId=%d got KEY_UP as stale", entry->deviceId);
		#endif
		} else if (!entry->syntheticRepeat) {
		resetKeyRepeatLocked();
		}

services/inputflinger/tests/InputDispatcher_test.cpp

+47 −7

Original line number	Diff line number	Diff line
		@@ -2144,8 +2144,9 @@ protected:
		mWindow->consumeFocusEvent(true);
		}

		void sendAndConsumeKeyDown() {
		void sendAndConsumeKeyDown(int32_t deviceId) {
		NotifyKeyArgs keyArgs = generateKeyArgs(AKEY_EVENT_ACTION_DOWN, ADISPLAY_ID_DEFAULT);
		keyArgs.deviceId = deviceId;
		keyArgs.policyFlags \|= POLICY_FLAG_TRUSTED; // Otherwise it won't generate repeat event
		mDispatcher->notifyKey(&keyArgs);

		@@ -2167,8 +2168,9 @@ protected:
		EXPECT_EQ(repeatCount, repeatKeyEvent->getRepeatCount());
		}

		void sendAndConsumeKeyUp() {
		void sendAndConsumeKeyUp(int32_t deviceId) {
		NotifyKeyArgs keyArgs = generateKeyArgs(AKEY_EVENT_ACTION_UP, ADISPLAY_ID_DEFAULT);
		keyArgs.deviceId = deviceId;
		keyArgs.policyFlags \|= POLICY_FLAG_TRUSTED; // Unless it won't generate repeat event
		mDispatcher->notifyKey(&keyArgs);

		@@ -2179,21 +2181,59 @@ protected:
		};

		TEST_F(InputDispatcherKeyRepeatTest, FocusedWindow_ReceivesKeyRepeat) {
		sendAndConsumeKeyDown();
		sendAndConsumeKeyDown(1 /* deviceId */);
		for (int32_t repeatCount = 1; repeatCount <= 10; ++repeatCount) {
		expectKeyRepeatOnce(repeatCount);
		}
		}

		TEST_F(InputDispatcherKeyRepeatTest, FocusedWindow_ReceivesKeyRepeatFromTwoDevices) {
		sendAndConsumeKeyDown(1 /* deviceId */);
		for (int32_t repeatCount = 1; repeatCount <= 10; ++repeatCount) {
		expectKeyRepeatOnce(repeatCount);
		}
		sendAndConsumeKeyDown(2 /* deviceId */);
		/* repeatCount will start from 1 for deviceId 2 */
		for (int32_t repeatCount = 1; repeatCount <= 10; ++repeatCount) {
		expectKeyRepeatOnce(repeatCount);
		}
		}

		TEST_F(InputDispatcherKeyRepeatTest, FocusedWindow_StopsKeyRepeatAfterUp) {
		sendAndConsumeKeyDown();
		sendAndConsumeKeyDown(1 /* deviceId */);
		expectKeyRepeatOnce(1 /repeatCount/);
		sendAndConsumeKeyUp(1 /* deviceId */);
		mWindow->assertNoEvents();
		}

		TEST_F(InputDispatcherKeyRepeatTest, FocusedWindow_KeyRepeatAfterStaleDeviceKeyUp) {
		sendAndConsumeKeyDown(1 /* deviceId */);
		expectKeyRepeatOnce(1 /repeatCount/);
		sendAndConsumeKeyDown(2 /* deviceId */);
		expectKeyRepeatOnce(1 /repeatCount/);
		// Stale key up from device 1.
		sendAndConsumeKeyUp(1 /* deviceId */);
		// Device 2 is still down, keep repeating
		expectKeyRepeatOnce(2 /repeatCount/);
		expectKeyRepeatOnce(3 /repeatCount/);
		// Device 2 key up
		sendAndConsumeKeyUp(2 /* deviceId */);
		mWindow->assertNoEvents();
		}

		TEST_F(InputDispatcherKeyRepeatTest, FocusedWindow_KeyRepeatStopsAfterRepeatingKeyUp) {
		sendAndConsumeKeyDown(1 /* deviceId */);
		expectKeyRepeatOnce(1 /repeatCount/);
		sendAndConsumeKeyDown(2 /* deviceId */);
		expectKeyRepeatOnce(1 /repeatCount/);
		sendAndConsumeKeyUp();
		// Device 2 which holds the key repeating goes up, expect the repeating to stop.
		sendAndConsumeKeyUp(2 /* deviceId */);
		// Device 1 still holds key down, but the repeating was already stopped
		mWindow->assertNoEvents();
		}

		TEST_F(InputDispatcherKeyRepeatTest, FocusedWindow_RepeatKeyEventsUseEventIdFromInputDispatcher) {
		sendAndConsumeKeyDown();
		sendAndConsumeKeyDown(1 /* deviceId */);
		for (int32_t repeatCount = 1; repeatCount <= 10; ++repeatCount) {
		InputEvent* repeatEvent = mWindow->consume();
		ASSERT_NE(nullptr, repeatEvent) << "Didn't receive event with repeat count " << repeatCount;
		@@ -2203,7 +2243,7 @@ TEST_F(InputDispatcherKeyRepeatTest, FocusedWindow_RepeatKeyEventsUseEventIdFrom
		}

		TEST_F(InputDispatcherKeyRepeatTest, FocusedWindow_RepeatKeyEventsUseUniqueEventId) {
		sendAndConsumeKeyDown();
		sendAndConsumeKeyDown(1 /* deviceId */);

		std::unordered_set<int32_t> idSet;
		for (int32_t repeatCount = 1; repeatCount <= 10; ++repeatCount) {