server/wm/CompatChangeTests.java

/*
 * Copyright (C) 2021 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.server.wm;

import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
import static android.content.pm.ActivityInfo.OVERRIDE_ENABLE_COMPAT_FAKE_FOCUS;
import static android.content.pm.ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_LARGE_VALUE;
import static android.content.pm.ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_MEDIUM_VALUE;
import static android.content.pm.ActivityInfo.OVERRIDE_SANDBOX_VIEW_BOUNDS_APIS;
import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_NOSENSOR;
import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE;
import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
import static android.content.res.Configuration.ORIENTATION_LANDSCAPE;
import static android.content.res.Configuration.ORIENTATION_PORTRAIT;
import static android.provider.DeviceConfig.NAMESPACE_CONSTRAIN_DISPLAY_APIS;
import static android.server.wm.allowdisplayorientationoverride.Components.ALLOW_DISPLAY_ORIENTATION_OVERRIDE_ACTIVITY;
import static android.server.wm.alloworientationoverride.Components.ALLOW_ORIENTATION_OVERRIDE_LANDSCAPE_ACTIVITY;
import static android.server.wm.alloworientationoverride.Components.ALLOW_ORIENTATION_OVERRIDE_RESPONSIVE_ACTIVITY;
import static android.server.wm.allowsandboxingviewboundsapis.Components.ACTION_TEST_VIEW_SANDBOX_ALLOWED_PASSED;
import static android.server.wm.allowsandboxingviewboundsapis.Components.ACTION_TEST_VIEW_SANDBOX_NOT_ALLOWED_PASSED;
import static android.server.wm.allowsandboxingviewboundsapis.Components.TEST_VIEW_SANDBOX_ALLOWED_ACTIVITY;
import static android.server.wm.allowsandboxingviewboundsapis.Components.TEST_VIEW_SANDBOX_ALLOWED_TIMEOUT_MS;
import static android.server.wm.enablefakefocusoptin.Components.ENABLE_FAKE_FOCUS_OPT_IN_LEFT_ACTIVITY;
import static android.server.wm.enablefakefocusoptin.Components.ENABLE_FAKE_FOCUS_OPT_IN_RIGHT_ACTIVITY;
import static android.server.wm.enablefakefocusoptout.Components.ENABLE_FAKE_FOCUS_OPT_OUT_LEFT_ACTIVITY;
import static android.server.wm.enablefakefocusoptout.Components.ENABLE_FAKE_FOCUS_OPT_OUT_RIGHT_ACTIVITY;
import static android.server.wm.ignorerequestedorientationoverrideoptin.Components.OPT_IN_CHANGE_ORIENTATION_WHILE_RELAUNCHING_ACTIVITY;
import static android.server.wm.ignorerequestedorientationoverrideoptout.Components.OPT_OUT_CHANGE_ORIENTATION_WHILE_RELAUNCHING_ACTIVITY;
import static android.server.wm.optoutsandboxingviewboundsapis.Components.ACTION_TEST_VIEW_SANDBOX_OPT_OUT_PASSED;
import static android.server.wm.optoutsandboxingviewboundsapis.Components.TEST_VIEW_SANDBOX_OPT_OUT_ACTIVITY;
import static android.server.wm.optoutsandboxingviewboundsapis.Components.TEST_VIEW_SANDBOX_OPT_OUT_TIMEOUT_MS;
import static android.server.wm.propertycameracompatallowforcerotation.Components.CAMERA_COMPAT_ALLOW_FORCE_ROTATION_ACTIVITY;
import static android.server.wm.propertycameracompatallowrefresh.Components.CAMERA_COMPAT_ALLOW_REFRESH_ACTIVITY;
import static android.server.wm.propertycameracompatenablerefreshviapauseoptin.Components.CAMERA_COMPAT_ENABLE_REFRESH_VIA_PAUSE_OPT_IN_ACTIVITY;
import static android.server.wm.propertycameracompatenablerefreshviapauseoptout.Components.CAMERA_COMPAT_ENABLE_REFRESH_VIA_PAUSE_OPT_OUT_ACTIVITY;
import static android.view.Surface.ROTATION_0;
import static android.view.Surface.ROTATION_90;

import static androidx.test.platform.app.InstrumentationRegistry.getInstrumentation;

import static com.google.common.truth.Truth.assertThat;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assume.assumeTrue;

import android.app.Activity;
import android.app.WindowConfiguration;
import android.compat.testing.PlatformCompatChangeRule;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.ActivityInfo;
import android.content.pm.PackageManager;
import android.content.res.Resources;
import android.graphics.Rect;
import android.os.Bundle;
import android.os.ConditionVariable;
import android.platform.test.annotations.Presubmit;
import android.provider.DeviceConfig;
import android.server.wm.app.AbstractLifecycleLogActivity;
import android.util.Size;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;

import libcore.junit.util.compat.CoreCompatChangeRule.DisableCompatChanges;
import libcore.junit.util.compat.CoreCompatChangeRule.EnableCompatChanges;

import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TestRule;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

/**
 * The test is focused on compatibility changes that have an effect on WM logic, and tests that
 * enabling these changes has the correct effect.
 *
 * This is achieved by launching a custom activity with certain properties (e.g., a resizeable
 * portrait activity) that behaves in a certain way (e.g., enter size compat mode after resizing the
 * display) and enabling a compatibility change (e.g., {@link ActivityInfo#FORCE_RESIZE_APP}) that
 * changes that behavior (e.g., not enter size compat mode).
 *
 * The behavior without enabling a compatibility change is also tested as a baseline.
 *
 * <p>Build/Install/Run:
 * atest CtsWindowManagerDeviceTestCases:CompatChangeTests
 */
@Presubmit
public final class CompatChangeTests extends MultiDisplayTestBase {
    private static final ComponentName RESIZEABLE_PORTRAIT_ACTIVITY =
            component(ResizeablePortraitActivity.class);
    private static final ComponentName NON_RESIZEABLE_PORTRAIT_ACTIVITY =
            component(NonResizeablePortraitActivity.class);
    private static final ComponentName NON_RESIZEABLE_LANDSCAPE_ACTIVITY =
            component(NonResizeableLandscapeActivity.class);
    private static final ComponentName NON_RESIZEABLE_NON_FIXED_ORIENTATION_ACTIVITY =
            component(NonResizeableNonFixedOrientationActivity.class);
    private static final ComponentName NON_RESIZEABLE_ASPECT_RATIO_ACTIVITY =
            component(NonResizeableAspectRatioActivity.class);
    private static final ComponentName NON_RESIZEABLE_LARGE_ASPECT_RATIO_ACTIVITY =
            component(NonResizeableLargeAspectRatioActivity.class);
    private static final ComponentName SUPPORTS_SIZE_CHANGES_PORTRAIT_ACTIVITY =
            component(SupportsSizeChangesPortraitActivity.class);
    private static final ComponentName RESIZEABLE_LEFT_ACTIVITY =
            component(ResizeableLeftActivity.class);
    private static final ComponentName RESIZEABLE_RIGHT_ACTIVITY =
            component(ResizeableRightActivity.class);
    private static final ComponentName RESPONSIVE_ACTIVITY =
            component(ResponsiveActivity.class);
    private static final ComponentName NO_PROPERTY_CHANGE_ORIENTATION_WHILE_RELAUNCHING_ACTIVITY =
            component(NoPropertyChangeOrientationWhileRelaunchingActivity.class);

    // Fixed orientation min aspect ratio
    private static final float FIXED_ORIENTATION_MIN_ASPECT_RATIO = 1.03f;
    // The min aspect ratio of NON_RESIZEABLE_ASPECT_RATIO_ACTIVITY (as defined in the manifest).
    private static final float ACTIVITY_MIN_ASPECT_RATIO = 1.6f;
    // The min aspect ratio of NON_RESIZEABLE_LARGE_ASPECT_RATIO_ACTIVITY (as defined in the
    // manifest). This needs to be higher than the aspect ratio of any device, which according to
    // CDD is at most 21:9.
    private static final float ACTIVITY_LARGE_MIN_ASPECT_RATIO = 4f;

    private static final float FLOAT_EQUALITY_DELTA = 0.01f;

    @Rule
    public TestRule compatChangeRule = new PlatformCompatChangeRule();

    @Before
    @Override
    public void setUp() throws Exception {
        super.setUp();
        enableAndAssumeGestureNavigationMode();
        createManagedLetterboxAspectRatioSession(FIXED_ORIENTATION_MIN_ASPECT_RATIO);
        mObjectTracker.manage(setAlwaysConstrainDisplayApisFlag(null));
        mObjectTracker.manage(setNeverConstrainDisplayApisAllPackagesFlag(null));
        mObjectTracker.manage(setNeverConstrainDisplayApisFlag(null));
    }

    @Test
    public void testOverrideUndefinedOrientationToPortrait_propertyIsFalse_overrideNotApplied() {
        try (var compatChange = new CompatChangeCloseable(
                ActivityInfo.OVERRIDE_UNDEFINED_ORIENTATION_TO_PORTRAIT,
                ALLOW_ORIENTATION_OVERRIDE_RESPONSIVE_ACTIVITY.getPackageName());
             var session = new ActivitySessionCloseable(
                     ALLOW_ORIENTATION_OVERRIDE_RESPONSIVE_ACTIVITY)) {
            waitAssertEquals("expected unspecified orientation",
                    SCREEN_ORIENTATION_UNSPECIFIED,
                    () -> session.getActivityState().getOverrideOrientation());
        }
    }

    @Test
    @EnableCompatChanges({ActivityInfo.OVERRIDE_UNDEFINED_ORIENTATION_TO_PORTRAIT})
    public void testOverrideUndefinedOrientationToPortrait() {
        try (var session = new ActivitySessionCloseable(RESPONSIVE_ACTIVITY)) {
            waitAssertEquals("expected portrait orientation", SCREEN_ORIENTATION_PORTRAIT,
                    () -> session.getActivityState().getOverrideOrientation());
        }
    }

    @Test
    public void testOverrideUndefinedOrientationToNoSensor_propertyIsFalse_overrideNotApplied() {
        try (var compatChange = new CompatChangeCloseable(
                ActivityInfo.OVERRIDE_UNDEFINED_ORIENTATION_TO_NOSENSOR,
                ALLOW_ORIENTATION_OVERRIDE_RESPONSIVE_ACTIVITY.getPackageName());
            var session = new ActivitySessionCloseable(
                    ALLOW_ORIENTATION_OVERRIDE_RESPONSIVE_ACTIVITY)) {
            waitAssertEquals("expected unspecified orientation",
                    SCREEN_ORIENTATION_UNSPECIFIED,
                    () -> session.getActivityState().getOverrideOrientation());
        }
    }

    @Test
    @EnableCompatChanges({ActivityInfo.OVERRIDE_UNDEFINED_ORIENTATION_TO_NOSENSOR})
    public void testOverrideUndefinedOrientationToNosensor() {
        try (var session = new ActivitySessionCloseable(RESPONSIVE_ACTIVITY)) {
            waitAssertEquals("expected no-sensor orientation",
                    SCREEN_ORIENTATION_NOSENSOR,
                    () -> session.getActivityState().getOverrideOrientation());
        }
    }

    @Test
    public void
            testOverrideLandscapeOrientationToReverseLandscape_propertyIsFalse_overrideNotApply() {
        try (var compatChange = new CompatChangeCloseable(
                ActivityInfo.OVERRIDE_LANDSCAPE_ORIENTATION_TO_REVERSE_LANDSCAPE,
                ALLOW_ORIENTATION_OVERRIDE_LANDSCAPE_ACTIVITY.getPackageName());
             var session = new ActivitySessionCloseable(
                     ALLOW_ORIENTATION_OVERRIDE_LANDSCAPE_ACTIVITY)) {
            waitAssertEquals("expected landscape orientation", SCREEN_ORIENTATION_LANDSCAPE,
                    () -> session.getActivityState().getOverrideOrientation());
        }
    }

    @Test
    @EnableCompatChanges({ActivityInfo.OVERRIDE_LANDSCAPE_ORIENTATION_TO_REVERSE_LANDSCAPE})
    public void testOverrideLandscapeOrientationToReverseLandscape() {
        try (var session = new ActivitySessionCloseable(NON_RESIZEABLE_LANDSCAPE_ACTIVITY)) {
            waitAssertEquals("expected reverse landscape orientation",
                    SCREEN_ORIENTATION_REVERSE_LANDSCAPE,
                    () -> session.getActivityState().getOverrideOrientation());
        }
    }

    @Test
    @EnableCompatChanges({ActivityInfo.OVERRIDE_USE_DISPLAY_LANDSCAPE_NATURAL_ORIENTATION})
    public void testOverrideUseDisplayLandscapeNaturalOrientation() {
        try (var displayMetricsSession = new DisplayMetricsWaitCloseable()) {
            // Run this test only when natural orientation is landscape
            Size displaySize = displayMetricsSession.getInitialDisplayMetrics().getSize();
            assumeTrue(displaySize.getHeight() < displaySize.getWidth());
        }

        try (var portrait = new DeviceOrientationCloseable(ORIENTATION_PORTRAIT);
             var session = new ActivitySessionCloseable(RESPONSIVE_ACTIVITY)) {
            // Verifying that orientation is overridden
            waitAssertEquals("expected rotation 0",
                    ROTATION_0, () -> mWmState.getRotation());
        }
    }

    @Test
    public void
            testOverrideUseDisplayLandscapeNaturalOrientation_propertyIsFalse_overrideNotApplied() {
        try (var displayMetricsSession = new DisplayMetricsWaitCloseable()) {
            // Run this test only when natural orientation is landscape
            Size displaySize = displayMetricsSession.getInitialDisplayMetrics().getSize();
            assumeTrue(displaySize.getHeight() < displaySize.getWidth());
        }

        final int originalRotation = mWmState.getRotation();

        try (var portrait = new DeviceOrientationCloseable(ORIENTATION_PORTRAIT);
             var compatChange = new CompatChangeCloseable(
                ActivityInfo.OVERRIDE_USE_DISPLAY_LANDSCAPE_NATURAL_ORIENTATION,
                ALLOW_DISPLAY_ORIENTATION_OVERRIDE_ACTIVITY.getPackageName());
             var session = new ActivitySessionCloseable(
                    ALLOW_DISPLAY_ORIENTATION_OVERRIDE_ACTIVITY)) {

            // Verifying that orientation not overridden
            if (portrait.isRotationApplied()) {
                // If the screen was rotated away from natural orientation (to portrait)
                waitAssertEquals("expected rotation 90",
                        ROTATION_90, () -> mWmState.getRotation());
            } else {
                // If the screen was already in portrait (rotated away from natural orientation)
                waitAssertEquals("expected originalRotation=" + originalRotation,
                        originalRotation, () -> mWmState.getRotation());
            }
        }
    }

    @Test
    public void testEnableFakeFocus_propertyIsFalse_overrideNotApplied() {
        assumeTrue("Skipping test: no split multi-window support",
                supportsSplitScreenMultiWindow());
        assumeTrue("Skipping test: config_isCompatFakeFocusEnabled not enabled",
                getFakeFocusEnabledConfig());

        try (var compatChange = new CompatChangeCloseable(
                OVERRIDE_ENABLE_COMPAT_FAKE_FOCUS,
                ENABLE_FAKE_FOCUS_OPT_OUT_LEFT_ACTIVITY.getPackageName());
             var splitScreen = new SplitScreenActivitiesCloseable(
                     ENABLE_FAKE_FOCUS_OPT_OUT_LEFT_ACTIVITY,
                     ENABLE_FAKE_FOCUS_OPT_OUT_RIGHT_ACTIVITY)) {
            waitAssertEquals("expected should not send compat fake focus",
                    /* expected */ false,
                    () -> splitScreen.getPrimaryActivity()
                            .getActivityState().getShouldSendCompatFakeFocus());
        }
    }

    @Test
    public void testEnableFakeFocus_propertyIsTrue_returnsTrue() {
        assumeTrue("Skipping test: no split multi-window support",
                supportsSplitScreenMultiWindow());
        assumeTrue("Skipping test: config_isCompatFakeFocusEnabled not enabled",
                getFakeFocusEnabledConfig());

        try (var splitScreen = new SplitScreenActivitiesCloseable(
                     ENABLE_FAKE_FOCUS_OPT_IN_LEFT_ACTIVITY,
                     ENABLE_FAKE_FOCUS_OPT_IN_RIGHT_ACTIVITY)) {
            waitAssertEquals("expected should send compat fake focus", /* expected */ true,
                    () -> splitScreen.getPrimaryActivity()
                            .getActivityState().getShouldSendCompatFakeFocus());
        }
    }

    @Test
    @EnableCompatChanges({OVERRIDE_ENABLE_COMPAT_FAKE_FOCUS})
    public void testEnableFakeFocus_overrideApplied_returnsTrue() {
        assumeTrue("Skipping test: no split multi-window support",
                supportsSplitScreenMultiWindow());
        assumeTrue("Skipping test: config_isCompatFakeFocusEnabled not enabled",
                getFakeFocusEnabledConfig());

        try (var splitScreen = new SplitScreenActivitiesCloseable(
                     RESIZEABLE_LEFT_ACTIVITY,
                     RESIZEABLE_RIGHT_ACTIVITY)) {
            waitAssertEquals("expected should send compat fake focus", /* expected */ true,
                    () -> splitScreen.getPrimaryActivity()
                            .getActivityState().getShouldSendCompatFakeFocus());
        }
    }

    boolean getFakeFocusEnabledConfig() {
        return mContext.getResources().getBoolean(
                Resources.getSystem().getIdentifier(
                        "config_isCompatFakeFocusEnabled",
                        "bool", "android"));
    }

    @Test
    public void testOverrideIgnoreRequestedOrientation_propertyIsFalse_overrideNotApplied() {
        assumeTrue("Skipping test: "
                    + "config_letterboxIsPolicyForIgnoringRequestedOrientationEnabled not enabled",
                isPolicyForIgnoringRequestedOrientationEnabled());

        try (var compatChange = new CompatChangeCloseable(
                    ActivityInfo.OVERRIDE_ENABLE_COMPAT_IGNORE_REQUESTED_ORIENTATION,
                    OPT_OUT_CHANGE_ORIENTATION_WHILE_RELAUNCHING_ACTIVITY.getPackageName());
             var session = new ActivitySessionCloseable(
                     OPT_OUT_CHANGE_ORIENTATION_WHILE_RELAUNCHING_ACTIVITY)) {
            waitAssertEquals("expected landscape orientation",
                    SCREEN_ORIENTATION_LANDSCAPE,
                    () -> session.getActivityState().getOverrideOrientation());
        }
    }

    @Test
    public void testOverrideIgnoreRequestedOrientation_isDisabled_propertyIsTrue_overrideApplied() {
        assumeTrue("Skipping test: "
                    + "config_letterboxIsPolicyForIgnoringRequestedOrientationEnabled not enabled",
                isPolicyForIgnoringRequestedOrientationEnabled());

        try (var session = new ActivitySessionCloseable(
                     OPT_IN_CHANGE_ORIENTATION_WHILE_RELAUNCHING_ACTIVITY)) {
            waitAssertEquals("expected portrait orientation",
                    SCREEN_ORIENTATION_PORTRAIT,
                    () -> session.getActivityState().getOverrideOrientation());
        }
    }

    @Test
    @EnableCompatChanges({ActivityInfo.OVERRIDE_ENABLE_COMPAT_IGNORE_REQUESTED_ORIENTATION})
    public void testOverrideIgnoreRequestedOrientation() {
        assumeTrue("Skipping test: "
                    + "config_letterboxIsPolicyForIgnoringRequestedOrientationEnabled not enabled",
                isPolicyForIgnoringRequestedOrientationEnabled());

        try (var session = new ActivitySessionCloseable(
                     NO_PROPERTY_CHANGE_ORIENTATION_WHILE_RELAUNCHING_ACTIVITY)) {
            waitAssertEquals("expected portrait orientation",
                    SCREEN_ORIENTATION_PORTRAIT,
                    () -> session.getActivityState().getOverrideOrientation());
        }
    }

    @Test
    public void testOptOutPropertyCameraCompatForceRotation_rotationDisabled() {
        assumeTrue("Skipping test: config_isWindowManagerCameraCompatTreatmentEnabled not enabled",
                isCameraCompatForceRotationTreatmentConfigEnabled());

        try (var session = new ActivitySessionCloseable(RESIZEABLE_PORTRAIT_ACTIVITY)) {
            // Activity without property or override is eligible for force rotation.
            waitAssertEquals("expected to force rotate for camera compat",
                    /* expected */ true,
                    () -> session.getActivityState().getShouldForceRotateForCameraCompat());
        }

        try (var session = new ActivitySessionCloseable(
                     CAMERA_COMPAT_ALLOW_FORCE_ROTATION_ACTIVITY)) {
            waitAssertEquals("expected to not force rotate for camera compat",
                    /* expected */ false,
                    () -> session.getActivityState().getShouldForceRotateForCameraCompat());
        }
    }

    @Test
    @EnableCompatChanges({ActivityInfo.OVERRIDE_CAMERA_COMPAT_DISABLE_FORCE_ROTATION})
    public void testOverrideForCameraCompatForceRotation_rotationDisabled() {
        assumeTrue("Skipping test: config_isWindowManagerCameraCompatTreatmentEnabled not enabled",
                isCameraCompatForceRotationTreatmentConfigEnabled());

        try (var session = new ActivitySessionCloseable(RESIZEABLE_PORTRAIT_ACTIVITY)) {
            waitAssertEquals("expected to not force rotate for camera compat",
                    /* expected */ false,
                    () -> session.getActivityState().getShouldForceRotateForCameraCompat());
        }
    }

    @Test
    public void testOptOutPropertyCameraCompatRefresh() {
        assumeTrue("Skipping test: config_isWindowManagerCameraCompatTreatmentEnabled not enabled",
                isCameraCompatForceRotationTreatmentConfigEnabled());

        try (var session = new ActivitySessionCloseable(RESIZEABLE_PORTRAIT_ACTIVITY)) {
            // Activity without property or override is eligible for refresh.
            waitAssertEquals("expected to refresh activity for camera compat",
                    /* expected */ true,
                    () -> session.getActivityState().getShouldRefreshActivityForCameraCompat());
        }

        try (var session = new ActivitySessionCloseable(CAMERA_COMPAT_ALLOW_REFRESH_ACTIVITY)) {
            waitAssertEquals("expected to not refresh activity for camera compat",
                    /* expected */ false,
                    () -> session.getActivityState().getShouldRefreshActivityForCameraCompat());
        }
    }

    @Test
    @EnableCompatChanges({ActivityInfo.OVERRIDE_CAMERA_COMPAT_DISABLE_REFRESH})
    public void testOverrideForCameraCompatRefresh() {
        assumeTrue("Skipping test: config_isWindowManagerCameraCompatTreatmentEnabled not enabled",
                isCameraCompatForceRotationTreatmentConfigEnabled());

        try (var session = new ActivitySessionCloseable(RESIZEABLE_PORTRAIT_ACTIVITY)) {
            waitAssertEquals("expected to not refresh activity for camera compat",
                    /* expected */ false,
                    () -> session.getActivityState().getShouldRefreshActivityForCameraCompat());
        }
    }

    @Test
    public void testOptInPropertyCameraCompatRefreshViaPause() {
        assumeTrue("Skipping test: config_isWindowManagerCameraCompatTreatmentEnabled not enabled",
                isCameraCompatForceRotationTreatmentConfigEnabled());

        try (var session = new ActivitySessionCloseable(RESIZEABLE_PORTRAIT_ACTIVITY)) {
            // Activity without property or override doesn't refresh via
            // "resumed -> paused -> resumed".
            waitAssertEquals("expected to not refresh activity via pause for camera compat",
                    /* expected */ false,
                    () -> session.getActivityState()
                            .getShouldRefreshActivityViaPauseForCameraCompat());
        }

        try (var session = new ActivitySessionCloseable(
                CAMERA_COMPAT_ENABLE_REFRESH_VIA_PAUSE_OPT_IN_ACTIVITY)) {
            waitAssertEquals("expected to Refresh activity via pause for camera compat",
                    /* expected */ true,
                    () -> session.getActivityState()
                            .getShouldRefreshActivityViaPauseForCameraCompat());
        }
    }

    @Test
    @EnableCompatChanges({ActivityInfo.OVERRIDE_CAMERA_COMPAT_ENABLE_REFRESH_VIA_PAUSE})
    public void testOverrideForCameraCompatRefreshViaPause() {
        assumeTrue("Skipping test: config_isWindowManagerCameraCompatTreatmentEnabled not enabled",
                isCameraCompatForceRotationTreatmentConfigEnabled());

        try (var session = new ActivitySessionCloseable(RESIZEABLE_PORTRAIT_ACTIVITY)) {
            waitAssertEquals("expected to Refresh activity via pause for camera compat",
                    /* expected */ true,
                    () -> session.getActivityState()
                            .getShouldRefreshActivityViaPauseForCameraCompat());
        }
    }

    @Test
    public void testOptOutPropertyCameraCompatRefreshViaPause() {
        assumeTrue("Skipping test: config_isWindowManagerCameraCompatTreatmentEnabled not enabled",
                isCameraCompatForceRotationTreatmentConfigEnabled());

        try (var compatChange = new CompatChangeCloseable(
                ActivityInfo.OVERRIDE_CAMERA_COMPAT_ENABLE_REFRESH_VIA_PAUSE,
                CAMERA_COMPAT_ENABLE_REFRESH_VIA_PAUSE_OPT_OUT_ACTIVITY.getPackageName());
             var session = new ActivitySessionCloseable(
                     CAMERA_COMPAT_ENABLE_REFRESH_VIA_PAUSE_OPT_OUT_ACTIVITY)) {
            waitAssertEquals("expected to not refresh activity via pause for camera compat",
                    /* expected */ false,
                    () -> session.getActivityState()
                            .getShouldRefreshActivityViaPauseForCameraCompat());
        }
    }

    /**
     * Test that a non-resizeable portrait activity enters size compat mode after resizing the
     * display.
     */
    @Test
    public void testSizeCompatForNonResizeableActivity() {
        runSizeCompatTest(NON_RESIZEABLE_PORTRAIT_ACTIVITY, /* inSizeCompatModeAfterResize */ true);
    }

    /**
     * Test that a non-resizeable portrait activity doesn't enter size compat mode after resizing
     * the display, when the {@link ActivityInfo#FORCE_RESIZE_APP} compat change is enabled.
     */
    @Test
    @EnableCompatChanges({ActivityInfo.FORCE_RESIZE_APP})
    public void testSizeCompatForNonResizeableActivityForceResizeEnabled() {
        runSizeCompatTest(NON_RESIZEABLE_PORTRAIT_ACTIVITY, /*inSizeCompatModeAfterResize */ false);
    }

    /**
     * Test that a resizeable portrait activity doesn't enter size compat mode after resizing
     * the display.
     */
    @Test
    public void testSizeCompatForResizeableActivity() {
        runSizeCompatTest(RESIZEABLE_PORTRAIT_ACTIVITY, /* inSizeCompatModeAfterResize */ false);
    }

    /**
     * Test that a non-resizeable portrait activity that supports size changes doesn't enter size
     * compat mode after resizing the display.
     */
    @Test
    public void testSizeCompatForSupportsSizeChangesActivity() {
        runSizeCompatTest(
                SUPPORTS_SIZE_CHANGES_PORTRAIT_ACTIVITY, /* inSizeCompatModeAfterResize */ false);
    }

    /**
     * Test that a resizeable portrait activity enters size compat mode after resizing
     * the display, when the {@link ActivityInfo#FORCE_NON_RESIZE_APP} compat change is enabled.
     */
    @Test
    @EnableCompatChanges({ActivityInfo.FORCE_NON_RESIZE_APP})
    public void testSizeCompatForResizeableActivityForceNonResizeEnabled() {
        runSizeCompatTest(RESIZEABLE_PORTRAIT_ACTIVITY, /* inSizeCompatModeAfterResize */ true);
    }

    /**
     * Test that a non-resizeable portrait activity that supports size changes enters size compat
     * mode after resizing the display, when the {@link ActivityInfo#FORCE_NON_RESIZE_APP} compat
     * change is enabled.
     */
    @Test
    @EnableCompatChanges({ActivityInfo.FORCE_NON_RESIZE_APP})
    public void testSizeCompatForSupportsSizeChangesActivityForceNonResizeEnabled() {
        runSizeCompatTest(
                SUPPORTS_SIZE_CHANGES_PORTRAIT_ACTIVITY, /* inSizeCompatModeAfterResize */ true);
    }

    /**
     * Test that a min aspect ratio activity eligible for size compat mode results in sandboxed
     * Display APIs.
     */
    @Test
    public void testSandboxForNonResizableAspectRatioActivity() {
        runSizeCompatModeSandboxTest(NON_RESIZEABLE_LARGE_ASPECT_RATIO_ACTIVITY,
                /* isSandboxed */ true, /* inSizeCompatModeAfterResize */ true);
    }

     // =================
     // NEVER_SANDBOX test cases
     // =================
     // Validates that an activity forced into size compat mode never has sandboxing applied to the
     // max bounds. It is expected that an activity in size compat mode normally always has
     // sandboxing applied.

    /**
     * Test that a min aspect ratio activity eligible for size compat mode does not have the Display
     * APIs sandboxed when the {@link ActivityInfo#NEVER_SANDBOX_DISPLAY_APIS} compat change is
     * enabled.
     */
    @Test
    @EnableCompatChanges({ActivityInfo.NEVER_SANDBOX_DISPLAY_APIS})
    public void testSandboxForNonResizableAspectRatioActivityNeverSandboxDisplayApisEnabled() {
        runSizeCompatModeSandboxTest(NON_RESIZEABLE_LARGE_ASPECT_RATIO_ACTIVITY,
                /* isSandboxed */ false, /* inSizeCompatModeAfterResize */ true);
    }

    /**
     * Test that a min aspect ratio activity eligible for size compat mode does not have the
     * Display APIs sandboxed when the 'never_constrain_display_apis_all_packages' Device Config
     * flag is true.
     */
    @Test
    public void testSandboxForNonResizableActivityNeverSandboxDeviceConfigAllPackagesFlagTrue() {
        try (var neverForAll = setNeverConstrainDisplayApisAllPackagesFlag("true");
                var neverAnApp = setNeverConstrainDisplayApisFlag("com.android.other::")) {
            runSizeCompatModeSandboxTest(NON_RESIZEABLE_LARGE_ASPECT_RATIO_ACTIVITY,
                    /* isSandboxed */ false, /* inSizeCompatModeAfterResize */ true);
        }
    }

    /**
     * Test that a min aspect ratio activity eligible for size compat mode does not have the Display
     * APIs sandboxed when the 'never_constrain_display_apis' Device Config flag contains the test
     * package with an open ended range.
     */
    @Test
    public void testSandboxForNonResizableActivityPackageUnboundedInNeverSandboxDeviceConfigFlag() {
        ComponentName activity = NON_RESIZEABLE_LARGE_ASPECT_RATIO_ACTIVITY;
        try (var neverForApp = setNeverConstrainDisplayApisFlag(
                "com.android.other::," + activity.getPackageName() + "::")) {
            runSizeCompatModeSandboxTest(activity, /* isSandboxed */ false,
                    /* inSizeCompatModeAfterResize */ true);
        }
    }

    /**
     * Test that a min aspect ratio activity eligible for size compat mode does not have the Display
     * APIs sandboxed when the 'never_constrain_display_apis' Device Config flag contains the test
     * package with a version range that matches the installed version of the package.
     */
    @Test
    public void testSandboxForNonResizableActivityPackageWithinRangeInNeverSandboxDeviceConfig() {
        ComponentName activity = NON_RESIZEABLE_LARGE_ASPECT_RATIO_ACTIVITY;
        long version = getPackageVersion(activity);
        try (var neverForApp = setNeverConstrainDisplayApisFlag(
                "com.android.other::," + activity.getPackageName() + ":" + String.valueOf(
                        version - 1) + ":" + String.valueOf(version + 1))) {
            runSizeCompatModeSandboxTest(activity, /* isSandboxed */ false,
                    /* inSizeCompatModeAfterResize */ true);
        }
    }

    /**
     * Test that a min aspect ratio activity eligible for size compat mode does have the Display
     * APIs sandboxed when the 'never_constrain_display_apis' Device Config flag contains the test
     * package with a version range that doesn't match the installed version of the package.
     */
    @Test
    public void testSandboxForNonResizableActivityPackageOutsideRangeInNeverSandboxDeviceConfig() {
        ComponentName activity = NON_RESIZEABLE_LARGE_ASPECT_RATIO_ACTIVITY;
        long version = getPackageVersion(activity);
        try (var neverForApp = setNeverConstrainDisplayApisFlag(
                "com.android.other::," + activity.getPackageName() + ":" + String.valueOf(
                        version + 1) + ":")) {
            runSizeCompatModeSandboxTest(activity, /* isSandboxed */ true,
                    /* inSizeCompatModeAfterResize */ true);
        }
    }

    /**
     * Test that a min aspect ratio activity eligible for size compat mode does have the Display
     * APIs sandboxed when the 'never_constrain_display_apis' Device Config flag doesn't contain the
     * test package.
     */
    @Test
    public void testSandboxForNonResizableActivityPackageNotInNeverSandboxDeviceConfigFlag() {
        try (var neverForApp = setNeverConstrainDisplayApisFlag(
                "com.android.other::,com.android.other2::")) {
            runSizeCompatModeSandboxTest(NON_RESIZEABLE_LARGE_ASPECT_RATIO_ACTIVITY,
                    /* isSandboxed */ true, /* inSizeCompatModeAfterResize */ true);
        }
    }

    /**
     * Test that a min aspect ratio activity eligible for size compat mode does have the Display
     * APIs sandboxed when the 'never_constrain_display_apis' Device Config flag is empty.
     */
    @Test
    public void testSandboxForNonResizableActivityNeverSandboxDeviceConfigFlagEmpty() {
        try (var empty = setNeverConstrainDisplayApisFlag("")) {
            runSizeCompatModeSandboxTest(NON_RESIZEABLE_LARGE_ASPECT_RATIO_ACTIVITY,
                    /* isSandboxed */ true, /* inSizeCompatModeAfterResize */ true);
        }
    }

    /**
     * Test that a min aspect ratio activity eligible for size compat mode does have the Display
     * APIs sandboxed when the 'never_constrain_display_apis' Device Config flag contains an invalid
     * entry for the test package.
     */
    @Test
    public void testSandboxForNonResizableActivityInvalidEntryInNeverSandboxDeviceConfigFlag() {
        ComponentName activity = NON_RESIZEABLE_LARGE_ASPECT_RATIO_ACTIVITY;
        try (var neverForApp = setNeverConstrainDisplayApisFlag(
                "com.android.other::," + activity.getPackageName() + ":::")) {
            runSizeCompatModeSandboxTest(activity, /* isSandboxed */ true,
                    /* inSizeCompatModeAfterResize */ true);
        }
    }

    /** =================
     * SANDBOX_VIEW_BOUNDS_APIS test cases
     * @see #testSandbox_viewApiForLetterboxedActivity
     * @see #testNoSandbox_viewApiForLetterboxedActivity
     * @see #testNoSandbox_viewApiForLetterboxedActivityOptOut
     * =================
     * Validates that an activity in letterbox mode has sandboxing applied to the
     * view bounds when OVERRIDE_SANDBOX_VIEW_BOUNDS_APIS is set.
     * Without this flag or with
     * {@link android.view.WindowManager#PROPERTY_COMPAT_ALLOW_SANDBOXING_VIEW_BOUNDS_APIS}
     * value=false in AndroidManifest.xml
     * {@link android.view.View#getLocationOnScreen},
     * {@link android.view.View#getWindowDisplayFrame}
     * {@link android.view.View#getBoundsOnScreen}
     * and {@link android.view.View#getWindowVisibleDisplayFrame}
     * return location or display frame offset by the window location on the screen:
     * {@link WindowConfiguration#getBounds}
     */
    @Test
    public void testSandbox_viewApiForLetterboxedActivity() {
        // Enable OVERRIDE_SANDBOX_VIEW_BOUNDS_APIS changeId for the test application
        try (var aspectRatio = new DisplayAspectRatioCloseable(ORIENTATION_LANDSCAPE, 2.0f);
             var compatChange = new CompatChangeCloseable(
                OVERRIDE_SANDBOX_VIEW_BOUNDS_APIS,
                TEST_VIEW_SANDBOX_ALLOWED_ACTIVITY.getPackageName());
             var receiver = new BroadcastReceiverCloseable(mContext,
                     ACTION_TEST_VIEW_SANDBOX_ALLOWED_PASSED)) {

            try (var session = new ActivitySessionCloseable(TEST_VIEW_SANDBOX_ALLOWED_ACTIVITY)) {
                // Wait for the broadcast action
                boolean testPassed = receiver
                        .getBroadcastReceivedVariable(ACTION_TEST_VIEW_SANDBOX_ALLOWED_PASSED)
                        .block(TEST_VIEW_SANDBOX_ALLOWED_TIMEOUT_MS);

                assertThat(testPassed).isTrue();
            }
        }
    }

    @Test
    public void testNoSandbox_viewApiForLetterboxedActivity() {
        // Enable OVERRIDE_SANDBOX_VIEW_BOUNDS_APIS changeId for the test application
        try (var aspectRatio = new DisplayAspectRatioCloseable(ORIENTATION_LANDSCAPE, 2.0f);
             var receiver = new BroadcastReceiverCloseable(mContext,
                     ACTION_TEST_VIEW_SANDBOX_NOT_ALLOWED_PASSED)) {

            try (var session = new ActivitySessionCloseable(TEST_VIEW_SANDBOX_ALLOWED_ACTIVITY)) {
                // Wait for the broadcast action
                boolean testPassed = receiver
                        .getBroadcastReceivedVariable(ACTION_TEST_VIEW_SANDBOX_NOT_ALLOWED_PASSED)
                        .block(TEST_VIEW_SANDBOX_ALLOWED_TIMEOUT_MS);

                assertThat(testPassed).isTrue();
            }
        }
    }

    @Test
    public void testNoSandbox_viewApiForLetterboxedActivityOptOut() {
        // Enable OVERRIDE_SANDBOX_VIEW_BOUNDS_APIS changeId for the test application
        try (var aspectRatio = new DisplayAspectRatioCloseable(ORIENTATION_LANDSCAPE, 2.0f);
             var compatChange = new CompatChangeCloseable(
                OVERRIDE_SANDBOX_VIEW_BOUNDS_APIS,
                TEST_VIEW_SANDBOX_OPT_OUT_ACTIVITY.getPackageName());
             var receiver = new BroadcastReceiverCloseable(mContext,
                     ACTION_TEST_VIEW_SANDBOX_OPT_OUT_PASSED)) {

            try (var session = new ActivitySessionCloseable(TEST_VIEW_SANDBOX_OPT_OUT_ACTIVITY)) {
                // Wait for the broadcast action
                boolean testPassed = receiver
                        .getBroadcastReceivedVariable(ACTION_TEST_VIEW_SANDBOX_OPT_OUT_PASSED)
                        .block(TEST_VIEW_SANDBOX_OPT_OUT_TIMEOUT_MS);

                assertThat(testPassed).isTrue();
            }
        }
    }

    // =================
    // ALWAYS_SANDBOX test cases
    // =================
    // Validates that an activity simply in letterbox mode has sandboxing applied to the max
    // bounds when ALWAYS_SANDBOX is set. Without the flag, we would not expect a letterbox activity
    // to be sandboxed, unless it is also eligible for size compat mode.

    /**
     * Test that a portrait activity not eligible for size compat mode does have the
     * Display APIs sandboxed when the {@link ActivityInfo#ALWAYS_SANDBOX_DISPLAY_APIS} compat
     * change is enabled.
     */
    @Test
    @EnableCompatChanges({ActivityInfo.ALWAYS_SANDBOX_DISPLAY_APIS})
    public void testSandboxForResizableActivityAlwaysSandboxDisplayApisEnabled() {
        runLetterboxSandboxTest(RESIZEABLE_PORTRAIT_ACTIVITY, /* isSandboxed */ true);
    }

    /**
     * Test that a portrait activity not eligible for size compat mode does not have the
     * Display APIs sandboxed when the 'always_constrain_display_apis' Device Config flag is empty.
     */
    @Test
    public void testSandboxResizableActivityAlwaysSandboxDeviceConfigFlagEmpty() {
        runLetterboxSandboxTest(RESIZEABLE_PORTRAIT_ACTIVITY, /* isSandboxed */ false);
    }

    /**
     * Test that a portrait activity not eligible for size compat mode does have the Display
     * APIs sandboxed when the 'always_constrain_display_apis' Device Config flag contains the test
     * package.
     */
    @Test
    public void testSandboxResizableActivityPackageInAlwaysSandboxDeviceConfigFlag() {
        ComponentName activity = RESIZEABLE_PORTRAIT_ACTIVITY;
        try (var alwaysForApp = setAlwaysConstrainDisplayApisFlag(
                "com.android.other::," + activity.getPackageName() + "::")) {
            runLetterboxSandboxTest(activity, /* isSandboxed */ true);
        }
    }

    /**
     * Test that only applying {@link ActivityInfo#OVERRIDE_MIN_ASPECT_RATIO} has no effect on its
     * own. The aspect ratio of the activity should be the same as that of the task, which should be
     * in line with that of the display.
     */
    @Test
    @EnableCompatChanges({ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO})
    public void testOverrideMinAspectRatioMissingSpecificOverride() {
        runMinAspectRatioTest(NON_RESIZEABLE_PORTRAIT_ACTIVITY, /* expected */ 0);
    }

    /**
     * Test that only applying {@link ActivityInfo#OVERRIDE_MIN_ASPECT_RATIO_LARGE} has no effect on
     * its own without the presence of {@link ActivityInfo#OVERRIDE_MIN_ASPECT_RATIO}.
     */
    @Test
    @EnableCompatChanges({ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_LARGE})
    public void testOverrideMinAspectRatioMissingGeneralOverride() {
        runMinAspectRatioTest(NON_RESIZEABLE_PORTRAIT_ACTIVITY, /* expected */ 0);
    }

    /**
     * Test that applying {@link ActivityInfo#OVERRIDE_MIN_ASPECT_RATIO_LARGE} has no effect on
     * activities whose orientation is fixed to landscape.
     */
    @Test
    @EnableCompatChanges({ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO,
            ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_LARGE})
    public void testOverrideMinAspectRatioForLandscapeActivity() {
        runMinAspectRatioTest(NON_RESIZEABLE_LANDSCAPE_ACTIVITY, /* expected */ 0);
    }

    /**
     * Test that applying {@link ActivityInfo#OVERRIDE_MIN_ASPECT_RATIO_LARGE} has no effect on
     * activities whose orientation isn't fixed.
     */
    @Test
    @EnableCompatChanges({ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO,
            ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_LARGE})
    @DisableCompatChanges({ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_PORTRAIT_ONLY})
    public void testOverrideMinAspectRatioForNonFixedOrientationActivityPortraitOnlyDisabled() {
        runMinAspectRatioTest(NON_RESIZEABLE_NON_FIXED_ORIENTATION_ACTIVITY, /* expected */
                OVERRIDE_MIN_ASPECT_RATIO_LARGE_VALUE);
    }

    /**
     * Test that applying {@link ActivityInfo#OVERRIDE_MIN_ASPECT_RATIO_LARGE} has no effect on
     * activities whose orientation is fixed to landscape.
     */
    @Test
    @EnableCompatChanges({ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO,
            ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_LARGE})
    @DisableCompatChanges({ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_PORTRAIT_ONLY})
    public void testOverrideMinAspectRatioForLandscapeActivityPortraitOnlyDisabled() {
        runMinAspectRatioTest(NON_RESIZEABLE_LANDSCAPE_ACTIVITY, /* expected */
                OVERRIDE_MIN_ASPECT_RATIO_LARGE_VALUE);
    }

    /**
     * Test that applying {@link ActivityInfo#OVERRIDE_MIN_ASPECT_RATIO_LARGE} has no effect on
     * activities whose orientation isn't fixed.
     */
    @Test
    @EnableCompatChanges({ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO,
            ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_LARGE})
    public void testOverrideMinAspectRatioForNonFixedOrientationActivity() {
        runMinAspectRatioTest(NON_RESIZEABLE_NON_FIXED_ORIENTATION_ACTIVITY, /* expected */ 0);
    }

    /**
     * Test that applying {@link ActivityInfo#OVERRIDE_MIN_ASPECT_RATIO_LARGE} sets the min aspect
     * ratio to {@link ActivityInfo#OVERRIDE_MIN_ASPECT_RATIO_LARGE_VALUE}.
     */
    @Test
    @EnableCompatChanges({ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO,
            ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_LARGE})
    public void testOverrideMinAspectRatioLargeAspectRatio() {
        runMinAspectRatioTest(NON_RESIZEABLE_PORTRAIT_ACTIVITY,
                /* expected */ OVERRIDE_MIN_ASPECT_RATIO_LARGE_VALUE);
    }

    /**
     * Test that applying {@link ActivityInfo#OVERRIDE_MIN_ASPECT_RATIO_MEDIUM} sets the min aspect
     * ratio to {@link ActivityInfo#OVERRIDE_MIN_ASPECT_RATIO_MEDIUM_VALUE}.
     */
    @Test
    @EnableCompatChanges({ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO,
            ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_MEDIUM})
    public void testOverrideMinAspectRatioMediumAspectRatio() {
        runMinAspectRatioTest(NON_RESIZEABLE_PORTRAIT_ACTIVITY,
                /* expected */ OVERRIDE_MIN_ASPECT_RATIO_MEDIUM_VALUE);
    }

    /**
     * Test that applying multiple min aspect ratio overrides result in the largest one taking
     * effect.
     */
    @Test
    @EnableCompatChanges({ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO,
            ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_LARGE,
            ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_MEDIUM})
    public void testOverrideMinAspectRatioBothAspectRatios() {
        runMinAspectRatioTest(NON_RESIZEABLE_PORTRAIT_ACTIVITY,
                /* expected */ OVERRIDE_MIN_ASPECT_RATIO_LARGE_VALUE);
    }

    /**
     * Test that the min aspect ratio of the activity as defined in the manifest is ignored if
     * there is an override for a larger min aspect ratio present (16:9 > 1.6).
     */
    @Test
    @EnableCompatChanges({ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO,
            ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_LARGE})
    public void testOverrideMinAspectRatioActivityMinAspectRatioSmallerThanOverride() {
        runMinAspectRatioTest(NON_RESIZEABLE_ASPECT_RATIO_ACTIVITY,
                /* expected */ OVERRIDE_MIN_ASPECT_RATIO_LARGE_VALUE);
    }

    /**
     * Test that the min aspect ratio of the activity as defined in the manifest is upheld if
     * there is an override for a smaller min aspect ratio present (3:2 < 1.6).
     */
    @Test
    @EnableCompatChanges({ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO,
            ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_MEDIUM})
    public void testOverrideMinAspectRatioActivityMinAspectRatioLargerThanOverride() {
        runMinAspectRatioTest(NON_RESIZEABLE_ASPECT_RATIO_ACTIVITY,
                /* expected */ ACTIVITY_MIN_ASPECT_RATIO);
    }

    private boolean isCameraCompatForceRotationTreatmentConfigEnabled() {
        return getBooleanConfig("config_isWindowManagerCameraCompatTreatmentEnabled");
    }

    private boolean isPolicyForIgnoringRequestedOrientationEnabled() {
        return getBooleanConfig("config_letterboxIsPolicyForIgnoringRequestedOrientationEnabled");
    }

    private boolean getBooleanConfig(String configName) {
        return mContext.getResources().getBoolean(
                Resources.getSystem().getIdentifier(configName, "bool", "android"));
    }

    /**
     * Launches the provided activity into size compat mode twice. The first time, the display
     * is resized to be half the size. The second time, the display is resized to be twice the
     * original size.
     *
     * @param activity                    the activity under test.
     * @param inSizeCompatModeAfterResize if the activity should be in size compat mode after
     *                                    resizing the display
     */
    private void runSizeCompatTest(ComponentName activity, boolean inSizeCompatModeAfterResize) {
        try (var session = new ActivitySessionCloseable(activity)) {
            runSizeCompatTestForActivity(activity, /* resizeRatio */ 0.5,
                    inSizeCompatModeAfterResize);
        }

        try (var session = new ActivitySessionCloseable(activity)) {
            runSizeCompatTestForActivity(activity, /* resizeRatio */ 2,
                    inSizeCompatModeAfterResize);
        }
    }

    /**
     * Launches the provided activity on the default display, initially not in size compat mode.
     * After resizing the display, verifies if activity is in size compat mode or not
     *
     * @param activity                    the activity under test
     * @param resizeRatio                 the ratio to resize the display
     * @param inSizeCompatModeAfterResize if the activity should be in size compat mode after
     *                                    resizing the display
     */
    private void runSizeCompatTestForActivity(ComponentName activity, final double resizeRatio,
            final boolean inSizeCompatModeAfterResize) {

        waitAndAssertSizeCompatMode(activity, /* expectedInSizeCompatMode */ false);

        try (var resized = new DisplaySizeScaleCloseable(resizeRatio, activity)) {
            assertThat(resized.getInitialDisplayAspectRatio())
                    .isLessThan(ACTIVITY_LARGE_MIN_ASPECT_RATIO);
            waitAndAssertSizeCompatMode(activity, inSizeCompatModeAfterResize);
        }
    }

    private void waitAndAssertSizeCompatMode(final ComponentName activity,
            final boolean expectedInSizeCompatMode) {
        waitAssertEquals("The window must be inSizeCompatMode==" + expectedInSizeCompatMode,
                expectedInSizeCompatMode,
                () -> getActivityWaitState(activity).inSizeCompatMode());
    }

    /**
     * Similar to {@link #runSizeCompatTest(ComponentName, boolean)}, but the activity is
     * expected to be in size compat mode after resizing the display.
     *
     * @param activity                    the activity under test
     * @param isSandboxed                 when {@code true},
     * {@link android.app.WindowConfiguration#getMaxBounds()}
     *                                    are sandboxed to the activity bounds. Otherwise, they
     *                                    inherit the
     *                                    DisplayArea bounds
     * @param inSizeCompatModeAfterResize if the activity should be in size compat mode after
     *                                    resizing the display
     */
    private void runSizeCompatModeSandboxTest(ComponentName activity, boolean isSandboxed,
            boolean inSizeCompatModeAfterResize) {
        try (var session = new ActivitySessionCloseable(activity, WINDOWING_MODE_FULLSCREEN)) {
            runSizeCompatTestForActivity(activity, /* resizeRatio */ 0.5,
                    inSizeCompatModeAfterResize);
            assertSandboxedByProvidesMaxBounds(activity, isSandboxed);
            assertSandboxedByBounds(activity, isSandboxed);
        }

        try (var session = new ActivitySessionCloseable(activity, WINDOWING_MODE_FULLSCREEN)) {
            runSizeCompatTestForActivity(activity, /* resizeRatio */ 2,
                    inSizeCompatModeAfterResize);
            assertSandboxedByProvidesMaxBounds(activity, isSandboxed);
            assertSandboxedByBounds(activity, isSandboxed);
        }
    }

    /**
     * Similar to {@link #runSizeCompatModeSandboxTest(ComponentName, boolean, boolean)}, but the
     * activity is put into letterbox mode after resizing the display.
     *
     * @param activityName the activity under test
     * @param isSandboxed  when {@code true}, {@link android.app.WindowConfiguration#getMaxBounds()}
     *                     are sandboxed to the activity bounds. Otherwise, they inherit the
     *                     DisplayArea bounds
     */
    private void runLetterboxSandboxTest(ComponentName activityName, boolean isSandboxed) {
        try (var aspectRatio = new DisplayAspectRatioCloseable(ORIENTATION_LANDSCAPE, 2.0f)) {
            assertThat(aspectRatio.getInitialDisplayAspectRatio())
                    .isLessThan(ACTIVITY_LARGE_MIN_ASPECT_RATIO);

            try (var session = new ActivitySessionCloseable(activityName)) {
                assertSandboxedByProvidesMaxBounds(activityName, isSandboxed);
            }
        }
    }

    private void assertSandboxedByBounds(ComponentName activityName, boolean isSandboxed) {
        final WindowManagerState.Activity activity = getActivityWaitState(activityName);
        assertNotNull(activity);
        final Rect activityBounds = activity.getBounds();
        final Rect maxBounds = activity.getMaxBounds();
        WindowManagerState.DisplayArea tda = mWmState.getTaskDisplayArea(activityName);
        assertNotNull(tda);
        if (isSandboxed) {
            assertEquals(
                    "The window has max bounds sandboxed to the window bounds",
                    activityBounds, maxBounds);
        } else {
            assertEquals(
                    "The window is not sandboxed, with max bounds reflecting the DisplayArea",
                    tda.getBounds(), maxBounds);
        }
    }

    private void assertSandboxedByProvidesMaxBounds(ComponentName activityName,
            boolean isSandboxed) {
        final WindowManagerState.Activity activity = getActivityWaitState(activityName);
        assertNotNull(activity);
        if (isSandboxed) {
            assertTrue(
                    "The window should have max bounds sandboxed to the window bounds",
                    activity.providesMaxBounds());
        } else {
            assertFalse(
                    "The window should not be sandboxed; max bounds should reflect the DisplayArea",
                    activity.providesMaxBounds());
        }
    }

    private CloseableDeviceConfig setNeverConstrainDisplayApisFlag(@Nullable String value) {
        return setConstrainDisplayApisFlag("never_constrain_display_apis", value);
    }

    private CloseableDeviceConfig setNeverConstrainDisplayApisAllPackagesFlag(
            @Nullable String value) {
        return setConstrainDisplayApisFlag("never_constrain_display_apis_all_packages", value);
    }

    private CloseableDeviceConfig setAlwaysConstrainDisplayApisFlag(
            @Nullable String value) {
        return setConstrainDisplayApisFlag("always_constrain_display_apis", value);
    }

    private CloseableDeviceConfig setConstrainDisplayApisFlag(@NonNull String flagName,
            @Nullable String value) {
        return new CloseableDeviceConfig(NAMESPACE_CONSTRAIN_DISPLAY_APIS, flagName, value);
    }

    /**
     * Launches the provided activity and verifies that its min aspect ratio is equal to {@code
     * expected}.
     *
     * @param activity the activity under test.
     * @param expected the expected min aspect ratio in both portrait and landscape displays.
     */
    private void runMinAspectRatioTest(ComponentName activity, float expected) {
        try (var session = new ActivitySessionCloseable(activity)) {
            assertNotNull(session.getActivityState());
            assertEquals(expected,
                    session.getActivityState().getMinAspectRatio(),
                    FLOAT_EQUALITY_DELTA);
        }
    }

    private long getPackageVersion(ComponentName activity) {
        try {
            return mContext.getPackageManager().getPackageInfo(activity.getPackageName(),
                    /* flags */ 0).getLongVersionCode();
        } catch (PackageManager.NameNotFoundException e) {
            throw new RuntimeException(e);
        }
    }

    private static ComponentName component(Class<? extends Activity> activity) {
        return new ComponentName(getInstrumentation().getContext(), activity);
    }

    public static class ResizeablePortraitActivity extends AbstractLifecycleLogActivity {
    }

    public static class ResponsiveActivity extends AbstractLifecycleLogActivity {
    }

    public static class NonResizeablePortraitActivity extends AbstractLifecycleLogActivity {
    }

    public static class NonResizeableLandscapeActivity extends AbstractLifecycleLogActivity {
    }

    public static class NonResizeableNonFixedOrientationActivity extends
            AbstractLifecycleLogActivity {
    }

    public static class NonResizeableAspectRatioActivity extends AbstractLifecycleLogActivity {
    }

    public static class NonResizeableLargeAspectRatioActivity extends AbstractLifecycleLogActivity {
    }

    public static class SupportsSizeChangesPortraitActivity extends AbstractLifecycleLogActivity {
    }

    public static class ResizeableLeftActivity extends AbstractLifecycleLogActivity {
    }

    public static class ResizeableRightActivity extends AbstractLifecycleLogActivity {
    }

    public static class NoPropertyChangeOrientationWhileRelaunchingActivity extends
            AbstractLifecycleLogActivity {

        private static boolean sHasChangeOrientationInOnResume;

        @Override
        protected void onCreate(Bundle instance) {
            super.onCreate(instance);
            // When OVERRIDE_ENABLE_COMPAT_IGNORE_REQUESTED_ORIENTATION is enabled this request
            // should be ignored if sHasChangeOrientationInOnResume is true.
            setRequestedOrientation(SCREEN_ORIENTATION_LANDSCAPE);
        }

        @Override
        protected void onResume() {
            super.onResume();
            if (!sHasChangeOrientationInOnResume) {
                setRequestedOrientation(SCREEN_ORIENTATION_PORTRAIT);
                sHasChangeOrientationInOnResume = true;
            }
        }
    }

    /**
     * Registers broadcast receiver which receives result actions from Activities under test.
     */
    private static class BroadcastReceiverCloseable implements AutoCloseable {
        private final Context mContext;
        private final Map<String, ConditionVariable> mBroadcastsReceived;
        private final BroadcastReceiver mAppCommunicator = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                getBroadcastReceivedVariable(intent.getAction()).open();
            }
        };

        BroadcastReceiverCloseable(final Context context, final String action) {
            this.mContext = context;
            // Keep the received broadcast items in the map.
            mBroadcastsReceived = Collections.synchronizedMap(new HashMap<>());
            // Register for broadcast actions.
            IntentFilter filter = new IntentFilter();
            filter.addAction(action);
            mContext.registerReceiver(mAppCommunicator, filter, Context.RECEIVER_EXPORTED);
        }

        ConditionVariable getBroadcastReceivedVariable(String action) {
            return mBroadcastsReceived.computeIfAbsent(action, key -> new ConditionVariable());
        }

        @Override
        public void close() {
            mContext.unregisterReceiver(mAppCommunicator);
        }
    }

    /**
     * Resets device config to the original value after the try-with-resources block finishes
     * try (var dc = new CloseableDeviceConfig()) {...}
     */
    private class CloseableDeviceConfig implements AutoCloseable {
        private String mOriginalValue;
        private final String mNamespace;
        private final String mFlagName;

        CloseableDeviceConfig(@NonNull String namespace, @NonNull String flagName,
                @Nullable String value) {
            mNamespace = namespace;
            mFlagName = flagName;
            runWithShellPermission(() -> {
                mOriginalValue = DeviceConfig.getProperty(namespace, flagName);
                DeviceConfig.setProperty(namespace, flagName, value, /* makeDefault */
                        false);
            });
        }

        @Override
        public void close() {
            runWithShellPermission(() -> DeviceConfig.setProperty(mNamespace, mFlagName,
                    mOriginalValue, /* makeDefault */ false));
        }
    }
}