Merge "uiautomator: Desktop multi-window support #2" into androidx-main

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();