Merge "Remove Overrides-to-Policy dependency for CameraCompat in `isCameraActive`." into main

9 files changed, 128 insertions, 91 deletions

diff --git a/services/core/java/com/android/server/wm/AppCompatAspectRatioPolicy.java b/services/core/java/com/android/server/wm/AppCompatAspectRatioPolicy.java
index b23e75a0fbc2..51ef87dcab1b 100644
--- a/services/core/java/com/android/server/wm/AppCompatAspectRatioPolicy.java
+++ b/services/core/java/com/android/server/wm/AppCompatAspectRatioPolicy.java
@@ -122,9 +122,12 @@ class AppCompatAspectRatioPolicy {
         if (aspectRatioOverrides.shouldApplyUserMinAspectRatioOverride()) {
             return aspectRatioOverrides.getUserMinAspectRatio();
         }
+        final DisplayContent displayContent = mActivityRecord.getDisplayContent();
+        final boolean shouldOverrideMinAspectRatioForCamera = displayContent != null
+                && displayContent.mAppCompatCameraPolicy.shouldOverrideMinAspectRatioForCamera(
+                        mActivityRecord);
         if (!aspectRatioOverrides.shouldOverrideMinAspectRatio()
-                && !mAppCompatOverrides.getAppCompatCameraOverrides()
-                .shouldOverrideMinAspectRatioForCamera()) {
+                && !shouldOverrideMinAspectRatioForCamera) {
             return info.getMinAspectRatio();
         }
 
diff --git a/services/core/java/com/android/server/wm/AppCompatCameraOverrides.java b/services/core/java/com/android/server/wm/AppCompatCameraOverrides.java
index d8abf69b65af..241390c12818 100644
--- a/services/core/java/com/android/server/wm/AppCompatCameraOverrides.java
+++ b/services/core/java/com/android/server/wm/AppCompatCameraOverrides.java
@@ -85,9 +85,10 @@ class AppCompatCameraOverrides {
     }
 
     /**
-     * Whether we should apply the min aspect ratio per-app override only when an app is connected
-     * to the camera.
-     * When this override is applied the min aspect ratio given in the app's manifest will be
+     * Whether applying the min aspect ratio per-app override only when an app is connected
+     * to the camera is allowed.
+     *
+     * <p>When this override is applied the min aspect ratio given in the app's manifest will be
      * overridden to the largest enabled aspect ratio treatment unless the app's manifest value
      * is higher. The treatment will also apply if no value is provided in the manifest.
      *
@@ -97,9 +98,8 @@ class AppCompatCameraOverrides {
      *     <li>Per-app override is enabled
      * </ul>
      */
-    boolean shouldOverrideMinAspectRatioForCamera() {
-        return isCameraActive() && mAllowMinAspectRatioOverrideOptProp
-                .shouldEnableWithOptInOverrideAndOptOutProperty(
+    boolean isOverrideMinAspectRatioForCameraEnabled() {
+        return mAllowMinAspectRatioOverrideOptProp.shouldEnableWithOptInOverrideAndOptOutProperty(
                         isChangeEnabled(mActivityRecord,
                                 OVERRIDE_MIN_ASPECT_RATIO_ONLY_FOR_CAMERA));
     }
@@ -174,24 +174,6 @@ class AppCompatCameraOverrides {
                 OVERRIDE_CAMERA_COMPAT_DISABLE_FREEFORM_WINDOWING_TREATMENT);
     }
 
-    /**
-     * @return {@code true} if the Camera is active for the current activity
-     */
-    boolean isCameraActive() {
-        return mActivityRecord.mDisplayContent != null
-                && mActivityRecord.mDisplayContent.mAppCompatCameraPolicy
-                    .isCameraActive(mActivityRecord, /* mustBeFullscreen */ true);
-    }
-
-    /**
-     * @return {@code true} if the configuration needs to be recomputed after a camera state update.
-     */
-    boolean shouldRecomputeConfigurationForCameraCompat() {
-        return isOverrideOrientationOnlyForCameraEnabled()
-                || isCameraCompatSplitScreenAspectRatioAllowed()
-                || shouldOverrideMinAspectRatioForCamera();
-    }
-
     boolean isOverrideOrientationOnlyForCameraEnabled() {
         return isChangeEnabled(mActivityRecord, OVERRIDE_ORIENTATION_ONLY_FOR_CAMERA);
     }
diff --git a/services/core/java/com/android/server/wm/AppCompatCameraPolicy.java b/services/core/java/com/android/server/wm/AppCompatCameraPolicy.java
index a42b8794b43d..67bfd7605128 100644
--- a/services/core/java/com/android/server/wm/AppCompatCameraPolicy.java
+++ b/services/core/java/com/android/server/wm/AppCompatCameraPolicy.java
@@ -166,6 +166,9 @@ class AppCompatCameraPolicy {
                 : SCREEN_ORIENTATION_UNSPECIFIED;
     }
 
+    /**
+     * @return {@code true} if the Camera is active for the provided {@link ActivityRecord}.
+     */
     boolean isCameraActive(@NonNull ActivityRecord activity, boolean mustBeFullscreen) {
         return mDisplayRotationCompatPolicy != null
                 && mDisplayRotationCompatPolicy.isCameraActive(activity, mustBeFullscreen);
@@ -179,4 +182,13 @@ class AppCompatCameraPolicy {
         return null;
     }
 
+    /**
+     * Whether we should apply the min aspect ratio per-app override only when an app is connected
+     * to the camera.
+     */
+    boolean shouldOverrideMinAspectRatioForCamera(@NonNull ActivityRecord activityRecord) {
+        return isCameraActive(activityRecord, /* mustBeFullscreen= */ true)
+                && activityRecord.mAppCompatController.getAppCompatCameraOverrides()
+                        .isOverrideMinAspectRatioForCameraEnabled();
+    }
 }
diff --git a/services/core/java/com/android/server/wm/AppCompatOrientationPolicy.java b/services/core/java/com/android/server/wm/AppCompatOrientationPolicy.java
index c5506de419d0..7477c6272d89 100644
--- a/services/core/java/com/android/server/wm/AppCompatOrientationPolicy.java
+++ b/services/core/java/com/android/server/wm/AppCompatOrientationPolicy.java
@@ -58,13 +58,16 @@ class AppCompatOrientationPolicy {
                 && displayContent.getIgnoreOrientationRequest();
         final boolean shouldApplyUserFullscreenOverride = mAppCompatOverrides
                 .getAppCompatAspectRatioOverrides().shouldApplyUserFullscreenOverride();
+        final boolean isCameraActive = displayContent != null
+                && displayContent.mAppCompatCameraPolicy.isCameraActive(mActivityRecord,
+                        /* mustBeFullscreen */ true);
         if (shouldApplyUserFullscreenOverride && isIgnoreOrientationRequestEnabled
                 // Do not override orientation to fullscreen for camera activities.
                 // Fixed-orientation activities are rarely tested in other orientations, and it
                 // often results in sideways or stretched previews. As the camera compat treatment
                 // targets fixed-orientation activities, overriding the orientation disables the
                 // treatment.
-                && !mAppCompatOverrides.getAppCompatCameraOverrides().isCameraActive()) {
+                && !isCameraActive) {
             Slog.v(TAG, "Requested orientation " + screenOrientationToString(candidate)
                     + " for " + mActivityRecord + " is overridden to "
                     + screenOrientationToString(SCREEN_ORIENTATION_USER)
@@ -110,7 +113,7 @@ class AppCompatOrientationPolicy {
                 // often results in sideways or stretched previews. As the camera compat treatment
                 // targets fixed-orientation activities, overriding the orientation disables the
                 // treatment.
-                && !mAppCompatOverrides.getAppCompatCameraOverrides().isCameraActive()) {
+                && !isCameraActive) {
             Slog.v(TAG, "Requested orientation  " + screenOrientationToString(candidate)
                     + " for " + mActivityRecord + " is overridden to "
                     + screenOrientationToString(SCREEN_ORIENTATION_USER));
diff --git a/services/core/java/com/android/server/wm/DesktopAppCompatAspectRatioPolicy.java b/services/core/java/com/android/server/wm/DesktopAppCompatAspectRatioPolicy.java
index ff1742b70edc..192469183a54 100644
--- a/services/core/java/com/android/server/wm/DesktopAppCompatAspectRatioPolicy.java
+++ b/services/core/java/com/android/server/wm/DesktopAppCompatAspectRatioPolicy.java
@@ -198,9 +198,11 @@ public class DesktopAppCompatAspectRatioPolicy {
             return aspectRatioOverrides.getUserMinAspectRatio();
         }
 
+        final DisplayContent dc = task.mDisplayContent;
+        final boolean shouldOverrideMinAspectRatioForCamera = dc != null
+                && dc.mAppCompatCameraPolicy.shouldOverrideMinAspectRatioForCamera(mActivityRecord);
         if (!aspectRatioOverrides.shouldOverrideMinAspectRatio()
-                && !mAppCompatOverrides.getAppCompatCameraOverrides()
-                .shouldOverrideMinAspectRatioForCamera()) {
+                && !shouldOverrideMinAspectRatioForCamera) {
             return info.getMinAspectRatio();
         }
 
diff --git a/services/core/java/com/android/server/wm/DisplayRotationCompatPolicy.java b/services/core/java/com/android/server/wm/DisplayRotationCompatPolicy.java
index 27d97677bb13..efc38439bfcf 100644
--- a/services/core/java/com/android/server/wm/DisplayRotationCompatPolicy.java
+++ b/services/core/java/com/android/server/wm/DisplayRotationCompatPolicy.java
@@ -408,9 +408,26 @@ final class DisplayRotationCompatPolicy implements CameraStateMonitor.CameraComp
 
     private void recomputeConfigurationForCameraCompatIfNeeded(
             @NonNull ActivityRecord activityRecord) {
-        if (activityRecord.mAppCompatController.getAppCompatCameraOverrides()
-                .shouldRecomputeConfigurationForCameraCompat()) {
+        if (shouldRecomputeConfigurationForCameraCompat(activityRecord)) {
             activityRecord.recomputeConfiguration();
         }
     }
+
+    /**
+     * @return {@code true} if the configuration needs to be recomputed after a camera state update.
+     */
+    private boolean shouldRecomputeConfigurationForCameraCompat(
+            @NonNull ActivityRecord activityRecord) {
+        final AppCompatCameraOverrides overrides = activityRecord.mAppCompatController
+                .getAppCompatCameraOverrides();
+        return overrides.isOverrideOrientationOnlyForCameraEnabled()
+                || overrides.isCameraCompatSplitScreenAspectRatioAllowed()
+                || shouldOverrideMinAspectRatio(activityRecord);
+    }
+
+    private boolean shouldOverrideMinAspectRatio(@NonNull ActivityRecord activityRecord) {
+        return activityRecord.mAppCompatController.getAppCompatCameraOverrides()
+                .isOverrideMinAspectRatioForCameraEnabled()
+                        && isCameraActive(activityRecord, /* mustBeFullscreen= */ true);
+    }
 }
diff --git a/services/tests/wmtests/src/com/android/server/wm/AppCompatActivityRobot.java b/services/tests/wmtests/src/com/android/server/wm/AppCompatActivityRobot.java
index a7a08b25fba2..8227ed915c8e 100644
--- a/services/tests/wmtests/src/com/android/server/wm/AppCompatActivityRobot.java
+++ b/services/tests/wmtests/src/com/android/server/wm/AppCompatActivityRobot.java
@@ -139,11 +139,6 @@ class AppCompatActivityRobot {
                 /* isUnresizable */ true);
     }
 
-    void activateCameraInPolicy(boolean isCameraActive) {
-        doReturn(isCameraActive).when(mDisplayContent.mAppCompatCameraPolicy)
-                .isCameraActive(any(ActivityRecord.class), anyBoolean());
-    }
-
     void setDisplayNaturalOrientation(@Configuration.Orientation int naturalOrientation) {
         doReturn(naturalOrientation).when(mDisplayContent).getNaturalOrientation();
     }
diff --git a/services/tests/wmtests/src/com/android/server/wm/AppCompatCameraOverridesTest.java b/services/tests/wmtests/src/com/android/server/wm/AppCompatCameraOverridesTest.java
index ba2a7335824c..d66c21a77fcd 100644
--- a/services/tests/wmtests/src/com/android/server/wm/AppCompatCameraOverridesTest.java
+++ b/services/tests/wmtests/src/com/android/server/wm/AppCompatCameraOverridesTest.java
@@ -267,7 +267,6 @@ public class AppCompatCameraOverridesTest extends WindowTestsBase {
             robot.conf().enableCameraCompatSplitScreenAspectRatio(true);
             robot.applyOnActivity((a) -> {
                 a.createActivityWithComponentInNewTask();
-                a.activateCameraInPolicy(true);
                 a.setShouldCreateCompatDisplayInsets(false);
             });
 
@@ -276,27 +275,12 @@ public class AppCompatCameraOverridesTest extends WindowTestsBase {
     }
 
     @Test
-    public void testIsCameraActive() {
-        runTestScenario((robot) -> {
-            robot.applyOnActivity((a) -> {
-                a.createActivityWithComponent();
-                a.activateCameraInPolicy(/* isCameraActive */ false);
-                robot.checkIsCameraActive(/* active */ false);
-                a.activateCameraInPolicy(/* isCameraActive */ true);
-                robot.checkIsCameraActive(/* active */ true);
-            });
-        });
-    }
-
-
-    @Test
     @EnableCompatChanges({OVERRIDE_MIN_ASPECT_RATIO_ONLY_FOR_CAMERA})
     public void shouldOverrideMinAspectRatioForCamera_overrideEnabled_returnsTrue() {
         runTestScenario((robot) -> {
             robot.activity().createActivityWithComponent();
-            robot.activity().activateCameraInPolicy(/* isCameraActive */ true);
 
-            robot.checkShouldOverrideMinAspectRatioForCamera(/* expected */ true);
+            robot.checkIsOverrideMinAspectRatioForCameraEnabled(/* expected */ true);
         });
     }
 
@@ -306,21 +290,8 @@ public class AppCompatCameraOverridesTest extends WindowTestsBase {
         runTestScenario((robot) -> {
             robot.prop().enable(PROPERTY_COMPAT_ALLOW_MIN_ASPECT_RATIO_OVERRIDE);
             robot.activity().createActivityWithComponent();
-            robot.activity().activateCameraInPolicy(/* isCameraActive */ true);
 
-            robot.checkShouldOverrideMinAspectRatioForCamera(/* expected */ true);
-        });
-    }
-
-    @Test
-    @EnableCompatChanges({OVERRIDE_MIN_ASPECT_RATIO_ONLY_FOR_CAMERA})
-    public void shouldOverrideMinAspectRatioForCamera_propertyTrue_overrideEnabled_returnsFalse() {
-        runTestScenario((robot) -> {
-            robot.prop().enable(PROPERTY_COMPAT_ALLOW_MIN_ASPECT_RATIO_OVERRIDE);
-            robot.activity().createActivityWithComponent();
-            robot.activity().activateCameraInPolicy(/* isCameraActive */ false);
-
-            robot.checkShouldOverrideMinAspectRatioForCamera(/* expected */ false);
+            robot.checkIsOverrideMinAspectRatioForCameraEnabled(/* expected */ true);
         });
     }
 
@@ -330,9 +301,8 @@ public class AppCompatCameraOverridesTest extends WindowTestsBase {
         runTestScenario((robot) -> {
             robot.prop().enable(PROPERTY_COMPAT_ALLOW_MIN_ASPECT_RATIO_OVERRIDE);
             robot.activity().createActivityWithComponent();
-            robot.activity().activateCameraInPolicy(/* isCameraActive */ true);
 
-            robot.checkShouldOverrideMinAspectRatioForCamera(/* expected */ false);
+            robot.checkIsOverrideMinAspectRatioForCameraEnabled(/* expected */ false);
         });
     }
 
@@ -341,9 +311,8 @@ public class AppCompatCameraOverridesTest extends WindowTestsBase {
     public void shouldOverrideMinAspectRatioForCamera_overrideDisabled_returnsFalse() {
         runTestScenario((robot) -> {
             robot.activity().createActivityWithComponent();
-            robot.activity().activateCameraInPolicy(/* isCameraActive */ true);
 
-            robot.checkShouldOverrideMinAspectRatioForCamera(/* expected */ false);
+            robot.checkIsOverrideMinAspectRatioForCameraEnabled(/* expected */ false);
         });
     }
 
@@ -354,7 +323,7 @@ public class AppCompatCameraOverridesTest extends WindowTestsBase {
             robot.prop().disable(PROPERTY_COMPAT_ALLOW_MIN_ASPECT_RATIO_OVERRIDE);
             robot.activity().createActivityWithComponent();
 
-            robot.checkShouldOverrideMinAspectRatioForCamera(/* expected */ false);
+            robot.checkIsOverrideMinAspectRatioForCameraEnabled(/* expected */ false);
         });
     }
 
@@ -364,9 +333,8 @@ public class AppCompatCameraOverridesTest extends WindowTestsBase {
         runTestScenario((robot) -> {
             robot.prop().disable(PROPERTY_COMPAT_ALLOW_MIN_ASPECT_RATIO_OVERRIDE);
             robot.activity().createActivityWithComponent();
-            robot.activity().activateCameraInPolicy(/* isCameraActive */ true);
 
-            robot.checkShouldOverrideMinAspectRatioForCamera(/* expected */ false);
+            robot.checkIsOverrideMinAspectRatioForCameraEnabled(/* expected */ false);
         });
     }
 
@@ -412,13 +380,9 @@ public class AppCompatCameraOverridesTest extends WindowTestsBase {
                     .shouldApplyFreeformTreatmentForCameraCompat(), expected);
         }
 
-        void checkShouldOverrideMinAspectRatioForCamera(boolean expected) {
+        void checkIsOverrideMinAspectRatioForCameraEnabled(boolean expected) {
             Assert.assertEquals(getAppCompatCameraOverrides()
-                    .shouldOverrideMinAspectRatioForCamera(), expected);
-        }
-
-        void checkIsCameraActive(boolean active) {
-            Assert.assertEquals(getAppCompatCameraOverrides().isCameraActive(), active);
+                    .isOverrideMinAspectRatioForCameraEnabled(), expected);
         }
 
         private AppCompatCameraOverrides getAppCompatCameraOverrides() {
diff --git a/services/tests/wmtests/src/com/android/server/wm/AppCompatCameraPolicyTest.java b/services/tests/wmtests/src/com/android/server/wm/AppCompatCameraPolicyTest.java
index 2ae23f88812a..d91b38efd40b 100644
--- a/services/tests/wmtests/src/com/android/server/wm/AppCompatCameraPolicyTest.java
+++ b/services/tests/wmtests/src/com/android/server/wm/AppCompatCameraPolicyTest.java
@@ -16,6 +16,8 @@
 
 package com.android.server.wm;
 
+import static android.content.pm.ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_ONLY_FOR_CAMERA;
+
 import static com.android.dx.mockito.inline.extended.ExtendedMockito.doReturn;
 import static com.android.dx.mockito.inline.extended.ExtendedMockito.spyOn;
 import static com.android.window.flags.Flags.FLAG_CAMERA_COMPAT_FOR_FREEFORM;
@@ -31,6 +33,9 @@ import android.platform.test.annotations.Presubmit;
 
 import androidx.annotation.NonNull;
 
+import libcore.junit.util.compat.CoreCompatChangeRule.DisableCompatChanges;
+import libcore.junit.util.compat.CoreCompatChangeRule.EnableCompatChanges;
+
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TestRule;
@@ -186,16 +191,6 @@ public class AppCompatCameraPolicyTest extends WindowTestsBase {
         });
     }
 
-    /**
-     * Runs a test scenario providing a Robot.
-     */
-    void runTestScenario(@NonNull Consumer<AppCompatCameraPolicyRobotTest> consumer) {
-        spyOn(mWm.mAppCompatConfiguration);
-        final AppCompatCameraPolicyRobotTest robot =
-                new AppCompatCameraPolicyRobotTest(mWm, mAtm, mSupervisor);
-        consumer.accept(robot);
-    }
-
     @Test
     public void testIsCameraCompatTreatmentActive_whenTreatmentForTopActivityIsEnabled() {
         runTestScenario((robot) -> {
@@ -220,6 +215,58 @@ public class AppCompatCameraPolicyTest extends WindowTestsBase {
         });
     }
 
+    @Test
+    @EnableCompatChanges(OVERRIDE_MIN_ASPECT_RATIO_ONLY_FOR_CAMERA)
+    public void testShouldOverrideMinAspectRatioForCamera_whenCameraIsNotRunning() {
+        runTestScenario((robot) -> {
+            robot.applyOnActivity((a)-> {
+                robot.conf().enableCameraCompatTreatmentAtBuildTime(/* enabled= */ true);
+                a.createActivityWithComponentInNewTaskAndDisplay();
+                a.setTopActivityCameraActive(/* active */ false);
+            });
+
+            robot.checkShouldOverrideMinAspectRatioForCamera(/* active */ false);
+        });
+    }
+
+    @Test
+    @DisableCompatChanges(OVERRIDE_MIN_ASPECT_RATIO_ONLY_FOR_CAMERA)
+    public void testShouldOverrideMinAspectRatioForCamera_whenCameraIsRunning_overrideDisabled() {
+        runTestScenario((robot) -> {
+            robot.applyOnActivity((a)-> {
+                robot.conf().enableCameraCompatTreatmentAtBuildTime(/* enabled= */ true);
+                a.createActivityWithComponentInNewTaskAndDisplay();
+                a.setTopActivityCameraActive(/* active */ true);
+            });
+
+            robot.checkShouldOverrideMinAspectRatioForCamera(/* active */ false);
+        });
+    }
+
+    @Test
+    @EnableCompatChanges(OVERRIDE_MIN_ASPECT_RATIO_ONLY_FOR_CAMERA)
+    public void testShouldOverrideMinAspectRatioForCamera_whenCameraIsRunning_overrideEnabled() {
+        runTestScenario((robot) -> {
+            robot.applyOnActivity((a)-> {
+                robot.conf().enableCameraCompatTreatmentAtBuildTime(/* enabled= */ true);
+                a.createActivityWithComponentInNewTaskAndDisplay();
+                a.setTopActivityCameraActive(/* active */ true);
+            });
+
+            robot.checkShouldOverrideMinAspectRatioForCamera(/* active */ true);
+        });
+    }
+
+    /**
+     * Runs a test scenario providing a Robot.
+     */
+    void runTestScenario(@NonNull Consumer<AppCompatCameraPolicyRobotTest> consumer) {
+        final AppCompatCameraPolicyRobotTest robot =
+                new AppCompatCameraPolicyRobotTest(mWm, mAtm, mSupervisor);
+        consumer.accept(robot);
+    }
+
+
     private static class AppCompatCameraPolicyRobotTest extends AppCompatRobotBase {
         AppCompatCameraPolicyRobotTest(@NonNull WindowManagerService wm,
                 @NonNull ActivityTaskManagerService atm,
@@ -230,7 +277,14 @@ public class AppCompatCameraPolicyTest extends WindowTestsBase {
         @Override
         void onPostDisplayContentCreation(@NonNull DisplayContent displayContent) {
             super.onPostDisplayContentCreation(displayContent);
+
             spyOn(displayContent.mAppCompatCameraPolicy);
+            if (displayContent.mAppCompatCameraPolicy.mDisplayRotationCompatPolicy != null) {
+                spyOn(displayContent.mAppCompatCameraPolicy.mDisplayRotationCompatPolicy);
+            }
+            if (displayContent.mAppCompatCameraPolicy.mCameraCompatFreeformPolicy != null) {
+                spyOn(displayContent.mAppCompatCameraPolicy.mCameraCompatFreeformPolicy);
+            }
         }
 
         void checkTopActivityHasDisplayRotationCompatPolicy(boolean exists) {
@@ -268,6 +322,11 @@ public class AppCompatCameraPolicyTest extends WindowTestsBase {
                     .isTreatmentEnabledForActivity(activity().top()), active);
         }
 
+        void checkShouldOverrideMinAspectRatioForCamera(boolean expected) {
+            assertEquals(getTopAppCompatCameraPolicy()
+                    .shouldOverrideMinAspectRatioForCamera(activity().top()), expected);
+        }
+
         // TODO(b/350460645): Create Desktop Windowing Robot to reuse common functionalities.
         void allowEnterDesktopMode(boolean isAllowed) {
             doReturn(isAllowed).when(() ->