Merge "Fix reporting of unchanged keep clear areas" into tm-dev

core/java/android/view/ViewRootImpl.java

@@ -222,7 +222,6 @@ import java.io.StringWriter;
 import java.lang.ref.WeakReference;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Objects;
@@ -800,8 +799,7 @@ public final class ViewRootImpl implements ViewParent,
             new ViewRootRectTracker(v -> v.collectPreferKeepClearRects());
     private final ViewRootRectTracker mUnrestrictedKeepClearRectsTracker =
             new ViewRootRectTracker(v -> v.collectUnrestrictedPreferKeepClearRects());
-    private List<Rect> mPendingKeepClearAreas;
+    private boolean mHasPendingKeepClearAreaChange;
-    private List<Rect> mPendingUnrestrictedKeepClearAreas;
 
     private IAccessibilityEmbeddedConnection mAccessibilityEmbeddedConnection;
 
@@ -4819,45 +4817,31 @@ public final class ViewRootImpl implements ViewParent,
     }
 
     void keepClearRectsChanged() {
-        List<Rect> restrictedKeepClearRects = mKeepClearRectsTracker.computeChangedRects();
+        boolean restrictedKeepClearRectsChanged = mKeepClearRectsTracker.computeChanges();
-        List<Rect> unrestrictedKeepClearRects =
+        boolean unrestrictedKeepClearRectsChanged =
-                mUnrestrictedKeepClearRectsTracker.computeChangedRects();
+                mUnrestrictedKeepClearRectsTracker.computeChanges();
-        if ((restrictedKeepClearRects != null || unrestrictedKeepClearRects != null)
-                && mView != null) {
-            if (restrictedKeepClearRects == null) {
-                restrictedKeepClearRects = Collections.emptyList();
-            }
-            if (unrestrictedKeepClearRects == null) {
-                unrestrictedKeepClearRects = Collections.emptyList();
-            }
 
-            if (mHandler.hasMessages(MSG_REPORT_KEEP_CLEAR_RECTS)) {
+        if ((restrictedKeepClearRectsChanged || unrestrictedKeepClearRectsChanged)
-                // Keep clear areas have been reported recently, wait before reporting new set
+                && mView != null) {
-                // of keep clear areas
+            mHasPendingKeepClearAreaChange = true;
-                mPendingKeepClearAreas = restrictedKeepClearRects;
+            // Only report keep clear areas immediately if they have not been reported recently
-                mPendingUnrestrictedKeepClearAreas = unrestrictedKeepClearRects;
+            if (!mHandler.hasMessages(MSG_REPORT_KEEP_CLEAR_RECTS)) {
-            } else {
                 mHandler.sendEmptyMessageDelayed(MSG_REPORT_KEEP_CLEAR_RECTS,
                         KEEP_CLEAR_AREA_REPORT_RATE_MILLIS);
-                try {
+                reportKeepClearAreasChanged();
-                    mWindowSession.reportKeepClearAreasChanged(mWindow, restrictedKeepClearRects,
-                            unrestrictedKeepClearRects);
-                } catch (RemoteException e) {
-                    throw e.rethrowFromSystemServer();
-                }
             }
         }
     }
 
     void reportKeepClearAreasChanged() {
-        final List<Rect> restrictedKeepClearRects = mPendingKeepClearAreas;
+        if (!mHasPendingKeepClearAreaChange) {
-        final List<Rect> unrestrictedKeepClearRects = mPendingUnrestrictedKeepClearAreas;
-        if (restrictedKeepClearRects == null && unrestrictedKeepClearRects == null) {
             return;
         }
+        mHasPendingKeepClearAreaChange = false;
 
-        mPendingKeepClearAreas = null;
+        final List<Rect> restrictedKeepClearRects = mKeepClearRectsTracker.getLastComputedRects();
-        mPendingUnrestrictedKeepClearAreas = null;
+        final List<Rect> unrestrictedKeepClearRects =
+                mUnrestrictedKeepClearRectsTracker.getLastComputedRects();
 
         try {
             mWindowSession.reportKeepClearAreasChanged(mWindow, restrictedKeepClearRects,

core/java/android/view/ViewRootRectTracker.java

@@ -73,10 +73,25 @@ class ViewRootRectTracker {
     }
 
     /**
-     * @return all visible rects from all views in the global (root) coordinate system
+     * @return all Rects from all visible Views in the global (root) coordinate system,
+     * or {@code null} if Rects are unchanged since the last call to this method.
      */
     @Nullable
     public List<Rect> computeChangedRects() {
+        if (computeChanges()) {
+            return mRects;
+        }
+        return null;
+    }
+
+    /**
+     * Computes changes to all Rects from all Views.
+     * After calling this method, the updated list of Rects can be retrieved
+     * with {@link #getLastComputedRects()}.
+     *
+     * @return {@code true} if there were changes, {@code false} otherwise.
+     */
+    public boolean computeChanges() {
         boolean changed = mRootRectsChanged;
         final Iterator<ViewInfo> i = mViewInfos.iterator();
         final List<Rect> rects = new ArrayList<>(mRootRects);
@@ -100,10 +115,22 @@ class ViewRootRectTracker {
             mRootRectsChanged = false;
             if (!mRects.equals(rects)) {
                 mRects = rects;
-                return rects;
+                return true;
             }
         }
-        return null;
+        return false;
+    }
+
+    /**
+     * Returns a List of all Rects from all visible Views in the global (root) coordinate system.
+     * This list is only updated when calling {@link #computeChanges()} or
+     * {@link #computeChangedRects()}.
+     *
+     * @return all Rects from all visible Views in the global (root) coordinate system
+     */
+    @NonNull
+    public List<Rect> getLastComputedRects() {
+        return mRects;
     }
 
     /**