Allow spy windows to prevent splitting
To avoid a crash in dispatcher, allow spy window to prevent splitting.
This would get the behaviour more in line with the existing app windows.
In the future, we need to holistically revisit the splitting behaviour.
The crash that this fixes can happen as follows:
In freeform window scenario, enable outbound event verification and
repeatedly touch the corners of the freeform window while
attempting to resize.
The spy windows are being used for capturing the window resizing
gesture, and also for interaction with the window's caption bar for
repositioning.
The test in this patch reproduces this scenario.
In this fix, we add a splitting behaviour to spy window to roughly match
the behaviour of the regular windows - if a first pointer lands into a
window that prevents splitting, then the remaining pointers will
continue going to that window, even if they are outside. This behaviour
is not very clear in various window configurations where one window
supports splitting while another doesn't. This will be revisited in
subsequent patches. The goal with this CL is to just fix the crash.
Bug: 347700797
Flag: EXEMPT bugfix
Test: TEST=inputflinger_tests; m $TEST && $ANDROID_HOST_OUT/nativetest64/$TEST/$TEST --gtest_break_on_failure --gtest_filter="*SpyThatPreventsSplittingWithApplication*"
Change-Id: I7d7c8668e993e66da0e39d1da8bb81831f6b3cc9
diff --git a/services/inputflinger/dispatcher/InputDispatcher.cpp b/services/inputflinger/dispatcher/InputDispatcher.cpp
index 7b974a8..6c4870f 100644
--- a/services/inputflinger/dispatcher/InputDispatcher.cpp
+++ b/services/inputflinger/dispatcher/InputDispatcher.cpp
@@ -1308,7 +1308,7 @@
// Alternatively, maybe there's a spy window that could handle this event.
const std::vector<sp<WindowInfoHandle>> touchedSpies =
- findTouchedSpyWindowsAtLocked(displayId, x, y, isStylus);
+ findTouchedSpyWindowsAtLocked(displayId, x, y, isStylus, motionEntry.deviceId);
for (const auto& windowHandle : touchedSpies) {
const std::shared_ptr<Connection> connection =
getConnectionLocked(windowHandle->getToken());
@@ -1463,15 +1463,27 @@
}
std::vector<sp<WindowInfoHandle>> InputDispatcher::findTouchedSpyWindowsAtLocked(
- ui::LogicalDisplayId displayId, float x, float y, bool isStylus) const {
+ ui::LogicalDisplayId displayId, float x, float y, bool isStylus, DeviceId deviceId) const {
// Traverse windows from front to back and gather the touched spy windows.
std::vector<sp<WindowInfoHandle>> spyWindows;
const auto& windowHandles = getWindowHandlesLocked(displayId);
for (const sp<WindowInfoHandle>& windowHandle : windowHandles) {
const WindowInfo& info = *windowHandle->getInfo();
-
if (!windowAcceptsTouchAt(info, displayId, x, y, isStylus, getTransformLocked(displayId))) {
- continue;
+ // Generally, we would skip any pointer that's outside of the window. However, if the
+ // spy prevents splitting, and already has some of the pointers from this device, then
+ // it should get more pointers from the same device, even if they are outside of that
+ // window
+ if (info.supportsSplitTouch()) {
+ continue;
+ }
+
+ // We know that split touch is not supported. Skip this window only if it doesn't have
+ // any touching pointers for this device already.
+ if (!windowHasTouchingPointersLocked(windowHandle, deviceId)) {
+ continue;
+ }
+ // If it already has pointers down for this device, then give it this pointer, too.
}
if (!info.isSpy()) {
// The first touched non-spy window was found, so return the spy windows touched so far.
@@ -2481,7 +2493,7 @@
}
std::vector<sp<WindowInfoHandle>> newTouchedWindows =
- findTouchedSpyWindowsAtLocked(displayId, x, y, isStylus);
+ findTouchedSpyWindowsAtLocked(displayId, x, y, isStylus, entry.deviceId);
if (newTouchedWindowHandle != nullptr) {
// Process the foreground window first so that it is the first to receive the event.
newTouchedWindows.insert(newTouchedWindows.begin(), newTouchedWindowHandle);
@@ -5670,7 +5682,7 @@
mMaximumObscuringOpacityForTouch = opacity;
}
-std::tuple<TouchState*, TouchedWindow*, ui::LogicalDisplayId /*displayId*/>
+std::tuple<TouchState*, TouchedWindow*, ui::LogicalDisplayId>
InputDispatcher::findTouchStateWindowAndDisplayLocked(const sp<IBinder>& token) {
for (auto& [displayId, state] : mTouchStatesByDisplay) {
for (TouchedWindow& w : state.windows) {
@@ -5682,6 +5694,22 @@
return std::make_tuple(nullptr, nullptr, ui::LogicalDisplayId::DEFAULT);
}
+std::tuple<const TouchState*, const TouchedWindow*, ui::LogicalDisplayId>
+InputDispatcher::findTouchStateWindowAndDisplayLocked(const sp<IBinder>& token) const {
+ return const_cast<InputDispatcher*>(this)->findTouchStateWindowAndDisplayLocked(token);
+}
+
+bool InputDispatcher::windowHasTouchingPointersLocked(const sp<WindowInfoHandle>& windowHandle,
+ DeviceId deviceId) const {
+ const auto& [touchState, touchedWindow, _] =
+ findTouchStateWindowAndDisplayLocked(windowHandle->getToken());
+ if (touchState == nullptr) {
+ // No touching pointers at all
+ return false;
+ }
+ return touchState->hasTouchingPointers(deviceId);
+}
+
bool InputDispatcher::transferTouchGesture(const sp<IBinder>& fromToken, const sp<IBinder>& toToken,
bool isDragDrop) {
if (fromToken == toToken) {
diff --git a/services/inputflinger/dispatcher/InputDispatcher.h b/services/inputflinger/dispatcher/InputDispatcher.h
index e2fc7a0..2125226 100644
--- a/services/inputflinger/dispatcher/InputDispatcher.h
+++ b/services/inputflinger/dispatcher/InputDispatcher.h
@@ -258,7 +258,8 @@
int32_t pointerId) const REQUIRES(mLock);
std::vector<sp<android::gui::WindowInfoHandle>> findTouchedSpyWindowsAtLocked(
- ui::LogicalDisplayId displayId, float x, float y, bool isStylus) const REQUIRES(mLock);
+ ui::LogicalDisplayId displayId, float x, float y, bool isStylus,
+ DeviceId deviceId) const REQUIRES(mLock);
sp<android::gui::WindowInfoHandle> findTouchedForegroundWindowLocked(
ui::LogicalDisplayId displayId) const REQUIRES(mLock);
@@ -684,16 +685,21 @@
const std::string& reason) REQUIRES(mLock);
void updateLastAnrStateLocked(const std::string& windowLabel, const std::string& reason)
REQUIRES(mLock);
- std::map<ui::LogicalDisplayId /*displayId*/, InputVerifier> mVerifiersByDisplay;
+ std::map<ui::LogicalDisplayId, InputVerifier> mVerifiersByDisplay;
// Returns a fallback KeyEntry that should be sent to the connection, if required.
std::unique_ptr<const KeyEntry> afterKeyEventLockedInterruptable(
const std::shared_ptr<Connection>& connection, DispatchEntry* dispatchEntry,
bool handled) REQUIRES(mLock);
// Find touched state and touched window by token.
- std::tuple<TouchState*, TouchedWindow*, ui::LogicalDisplayId /*displayId*/>
+ std::tuple<TouchState*, TouchedWindow*, ui::LogicalDisplayId>
findTouchStateWindowAndDisplayLocked(const sp<IBinder>& token) REQUIRES(mLock);
+ std::tuple<const TouchState*, const TouchedWindow*, ui::LogicalDisplayId>
+ findTouchStateWindowAndDisplayLocked(const sp<IBinder>& token) const REQUIRES(mLock);
+ bool windowHasTouchingPointersLocked(const sp<android::gui::WindowInfoHandle>& windowHandle,
+ DeviceId deviceId) const REQUIRES(mLock);
+
// Statistics gathering.
LatencyAggregator mLatencyAggregator GUARDED_BY(mLock);
LatencyTracker mLatencyTracker GUARDED_BY(mLock);
diff --git a/services/inputflinger/tests/InputDispatcher_test.cpp b/services/inputflinger/tests/InputDispatcher_test.cpp
index c24d302..4e662d4 100644
--- a/services/inputflinger/tests/InputDispatcher_test.cpp
+++ b/services/inputflinger/tests/InputDispatcher_test.cpp
@@ -4483,6 +4483,201 @@
window->assertNoEvents();
}
+/**
+ * A spy window sits above a window with NO_INPUT_CHANNEL. Ensure that the spy receives events even
+ * though the window underneath should not get any events.
+ */
+TEST_F(InputDispatcherTest, NonSplittableSpyAboveNoInputChannelWindowSinglePointer) {
+ std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
+
+ sp<FakeWindowHandle> spyWindow = sp<FakeWindowHandle>::make(application, mDispatcher, "Spy",
+ ui::LogicalDisplayId::DEFAULT);
+ spyWindow->setFrame(Rect(0, 0, 100, 100));
+ spyWindow->setTrustedOverlay(true);
+ spyWindow->setPreventSplitting(true);
+ spyWindow->setSpy(true);
+ // Another window below spy that has both NO_INPUT_CHANNEL and PREVENT_SPLITTING
+ sp<FakeWindowHandle> inputSinkWindow =
+ sp<FakeWindowHandle>::make(application, mDispatcher, "Input sink below spy",
+ ui::LogicalDisplayId::DEFAULT);
+ inputSinkWindow->setFrame(Rect(0, 0, 100, 100));
+ inputSinkWindow->setTrustedOverlay(true);
+ inputSinkWindow->setPreventSplitting(true);
+ inputSinkWindow->setNoInputChannel(true);
+
+ mDispatcher->onWindowInfosChanged(
+ {{*spyWindow->getInfo(), *inputSinkWindow->getInfo()}, {}, 0, 0});
+
+ // Tap the spy window
+ mDispatcher->notifyMotion(MotionArgsBuilder(ACTION_DOWN, AINPUT_SOURCE_TOUCHSCREEN)
+ .pointer(PointerBuilder(0, ToolType::FINGER).x(50).y(51))
+ .build());
+ mDispatcher->notifyMotion(
+ MotionArgsBuilder(ACTION_UP, AINPUT_SOURCE_TOUCHSCREEN)
+ .pointer(PointerBuilder(/*id=*/0, ToolType::FINGER).x(50).y(51))
+ .build());
+
+ spyWindow->consumeMotionEvent(AllOf(WithMotionAction(ACTION_DOWN)));
+ spyWindow->consumeMotionEvent(AllOf(WithMotionAction(ACTION_UP)));
+ inputSinkWindow->assertNoEvents();
+}
+
+/**
+ * A spy window sits above a window with NO_INPUT_CHANNEL. Ensure that the spy receives events even
+ * though the window underneath should not get any events.
+ * Same test as above, but with two pointers touching instead of one.
+ */
+TEST_F(InputDispatcherTest, NonSplittableSpyAboveNoInputChannelWindowTwoPointers) {
+ std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
+
+ sp<FakeWindowHandle> spyWindow = sp<FakeWindowHandle>::make(application, mDispatcher, "Spy",
+ ui::LogicalDisplayId::DEFAULT);
+ spyWindow->setFrame(Rect(0, 0, 100, 100));
+ spyWindow->setTrustedOverlay(true);
+ spyWindow->setPreventSplitting(true);
+ spyWindow->setSpy(true);
+ // Another window below spy that would have both NO_INPUT_CHANNEL and PREVENT_SPLITTING
+ sp<FakeWindowHandle> inputSinkWindow =
+ sp<FakeWindowHandle>::make(application, mDispatcher, "Input sink below spy",
+ ui::LogicalDisplayId::DEFAULT);
+ inputSinkWindow->setFrame(Rect(0, 0, 100, 100));
+ inputSinkWindow->setTrustedOverlay(true);
+ inputSinkWindow->setPreventSplitting(true);
+ inputSinkWindow->setNoInputChannel(true);
+
+ mDispatcher->onWindowInfosChanged(
+ {{*spyWindow->getInfo(), *inputSinkWindow->getInfo()}, {}, 0, 0});
+
+ // Both fingers land into the spy window
+ mDispatcher->notifyMotion(MotionArgsBuilder(ACTION_DOWN, AINPUT_SOURCE_TOUCHSCREEN)
+ .pointer(PointerBuilder(0, ToolType::FINGER).x(50).y(51))
+ .build());
+ mDispatcher->notifyMotion(
+ MotionArgsBuilder(POINTER_1_DOWN, AINPUT_SOURCE_TOUCHSCREEN)
+ .pointer(PointerBuilder(/*id=*/0, ToolType::FINGER).x(50).y(51))
+ .pointer(PointerBuilder(/*id=*/1, ToolType::FINGER).x(10).y(11))
+ .build());
+ mDispatcher->notifyMotion(
+ MotionArgsBuilder(POINTER_1_UP, AINPUT_SOURCE_TOUCHSCREEN)
+ .pointer(PointerBuilder(/*id=*/0, ToolType::FINGER).x(50).y(51))
+ .pointer(PointerBuilder(/*id=*/1, ToolType::FINGER).x(10).y(11))
+ .build());
+ mDispatcher->notifyMotion(
+ MotionArgsBuilder(ACTION_UP, AINPUT_SOURCE_TOUCHSCREEN)
+ .pointer(PointerBuilder(/*id=*/0, ToolType::FINGER).x(50).y(51))
+ .build());
+
+ spyWindow->consumeMotionEvent(AllOf(WithMotionAction(ACTION_DOWN)));
+ spyWindow->consumeMotionPointerDown(1, WithPointerCount(2));
+ spyWindow->consumeMotionPointerUp(1, WithPointerCount(2));
+ spyWindow->consumeMotionEvent(AllOf(WithMotionAction(ACTION_UP)));
+ inputSinkWindow->assertNoEvents();
+}
+
+/** Check the behaviour for cases where input sink prevents or doesn't prevent splitting. */
+class SpyThatPreventsSplittingWithApplicationFixture : public InputDispatcherTest,
+ public ::testing::WithParamInterface<bool> {
+};
+
+/**
+ * Three windows:
+ * - An application window (app window)
+ * - A spy window that does not overlap the app window. Has PREVENT_SPLITTING flag
+ * - A window below the spy that has NO_INPUT_CHANNEL (call it 'inputSink')
+ *
+ * The spy window is side-by-side with the app window. The inputSink is below the spy.
+ * We first touch the area outside of the appWindow, but inside spyWindow.
+ * Only the SPY window should get the DOWN event.
+ * The spy pilfers after receiving the first DOWN event.
+ * Next, we touch the app window.
+ * The spy should receive POINTER_DOWN(1) (since spy is preventing splits).
+ * Also, since the spy is already pilfering the first pointer, it will be sent the remaining new
+ * pointers automatically, as well.
+ * Next, the first pointer (from the spy) is lifted.
+ * Spy should get POINTER_UP(0).
+ * This event should not go to the app because the app never received this pointer to begin with.
+ * Now, lift the remaining pointer and check that the spy receives UP event.
+ *
+ * Finally, send a new ACTION_DOWN event to the spy and check that it's received.
+ * This test attempts to reproduce a crash in the dispatcher.
+ */
+TEST_P(SpyThatPreventsSplittingWithApplicationFixture, SpyThatPreventsSplittingWithApplication) {
+ std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
+
+ sp<FakeWindowHandle> spyWindow = sp<FakeWindowHandle>::make(application, mDispatcher, "Spy",
+ ui::LogicalDisplayId::DEFAULT);
+ spyWindow->setFrame(Rect(100, 100, 200, 200));
+ spyWindow->setTrustedOverlay(true);
+ spyWindow->setPreventSplitting(true);
+ spyWindow->setSpy(true);
+ // Another window below spy that has both NO_INPUT_CHANNEL and PREVENT_SPLITTING
+ sp<FakeWindowHandle> inputSinkWindow =
+ sp<FakeWindowHandle>::make(application, mDispatcher, "Input sink below spy",
+ ui::LogicalDisplayId::DEFAULT);
+ inputSinkWindow->setFrame(Rect(100, 100, 200, 200)); // directly below the spy
+ inputSinkWindow->setTrustedOverlay(true);
+ inputSinkWindow->setPreventSplitting(GetParam());
+ inputSinkWindow->setNoInputChannel(true);
+
+ sp<FakeWindowHandle> appWindow = sp<FakeWindowHandle>::make(application, mDispatcher, "App",
+ ui::LogicalDisplayId::DEFAULT);
+ appWindow->setFrame(Rect(0, 0, 100, 100));
+
+ mDispatcher->setFocusedApplication(ui::LogicalDisplayId::DEFAULT, application);
+ mDispatcher->onWindowInfosChanged(
+ {{*spyWindow->getInfo(), *inputSinkWindow->getInfo(), *appWindow->getInfo()},
+ {},
+ 0,
+ 0});
+
+ // First finger lands outside of the appWindow, but inside of the spy window
+ mDispatcher->notifyMotion(MotionArgsBuilder(ACTION_DOWN, AINPUT_SOURCE_TOUCHSCREEN)
+ .pointer(PointerBuilder(0, ToolType::FINGER).x(150).y(150))
+ .build());
+ spyWindow->consumeMotionEvent(AllOf(WithMotionAction(ACTION_DOWN)));
+
+ mDispatcher->pilferPointers(spyWindow->getToken());
+
+ // Second finger lands in the app, and goes to the spy window. It doesn't go to the app because
+ // the spy is already pilfering the first pointer, and this automatically grants the remaining
+ // new pointers to the spy, as well.
+ mDispatcher->notifyMotion(
+ MotionArgsBuilder(POINTER_1_DOWN, AINPUT_SOURCE_TOUCHSCREEN)
+ .pointer(PointerBuilder(/*id=*/0, ToolType::FINGER).x(150).y(150))
+ .pointer(PointerBuilder(/*id=*/1, ToolType::FINGER).x(50).y(50))
+ .build());
+
+ spyWindow->consumeMotionPointerDown(1, WithPointerCount(2));
+
+ // Now lift up the first pointer
+ mDispatcher->notifyMotion(
+ MotionArgsBuilder(POINTER_0_UP, AINPUT_SOURCE_TOUCHSCREEN)
+ .pointer(PointerBuilder(/*id=*/0, ToolType::FINGER).x(150).y(150))
+ .pointer(PointerBuilder(/*id=*/1, ToolType::FINGER).x(50).y(50))
+ .build());
+ spyWindow->consumeMotionPointerUp(0, WithPointerCount(2));
+
+ // And lift the remaining pointer!
+ mDispatcher->notifyMotion(
+ MotionArgsBuilder(ACTION_UP, AINPUT_SOURCE_TOUCHSCREEN)
+ .pointer(PointerBuilder(/*id=*/1, ToolType::FINGER).x(50).y(50))
+ .build());
+ spyWindow->consumeMotionEvent(AllOf(WithMotionAction(ACTION_UP), WithPointerCount(1)));
+
+ // Now send a new DOWN, which should again go to spy.
+ mDispatcher->notifyMotion(MotionArgsBuilder(ACTION_DOWN, AINPUT_SOURCE_TOUCHSCREEN)
+ .pointer(PointerBuilder(0, ToolType::FINGER).x(150).y(150))
+ .build());
+ spyWindow->consumeMotionEvent(AllOf(WithMotionAction(ACTION_DOWN)));
+ // The app window doesn't get any events this entire time because the spy received the events
+ // first and pilfered, which makes all new pointers go to it as well.
+ appWindow->assertNoEvents();
+}
+
+// Behaviour should be the same regardless of whether inputSink supports splitting.
+INSTANTIATE_TEST_SUITE_P(SpyThatPreventsSplittingWithApplication,
+ SpyThatPreventsSplittingWithApplicationFixture, testing::Bool());
+
TEST_F(InputDispatcherTest, HoverWithSpyWindows) {
std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
diff --git a/services/inputflinger/tests/TestEventMatchers.h b/services/inputflinger/tests/TestEventMatchers.h
index f8e3c22..cfedc6e 100644
--- a/services/inputflinger/tests/TestEventMatchers.h
+++ b/services/inputflinger/tests/TestEventMatchers.h
@@ -609,10 +609,33 @@
return arg.getRepeatCount() == repeatCount;
}
-MATCHER_P2(WithPointerId, index, id, "MotionEvent with specified pointer ID for pointer index") {
- const auto argPointerId = arg.pointerProperties[index].id;
- *result_listener << "expected pointer with index " << index << " to have ID " << argPointerId;
- return argPointerId == id;
+class WithPointerIdMatcher {
+public:
+ using is_gtest_matcher = void;
+ explicit WithPointerIdMatcher(size_t index, int32_t pointerId)
+ : mIndex(index), mPointerId(pointerId) {}
+
+ bool MatchAndExplain(const NotifyMotionArgs& args, std::ostream*) const {
+ return args.pointerProperties[mIndex].id == mPointerId;
+ }
+
+ bool MatchAndExplain(const MotionEvent& event, std::ostream*) const {
+ return event.getPointerId(mIndex) == mPointerId;
+ }
+
+ void DescribeTo(std::ostream* os) const {
+ *os << "with pointer[" << mIndex << "] id = " << mPointerId;
+ }
+
+ void DescribeNegationTo(std::ostream* os) const { *os << "wrong pointerId"; }
+
+private:
+ const size_t mIndex;
+ const int32_t mPointerId;
+};
+
+inline WithPointerIdMatcher WithPointerId(size_t index, int32_t pointerId) {
+ return WithPointerIdMatcher(index, pointerId);
}
MATCHER_P2(WithCursorPosition, x, y, "InputEvent with specified cursor position") {