fix(android): clear the composer, not just the key plane, before a scroll swipes

The helper kept the largest `TYPE_INPUT_METHOD` rectangle as the keyboard. A composer bar and its key
plane can arrive as separate windows and the key plane is the larger one, so the earlier top edge was
discarded and the clipped band still ended inside the composer: the swipe landed on keys the rule
exists to keep it off.

The read now copies every input method window and unions the ones the swipe's centre line crosses,
which is the same line the shared clip rule tests. A candidate strip at the edge of the screen that the
swipe can never reach no longer shortens the band either. The selection runs on plain window edges,
because `Rect` is a device type whose constructors throw off-device, so the two-window case is a unit
test rather than a simulator-only path.

Author: thymikee

android/snapshot-helper/src/main/java/com/callstack/agentdevice/snapshothelper/GestureViewportReader.java

@@ -4,6 +4,7 @@
 import android.graphics.Rect;
 import android.view.accessibility.AccessibilityNodeInfo;
 import android.view.accessibility.AccessibilityWindowInfo;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.TimeoutException;
 
@@ -29,6 +30,33 @@ static final class Reading {
     }
   }
 
+  /**
+   * One reported window's edges in screen pixels. Plain fields because {@code Rect} is a device type
+   * whose constructors throw off-device, and which of several input method windows a swipe strikes is
+   * arithmetic that has to be testable without one.
+   */
+  static final class WindowEdges {
+    final int left;
+    final int top;
+    final int right;
+    final int bottom;
+
+    WindowEdges(int left, int top, int right, int bottom) {
+      this.left = left;
+      this.top = top;
+      this.right = right;
+      this.bottom = bottom;
+    }
+
+    static WindowEdges of(Rect rect) {
+      return new WindowEdges(rect.left, rect.top, rect.right, rect.bottom);
+    }
+
+    Rect toRect() {
+      return new Rect(left, top, right, bottom);
+    }
+  }
+
   @SuppressWarnings("deprecation")
   static Reading readReading(UiAutomation automation) {
     try {
@@ -45,20 +73,18 @@ static Reading readReading(UiAutomation automation) {
     AccessibilityTreeCapture.enableInteractiveWindowRetrieval(automation);
     Rect activeBounds = null;
     Rect fallbackBounds = null;
-    Rect inputMethodBounds = null;
+    List<WindowEdges> inputMethodWindows = new ArrayList<>();
     List<AccessibilityWindowInfo> windows = automation.getWindows();
     try {
       for (AccessibilityWindowInfo window : windows) {
         int type = window.getType();
         if (type == AccessibilityWindowInfo.TYPE_INPUT_METHOD) {
-          // Keep the largest IME window: a composer bar and its key plane can be reported as
-          // separate windows, and the scroll only needs how far down the free surface reaches.
+          // Copy every input method window. Which of them a swipe has to clear depends on the
+          // application window, which this loop has not finished reading, so they are collected here
+          // and resolved once it has.
           Rect bounds = new Rect();
           window.getBoundsInScreen(bounds);
-          if (!bounds.isEmpty() && (inputMethodBounds == null || bounds.height() * bounds.width()
-              > inputMethodBounds.height() * inputMethodBounds.width())) {
-            inputMethodBounds = bounds;
-          }
+          if (!bounds.isEmpty()) inputMethodWindows.add(WindowEdges.of(bounds));
           continue;
         }
         if (type != AccessibilityWindowInfo.TYPE_APPLICATION) continue;
@@ -76,7 +102,40 @@ static Reading readReading(UiAutomation automation) {
         window.recycle();
       }
     }
-    return new Reading(resolveApplication(automation, activeBounds, fallbackBounds), inputMethodBounds);
+    Rect application = resolveApplication(automation, activeBounds, fallbackBounds);
+    WindowEdges struck = struckInputMethod(
+        inputMethodWindows, application == null ? null : WindowEdges.of(application));
+    return new Reading(application, struck == null ? null : struck.toRect());
+  }
+
+  /**
+   * The input method share a swipe has to stay above, or null when none of it is in the way.
+   *
+   * <p>A composer bar and its key plane can arrive as separate windows, and the larger rectangle is
+   * usually the lower key plane: keeping only that leaves the swipe inside the composer reaching
+   * further up the screen. So this unions the windows the swipe's centre line crosses — the same line
+   * the shared clip rule tests — and ignores the ones beside it that the swipe cannot reach.
+   */
+  static WindowEdges struckInputMethod(List<WindowEdges> inputMethodWindows, WindowEdges application) {
+    WindowEdges struck = null;
+    for (WindowEdges bounds : inputMethodWindows) {
+      if (application != null) {
+        double swipeCenterX = application.left + (application.right - application.left) / 2.0;
+        boolean strikesSwipePath = swipeCenterX >= bounds.left && swipeCenterX < bounds.right;
+        boolean overlapsWindow = bounds.bottom > application.top && bounds.top < application.bottom;
+        if (!strikesSwipePath || !overlapsWindow) continue;
+      }
+      if (struck == null) {
+        struck = bounds;
+        continue;
+      }
+      struck = new WindowEdges(
+          Math.min(struck.left, bounds.left),
+          Math.min(struck.top, bounds.top),
+          Math.max(struck.right, bounds.right),
+          Math.max(struck.bottom, bounds.bottom));
+    }
+    return struck;
   }
 
   static Rect read(UiAutomation automation) {

android/snapshot-helper/src/test/java/com/callstack/agentdevice/snapshothelper/GestureViewportReaderTest.java

@@ -0,0 +1,87 @@
+package com.callstack.agentdevice.snapshothelper;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public final class GestureViewportReaderTest {
+  private GestureViewportReaderTest() {}
+
+  private static final GestureViewportReader.WindowEdges APPLICATION =
+      new GestureViewportReader.WindowEdges(0, 0, 1080, 2400);
+  private static final GestureViewportReader.WindowEdges KEY_PLANE =
+      new GestureViewportReader.WindowEdges(0, 1517, 1080, 2400);
+  private static final GestureViewportReader.WindowEdges COMPOSER =
+      new GestureViewportReader.WindowEdges(0, 1400, 1080, 1517);
+  private static final GestureViewportReader.WindowEdges SIDE_STRIP =
+      new GestureViewportReader.WindowEdges(900, 1200, 1080, 2400);
+
+  static void run() {
+    assertNoInputMethodOnScreen();
+    assertComposerAboveItsKeyPlaneKeepsItsEarlierTopEdge();
+    assertWindowBesideTheSwipePathIsIgnored();
+  }
+
+  private static void assertNoInputMethodOnScreen() {
+    assertEdges(
+        GestureViewportReader.struckInputMethod(
+            Collections.<GestureViewportReader.WindowEdges>emptyList(), APPLICATION),
+        null,
+        "no input method window on screen");
+  }
+
+  private static void assertComposerAboveItsKeyPlaneKeepsItsEarlierTopEdge() {
+    List<GestureViewportReader.WindowEdges> both = Arrays.asList(KEY_PLANE, COMPOSER);
+    // The key plane is the larger rectangle. Keeping only it would plan a swipe ending inside the
+    // composer, whose top edge reaches 117px further up the screen.
+    assertEdges(
+        GestureViewportReader.struckInputMethod(both, APPLICATION),
+        new GestureViewportReader.WindowEdges(0, 1400, 1080, 2400),
+        "composer above its key plane");
+    assertEdges(
+        GestureViewportReader.struckInputMethod(Arrays.asList(COMPOSER, KEY_PLANE), APPLICATION),
+        new GestureViewportReader.WindowEdges(0, 1400, 1080, 2400),
+        "composer listed after its key plane");
+  }
+
+  private static void assertWindowBesideTheSwipePathIsIgnored() {
+    // A floating candidate strip at the right edge never crosses the centre line a vertical swipe
+    // travels, so its higher top edge must not shorten the band.
+    assertEdges(
+        GestureViewportReader.struckInputMethod(Arrays.asList(KEY_PLANE, SIDE_STRIP), APPLICATION),
+        KEY_PLANE,
+        "input method window beside the swipe path");
+    assertEdges(
+        GestureViewportReader.struckInputMethod(
+            Collections.singletonList(SIDE_STRIP), APPLICATION),
+        null,
+        "only an unreachable input method window on screen");
+  }
+
+  private static void assertEdges(
+      GestureViewportReader.WindowEdges actual,
+      GestureViewportReader.WindowEdges expected,
+      String label) {
+    if (expected == null) {
+      if (actual != null) {
+        throw new AssertionError(
+            "Expected no input method rect for " + label + ", got " + describe(actual));
+      }
+      return;
+    }
+    if (actual == null) {
+      throw new AssertionError("Expected " + describe(expected) + " for " + label + ", got none");
+    }
+    if (actual.left != expected.left
+        || actual.top != expected.top
+        || actual.right != expected.right
+        || actual.bottom != expected.bottom) {
+      throw new AssertionError(
+          "Expected " + describe(expected) + " for " + label + ", got " + describe(actual));
+    }
+  }
+
+  private static String describe(GestureViewportReader.WindowEdges edges) {
+    return "[" + edges.left + "," + edges.top + "][" + edges.right + "," + edges.bottom + "]";
+  }
+}

android/snapshot-helper/src/test/java/com/callstack/agentdevice/snapshothelper/SnapshotHelperTestSuite.java

@@ -7,5 +7,6 @@ public static void main(String[] args) throws Exception {
     PointerEventScheduleTest.run();
     AccessibilityCaptureStabilizerTest.run();
     BoundedUiAutomationConnectionTest.run();
+    GestureViewportReaderTest.run();
   }
 }