Keep track of pilfered pointer explicitly
The pointers that are getting pilfered were not being tracked explicitly
before. The behaviour relied on the window going away in order to reset
the "isPilfering" value to "false".
Now, however, some windows are getting persisted longer, because they
might receive a hover gesture that doesn't end (like a mouse that
someone stops using).
Therefore, we need to explicitly keep track of which pointers are being
pilfered. This is also in line with our eventual goal of explicit
per-window pointer management.
In the failing case, the windows was considered to be "pilfering". Since
the gesture monitors were receiving all of the pointers, the pointers
would no longer get dispatched to any windows underneath.
With this CL, we maintain the existing intended behaviours of pilfering,
while also expanding the support for multiple pilfered pointers.
In the added test case, there is a mouse interaction first, which
persists the gesture monitor window. Next, we pilfer a touch event,
which sets the "isPilfering" flag to ON. And finally, we inject the new
touch gesture. This gesture was (incorrectly) getting only sent to the
gesture monitor, because it kept maintaining the "isPilfering" status.
Bug: 266705421
Test: m inputflinger_tests && $ANDROID_HOST_OUT/nativetest64/inputflinger_tests/inputflinger_tests --gtest_filter="*MouseAndTouchWithSpyWindows*"
Change-Id: I6b72dc3e4de0e0ef09ccc469df0f703762c76fa6
diff --git a/services/inputflinger/dispatcher/TouchState.cpp b/services/inputflinger/dispatcher/TouchState.cpp
index ad37d02..e9c6ad5 100644
--- a/services/inputflinger/dispatcher/TouchState.cpp
+++ b/services/inputflinger/dispatcher/TouchState.cpp
@@ -34,6 +34,7 @@
void TouchState::removeTouchedPointer(int32_t pointerId) {
for (TouchedWindow& touchedWindow : windows) {
touchedWindow.pointerIds.clearBit(pointerId);
+ touchedWindow.pilferedPointerIds.reset(pointerId);
}
}
@@ -42,6 +43,7 @@
for (TouchedWindow& touchedWindow : windows) {
if (touchedWindow.windowHandle == windowHandle) {
touchedWindow.pointerIds.clearBit(pointerId);
+ touchedWindow.pilferedPointerIds.reset(pointerId);
return;
}
}
@@ -137,11 +139,40 @@
std::erase_if(windows, [](const TouchedWindow& w) { return w.pointerIds.isEmpty(); });
}
-void TouchState::cancelPointersForNonPilferingWindows(const BitSet32 pointerIds) {
- if (pointerIds.isEmpty()) return;
- std::for_each(windows.begin(), windows.end(), [&pointerIds](TouchedWindow& w) {
- if (!w.isPilferingPointers) {
- w.pointerIds &= BitSet32(~pointerIds.value);
+/**
+ * For any pointer that's being pilfered, remove it from all of the other windows that currently
+ * aren't pilfering it. For example, if we determined that pointer 1 is going to both window A and
+ * window B, but window A is currently pilfering pointer 1, then pointer 1 should not go to window
+ * B.
+ */
+void TouchState::cancelPointersForNonPilferingWindows() {
+ // First, find all pointers that are being pilfered, across all windows
+ std::bitset<MAX_POINTERS> allPilferedPointerIds;
+ std::for_each(windows.begin(), windows.end(), [&allPilferedPointerIds](const TouchedWindow& w) {
+ allPilferedPointerIds |= w.pilferedPointerIds;
+ });
+
+ // Optimization: most of the time, pilfering does not occur
+ if (allPilferedPointerIds.none()) return;
+
+ // Now, remove all pointers from every window that's being pilfered by other windows.
+ // For example, if window A is pilfering pointer 1 (only), and window B is pilfering pointer 2
+ // (only), the remove pointer 2 from window A and pointer 1 from window B. Usually, the set of
+ // pilfered pointers will be disjoint across all windows, but there's no reason to cause that
+ // limitation here.
+ std::for_each(windows.begin(), windows.end(), [&allPilferedPointerIds](TouchedWindow& w) {
+ std::bitset<MAX_POINTERS> pilferedByOtherWindows =
+ w.pilferedPointerIds ^ allPilferedPointerIds;
+ // TODO(b/211379801) : convert pointerIds to use std::bitset, which would allow us to
+ // replace the loop below with a bitwise operation. Currently, the XOR operation above is
+ // redundant, but is done to make the code more explicit / easier to convert later.
+ for (std::size_t i = 0; i < pilferedByOtherWindows.size(); i++) {
+ if (pilferedByOtherWindows.test(i) && !w.pilferedPointerIds.test(i)) {
+ // Pointer is pilfered by other windows, but not by this one! Remove it from here.
+ // We could call 'removeTouchedPointerFromWindow' here, but it's faster to directly
+ // manipulate it.
+ w.pointerIds.clearBit(i);
+ }
}
});
std::erase_if(windows, [](const TouchedWindow& w) { return w.pointerIds.isEmpty(); });