uiautomator: Desktop multi-window support #2

This CL adds the refresh() for SDKs where the refresh system API
is unavailable, ensuring the underlying window is always valid and
updated when accessed. This is important for preventing stale window
accesss and reducing test flakes often caused by window closures or
updates during testing.

Design: go/uiautomator-window-design
Bug: 425372420
Test: ./gradlew :test:uiautomator:i:t:connectedAndroidTest (UiWindowTest)
Relnote: New APIs for desktop multi-window
Merged-In: I40528316751814034580696f01ab78eb696e83bf
Change-Id: I40528316751814034580696f01ab78eb696e83bf

Author: Hyung Tae Kim

test/uiautomator/integration-tests/testapp/src/androidTest/java/androidx/test/uiautomator/testapp/UiWindowTest.java

@@ -25,13 +25,15 @@
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 import static org.junit.Assume.assumeTrue;
 
 import android.app.Activity;
 import android.content.Intent;
 
 import androidx.test.filters.LargeTest;
 import androidx.test.uiautomator.By;
+import androidx.test.uiautomator.StaleObjectException;
 import androidx.test.uiautomator.UiObject2;
 import androidx.test.uiautomator.UiWindow;
 
@@ -127,6 +129,7 @@ public void testUiDevice_closeNonActiveDesktopWindow() {
         UiWindow nonActiveWindow = appWindows.get(1);
         assertNotNull(nonActiveWindow);
         assertFalse(nonActiveWindow.isActive());
+        int nonActiveWindowId = nonActiveWindow.getId();
 
         List<UiWindow> windows =
                 mDevice.findWindows(
@@ -147,7 +150,7 @@ public void testUiDevice_closeNonActiveDesktopWindow() {
         // Wait for the app window to no longer be present, identified by its unique window ID.
         assertTrue(
                 "Window should no longer be present if the close button is clicked.",
-                mDevice.wait(d -> !d.hasWindow(By.Window.id(nonActiveWindow.getId())), TIMEOUT_MS));
+                mDevice.wait(d -> !d.hasWindow(By.Window.id(nonActiveWindowId)), TIMEOUT_MS));
     }
 
     @Test
@@ -244,4 +247,22 @@ public void testUiWindow_getRootObjectAndPackageName() {
             assertEquals("com.android.systemui", root.getApplicationPackage());
         }
     }
+
+    @Test(expected = StaleObjectException.class)
+    public void testUiWindow_staleWindowException() {
+        // Get a window reference.
+        UiWindow window = mDevice.findWindow(By.Window.pkg(TEST_APP).active(true));
+        assertNotNull(window);
+
+        // Close the activity to make the window stale
+        UiObject2 button = mDevice.findObject(By.res(TEST_APP, "close_task_window_button"));
+        assertNotNull(button);
+        button.click();
+        mDevice.wait(d -> !d.hasWindow(By.Window.pkg(TEST_APP)), TIMEOUT_MS);
+
+        // If the window is gone and stale, accessing it will throw a StaleObjectException.
+        window.getRootObject();
+        fail("Should not reach here. Expected exception was not caught when accessing stale "
+                + "window");
+    }
 }

test/uiautomator/uiautomator/src/main/java/androidx/test/uiautomator/UiWindow.java

@@ -147,10 +147,72 @@ private AccessibilityWindowInfo getAccessibilityWindowInfo() {
         if (mCachedWindow == null) {
             throw new IllegalStateException("This window has already been recycled.");
         }
-        // TODO(b/405371739): Implement the window staleness check when refresh() is accessible.
+
+        getDevice().waitForIdle();
+        if (!refresh()) {
+            getDevice().runWatchers();
+            if (!refresh()) {
+                throw new StaleObjectException();
+            }
+        }
         return mCachedWindow;
     }
 
+    /**
+     * Refreshes this window's state if it is stale.
+     *
+     * <p>Ideally, this would call the hidden {@code AccessibilityWindowInfo.refresh()} method
+     * for an in-place update. Since it is unavailable, for older API levels, it uses a fallback
+     * ({@link #refreshFromPool()}) that finds the window info from the refreshed root node.
+     *
+     * @return {@code true} if the refresh succeeded, {@code false} if this window is stale and
+     * no longer exists.
+     */
+    private boolean refresh() {
+        // TODO(b/405371739): Extend this to handle different API level behaviors when the
+        //  refresh API is available in the future SDK.
+        return refreshFromPool();
+    }
+
+    /**
+     * Refreshes this window by replacing it with an updated instance from the pool.
+     *
+     * <p>This is a fallback for SDKs where the refresh system API is unavailable. To refresh the
+     * info, it returns the old cached window to the pool, then obtains a new one (which may or
+     * may not be the one just recycled) from the pool based on the refreshed root node.
+     * <p>Note: This will effectively update the window but not in-place, so the underlying cached
+     * window may reference a new object each time this method is called.
+     */
+    private boolean refreshFromPool() {
+        AccessibilityNodeInfo rootNode = mCachedWindow.getRoot();
+        if (rootNode == null) {
+            return false;
+        }
+        AccessibilityWindowInfo refreshedWindow = null;
+        try {
+            if (!rootNode.refresh()) {
+                return false;
+            }
+            refreshedWindow = rootNode.getWindow();
+            if (refreshedWindow == null || refreshedWindow.getId() != mCachedWindow.getId()) {
+                return false;
+            }
+            // This is a best effort to keep the cached window referencing the same object from
+            // the pool by recycling the old info then immediately acquiring it back for the
+            // refreshed info.
+            mCachedWindow.recycle();
+            mCachedWindow = AccessibilityWindowInfo.obtain(refreshedWindow);
+            return true;
+        } finally {
+            if (rootNode != null) {
+                rootNode.recycle();
+            }
+            if (refreshedWindow != null) {
+                refreshedWindow.recycle();
+            }
+        }
+    }
+
     /** Recycles this window. */
     private void recycle() {
         mCachedWindow.recycle();